diff --git a/public/images/ethereum/consensus/fast-confirmation.png b/public/images/ethereum/consensus/fast-confirmation.png new file mode 100644 index 000000000..63ecc96b7 Binary files /dev/null and b/public/images/ethereum/consensus/fast-confirmation.png differ diff --git a/src/api/@tanstack/react-query.gen.ts b/src/api/@tanstack/react-query.gen.ts index d38c00969..6a5b0f46b 100644 --- a/src/api/@tanstack/react-query.gen.ts +++ b/src/api/@tanstack/react-query.gen.ts @@ -76,6 +76,12 @@ import { fctBlockDataColumnSidecarFirstSeenByNodeServiceList, fctBlockDataColumnSidecarFirstSeenServiceGet, fctBlockDataColumnSidecarFirstSeenServiceList, + fctBlockFastConfirmationByClientDailyServiceGet, + fctBlockFastConfirmationByClientDailyServiceList, + fctBlockFastConfirmationByClientHourlyServiceGet, + fctBlockFastConfirmationByClientHourlyServiceList, + fctBlockFastConfirmationByNodeServiceGet, + fctBlockFastConfirmationByNodeServiceList, fctBlockFirstSeenByNodeServiceGet, fctBlockFirstSeenByNodeServiceList, fctBlockHeadServiceGet, @@ -643,6 +649,24 @@ import type { FctBlockDataColumnSidecarFirstSeenServiceListData, FctBlockDataColumnSidecarFirstSeenServiceListError, FctBlockDataColumnSidecarFirstSeenServiceListResponse, + FctBlockFastConfirmationByClientDailyServiceGetData, + FctBlockFastConfirmationByClientDailyServiceGetError, + FctBlockFastConfirmationByClientDailyServiceGetResponse, + FctBlockFastConfirmationByClientDailyServiceListData, + FctBlockFastConfirmationByClientDailyServiceListError, + FctBlockFastConfirmationByClientDailyServiceListResponse, + FctBlockFastConfirmationByClientHourlyServiceGetData, + FctBlockFastConfirmationByClientHourlyServiceGetError, + FctBlockFastConfirmationByClientHourlyServiceGetResponse, + FctBlockFastConfirmationByClientHourlyServiceListData, + FctBlockFastConfirmationByClientHourlyServiceListError, + FctBlockFastConfirmationByClientHourlyServiceListResponse, + FctBlockFastConfirmationByNodeServiceGetData, + FctBlockFastConfirmationByNodeServiceGetError, + FctBlockFastConfirmationByNodeServiceGetResponse, + FctBlockFastConfirmationByNodeServiceListData, + FctBlockFastConfirmationByNodeServiceListError, + FctBlockFastConfirmationByNodeServiceListResponse, FctBlockFirstSeenByNodeServiceGetData, FctBlockFirstSeenByNodeServiceGetError, FctBlockFirstSeenByNodeServiceGetResponse, @@ -3850,6 +3874,186 @@ export const fctBlockDataColumnSidecarFirstSeenByNodeServiceGetOptions = ( queryKey: fctBlockDataColumnSidecarFirstSeenByNodeServiceGetQueryKey(options), }); +export const fctBlockFastConfirmationByClientDailyServiceListQueryKey = ( + options?: Options +) => createQueryKey('fctBlockFastConfirmationByClientDailyServiceList', options); + +/** + * List records + * + * Retrieve paginated results with optional filtering + */ +export const fctBlockFastConfirmationByClientDailyServiceListOptions = ( + options?: Options +) => + queryOptions< + FctBlockFastConfirmationByClientDailyServiceListResponse, + FctBlockFastConfirmationByClientDailyServiceListError, + FctBlockFastConfirmationByClientDailyServiceListResponse, + ReturnType + >({ + queryFn: async ({ queryKey, signal }) => { + const { data } = await fctBlockFastConfirmationByClientDailyServiceList({ + ...options, + ...queryKey[0], + signal, + throwOnError: true, + }); + return data; + }, + queryKey: fctBlockFastConfirmationByClientDailyServiceListQueryKey(options), + }); + +export const fctBlockFastConfirmationByClientDailyServiceGetQueryKey = ( + options: Options +) => createQueryKey('fctBlockFastConfirmationByClientDailyServiceGet', options); + +/** + * Get record + * + * Retrieve a single record by day_start_date + */ +export const fctBlockFastConfirmationByClientDailyServiceGetOptions = ( + options: Options +) => + queryOptions< + FctBlockFastConfirmationByClientDailyServiceGetResponse, + FctBlockFastConfirmationByClientDailyServiceGetError, + FctBlockFastConfirmationByClientDailyServiceGetResponse, + ReturnType + >({ + queryFn: async ({ queryKey, signal }) => { + const { data } = await fctBlockFastConfirmationByClientDailyServiceGet({ + ...options, + ...queryKey[0], + signal, + throwOnError: true, + }); + return data; + }, + queryKey: fctBlockFastConfirmationByClientDailyServiceGetQueryKey(options), + }); + +export const fctBlockFastConfirmationByClientHourlyServiceListQueryKey = ( + options?: Options +) => createQueryKey('fctBlockFastConfirmationByClientHourlyServiceList', options); + +/** + * List records + * + * Retrieve paginated results with optional filtering + */ +export const fctBlockFastConfirmationByClientHourlyServiceListOptions = ( + options?: Options +) => + queryOptions< + FctBlockFastConfirmationByClientHourlyServiceListResponse, + FctBlockFastConfirmationByClientHourlyServiceListError, + FctBlockFastConfirmationByClientHourlyServiceListResponse, + ReturnType + >({ + queryFn: async ({ queryKey, signal }) => { + const { data } = await fctBlockFastConfirmationByClientHourlyServiceList({ + ...options, + ...queryKey[0], + signal, + throwOnError: true, + }); + return data; + }, + queryKey: fctBlockFastConfirmationByClientHourlyServiceListQueryKey(options), + }); + +export const fctBlockFastConfirmationByClientHourlyServiceGetQueryKey = ( + options: Options +) => createQueryKey('fctBlockFastConfirmationByClientHourlyServiceGet', options); + +/** + * Get record + * + * Retrieve a single record by hour_start_date_time + */ +export const fctBlockFastConfirmationByClientHourlyServiceGetOptions = ( + options: Options +) => + queryOptions< + FctBlockFastConfirmationByClientHourlyServiceGetResponse, + FctBlockFastConfirmationByClientHourlyServiceGetError, + FctBlockFastConfirmationByClientHourlyServiceGetResponse, + ReturnType + >({ + queryFn: async ({ queryKey, signal }) => { + const { data } = await fctBlockFastConfirmationByClientHourlyServiceGet({ + ...options, + ...queryKey[0], + signal, + throwOnError: true, + }); + return data; + }, + queryKey: fctBlockFastConfirmationByClientHourlyServiceGetQueryKey(options), + }); + +export const fctBlockFastConfirmationByNodeServiceListQueryKey = ( + options?: Options +) => createQueryKey('fctBlockFastConfirmationByNodeServiceList', options); + +/** + * List records + * + * Retrieve paginated results with optional filtering + */ +export const fctBlockFastConfirmationByNodeServiceListOptions = ( + options?: Options +) => + queryOptions< + FctBlockFastConfirmationByNodeServiceListResponse, + FctBlockFastConfirmationByNodeServiceListError, + FctBlockFastConfirmationByNodeServiceListResponse, + ReturnType + >({ + queryFn: async ({ queryKey, signal }) => { + const { data } = await fctBlockFastConfirmationByNodeServiceList({ + ...options, + ...queryKey[0], + signal, + throwOnError: true, + }); + return data; + }, + queryKey: fctBlockFastConfirmationByNodeServiceListQueryKey(options), + }); + +export const fctBlockFastConfirmationByNodeServiceGetQueryKey = ( + options: Options +) => createQueryKey('fctBlockFastConfirmationByNodeServiceGet', options); + +/** + * Get record + * + * Retrieve a single record by slot_start_date_time + */ +export const fctBlockFastConfirmationByNodeServiceGetOptions = ( + options: Options +) => + queryOptions< + FctBlockFastConfirmationByNodeServiceGetResponse, + FctBlockFastConfirmationByNodeServiceGetError, + FctBlockFastConfirmationByNodeServiceGetResponse, + ReturnType + >({ + queryFn: async ({ queryKey, signal }) => { + const { data } = await fctBlockFastConfirmationByNodeServiceGet({ + ...options, + ...queryKey[0], + signal, + throwOnError: true, + }); + return data; + }, + queryKey: fctBlockFastConfirmationByNodeServiceGetQueryKey(options), + }); + export const fctBlockFirstSeenByNodeServiceListQueryKey = (options?: Options) => createQueryKey('fctBlockFirstSeenByNodeServiceList', options); diff --git a/src/api/index.ts b/src/api/index.ts index c362d6362..eaad2da0e 100644 --- a/src/api/index.ts +++ b/src/api/index.ts @@ -73,6 +73,12 @@ export { fctBlockDataColumnSidecarFirstSeenByNodeServiceList, fctBlockDataColumnSidecarFirstSeenServiceGet, fctBlockDataColumnSidecarFirstSeenServiceList, + fctBlockFastConfirmationByClientDailyServiceGet, + fctBlockFastConfirmationByClientDailyServiceList, + fctBlockFastConfirmationByClientHourlyServiceGet, + fctBlockFastConfirmationByClientHourlyServiceList, + fctBlockFastConfirmationByNodeServiceGet, + fctBlockFastConfirmationByNodeServiceList, fctBlockFirstSeenByNodeServiceGet, fctBlockFirstSeenByNodeServiceList, fctBlockHeadServiceGet, @@ -822,6 +828,39 @@ export type { FctBlockDataColumnSidecarFirstSeenServiceListErrors, FctBlockDataColumnSidecarFirstSeenServiceListResponse, FctBlockDataColumnSidecarFirstSeenServiceListResponses, + FctBlockFastConfirmationByClientDaily, + FctBlockFastConfirmationByClientDailyServiceGetData, + FctBlockFastConfirmationByClientDailyServiceGetError, + FctBlockFastConfirmationByClientDailyServiceGetErrors, + FctBlockFastConfirmationByClientDailyServiceGetResponse, + FctBlockFastConfirmationByClientDailyServiceGetResponses, + FctBlockFastConfirmationByClientDailyServiceListData, + FctBlockFastConfirmationByClientDailyServiceListError, + FctBlockFastConfirmationByClientDailyServiceListErrors, + FctBlockFastConfirmationByClientDailyServiceListResponse, + FctBlockFastConfirmationByClientDailyServiceListResponses, + FctBlockFastConfirmationByClientHourly, + FctBlockFastConfirmationByClientHourlyServiceGetData, + FctBlockFastConfirmationByClientHourlyServiceGetError, + FctBlockFastConfirmationByClientHourlyServiceGetErrors, + FctBlockFastConfirmationByClientHourlyServiceGetResponse, + FctBlockFastConfirmationByClientHourlyServiceGetResponses, + FctBlockFastConfirmationByClientHourlyServiceListData, + FctBlockFastConfirmationByClientHourlyServiceListError, + FctBlockFastConfirmationByClientHourlyServiceListErrors, + FctBlockFastConfirmationByClientHourlyServiceListResponse, + FctBlockFastConfirmationByClientHourlyServiceListResponses, + FctBlockFastConfirmationByNode, + FctBlockFastConfirmationByNodeServiceGetData, + FctBlockFastConfirmationByNodeServiceGetError, + FctBlockFastConfirmationByNodeServiceGetErrors, + FctBlockFastConfirmationByNodeServiceGetResponse, + FctBlockFastConfirmationByNodeServiceGetResponses, + FctBlockFastConfirmationByNodeServiceListData, + FctBlockFastConfirmationByNodeServiceListError, + FctBlockFastConfirmationByNodeServiceListErrors, + FctBlockFastConfirmationByNodeServiceListResponse, + FctBlockFastConfirmationByNodeServiceListResponses, FctBlockFirstSeenByNode, FctBlockFirstSeenByNodeServiceGetData, FctBlockFirstSeenByNodeServiceGetError, @@ -1946,6 +1985,9 @@ export type { GetFctBlockBlobHeadResponse, GetFctBlockDataColumnSidecarFirstSeenByNodeResponse, GetFctBlockDataColumnSidecarFirstSeenResponse, + GetFctBlockFastConfirmationByClientDailyResponse, + GetFctBlockFastConfirmationByClientHourlyResponse, + GetFctBlockFastConfirmationByNodeResponse, GetFctBlockFirstSeenByNodeResponse, GetFctBlockHeadResponse, GetFctBlockMevHeadResponse, @@ -2982,6 +3024,9 @@ export type { ListFctBlockBlobHeadResponse, ListFctBlockDataColumnSidecarFirstSeenByNodeResponse, ListFctBlockDataColumnSidecarFirstSeenResponse, + ListFctBlockFastConfirmationByClientDailyResponse, + ListFctBlockFastConfirmationByClientHourlyResponse, + ListFctBlockFastConfirmationByNodeResponse, ListFctBlockFirstSeenByNodeResponse, ListFctBlockHeadResponse, ListFctBlockMevHeadResponse, diff --git a/src/api/sdk.gen.ts b/src/api/sdk.gen.ts index 25d45ef94..f9e020a65 100644 --- a/src/api/sdk.gen.ts +++ b/src/api/sdk.gen.ts @@ -219,6 +219,24 @@ import type { FctBlockDataColumnSidecarFirstSeenServiceListData, FctBlockDataColumnSidecarFirstSeenServiceListErrors, FctBlockDataColumnSidecarFirstSeenServiceListResponses, + FctBlockFastConfirmationByClientDailyServiceGetData, + FctBlockFastConfirmationByClientDailyServiceGetErrors, + FctBlockFastConfirmationByClientDailyServiceGetResponses, + FctBlockFastConfirmationByClientDailyServiceListData, + FctBlockFastConfirmationByClientDailyServiceListErrors, + FctBlockFastConfirmationByClientDailyServiceListResponses, + FctBlockFastConfirmationByClientHourlyServiceGetData, + FctBlockFastConfirmationByClientHourlyServiceGetErrors, + FctBlockFastConfirmationByClientHourlyServiceGetResponses, + FctBlockFastConfirmationByClientHourlyServiceListData, + FctBlockFastConfirmationByClientHourlyServiceListErrors, + FctBlockFastConfirmationByClientHourlyServiceListResponses, + FctBlockFastConfirmationByNodeServiceGetData, + FctBlockFastConfirmationByNodeServiceGetErrors, + FctBlockFastConfirmationByNodeServiceGetResponses, + FctBlockFastConfirmationByNodeServiceListData, + FctBlockFastConfirmationByNodeServiceListErrors, + FctBlockFastConfirmationByNodeServiceListResponses, FctBlockFirstSeenByNodeServiceGetData, FctBlockFirstSeenByNodeServiceGetErrors, FctBlockFirstSeenByNodeServiceGetResponses, @@ -1409,6 +1427,18 @@ import { zFctBlockDataColumnSidecarFirstSeenServiceGetResponse, zFctBlockDataColumnSidecarFirstSeenServiceListData, zFctBlockDataColumnSidecarFirstSeenServiceListResponse, + zFctBlockFastConfirmationByClientDailyServiceGetData, + zFctBlockFastConfirmationByClientDailyServiceGetResponse, + zFctBlockFastConfirmationByClientDailyServiceListData, + zFctBlockFastConfirmationByClientDailyServiceListResponse, + zFctBlockFastConfirmationByClientHourlyServiceGetData, + zFctBlockFastConfirmationByClientHourlyServiceGetResponse, + zFctBlockFastConfirmationByClientHourlyServiceListData, + zFctBlockFastConfirmationByClientHourlyServiceListResponse, + zFctBlockFastConfirmationByNodeServiceGetData, + zFctBlockFastConfirmationByNodeServiceGetResponse, + zFctBlockFastConfirmationByNodeServiceListData, + zFctBlockFastConfirmationByNodeServiceListResponse, zFctBlockFirstSeenByNodeServiceGetData, zFctBlockFirstSeenByNodeServiceGetResponse, zFctBlockFirstSeenByNodeServiceListData, @@ -3507,6 +3537,120 @@ export const fctBlockDataColumnSidecarFirstSeenByNodeServiceGet = ( + options?: Options +) => + (options?.client ?? client).get< + FctBlockFastConfirmationByClientDailyServiceListResponses, + FctBlockFastConfirmationByClientDailyServiceListErrors, + ThrowOnError + >({ + requestValidator: async data => await zFctBlockFastConfirmationByClientDailyServiceListData.parseAsync(data), + responseValidator: async data => await zFctBlockFastConfirmationByClientDailyServiceListResponse.parseAsync(data), + url: '/api/v1/fct_block_fast_confirmation_by_client_daily', + ...options, + }); + +/** + * Get record + * + * Retrieve a single record by day_start_date + */ +export const fctBlockFastConfirmationByClientDailyServiceGet = ( + options: Options +) => + (options.client ?? client).get< + FctBlockFastConfirmationByClientDailyServiceGetResponses, + FctBlockFastConfirmationByClientDailyServiceGetErrors, + ThrowOnError + >({ + requestValidator: async data => await zFctBlockFastConfirmationByClientDailyServiceGetData.parseAsync(data), + responseValidator: async data => await zFctBlockFastConfirmationByClientDailyServiceGetResponse.parseAsync(data), + url: '/api/v1/fct_block_fast_confirmation_by_client_daily/{day_start_date}', + ...options, + }); + +/** + * List records + * + * Retrieve paginated results with optional filtering + */ +export const fctBlockFastConfirmationByClientHourlyServiceList = ( + options?: Options +) => + (options?.client ?? client).get< + FctBlockFastConfirmationByClientHourlyServiceListResponses, + FctBlockFastConfirmationByClientHourlyServiceListErrors, + ThrowOnError + >({ + requestValidator: async data => await zFctBlockFastConfirmationByClientHourlyServiceListData.parseAsync(data), + responseValidator: async data => await zFctBlockFastConfirmationByClientHourlyServiceListResponse.parseAsync(data), + url: '/api/v1/fct_block_fast_confirmation_by_client_hourly', + ...options, + }); + +/** + * Get record + * + * Retrieve a single record by hour_start_date_time + */ +export const fctBlockFastConfirmationByClientHourlyServiceGet = ( + options: Options +) => + (options.client ?? client).get< + FctBlockFastConfirmationByClientHourlyServiceGetResponses, + FctBlockFastConfirmationByClientHourlyServiceGetErrors, + ThrowOnError + >({ + requestValidator: async data => await zFctBlockFastConfirmationByClientHourlyServiceGetData.parseAsync(data), + responseValidator: async data => await zFctBlockFastConfirmationByClientHourlyServiceGetResponse.parseAsync(data), + url: '/api/v1/fct_block_fast_confirmation_by_client_hourly/{hour_start_date_time}', + ...options, + }); + +/** + * List records + * + * Retrieve paginated results with optional filtering + */ +export const fctBlockFastConfirmationByNodeServiceList = ( + options?: Options +) => + (options?.client ?? client).get< + FctBlockFastConfirmationByNodeServiceListResponses, + FctBlockFastConfirmationByNodeServiceListErrors, + ThrowOnError + >({ + requestValidator: async data => await zFctBlockFastConfirmationByNodeServiceListData.parseAsync(data), + responseValidator: async data => await zFctBlockFastConfirmationByNodeServiceListResponse.parseAsync(data), + url: '/api/v1/fct_block_fast_confirmation_by_node', + ...options, + }); + +/** + * Get record + * + * Retrieve a single record by slot_start_date_time + */ +export const fctBlockFastConfirmationByNodeServiceGet = ( + options: Options +) => + (options.client ?? client).get< + FctBlockFastConfirmationByNodeServiceGetResponses, + FctBlockFastConfirmationByNodeServiceGetErrors, + ThrowOnError + >({ + requestValidator: async data => await zFctBlockFastConfirmationByNodeServiceGetData.parseAsync(data), + responseValidator: async data => await zFctBlockFastConfirmationByNodeServiceGetResponse.parseAsync(data), + url: '/api/v1/fct_block_fast_confirmation_by_node/{slot_start_date_time}', + ...options, + }); + /** * List records * diff --git a/src/api/types.gen.ts b/src/api/types.gen.ts index d2ac60db5..85aa47e9a 100644 --- a/src/api/types.gen.ts +++ b/src/api/types.gen.ts @@ -1819,6 +1819,259 @@ export type FctBlockDataColumnSidecarFirstSeenByNode = { username?: string; }; +export type FctBlockFastConfirmationByClientDaily = { + /** + * Average milliseconds from slot start to fast confirmation + */ + avg_fast_confirmation_ms?: number; + /** + * Average milliseconds from slot start to finality + */ + avg_finality_ms?: number; + /** + * Start of the day period + */ + day_start_date?: string; + /** + * Observations where the block was only confirmed through an event for a later block + */ + descendant_count?: number; + /** + * Observations where the node emitted a fast confirmation event for the block itself + */ + direct_count?: number; + /** + * Maximum milliseconds from slot start to fast confirmation + */ + max_fast_confirmation_ms?: number; + /** + * Maximum milliseconds from slot start to finality + */ + max_finality_ms?: number; + /** + * Consensus client implementation running the fast confirmation rule + */ + meta_consensus_implementation?: string; + /** + * Minimum milliseconds from slot start to fast confirmation + */ + min_fast_confirmation_ms?: number; + /** + * Minimum milliseconds from slot start to finality + */ + min_finality_ms?: number; + /** + * Number of fast confirmation nodes running this consensus client + */ + node_count?: number; + /** + * Number of (canonical block, node) observations + */ + observation_count?: number; + /** + * Fast confirmation events for blocks that did not become canonical + */ + orphaned_count?: number; + /** + * Median milliseconds from slot start to fast confirmation + */ + p50_fast_confirmation_ms?: number; + /** + * Median milliseconds from slot start to finality + */ + p50_finality_ms?: number; + /** + * Median per-block ratio of time to finality over time to fast confirmation + */ + p50_speedup?: number; + /** + * 90th percentile milliseconds from slot start to fast confirmation + */ + p90_fast_confirmation_ms?: number; + /** + * 95th percentile milliseconds from slot start to fast confirmation + */ + p95_fast_confirmation_ms?: number; + /** + * 95th percentile milliseconds from slot start to finality + */ + p95_finality_ms?: number; + /** + * 99th percentile milliseconds from slot start to fast confirmation + */ + p99_fast_confirmation_ms?: number; + /** + * Number of canonical blocks scored for this consensus client + */ + slot_count?: number; + /** + * Observations where the node did not fast confirm the block within 30 minutes + */ + unconfirmed_count?: number; + /** + * Timestamp when the record was last updated + */ + updated_date_time?: number; +}; + +export type FctBlockFastConfirmationByClientHourly = { + /** + * Average milliseconds from slot start to fast confirmation + */ + avg_fast_confirmation_ms?: number; + /** + * Average milliseconds from slot start to finality + */ + avg_finality_ms?: number; + /** + * Observations where the block was only confirmed through an event for a later block + */ + descendant_count?: number; + /** + * Observations where the node emitted a fast confirmation event for the block itself + */ + direct_count?: number; + /** + * Start of the hour period + */ + hour_start_date_time?: number; + /** + * Maximum milliseconds from slot start to fast confirmation + */ + max_fast_confirmation_ms?: number; + /** + * Maximum milliseconds from slot start to finality + */ + max_finality_ms?: number; + /** + * Consensus client implementation running the fast confirmation rule + */ + meta_consensus_implementation?: string; + /** + * Minimum milliseconds from slot start to fast confirmation + */ + min_fast_confirmation_ms?: number; + /** + * Minimum milliseconds from slot start to finality + */ + min_finality_ms?: number; + /** + * Number of fast confirmation nodes running this consensus client + */ + node_count?: number; + /** + * Number of (canonical block, node) observations + */ + observation_count?: number; + /** + * Fast confirmation events for blocks that did not become canonical + */ + orphaned_count?: number; + /** + * Median milliseconds from slot start to fast confirmation + */ + p50_fast_confirmation_ms?: number; + /** + * Median milliseconds from slot start to finality + */ + p50_finality_ms?: number; + /** + * Median per-block ratio of time to finality over time to fast confirmation + */ + p50_speedup?: number; + /** + * 90th percentile milliseconds from slot start to fast confirmation + */ + p90_fast_confirmation_ms?: number; + /** + * 95th percentile milliseconds from slot start to fast confirmation + */ + p95_fast_confirmation_ms?: number; + /** + * 95th percentile milliseconds from slot start to finality + */ + p95_finality_ms?: number; + /** + * 99th percentile milliseconds from slot start to fast confirmation + */ + p99_fast_confirmation_ms?: number; + /** + * Number of canonical blocks scored for this consensus client + */ + slot_count?: number; + /** + * Observations where the node did not fast confirm the block within 30 minutes + */ + unconfirmed_count?: number; + /** + * Timestamp when the record was last updated + */ + updated_date_time?: number; +}; + +export type FctBlockFastConfirmationByNode = { + /** + * The beacon block root hash + */ + block_root?: string; + /** + * How the block was fast confirmed: direct (an event for this block), descendant (only implied by an event for a later block), or unconfirmed (no confirmation seen within 30 minutes) + */ + confirmation_type?: string; + /** + * The epoch number containing the slot + */ + epoch?: number; + /** + * The wall clock time when the epoch started + */ + epoch_start_date_time?: number; + /** + * Slot of the block whose fast confirmation event first covered this block. Equals slot for direct confirmations + */ + fast_confirmation_slot?: number | null; + /** + * Milliseconds from slot start until the node fast confirmed this block, directly or through a descendant + */ + fast_confirmed_slot_start_diff?: number | null; + /** + * Epoch of the finalized checkpoint that first covered this block + */ + finalized_epoch?: number | null; + /** + * Milliseconds from slot start until the first sentry observed a finalized checkpoint covering this block + */ + finalized_slot_start_diff?: number | null; + /** + * Name of the sentry node that emitted the fast confirmation events + */ + meta_client_name?: string; + /** + * Consensus client implementation running the fast confirmation rule + */ + meta_consensus_implementation?: string; + /** + * Consensus client version running the fast confirmation rule + */ + meta_consensus_version?: string; + /** + * The slot number of the block + */ + slot?: number; + /** + * The wall clock time when the slot started + */ + slot_start_date_time?: number; + /** + * Chain status of the block: canonical, or orphaned when a node fast confirmed a block that did not become canonical + */ + status?: string; + /** + * Timestamp when the record was last updated + */ + updated_date_time?: number; +}; + export type FctBlockFirstSeenByNode = { /** * The beacon block root hash @@ -7003,6 +7256,27 @@ export type GetFctBlockDataColumnSidecarFirstSeenResponse = { item?: FctBlockDataColumnSidecarFirstSeen; }; +/** + * Response for getting a single fct_block_fast_confirmation_by_client_daily record + */ +export type GetFctBlockFastConfirmationByClientDailyResponse = { + item?: FctBlockFastConfirmationByClientDaily; +}; + +/** + * Response for getting a single fct_block_fast_confirmation_by_client_hourly record + */ +export type GetFctBlockFastConfirmationByClientHourlyResponse = { + item?: FctBlockFastConfirmationByClientHourly; +}; + +/** + * Response for getting a single fct_block_fast_confirmation_by_node record + */ +export type GetFctBlockFastConfirmationByNodeResponse = { + item?: FctBlockFastConfirmationByNode; +}; + /** * Response for getting a single fct_block_first_seen_by_node record */ @@ -12073,6 +12347,48 @@ export type ListFctBlockDataColumnSidecarFirstSeenResponse = { next_page_token?: string; }; +/** + * Response for listing fct_block_fast_confirmation_by_client_daily records + */ +export type ListFctBlockFastConfirmationByClientDailyResponse = { + /** + * The list of fct_block_fast_confirmation_by_client_daily. + */ + fct_block_fast_confirmation_by_client_daily?: Array; + /** + * A token, which can be sent as `page_token` to retrieve the next page. If this field is omitted, there are no subsequent pages. + */ + next_page_token?: string; +}; + +/** + * Response for listing fct_block_fast_confirmation_by_client_hourly records + */ +export type ListFctBlockFastConfirmationByClientHourlyResponse = { + /** + * The list of fct_block_fast_confirmation_by_client_hourly. + */ + fct_block_fast_confirmation_by_client_hourly?: Array; + /** + * A token, which can be sent as `page_token` to retrieve the next page. If this field is omitted, there are no subsequent pages. + */ + next_page_token?: string; +}; + +/** + * Response for listing fct_block_fast_confirmation_by_node records + */ +export type ListFctBlockFastConfirmationByNodeResponse = { + /** + * The list of fct_block_fast_confirmation_by_node. + */ + fct_block_fast_confirmation_by_node?: Array; + /** + * A token, which can be sent as `page_token` to retrieve the next page. If this field is omitted, there are no subsequent pages. + */ + next_page_token?: string; +}; + /** * Response for listing fct_block_first_seen_by_node records */ @@ -31140,6 +31456,2554 @@ export type FctBlockDataColumnSidecarFirstSeenByNodeServiceGetResponses = { export type FctBlockDataColumnSidecarFirstSeenByNodeServiceGetResponse = FctBlockDataColumnSidecarFirstSeenByNodeServiceGetResponses[keyof FctBlockDataColumnSidecarFirstSeenByNodeServiceGetResponses]; +export type FctBlockFastConfirmationByClientDailyServiceListData = { + body?: never; + path?: never; + query?: { + /** + * Start of the day period (filter: eq) + */ + day_start_date_eq?: string; + /** + * Start of the day period (filter: ne) + */ + day_start_date_ne?: string; + /** + * Start of the day period (filter: contains) + */ + day_start_date_contains?: string; + /** + * Start of the day period (filter: starts_with) + */ + day_start_date_starts_with?: string; + /** + * Start of the day period (filter: ends_with) + */ + day_start_date_ends_with?: string; + /** + * Start of the day period (filter: like) + */ + day_start_date_like?: string; + /** + * Start of the day period (filter: not_like) + */ + day_start_date_not_like?: string; + /** + * Start of the day period (filter: in_values) (comma-separated list) + */ + day_start_date_in_values?: string; + /** + * Start of the day period (filter: not_in_values) (comma-separated list) + */ + day_start_date_not_in_values?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: eq) + */ + meta_consensus_implementation_eq?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: ne) + */ + meta_consensus_implementation_ne?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: contains) + */ + meta_consensus_implementation_contains?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: starts_with) + */ + meta_consensus_implementation_starts_with?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: ends_with) + */ + meta_consensus_implementation_ends_with?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: like) + */ + meta_consensus_implementation_like?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: not_like) + */ + meta_consensus_implementation_not_like?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: in_values) (comma-separated list) + */ + meta_consensus_implementation_in_values?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: not_in_values) (comma-separated list) + */ + meta_consensus_implementation_not_in_values?: string; + /** + * Timestamp when the record was last updated (filter: eq) + */ + updated_date_time_eq?: number; + /** + * Timestamp when the record was last updated (filter: ne) + */ + updated_date_time_ne?: number; + /** + * Timestamp when the record was last updated (filter: lt) + */ + updated_date_time_lt?: number; + /** + * Timestamp when the record was last updated (filter: lte) + */ + updated_date_time_lte?: number; + /** + * Timestamp when the record was last updated (filter: gt) + */ + updated_date_time_gt?: number; + /** + * Timestamp when the record was last updated (filter: gte) + */ + updated_date_time_gte?: number; + /** + * Timestamp when the record was last updated (filter: between_min) + */ + updated_date_time_between_min?: number; + /** + * Timestamp when the record was last updated (filter: between_max_value) + */ + updated_date_time_between_max_value?: number; + /** + * Timestamp when the record was last updated (filter: in_values) (comma-separated list) + */ + updated_date_time_in_values?: string; + /** + * Timestamp when the record was last updated (filter: not_in_values) (comma-separated list) + */ + updated_date_time_not_in_values?: string; + /** + * Number of fast confirmation nodes running this consensus client (filter: eq) + */ + node_count_eq?: number; + /** + * Number of fast confirmation nodes running this consensus client (filter: ne) + */ + node_count_ne?: number; + /** + * Number of fast confirmation nodes running this consensus client (filter: lt) + */ + node_count_lt?: number; + /** + * Number of fast confirmation nodes running this consensus client (filter: lte) + */ + node_count_lte?: number; + /** + * Number of fast confirmation nodes running this consensus client (filter: gt) + */ + node_count_gt?: number; + /** + * Number of fast confirmation nodes running this consensus client (filter: gte) + */ + node_count_gte?: number; + /** + * Number of fast confirmation nodes running this consensus client (filter: between_min) + */ + node_count_between_min?: number; + /** + * Number of fast confirmation nodes running this consensus client (filter: between_max_value) + */ + node_count_between_max_value?: number; + /** + * Number of fast confirmation nodes running this consensus client (filter: in_values) (comma-separated list) + */ + node_count_in_values?: string; + /** + * Number of fast confirmation nodes running this consensus client (filter: not_in_values) (comma-separated list) + */ + node_count_not_in_values?: string; + /** + * Number of canonical blocks scored for this consensus client (filter: eq) + */ + slot_count_eq?: number; + /** + * Number of canonical blocks scored for this consensus client (filter: ne) + */ + slot_count_ne?: number; + /** + * Number of canonical blocks scored for this consensus client (filter: lt) + */ + slot_count_lt?: number; + /** + * Number of canonical blocks scored for this consensus client (filter: lte) + */ + slot_count_lte?: number; + /** + * Number of canonical blocks scored for this consensus client (filter: gt) + */ + slot_count_gt?: number; + /** + * Number of canonical blocks scored for this consensus client (filter: gte) + */ + slot_count_gte?: number; + /** + * Number of canonical blocks scored for this consensus client (filter: between_min) + */ + slot_count_between_min?: number; + /** + * Number of canonical blocks scored for this consensus client (filter: between_max_value) + */ + slot_count_between_max_value?: number; + /** + * Number of canonical blocks scored for this consensus client (filter: in_values) (comma-separated list) + */ + slot_count_in_values?: string; + /** + * Number of canonical blocks scored for this consensus client (filter: not_in_values) (comma-separated list) + */ + slot_count_not_in_values?: string; + /** + * Number of (canonical block, node) observations (filter: eq) + */ + observation_count_eq?: number; + /** + * Number of (canonical block, node) observations (filter: ne) + */ + observation_count_ne?: number; + /** + * Number of (canonical block, node) observations (filter: lt) + */ + observation_count_lt?: number; + /** + * Number of (canonical block, node) observations (filter: lte) + */ + observation_count_lte?: number; + /** + * Number of (canonical block, node) observations (filter: gt) + */ + observation_count_gt?: number; + /** + * Number of (canonical block, node) observations (filter: gte) + */ + observation_count_gte?: number; + /** + * Number of (canonical block, node) observations (filter: between_min) + */ + observation_count_between_min?: number; + /** + * Number of (canonical block, node) observations (filter: between_max_value) + */ + observation_count_between_max_value?: number; + /** + * Number of (canonical block, node) observations (filter: in_values) (comma-separated list) + */ + observation_count_in_values?: string; + /** + * Number of (canonical block, node) observations (filter: not_in_values) (comma-separated list) + */ + observation_count_not_in_values?: string; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: eq) + */ + direct_count_eq?: number; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: ne) + */ + direct_count_ne?: number; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: lt) + */ + direct_count_lt?: number; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: lte) + */ + direct_count_lte?: number; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: gt) + */ + direct_count_gt?: number; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: gte) + */ + direct_count_gte?: number; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: between_min) + */ + direct_count_between_min?: number; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: between_max_value) + */ + direct_count_between_max_value?: number; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: in_values) (comma-separated list) + */ + direct_count_in_values?: string; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: not_in_values) (comma-separated list) + */ + direct_count_not_in_values?: string; + /** + * Observations where the block was only confirmed through an event for a later block (filter: eq) + */ + descendant_count_eq?: number; + /** + * Observations where the block was only confirmed through an event for a later block (filter: ne) + */ + descendant_count_ne?: number; + /** + * Observations where the block was only confirmed through an event for a later block (filter: lt) + */ + descendant_count_lt?: number; + /** + * Observations where the block was only confirmed through an event for a later block (filter: lte) + */ + descendant_count_lte?: number; + /** + * Observations where the block was only confirmed through an event for a later block (filter: gt) + */ + descendant_count_gt?: number; + /** + * Observations where the block was only confirmed through an event for a later block (filter: gte) + */ + descendant_count_gte?: number; + /** + * Observations where the block was only confirmed through an event for a later block (filter: between_min) + */ + descendant_count_between_min?: number; + /** + * Observations where the block was only confirmed through an event for a later block (filter: between_max_value) + */ + descendant_count_between_max_value?: number; + /** + * Observations where the block was only confirmed through an event for a later block (filter: in_values) (comma-separated list) + */ + descendant_count_in_values?: string; + /** + * Observations where the block was only confirmed through an event for a later block (filter: not_in_values) (comma-separated list) + */ + descendant_count_not_in_values?: string; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: eq) + */ + unconfirmed_count_eq?: number; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: ne) + */ + unconfirmed_count_ne?: number; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: lt) + */ + unconfirmed_count_lt?: number; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: lte) + */ + unconfirmed_count_lte?: number; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: gt) + */ + unconfirmed_count_gt?: number; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: gte) + */ + unconfirmed_count_gte?: number; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: between_min) + */ + unconfirmed_count_between_min?: number; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: between_max_value) + */ + unconfirmed_count_between_max_value?: number; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: in_values) (comma-separated list) + */ + unconfirmed_count_in_values?: string; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: not_in_values) (comma-separated list) + */ + unconfirmed_count_not_in_values?: string; + /** + * Fast confirmation events for blocks that did not become canonical (filter: eq) + */ + orphaned_count_eq?: number; + /** + * Fast confirmation events for blocks that did not become canonical (filter: ne) + */ + orphaned_count_ne?: number; + /** + * Fast confirmation events for blocks that did not become canonical (filter: lt) + */ + orphaned_count_lt?: number; + /** + * Fast confirmation events for blocks that did not become canonical (filter: lte) + */ + orphaned_count_lte?: number; + /** + * Fast confirmation events for blocks that did not become canonical (filter: gt) + */ + orphaned_count_gt?: number; + /** + * Fast confirmation events for blocks that did not become canonical (filter: gte) + */ + orphaned_count_gte?: number; + /** + * Fast confirmation events for blocks that did not become canonical (filter: between_min) + */ + orphaned_count_between_min?: number; + /** + * Fast confirmation events for blocks that did not become canonical (filter: between_max_value) + */ + orphaned_count_between_max_value?: number; + /** + * Fast confirmation events for blocks that did not become canonical (filter: in_values) (comma-separated list) + */ + orphaned_count_in_values?: string; + /** + * Fast confirmation events for blocks that did not become canonical (filter: not_in_values) (comma-separated list) + */ + orphaned_count_not_in_values?: string; + /** + * Average milliseconds from slot start to fast confirmation (filter: eq) + */ + avg_fast_confirmation_ms_eq?: number; + /** + * Average milliseconds from slot start to fast confirmation (filter: ne) + */ + avg_fast_confirmation_ms_ne?: number; + /** + * Average milliseconds from slot start to fast confirmation (filter: lt) + */ + avg_fast_confirmation_ms_lt?: number; + /** + * Average milliseconds from slot start to fast confirmation (filter: lte) + */ + avg_fast_confirmation_ms_lte?: number; + /** + * Average milliseconds from slot start to fast confirmation (filter: gt) + */ + avg_fast_confirmation_ms_gt?: number; + /** + * Average milliseconds from slot start to fast confirmation (filter: gte) + */ + avg_fast_confirmation_ms_gte?: number; + /** + * Average milliseconds from slot start to fast confirmation (filter: between_min) + */ + avg_fast_confirmation_ms_between_min?: number; + /** + * Average milliseconds from slot start to fast confirmation (filter: between_max_value) + */ + avg_fast_confirmation_ms_between_max_value?: number; + /** + * Average milliseconds from slot start to fast confirmation (filter: in_values) (comma-separated list) + */ + avg_fast_confirmation_ms_in_values?: string; + /** + * Average milliseconds from slot start to fast confirmation (filter: not_in_values) (comma-separated list) + */ + avg_fast_confirmation_ms_not_in_values?: string; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: eq) + */ + min_fast_confirmation_ms_eq?: number; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: ne) + */ + min_fast_confirmation_ms_ne?: number; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: lt) + */ + min_fast_confirmation_ms_lt?: number; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: lte) + */ + min_fast_confirmation_ms_lte?: number; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: gt) + */ + min_fast_confirmation_ms_gt?: number; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: gte) + */ + min_fast_confirmation_ms_gte?: number; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: between_min) + */ + min_fast_confirmation_ms_between_min?: number; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: between_max_value) + */ + min_fast_confirmation_ms_between_max_value?: number; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: in_values) (comma-separated list) + */ + min_fast_confirmation_ms_in_values?: string; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: not_in_values) (comma-separated list) + */ + min_fast_confirmation_ms_not_in_values?: string; + /** + * Median milliseconds from slot start to fast confirmation (filter: eq) + */ + p50_fast_confirmation_ms_eq?: number; + /** + * Median milliseconds from slot start to fast confirmation (filter: ne) + */ + p50_fast_confirmation_ms_ne?: number; + /** + * Median milliseconds from slot start to fast confirmation (filter: lt) + */ + p50_fast_confirmation_ms_lt?: number; + /** + * Median milliseconds from slot start to fast confirmation (filter: lte) + */ + p50_fast_confirmation_ms_lte?: number; + /** + * Median milliseconds from slot start to fast confirmation (filter: gt) + */ + p50_fast_confirmation_ms_gt?: number; + /** + * Median milliseconds from slot start to fast confirmation (filter: gte) + */ + p50_fast_confirmation_ms_gte?: number; + /** + * Median milliseconds from slot start to fast confirmation (filter: between_min) + */ + p50_fast_confirmation_ms_between_min?: number; + /** + * Median milliseconds from slot start to fast confirmation (filter: between_max_value) + */ + p50_fast_confirmation_ms_between_max_value?: number; + /** + * Median milliseconds from slot start to fast confirmation (filter: in_values) (comma-separated list) + */ + p50_fast_confirmation_ms_in_values?: string; + /** + * Median milliseconds from slot start to fast confirmation (filter: not_in_values) (comma-separated list) + */ + p50_fast_confirmation_ms_not_in_values?: string; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: eq) + */ + p90_fast_confirmation_ms_eq?: number; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: ne) + */ + p90_fast_confirmation_ms_ne?: number; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: lt) + */ + p90_fast_confirmation_ms_lt?: number; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: lte) + */ + p90_fast_confirmation_ms_lte?: number; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: gt) + */ + p90_fast_confirmation_ms_gt?: number; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: gte) + */ + p90_fast_confirmation_ms_gte?: number; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: between_min) + */ + p90_fast_confirmation_ms_between_min?: number; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: between_max_value) + */ + p90_fast_confirmation_ms_between_max_value?: number; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: in_values) (comma-separated list) + */ + p90_fast_confirmation_ms_in_values?: string; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: not_in_values) (comma-separated list) + */ + p90_fast_confirmation_ms_not_in_values?: string; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: eq) + */ + p95_fast_confirmation_ms_eq?: number; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: ne) + */ + p95_fast_confirmation_ms_ne?: number; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: lt) + */ + p95_fast_confirmation_ms_lt?: number; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: lte) + */ + p95_fast_confirmation_ms_lte?: number; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: gt) + */ + p95_fast_confirmation_ms_gt?: number; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: gte) + */ + p95_fast_confirmation_ms_gte?: number; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: between_min) + */ + p95_fast_confirmation_ms_between_min?: number; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: between_max_value) + */ + p95_fast_confirmation_ms_between_max_value?: number; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: in_values) (comma-separated list) + */ + p95_fast_confirmation_ms_in_values?: string; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: not_in_values) (comma-separated list) + */ + p95_fast_confirmation_ms_not_in_values?: string; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: eq) + */ + p99_fast_confirmation_ms_eq?: number; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: ne) + */ + p99_fast_confirmation_ms_ne?: number; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: lt) + */ + p99_fast_confirmation_ms_lt?: number; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: lte) + */ + p99_fast_confirmation_ms_lte?: number; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: gt) + */ + p99_fast_confirmation_ms_gt?: number; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: gte) + */ + p99_fast_confirmation_ms_gte?: number; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: between_min) + */ + p99_fast_confirmation_ms_between_min?: number; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: between_max_value) + */ + p99_fast_confirmation_ms_between_max_value?: number; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: in_values) (comma-separated list) + */ + p99_fast_confirmation_ms_in_values?: string; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: not_in_values) (comma-separated list) + */ + p99_fast_confirmation_ms_not_in_values?: string; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: eq) + */ + max_fast_confirmation_ms_eq?: number; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: ne) + */ + max_fast_confirmation_ms_ne?: number; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: lt) + */ + max_fast_confirmation_ms_lt?: number; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: lte) + */ + max_fast_confirmation_ms_lte?: number; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: gt) + */ + max_fast_confirmation_ms_gt?: number; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: gte) + */ + max_fast_confirmation_ms_gte?: number; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: between_min) + */ + max_fast_confirmation_ms_between_min?: number; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: between_max_value) + */ + max_fast_confirmation_ms_between_max_value?: number; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: in_values) (comma-separated list) + */ + max_fast_confirmation_ms_in_values?: string; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: not_in_values) (comma-separated list) + */ + max_fast_confirmation_ms_not_in_values?: string; + /** + * Average milliseconds from slot start to finality (filter: eq) + */ + avg_finality_ms_eq?: number; + /** + * Average milliseconds from slot start to finality (filter: ne) + */ + avg_finality_ms_ne?: number; + /** + * Average milliseconds from slot start to finality (filter: lt) + */ + avg_finality_ms_lt?: number; + /** + * Average milliseconds from slot start to finality (filter: lte) + */ + avg_finality_ms_lte?: number; + /** + * Average milliseconds from slot start to finality (filter: gt) + */ + avg_finality_ms_gt?: number; + /** + * Average milliseconds from slot start to finality (filter: gte) + */ + avg_finality_ms_gte?: number; + /** + * Average milliseconds from slot start to finality (filter: between_min) + */ + avg_finality_ms_between_min?: number; + /** + * Average milliseconds from slot start to finality (filter: between_max_value) + */ + avg_finality_ms_between_max_value?: number; + /** + * Average milliseconds from slot start to finality (filter: in_values) (comma-separated list) + */ + avg_finality_ms_in_values?: string; + /** + * Average milliseconds from slot start to finality (filter: not_in_values) (comma-separated list) + */ + avg_finality_ms_not_in_values?: string; + /** + * Minimum milliseconds from slot start to finality (filter: eq) + */ + min_finality_ms_eq?: number; + /** + * Minimum milliseconds from slot start to finality (filter: ne) + */ + min_finality_ms_ne?: number; + /** + * Minimum milliseconds from slot start to finality (filter: lt) + */ + min_finality_ms_lt?: number; + /** + * Minimum milliseconds from slot start to finality (filter: lte) + */ + min_finality_ms_lte?: number; + /** + * Minimum milliseconds from slot start to finality (filter: gt) + */ + min_finality_ms_gt?: number; + /** + * Minimum milliseconds from slot start to finality (filter: gte) + */ + min_finality_ms_gte?: number; + /** + * Minimum milliseconds from slot start to finality (filter: between_min) + */ + min_finality_ms_between_min?: number; + /** + * Minimum milliseconds from slot start to finality (filter: between_max_value) + */ + min_finality_ms_between_max_value?: number; + /** + * Minimum milliseconds from slot start to finality (filter: in_values) (comma-separated list) + */ + min_finality_ms_in_values?: string; + /** + * Minimum milliseconds from slot start to finality (filter: not_in_values) (comma-separated list) + */ + min_finality_ms_not_in_values?: string; + /** + * Median milliseconds from slot start to finality (filter: eq) + */ + p50_finality_ms_eq?: number; + /** + * Median milliseconds from slot start to finality (filter: ne) + */ + p50_finality_ms_ne?: number; + /** + * Median milliseconds from slot start to finality (filter: lt) + */ + p50_finality_ms_lt?: number; + /** + * Median milliseconds from slot start to finality (filter: lte) + */ + p50_finality_ms_lte?: number; + /** + * Median milliseconds from slot start to finality (filter: gt) + */ + p50_finality_ms_gt?: number; + /** + * Median milliseconds from slot start to finality (filter: gte) + */ + p50_finality_ms_gte?: number; + /** + * Median milliseconds from slot start to finality (filter: between_min) + */ + p50_finality_ms_between_min?: number; + /** + * Median milliseconds from slot start to finality (filter: between_max_value) + */ + p50_finality_ms_between_max_value?: number; + /** + * Median milliseconds from slot start to finality (filter: in_values) (comma-separated list) + */ + p50_finality_ms_in_values?: string; + /** + * Median milliseconds from slot start to finality (filter: not_in_values) (comma-separated list) + */ + p50_finality_ms_not_in_values?: string; + /** + * 95th percentile milliseconds from slot start to finality (filter: eq) + */ + p95_finality_ms_eq?: number; + /** + * 95th percentile milliseconds from slot start to finality (filter: ne) + */ + p95_finality_ms_ne?: number; + /** + * 95th percentile milliseconds from slot start to finality (filter: lt) + */ + p95_finality_ms_lt?: number; + /** + * 95th percentile milliseconds from slot start to finality (filter: lte) + */ + p95_finality_ms_lte?: number; + /** + * 95th percentile milliseconds from slot start to finality (filter: gt) + */ + p95_finality_ms_gt?: number; + /** + * 95th percentile milliseconds from slot start to finality (filter: gte) + */ + p95_finality_ms_gte?: number; + /** + * 95th percentile milliseconds from slot start to finality (filter: between_min) + */ + p95_finality_ms_between_min?: number; + /** + * 95th percentile milliseconds from slot start to finality (filter: between_max_value) + */ + p95_finality_ms_between_max_value?: number; + /** + * 95th percentile milliseconds from slot start to finality (filter: in_values) (comma-separated list) + */ + p95_finality_ms_in_values?: string; + /** + * 95th percentile milliseconds from slot start to finality (filter: not_in_values) (comma-separated list) + */ + p95_finality_ms_not_in_values?: string; + /** + * Maximum milliseconds from slot start to finality (filter: eq) + */ + max_finality_ms_eq?: number; + /** + * Maximum milliseconds from slot start to finality (filter: ne) + */ + max_finality_ms_ne?: number; + /** + * Maximum milliseconds from slot start to finality (filter: lt) + */ + max_finality_ms_lt?: number; + /** + * Maximum milliseconds from slot start to finality (filter: lte) + */ + max_finality_ms_lte?: number; + /** + * Maximum milliseconds from slot start to finality (filter: gt) + */ + max_finality_ms_gt?: number; + /** + * Maximum milliseconds from slot start to finality (filter: gte) + */ + max_finality_ms_gte?: number; + /** + * Maximum milliseconds from slot start to finality (filter: between_min) + */ + max_finality_ms_between_min?: number; + /** + * Maximum milliseconds from slot start to finality (filter: between_max_value) + */ + max_finality_ms_between_max_value?: number; + /** + * Maximum milliseconds from slot start to finality (filter: in_values) (comma-separated list) + */ + max_finality_ms_in_values?: string; + /** + * Maximum milliseconds from slot start to finality (filter: not_in_values) (comma-separated list) + */ + max_finality_ms_not_in_values?: string; + /** + * Filter p50_speedup using value + */ + p50_speedup_value?: number; + /** + * The maximum number of fct_block_fast_confirmation_by_client_daily to return. If unspecified, at most 100 items will be returned. The maximum value is 10000; values above 10000 will be coerced to 10000. + */ + page_size?: number; + /** + * A page token, received from a previous `ListFctBlockFastConfirmationByClientDaily` call. Provide this to retrieve the subsequent page. + */ + page_token?: string; + /** + * The order of results. Format: comma-separated list of fields. Example: "foo,bar" or "foo desc,bar" for descending order on foo. If unspecified, results will be returned in the default order. + */ + order_by?: string; + }; + url: '/api/v1/fct_block_fast_confirmation_by_client_daily'; +}; + +export type FctBlockFastConfirmationByClientDailyServiceListErrors = { + /** + * Default error response + */ + default: Status; +}; + +export type FctBlockFastConfirmationByClientDailyServiceListError = + FctBlockFastConfirmationByClientDailyServiceListErrors[keyof FctBlockFastConfirmationByClientDailyServiceListErrors]; + +export type FctBlockFastConfirmationByClientDailyServiceListResponses = { + /** + * OK + */ + 200: ListFctBlockFastConfirmationByClientDailyResponse; +}; + +export type FctBlockFastConfirmationByClientDailyServiceListResponse = + FctBlockFastConfirmationByClientDailyServiceListResponses[keyof FctBlockFastConfirmationByClientDailyServiceListResponses]; + +export type FctBlockFastConfirmationByClientDailyServiceGetData = { + body?: never; + path: { + /** + * Start of the day period + */ + day_start_date: string; + }; + query?: never; + url: '/api/v1/fct_block_fast_confirmation_by_client_daily/{day_start_date}'; +}; + +export type FctBlockFastConfirmationByClientDailyServiceGetErrors = { + /** + * Default error response + */ + default: Status; +}; + +export type FctBlockFastConfirmationByClientDailyServiceGetError = + FctBlockFastConfirmationByClientDailyServiceGetErrors[keyof FctBlockFastConfirmationByClientDailyServiceGetErrors]; + +export type FctBlockFastConfirmationByClientDailyServiceGetResponses = { + /** + * OK + */ + 200: GetFctBlockFastConfirmationByClientDailyResponse; +}; + +export type FctBlockFastConfirmationByClientDailyServiceGetResponse = + FctBlockFastConfirmationByClientDailyServiceGetResponses[keyof FctBlockFastConfirmationByClientDailyServiceGetResponses]; + +export type FctBlockFastConfirmationByClientHourlyServiceListData = { + body?: never; + path?: never; + query?: { + /** + * Start of the hour period (filter: eq) + */ + hour_start_date_time_eq?: number; + /** + * Start of the hour period (filter: ne) + */ + hour_start_date_time_ne?: number; + /** + * Start of the hour period (filter: lt) + */ + hour_start_date_time_lt?: number; + /** + * Start of the hour period (filter: lte) + */ + hour_start_date_time_lte?: number; + /** + * Start of the hour period (filter: gt) + */ + hour_start_date_time_gt?: number; + /** + * Start of the hour period (filter: gte) + */ + hour_start_date_time_gte?: number; + /** + * Start of the hour period (filter: between_min) + */ + hour_start_date_time_between_min?: number; + /** + * Start of the hour period (filter: between_max_value) + */ + hour_start_date_time_between_max_value?: number; + /** + * Start of the hour period (filter: in_values) (comma-separated list) + */ + hour_start_date_time_in_values?: string; + /** + * Start of the hour period (filter: not_in_values) (comma-separated list) + */ + hour_start_date_time_not_in_values?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: eq) + */ + meta_consensus_implementation_eq?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: ne) + */ + meta_consensus_implementation_ne?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: contains) + */ + meta_consensus_implementation_contains?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: starts_with) + */ + meta_consensus_implementation_starts_with?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: ends_with) + */ + meta_consensus_implementation_ends_with?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: like) + */ + meta_consensus_implementation_like?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: not_like) + */ + meta_consensus_implementation_not_like?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: in_values) (comma-separated list) + */ + meta_consensus_implementation_in_values?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: not_in_values) (comma-separated list) + */ + meta_consensus_implementation_not_in_values?: string; + /** + * Timestamp when the record was last updated (filter: eq) + */ + updated_date_time_eq?: number; + /** + * Timestamp when the record was last updated (filter: ne) + */ + updated_date_time_ne?: number; + /** + * Timestamp when the record was last updated (filter: lt) + */ + updated_date_time_lt?: number; + /** + * Timestamp when the record was last updated (filter: lte) + */ + updated_date_time_lte?: number; + /** + * Timestamp when the record was last updated (filter: gt) + */ + updated_date_time_gt?: number; + /** + * Timestamp when the record was last updated (filter: gte) + */ + updated_date_time_gte?: number; + /** + * Timestamp when the record was last updated (filter: between_min) + */ + updated_date_time_between_min?: number; + /** + * Timestamp when the record was last updated (filter: between_max_value) + */ + updated_date_time_between_max_value?: number; + /** + * Timestamp when the record was last updated (filter: in_values) (comma-separated list) + */ + updated_date_time_in_values?: string; + /** + * Timestamp when the record was last updated (filter: not_in_values) (comma-separated list) + */ + updated_date_time_not_in_values?: string; + /** + * Number of fast confirmation nodes running this consensus client (filter: eq) + */ + node_count_eq?: number; + /** + * Number of fast confirmation nodes running this consensus client (filter: ne) + */ + node_count_ne?: number; + /** + * Number of fast confirmation nodes running this consensus client (filter: lt) + */ + node_count_lt?: number; + /** + * Number of fast confirmation nodes running this consensus client (filter: lte) + */ + node_count_lte?: number; + /** + * Number of fast confirmation nodes running this consensus client (filter: gt) + */ + node_count_gt?: number; + /** + * Number of fast confirmation nodes running this consensus client (filter: gte) + */ + node_count_gte?: number; + /** + * Number of fast confirmation nodes running this consensus client (filter: between_min) + */ + node_count_between_min?: number; + /** + * Number of fast confirmation nodes running this consensus client (filter: between_max_value) + */ + node_count_between_max_value?: number; + /** + * Number of fast confirmation nodes running this consensus client (filter: in_values) (comma-separated list) + */ + node_count_in_values?: string; + /** + * Number of fast confirmation nodes running this consensus client (filter: not_in_values) (comma-separated list) + */ + node_count_not_in_values?: string; + /** + * Number of canonical blocks scored for this consensus client (filter: eq) + */ + slot_count_eq?: number; + /** + * Number of canonical blocks scored for this consensus client (filter: ne) + */ + slot_count_ne?: number; + /** + * Number of canonical blocks scored for this consensus client (filter: lt) + */ + slot_count_lt?: number; + /** + * Number of canonical blocks scored for this consensus client (filter: lte) + */ + slot_count_lte?: number; + /** + * Number of canonical blocks scored for this consensus client (filter: gt) + */ + slot_count_gt?: number; + /** + * Number of canonical blocks scored for this consensus client (filter: gte) + */ + slot_count_gte?: number; + /** + * Number of canonical blocks scored for this consensus client (filter: between_min) + */ + slot_count_between_min?: number; + /** + * Number of canonical blocks scored for this consensus client (filter: between_max_value) + */ + slot_count_between_max_value?: number; + /** + * Number of canonical blocks scored for this consensus client (filter: in_values) (comma-separated list) + */ + slot_count_in_values?: string; + /** + * Number of canonical blocks scored for this consensus client (filter: not_in_values) (comma-separated list) + */ + slot_count_not_in_values?: string; + /** + * Number of (canonical block, node) observations (filter: eq) + */ + observation_count_eq?: number; + /** + * Number of (canonical block, node) observations (filter: ne) + */ + observation_count_ne?: number; + /** + * Number of (canonical block, node) observations (filter: lt) + */ + observation_count_lt?: number; + /** + * Number of (canonical block, node) observations (filter: lte) + */ + observation_count_lte?: number; + /** + * Number of (canonical block, node) observations (filter: gt) + */ + observation_count_gt?: number; + /** + * Number of (canonical block, node) observations (filter: gte) + */ + observation_count_gte?: number; + /** + * Number of (canonical block, node) observations (filter: between_min) + */ + observation_count_between_min?: number; + /** + * Number of (canonical block, node) observations (filter: between_max_value) + */ + observation_count_between_max_value?: number; + /** + * Number of (canonical block, node) observations (filter: in_values) (comma-separated list) + */ + observation_count_in_values?: string; + /** + * Number of (canonical block, node) observations (filter: not_in_values) (comma-separated list) + */ + observation_count_not_in_values?: string; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: eq) + */ + direct_count_eq?: number; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: ne) + */ + direct_count_ne?: number; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: lt) + */ + direct_count_lt?: number; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: lte) + */ + direct_count_lte?: number; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: gt) + */ + direct_count_gt?: number; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: gte) + */ + direct_count_gte?: number; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: between_min) + */ + direct_count_between_min?: number; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: between_max_value) + */ + direct_count_between_max_value?: number; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: in_values) (comma-separated list) + */ + direct_count_in_values?: string; + /** + * Observations where the node emitted a fast confirmation event for the block itself (filter: not_in_values) (comma-separated list) + */ + direct_count_not_in_values?: string; + /** + * Observations where the block was only confirmed through an event for a later block (filter: eq) + */ + descendant_count_eq?: number; + /** + * Observations where the block was only confirmed through an event for a later block (filter: ne) + */ + descendant_count_ne?: number; + /** + * Observations where the block was only confirmed through an event for a later block (filter: lt) + */ + descendant_count_lt?: number; + /** + * Observations where the block was only confirmed through an event for a later block (filter: lte) + */ + descendant_count_lte?: number; + /** + * Observations where the block was only confirmed through an event for a later block (filter: gt) + */ + descendant_count_gt?: number; + /** + * Observations where the block was only confirmed through an event for a later block (filter: gte) + */ + descendant_count_gte?: number; + /** + * Observations where the block was only confirmed through an event for a later block (filter: between_min) + */ + descendant_count_between_min?: number; + /** + * Observations where the block was only confirmed through an event for a later block (filter: between_max_value) + */ + descendant_count_between_max_value?: number; + /** + * Observations where the block was only confirmed through an event for a later block (filter: in_values) (comma-separated list) + */ + descendant_count_in_values?: string; + /** + * Observations where the block was only confirmed through an event for a later block (filter: not_in_values) (comma-separated list) + */ + descendant_count_not_in_values?: string; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: eq) + */ + unconfirmed_count_eq?: number; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: ne) + */ + unconfirmed_count_ne?: number; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: lt) + */ + unconfirmed_count_lt?: number; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: lte) + */ + unconfirmed_count_lte?: number; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: gt) + */ + unconfirmed_count_gt?: number; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: gte) + */ + unconfirmed_count_gte?: number; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: between_min) + */ + unconfirmed_count_between_min?: number; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: between_max_value) + */ + unconfirmed_count_between_max_value?: number; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: in_values) (comma-separated list) + */ + unconfirmed_count_in_values?: string; + /** + * Observations where the node did not fast confirm the block within 30 minutes (filter: not_in_values) (comma-separated list) + */ + unconfirmed_count_not_in_values?: string; + /** + * Fast confirmation events for blocks that did not become canonical (filter: eq) + */ + orphaned_count_eq?: number; + /** + * Fast confirmation events for blocks that did not become canonical (filter: ne) + */ + orphaned_count_ne?: number; + /** + * Fast confirmation events for blocks that did not become canonical (filter: lt) + */ + orphaned_count_lt?: number; + /** + * Fast confirmation events for blocks that did not become canonical (filter: lte) + */ + orphaned_count_lte?: number; + /** + * Fast confirmation events for blocks that did not become canonical (filter: gt) + */ + orphaned_count_gt?: number; + /** + * Fast confirmation events for blocks that did not become canonical (filter: gte) + */ + orphaned_count_gte?: number; + /** + * Fast confirmation events for blocks that did not become canonical (filter: between_min) + */ + orphaned_count_between_min?: number; + /** + * Fast confirmation events for blocks that did not become canonical (filter: between_max_value) + */ + orphaned_count_between_max_value?: number; + /** + * Fast confirmation events for blocks that did not become canonical (filter: in_values) (comma-separated list) + */ + orphaned_count_in_values?: string; + /** + * Fast confirmation events for blocks that did not become canonical (filter: not_in_values) (comma-separated list) + */ + orphaned_count_not_in_values?: string; + /** + * Average milliseconds from slot start to fast confirmation (filter: eq) + */ + avg_fast_confirmation_ms_eq?: number; + /** + * Average milliseconds from slot start to fast confirmation (filter: ne) + */ + avg_fast_confirmation_ms_ne?: number; + /** + * Average milliseconds from slot start to fast confirmation (filter: lt) + */ + avg_fast_confirmation_ms_lt?: number; + /** + * Average milliseconds from slot start to fast confirmation (filter: lte) + */ + avg_fast_confirmation_ms_lte?: number; + /** + * Average milliseconds from slot start to fast confirmation (filter: gt) + */ + avg_fast_confirmation_ms_gt?: number; + /** + * Average milliseconds from slot start to fast confirmation (filter: gte) + */ + avg_fast_confirmation_ms_gte?: number; + /** + * Average milliseconds from slot start to fast confirmation (filter: between_min) + */ + avg_fast_confirmation_ms_between_min?: number; + /** + * Average milliseconds from slot start to fast confirmation (filter: between_max_value) + */ + avg_fast_confirmation_ms_between_max_value?: number; + /** + * Average milliseconds from slot start to fast confirmation (filter: in_values) (comma-separated list) + */ + avg_fast_confirmation_ms_in_values?: string; + /** + * Average milliseconds from slot start to fast confirmation (filter: not_in_values) (comma-separated list) + */ + avg_fast_confirmation_ms_not_in_values?: string; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: eq) + */ + min_fast_confirmation_ms_eq?: number; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: ne) + */ + min_fast_confirmation_ms_ne?: number; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: lt) + */ + min_fast_confirmation_ms_lt?: number; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: lte) + */ + min_fast_confirmation_ms_lte?: number; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: gt) + */ + min_fast_confirmation_ms_gt?: number; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: gte) + */ + min_fast_confirmation_ms_gte?: number; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: between_min) + */ + min_fast_confirmation_ms_between_min?: number; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: between_max_value) + */ + min_fast_confirmation_ms_between_max_value?: number; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: in_values) (comma-separated list) + */ + min_fast_confirmation_ms_in_values?: string; + /** + * Minimum milliseconds from slot start to fast confirmation (filter: not_in_values) (comma-separated list) + */ + min_fast_confirmation_ms_not_in_values?: string; + /** + * Median milliseconds from slot start to fast confirmation (filter: eq) + */ + p50_fast_confirmation_ms_eq?: number; + /** + * Median milliseconds from slot start to fast confirmation (filter: ne) + */ + p50_fast_confirmation_ms_ne?: number; + /** + * Median milliseconds from slot start to fast confirmation (filter: lt) + */ + p50_fast_confirmation_ms_lt?: number; + /** + * Median milliseconds from slot start to fast confirmation (filter: lte) + */ + p50_fast_confirmation_ms_lte?: number; + /** + * Median milliseconds from slot start to fast confirmation (filter: gt) + */ + p50_fast_confirmation_ms_gt?: number; + /** + * Median milliseconds from slot start to fast confirmation (filter: gte) + */ + p50_fast_confirmation_ms_gte?: number; + /** + * Median milliseconds from slot start to fast confirmation (filter: between_min) + */ + p50_fast_confirmation_ms_between_min?: number; + /** + * Median milliseconds from slot start to fast confirmation (filter: between_max_value) + */ + p50_fast_confirmation_ms_between_max_value?: number; + /** + * Median milliseconds from slot start to fast confirmation (filter: in_values) (comma-separated list) + */ + p50_fast_confirmation_ms_in_values?: string; + /** + * Median milliseconds from slot start to fast confirmation (filter: not_in_values) (comma-separated list) + */ + p50_fast_confirmation_ms_not_in_values?: string; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: eq) + */ + p90_fast_confirmation_ms_eq?: number; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: ne) + */ + p90_fast_confirmation_ms_ne?: number; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: lt) + */ + p90_fast_confirmation_ms_lt?: number; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: lte) + */ + p90_fast_confirmation_ms_lte?: number; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: gt) + */ + p90_fast_confirmation_ms_gt?: number; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: gte) + */ + p90_fast_confirmation_ms_gte?: number; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: between_min) + */ + p90_fast_confirmation_ms_between_min?: number; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: between_max_value) + */ + p90_fast_confirmation_ms_between_max_value?: number; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: in_values) (comma-separated list) + */ + p90_fast_confirmation_ms_in_values?: string; + /** + * 90th percentile milliseconds from slot start to fast confirmation (filter: not_in_values) (comma-separated list) + */ + p90_fast_confirmation_ms_not_in_values?: string; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: eq) + */ + p95_fast_confirmation_ms_eq?: number; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: ne) + */ + p95_fast_confirmation_ms_ne?: number; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: lt) + */ + p95_fast_confirmation_ms_lt?: number; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: lte) + */ + p95_fast_confirmation_ms_lte?: number; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: gt) + */ + p95_fast_confirmation_ms_gt?: number; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: gte) + */ + p95_fast_confirmation_ms_gte?: number; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: between_min) + */ + p95_fast_confirmation_ms_between_min?: number; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: between_max_value) + */ + p95_fast_confirmation_ms_between_max_value?: number; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: in_values) (comma-separated list) + */ + p95_fast_confirmation_ms_in_values?: string; + /** + * 95th percentile milliseconds from slot start to fast confirmation (filter: not_in_values) (comma-separated list) + */ + p95_fast_confirmation_ms_not_in_values?: string; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: eq) + */ + p99_fast_confirmation_ms_eq?: number; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: ne) + */ + p99_fast_confirmation_ms_ne?: number; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: lt) + */ + p99_fast_confirmation_ms_lt?: number; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: lte) + */ + p99_fast_confirmation_ms_lte?: number; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: gt) + */ + p99_fast_confirmation_ms_gt?: number; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: gte) + */ + p99_fast_confirmation_ms_gte?: number; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: between_min) + */ + p99_fast_confirmation_ms_between_min?: number; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: between_max_value) + */ + p99_fast_confirmation_ms_between_max_value?: number; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: in_values) (comma-separated list) + */ + p99_fast_confirmation_ms_in_values?: string; + /** + * 99th percentile milliseconds from slot start to fast confirmation (filter: not_in_values) (comma-separated list) + */ + p99_fast_confirmation_ms_not_in_values?: string; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: eq) + */ + max_fast_confirmation_ms_eq?: number; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: ne) + */ + max_fast_confirmation_ms_ne?: number; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: lt) + */ + max_fast_confirmation_ms_lt?: number; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: lte) + */ + max_fast_confirmation_ms_lte?: number; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: gt) + */ + max_fast_confirmation_ms_gt?: number; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: gte) + */ + max_fast_confirmation_ms_gte?: number; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: between_min) + */ + max_fast_confirmation_ms_between_min?: number; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: between_max_value) + */ + max_fast_confirmation_ms_between_max_value?: number; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: in_values) (comma-separated list) + */ + max_fast_confirmation_ms_in_values?: string; + /** + * Maximum milliseconds from slot start to fast confirmation (filter: not_in_values) (comma-separated list) + */ + max_fast_confirmation_ms_not_in_values?: string; + /** + * Average milliseconds from slot start to finality (filter: eq) + */ + avg_finality_ms_eq?: number; + /** + * Average milliseconds from slot start to finality (filter: ne) + */ + avg_finality_ms_ne?: number; + /** + * Average milliseconds from slot start to finality (filter: lt) + */ + avg_finality_ms_lt?: number; + /** + * Average milliseconds from slot start to finality (filter: lte) + */ + avg_finality_ms_lte?: number; + /** + * Average milliseconds from slot start to finality (filter: gt) + */ + avg_finality_ms_gt?: number; + /** + * Average milliseconds from slot start to finality (filter: gte) + */ + avg_finality_ms_gte?: number; + /** + * Average milliseconds from slot start to finality (filter: between_min) + */ + avg_finality_ms_between_min?: number; + /** + * Average milliseconds from slot start to finality (filter: between_max_value) + */ + avg_finality_ms_between_max_value?: number; + /** + * Average milliseconds from slot start to finality (filter: in_values) (comma-separated list) + */ + avg_finality_ms_in_values?: string; + /** + * Average milliseconds from slot start to finality (filter: not_in_values) (comma-separated list) + */ + avg_finality_ms_not_in_values?: string; + /** + * Minimum milliseconds from slot start to finality (filter: eq) + */ + min_finality_ms_eq?: number; + /** + * Minimum milliseconds from slot start to finality (filter: ne) + */ + min_finality_ms_ne?: number; + /** + * Minimum milliseconds from slot start to finality (filter: lt) + */ + min_finality_ms_lt?: number; + /** + * Minimum milliseconds from slot start to finality (filter: lte) + */ + min_finality_ms_lte?: number; + /** + * Minimum milliseconds from slot start to finality (filter: gt) + */ + min_finality_ms_gt?: number; + /** + * Minimum milliseconds from slot start to finality (filter: gte) + */ + min_finality_ms_gte?: number; + /** + * Minimum milliseconds from slot start to finality (filter: between_min) + */ + min_finality_ms_between_min?: number; + /** + * Minimum milliseconds from slot start to finality (filter: between_max_value) + */ + min_finality_ms_between_max_value?: number; + /** + * Minimum milliseconds from slot start to finality (filter: in_values) (comma-separated list) + */ + min_finality_ms_in_values?: string; + /** + * Minimum milliseconds from slot start to finality (filter: not_in_values) (comma-separated list) + */ + min_finality_ms_not_in_values?: string; + /** + * Median milliseconds from slot start to finality (filter: eq) + */ + p50_finality_ms_eq?: number; + /** + * Median milliseconds from slot start to finality (filter: ne) + */ + p50_finality_ms_ne?: number; + /** + * Median milliseconds from slot start to finality (filter: lt) + */ + p50_finality_ms_lt?: number; + /** + * Median milliseconds from slot start to finality (filter: lte) + */ + p50_finality_ms_lte?: number; + /** + * Median milliseconds from slot start to finality (filter: gt) + */ + p50_finality_ms_gt?: number; + /** + * Median milliseconds from slot start to finality (filter: gte) + */ + p50_finality_ms_gte?: number; + /** + * Median milliseconds from slot start to finality (filter: between_min) + */ + p50_finality_ms_between_min?: number; + /** + * Median milliseconds from slot start to finality (filter: between_max_value) + */ + p50_finality_ms_between_max_value?: number; + /** + * Median milliseconds from slot start to finality (filter: in_values) (comma-separated list) + */ + p50_finality_ms_in_values?: string; + /** + * Median milliseconds from slot start to finality (filter: not_in_values) (comma-separated list) + */ + p50_finality_ms_not_in_values?: string; + /** + * 95th percentile milliseconds from slot start to finality (filter: eq) + */ + p95_finality_ms_eq?: number; + /** + * 95th percentile milliseconds from slot start to finality (filter: ne) + */ + p95_finality_ms_ne?: number; + /** + * 95th percentile milliseconds from slot start to finality (filter: lt) + */ + p95_finality_ms_lt?: number; + /** + * 95th percentile milliseconds from slot start to finality (filter: lte) + */ + p95_finality_ms_lte?: number; + /** + * 95th percentile milliseconds from slot start to finality (filter: gt) + */ + p95_finality_ms_gt?: number; + /** + * 95th percentile milliseconds from slot start to finality (filter: gte) + */ + p95_finality_ms_gte?: number; + /** + * 95th percentile milliseconds from slot start to finality (filter: between_min) + */ + p95_finality_ms_between_min?: number; + /** + * 95th percentile milliseconds from slot start to finality (filter: between_max_value) + */ + p95_finality_ms_between_max_value?: number; + /** + * 95th percentile milliseconds from slot start to finality (filter: in_values) (comma-separated list) + */ + p95_finality_ms_in_values?: string; + /** + * 95th percentile milliseconds from slot start to finality (filter: not_in_values) (comma-separated list) + */ + p95_finality_ms_not_in_values?: string; + /** + * Maximum milliseconds from slot start to finality (filter: eq) + */ + max_finality_ms_eq?: number; + /** + * Maximum milliseconds from slot start to finality (filter: ne) + */ + max_finality_ms_ne?: number; + /** + * Maximum milliseconds from slot start to finality (filter: lt) + */ + max_finality_ms_lt?: number; + /** + * Maximum milliseconds from slot start to finality (filter: lte) + */ + max_finality_ms_lte?: number; + /** + * Maximum milliseconds from slot start to finality (filter: gt) + */ + max_finality_ms_gt?: number; + /** + * Maximum milliseconds from slot start to finality (filter: gte) + */ + max_finality_ms_gte?: number; + /** + * Maximum milliseconds from slot start to finality (filter: between_min) + */ + max_finality_ms_between_min?: number; + /** + * Maximum milliseconds from slot start to finality (filter: between_max_value) + */ + max_finality_ms_between_max_value?: number; + /** + * Maximum milliseconds from slot start to finality (filter: in_values) (comma-separated list) + */ + max_finality_ms_in_values?: string; + /** + * Maximum milliseconds from slot start to finality (filter: not_in_values) (comma-separated list) + */ + max_finality_ms_not_in_values?: string; + /** + * Filter p50_speedup using value + */ + p50_speedup_value?: number; + /** + * The maximum number of fct_block_fast_confirmation_by_client_hourly to return. If unspecified, at most 100 items will be returned. The maximum value is 10000; values above 10000 will be coerced to 10000. + */ + page_size?: number; + /** + * A page token, received from a previous `ListFctBlockFastConfirmationByClientHourly` call. Provide this to retrieve the subsequent page. + */ + page_token?: string; + /** + * The order of results. Format: comma-separated list of fields. Example: "foo,bar" or "foo desc,bar" for descending order on foo. If unspecified, results will be returned in the default order. + */ + order_by?: string; + }; + url: '/api/v1/fct_block_fast_confirmation_by_client_hourly'; +}; + +export type FctBlockFastConfirmationByClientHourlyServiceListErrors = { + /** + * Default error response + */ + default: Status; +}; + +export type FctBlockFastConfirmationByClientHourlyServiceListError = + FctBlockFastConfirmationByClientHourlyServiceListErrors[keyof FctBlockFastConfirmationByClientHourlyServiceListErrors]; + +export type FctBlockFastConfirmationByClientHourlyServiceListResponses = { + /** + * OK + */ + 200: ListFctBlockFastConfirmationByClientHourlyResponse; +}; + +export type FctBlockFastConfirmationByClientHourlyServiceListResponse = + FctBlockFastConfirmationByClientHourlyServiceListResponses[keyof FctBlockFastConfirmationByClientHourlyServiceListResponses]; + +export type FctBlockFastConfirmationByClientHourlyServiceGetData = { + body?: never; + path: { + /** + * Start of the hour period + */ + hour_start_date_time: number; + }; + query?: never; + url: '/api/v1/fct_block_fast_confirmation_by_client_hourly/{hour_start_date_time}'; +}; + +export type FctBlockFastConfirmationByClientHourlyServiceGetErrors = { + /** + * Default error response + */ + default: Status; +}; + +export type FctBlockFastConfirmationByClientHourlyServiceGetError = + FctBlockFastConfirmationByClientHourlyServiceGetErrors[keyof FctBlockFastConfirmationByClientHourlyServiceGetErrors]; + +export type FctBlockFastConfirmationByClientHourlyServiceGetResponses = { + /** + * OK + */ + 200: GetFctBlockFastConfirmationByClientHourlyResponse; +}; + +export type FctBlockFastConfirmationByClientHourlyServiceGetResponse = + FctBlockFastConfirmationByClientHourlyServiceGetResponses[keyof FctBlockFastConfirmationByClientHourlyServiceGetResponses]; + +export type FctBlockFastConfirmationByNodeServiceListData = { + body?: never; + path?: never; + query?: { + /** + * The wall clock time when the slot started (filter: eq) + */ + slot_start_date_time_eq?: number; + /** + * The wall clock time when the slot started (filter: ne) + */ + slot_start_date_time_ne?: number; + /** + * The wall clock time when the slot started (filter: lt) + */ + slot_start_date_time_lt?: number; + /** + * The wall clock time when the slot started (filter: lte) + */ + slot_start_date_time_lte?: number; + /** + * The wall clock time when the slot started (filter: gt) + */ + slot_start_date_time_gt?: number; + /** + * The wall clock time when the slot started (filter: gte) + */ + slot_start_date_time_gte?: number; + /** + * The wall clock time when the slot started (filter: between_min) + */ + slot_start_date_time_between_min?: number; + /** + * The wall clock time when the slot started (filter: between_max_value) + */ + slot_start_date_time_between_max_value?: number; + /** + * The wall clock time when the slot started (filter: in_values) (comma-separated list) + */ + slot_start_date_time_in_values?: string; + /** + * The wall clock time when the slot started (filter: not_in_values) (comma-separated list) + */ + slot_start_date_time_not_in_values?: string; + /** + * Name of the sentry node that emitted the fast confirmation events (filter: eq) + */ + meta_client_name_eq?: string; + /** + * Name of the sentry node that emitted the fast confirmation events (filter: ne) + */ + meta_client_name_ne?: string; + /** + * Name of the sentry node that emitted the fast confirmation events (filter: contains) + */ + meta_client_name_contains?: string; + /** + * Name of the sentry node that emitted the fast confirmation events (filter: starts_with) + */ + meta_client_name_starts_with?: string; + /** + * Name of the sentry node that emitted the fast confirmation events (filter: ends_with) + */ + meta_client_name_ends_with?: string; + /** + * Name of the sentry node that emitted the fast confirmation events (filter: like) + */ + meta_client_name_like?: string; + /** + * Name of the sentry node that emitted the fast confirmation events (filter: not_like) + */ + meta_client_name_not_like?: string; + /** + * Name of the sentry node that emitted the fast confirmation events (filter: in_values) (comma-separated list) + */ + meta_client_name_in_values?: string; + /** + * Name of the sentry node that emitted the fast confirmation events (filter: not_in_values) (comma-separated list) + */ + meta_client_name_not_in_values?: string; + /** + * The beacon block root hash (filter: eq) + */ + block_root_eq?: string; + /** + * The beacon block root hash (filter: ne) + */ + block_root_ne?: string; + /** + * The beacon block root hash (filter: contains) + */ + block_root_contains?: string; + /** + * The beacon block root hash (filter: starts_with) + */ + block_root_starts_with?: string; + /** + * The beacon block root hash (filter: ends_with) + */ + block_root_ends_with?: string; + /** + * The beacon block root hash (filter: like) + */ + block_root_like?: string; + /** + * The beacon block root hash (filter: not_like) + */ + block_root_not_like?: string; + /** + * The beacon block root hash (filter: in_values) (comma-separated list) + */ + block_root_in_values?: string; + /** + * The beacon block root hash (filter: not_in_values) (comma-separated list) + */ + block_root_not_in_values?: string; + /** + * Timestamp when the record was last updated (filter: eq) + */ + updated_date_time_eq?: number; + /** + * Timestamp when the record was last updated (filter: ne) + */ + updated_date_time_ne?: number; + /** + * Timestamp when the record was last updated (filter: lt) + */ + updated_date_time_lt?: number; + /** + * Timestamp when the record was last updated (filter: lte) + */ + updated_date_time_lte?: number; + /** + * Timestamp when the record was last updated (filter: gt) + */ + updated_date_time_gt?: number; + /** + * Timestamp when the record was last updated (filter: gte) + */ + updated_date_time_gte?: number; + /** + * Timestamp when the record was last updated (filter: between_min) + */ + updated_date_time_between_min?: number; + /** + * Timestamp when the record was last updated (filter: between_max_value) + */ + updated_date_time_between_max_value?: number; + /** + * Timestamp when the record was last updated (filter: in_values) (comma-separated list) + */ + updated_date_time_in_values?: string; + /** + * Timestamp when the record was last updated (filter: not_in_values) (comma-separated list) + */ + updated_date_time_not_in_values?: string; + /** + * The slot number of the block (filter: eq) + */ + slot_eq?: number; + /** + * The slot number of the block (filter: ne) + */ + slot_ne?: number; + /** + * The slot number of the block (filter: lt) + */ + slot_lt?: number; + /** + * The slot number of the block (filter: lte) + */ + slot_lte?: number; + /** + * The slot number of the block (filter: gt) + */ + slot_gt?: number; + /** + * The slot number of the block (filter: gte) + */ + slot_gte?: number; + /** + * The slot number of the block (filter: between_min) + */ + slot_between_min?: number; + /** + * The slot number of the block (filter: between_max_value) + */ + slot_between_max_value?: number; + /** + * The slot number of the block (filter: in_values) (comma-separated list) + */ + slot_in_values?: string; + /** + * The slot number of the block (filter: not_in_values) (comma-separated list) + */ + slot_not_in_values?: string; + /** + * The epoch number containing the slot (filter: eq) + */ + epoch_eq?: number; + /** + * The epoch number containing the slot (filter: ne) + */ + epoch_ne?: number; + /** + * The epoch number containing the slot (filter: lt) + */ + epoch_lt?: number; + /** + * The epoch number containing the slot (filter: lte) + */ + epoch_lte?: number; + /** + * The epoch number containing the slot (filter: gt) + */ + epoch_gt?: number; + /** + * The epoch number containing the slot (filter: gte) + */ + epoch_gte?: number; + /** + * The epoch number containing the slot (filter: between_min) + */ + epoch_between_min?: number; + /** + * The epoch number containing the slot (filter: between_max_value) + */ + epoch_between_max_value?: number; + /** + * The epoch number containing the slot (filter: in_values) (comma-separated list) + */ + epoch_in_values?: string; + /** + * The epoch number containing the slot (filter: not_in_values) (comma-separated list) + */ + epoch_not_in_values?: string; + /** + * The wall clock time when the epoch started (filter: eq) + */ + epoch_start_date_time_eq?: number; + /** + * The wall clock time when the epoch started (filter: ne) + */ + epoch_start_date_time_ne?: number; + /** + * The wall clock time when the epoch started (filter: lt) + */ + epoch_start_date_time_lt?: number; + /** + * The wall clock time when the epoch started (filter: lte) + */ + epoch_start_date_time_lte?: number; + /** + * The wall clock time when the epoch started (filter: gt) + */ + epoch_start_date_time_gt?: number; + /** + * The wall clock time when the epoch started (filter: gte) + */ + epoch_start_date_time_gte?: number; + /** + * The wall clock time when the epoch started (filter: between_min) + */ + epoch_start_date_time_between_min?: number; + /** + * The wall clock time when the epoch started (filter: between_max_value) + */ + epoch_start_date_time_between_max_value?: number; + /** + * The wall clock time when the epoch started (filter: in_values) (comma-separated list) + */ + epoch_start_date_time_in_values?: string; + /** + * The wall clock time when the epoch started (filter: not_in_values) (comma-separated list) + */ + epoch_start_date_time_not_in_values?: string; + /** + * Chain status of the block: canonical, or orphaned when a node fast confirmed a block that did not become canonical (filter: eq) + */ + status_eq?: string; + /** + * Chain status of the block: canonical, or orphaned when a node fast confirmed a block that did not become canonical (filter: ne) + */ + status_ne?: string; + /** + * Chain status of the block: canonical, or orphaned when a node fast confirmed a block that did not become canonical (filter: contains) + */ + status_contains?: string; + /** + * Chain status of the block: canonical, or orphaned when a node fast confirmed a block that did not become canonical (filter: starts_with) + */ + status_starts_with?: string; + /** + * Chain status of the block: canonical, or orphaned when a node fast confirmed a block that did not become canonical (filter: ends_with) + */ + status_ends_with?: string; + /** + * Chain status of the block: canonical, or orphaned when a node fast confirmed a block that did not become canonical (filter: like) + */ + status_like?: string; + /** + * Chain status of the block: canonical, or orphaned when a node fast confirmed a block that did not become canonical (filter: not_like) + */ + status_not_like?: string; + /** + * Chain status of the block: canonical, or orphaned when a node fast confirmed a block that did not become canonical (filter: in_values) (comma-separated list) + */ + status_in_values?: string; + /** + * Chain status of the block: canonical, or orphaned when a node fast confirmed a block that did not become canonical (filter: not_in_values) (comma-separated list) + */ + status_not_in_values?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: eq) + */ + meta_consensus_implementation_eq?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: ne) + */ + meta_consensus_implementation_ne?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: contains) + */ + meta_consensus_implementation_contains?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: starts_with) + */ + meta_consensus_implementation_starts_with?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: ends_with) + */ + meta_consensus_implementation_ends_with?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: like) + */ + meta_consensus_implementation_like?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: not_like) + */ + meta_consensus_implementation_not_like?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: in_values) (comma-separated list) + */ + meta_consensus_implementation_in_values?: string; + /** + * Consensus client implementation running the fast confirmation rule (filter: not_in_values) (comma-separated list) + */ + meta_consensus_implementation_not_in_values?: string; + /** + * Consensus client version running the fast confirmation rule (filter: eq) + */ + meta_consensus_version_eq?: string; + /** + * Consensus client version running the fast confirmation rule (filter: ne) + */ + meta_consensus_version_ne?: string; + /** + * Consensus client version running the fast confirmation rule (filter: contains) + */ + meta_consensus_version_contains?: string; + /** + * Consensus client version running the fast confirmation rule (filter: starts_with) + */ + meta_consensus_version_starts_with?: string; + /** + * Consensus client version running the fast confirmation rule (filter: ends_with) + */ + meta_consensus_version_ends_with?: string; + /** + * Consensus client version running the fast confirmation rule (filter: like) + */ + meta_consensus_version_like?: string; + /** + * Consensus client version running the fast confirmation rule (filter: not_like) + */ + meta_consensus_version_not_like?: string; + /** + * Consensus client version running the fast confirmation rule (filter: in_values) (comma-separated list) + */ + meta_consensus_version_in_values?: string; + /** + * Consensus client version running the fast confirmation rule (filter: not_in_values) (comma-separated list) + */ + meta_consensus_version_not_in_values?: string; + /** + * How the block was fast confirmed: direct (an event for this block), descendant (only implied by an event for a later block), or unconfirmed (no confirmation seen within 30 minutes) (filter: eq) + */ + confirmation_type_eq?: string; + /** + * How the block was fast confirmed: direct (an event for this block), descendant (only implied by an event for a later block), or unconfirmed (no confirmation seen within 30 minutes) (filter: ne) + */ + confirmation_type_ne?: string; + /** + * How the block was fast confirmed: direct (an event for this block), descendant (only implied by an event for a later block), or unconfirmed (no confirmation seen within 30 minutes) (filter: contains) + */ + confirmation_type_contains?: string; + /** + * How the block was fast confirmed: direct (an event for this block), descendant (only implied by an event for a later block), or unconfirmed (no confirmation seen within 30 minutes) (filter: starts_with) + */ + confirmation_type_starts_with?: string; + /** + * How the block was fast confirmed: direct (an event for this block), descendant (only implied by an event for a later block), or unconfirmed (no confirmation seen within 30 minutes) (filter: ends_with) + */ + confirmation_type_ends_with?: string; + /** + * How the block was fast confirmed: direct (an event for this block), descendant (only implied by an event for a later block), or unconfirmed (no confirmation seen within 30 minutes) (filter: like) + */ + confirmation_type_like?: string; + /** + * How the block was fast confirmed: direct (an event for this block), descendant (only implied by an event for a later block), or unconfirmed (no confirmation seen within 30 minutes) (filter: not_like) + */ + confirmation_type_not_like?: string; + /** + * How the block was fast confirmed: direct (an event for this block), descendant (only implied by an event for a later block), or unconfirmed (no confirmation seen within 30 minutes) (filter: in_values) (comma-separated list) + */ + confirmation_type_in_values?: string; + /** + * How the block was fast confirmed: direct (an event for this block), descendant (only implied by an event for a later block), or unconfirmed (no confirmation seen within 30 minutes) (filter: not_in_values) (comma-separated list) + */ + confirmation_type_not_in_values?: string; + /** + * Milliseconds from slot start until the node fast confirmed this block, directly or through a descendant (filter: eq) + */ + fast_confirmed_slot_start_diff_eq?: number; + /** + * Milliseconds from slot start until the node fast confirmed this block, directly or through a descendant (filter: ne) + */ + fast_confirmed_slot_start_diff_ne?: number; + /** + * Milliseconds from slot start until the node fast confirmed this block, directly or through a descendant (filter: lt) + */ + fast_confirmed_slot_start_diff_lt?: number; + /** + * Milliseconds from slot start until the node fast confirmed this block, directly or through a descendant (filter: lte) + */ + fast_confirmed_slot_start_diff_lte?: number; + /** + * Milliseconds from slot start until the node fast confirmed this block, directly or through a descendant (filter: gt) + */ + fast_confirmed_slot_start_diff_gt?: number; + /** + * Milliseconds from slot start until the node fast confirmed this block, directly or through a descendant (filter: gte) + */ + fast_confirmed_slot_start_diff_gte?: number; + /** + * Milliseconds from slot start until the node fast confirmed this block, directly or through a descendant (filter: between_min) + */ + fast_confirmed_slot_start_diff_between_min?: number; + /** + * Milliseconds from slot start until the node fast confirmed this block, directly or through a descendant (filter: between_max_value) + */ + fast_confirmed_slot_start_diff_between_max_value?: number; + /** + * Milliseconds from slot start until the node fast confirmed this block, directly or through a descendant (filter: in_values) (comma-separated list) + */ + fast_confirmed_slot_start_diff_in_values?: string; + /** + * Milliseconds from slot start until the node fast confirmed this block, directly or through a descendant (filter: not_in_values) (comma-separated list) + */ + fast_confirmed_slot_start_diff_not_in_values?: string; + /** + * Slot of the block whose fast confirmation event first covered this block. Equals slot for direct confirmations (filter: eq) + */ + fast_confirmation_slot_eq?: number; + /** + * Slot of the block whose fast confirmation event first covered this block. Equals slot for direct confirmations (filter: ne) + */ + fast_confirmation_slot_ne?: number; + /** + * Slot of the block whose fast confirmation event first covered this block. Equals slot for direct confirmations (filter: lt) + */ + fast_confirmation_slot_lt?: number; + /** + * Slot of the block whose fast confirmation event first covered this block. Equals slot for direct confirmations (filter: lte) + */ + fast_confirmation_slot_lte?: number; + /** + * Slot of the block whose fast confirmation event first covered this block. Equals slot for direct confirmations (filter: gt) + */ + fast_confirmation_slot_gt?: number; + /** + * Slot of the block whose fast confirmation event first covered this block. Equals slot for direct confirmations (filter: gte) + */ + fast_confirmation_slot_gte?: number; + /** + * Slot of the block whose fast confirmation event first covered this block. Equals slot for direct confirmations (filter: between_min) + */ + fast_confirmation_slot_between_min?: number; + /** + * Slot of the block whose fast confirmation event first covered this block. Equals slot for direct confirmations (filter: between_max_value) + */ + fast_confirmation_slot_between_max_value?: number; + /** + * Slot of the block whose fast confirmation event first covered this block. Equals slot for direct confirmations (filter: in_values) (comma-separated list) + */ + fast_confirmation_slot_in_values?: string; + /** + * Slot of the block whose fast confirmation event first covered this block. Equals slot for direct confirmations (filter: not_in_values) (comma-separated list) + */ + fast_confirmation_slot_not_in_values?: string; + /** + * Milliseconds from slot start until the first sentry observed a finalized checkpoint covering this block (filter: eq) + */ + finalized_slot_start_diff_eq?: number; + /** + * Milliseconds from slot start until the first sentry observed a finalized checkpoint covering this block (filter: ne) + */ + finalized_slot_start_diff_ne?: number; + /** + * Milliseconds from slot start until the first sentry observed a finalized checkpoint covering this block (filter: lt) + */ + finalized_slot_start_diff_lt?: number; + /** + * Milliseconds from slot start until the first sentry observed a finalized checkpoint covering this block (filter: lte) + */ + finalized_slot_start_diff_lte?: number; + /** + * Milliseconds from slot start until the first sentry observed a finalized checkpoint covering this block (filter: gt) + */ + finalized_slot_start_diff_gt?: number; + /** + * Milliseconds from slot start until the first sentry observed a finalized checkpoint covering this block (filter: gte) + */ + finalized_slot_start_diff_gte?: number; + /** + * Milliseconds from slot start until the first sentry observed a finalized checkpoint covering this block (filter: between_min) + */ + finalized_slot_start_diff_between_min?: number; + /** + * Milliseconds from slot start until the first sentry observed a finalized checkpoint covering this block (filter: between_max_value) + */ + finalized_slot_start_diff_between_max_value?: number; + /** + * Milliseconds from slot start until the first sentry observed a finalized checkpoint covering this block (filter: in_values) (comma-separated list) + */ + finalized_slot_start_diff_in_values?: string; + /** + * Milliseconds from slot start until the first sentry observed a finalized checkpoint covering this block (filter: not_in_values) (comma-separated list) + */ + finalized_slot_start_diff_not_in_values?: string; + /** + * Epoch of the finalized checkpoint that first covered this block (filter: eq) + */ + finalized_epoch_eq?: number; + /** + * Epoch of the finalized checkpoint that first covered this block (filter: ne) + */ + finalized_epoch_ne?: number; + /** + * Epoch of the finalized checkpoint that first covered this block (filter: lt) + */ + finalized_epoch_lt?: number; + /** + * Epoch of the finalized checkpoint that first covered this block (filter: lte) + */ + finalized_epoch_lte?: number; + /** + * Epoch of the finalized checkpoint that first covered this block (filter: gt) + */ + finalized_epoch_gt?: number; + /** + * Epoch of the finalized checkpoint that first covered this block (filter: gte) + */ + finalized_epoch_gte?: number; + /** + * Epoch of the finalized checkpoint that first covered this block (filter: between_min) + */ + finalized_epoch_between_min?: number; + /** + * Epoch of the finalized checkpoint that first covered this block (filter: between_max_value) + */ + finalized_epoch_between_max_value?: number; + /** + * Epoch of the finalized checkpoint that first covered this block (filter: in_values) (comma-separated list) + */ + finalized_epoch_in_values?: string; + /** + * Epoch of the finalized checkpoint that first covered this block (filter: not_in_values) (comma-separated list) + */ + finalized_epoch_not_in_values?: string; + /** + * The maximum number of fct_block_fast_confirmation_by_node to return. If unspecified, at most 100 items will be returned. The maximum value is 10000; values above 10000 will be coerced to 10000. + */ + page_size?: number; + /** + * A page token, received from a previous `ListFctBlockFastConfirmationByNode` call. Provide this to retrieve the subsequent page. + */ + page_token?: string; + /** + * The order of results. Format: comma-separated list of fields. Example: "foo,bar" or "foo desc,bar" for descending order on foo. If unspecified, results will be returned in the default order. + */ + order_by?: string; + }; + url: '/api/v1/fct_block_fast_confirmation_by_node'; +}; + +export type FctBlockFastConfirmationByNodeServiceListErrors = { + /** + * Default error response + */ + default: Status; +}; + +export type FctBlockFastConfirmationByNodeServiceListError = + FctBlockFastConfirmationByNodeServiceListErrors[keyof FctBlockFastConfirmationByNodeServiceListErrors]; + +export type FctBlockFastConfirmationByNodeServiceListResponses = { + /** + * OK + */ + 200: ListFctBlockFastConfirmationByNodeResponse; +}; + +export type FctBlockFastConfirmationByNodeServiceListResponse = + FctBlockFastConfirmationByNodeServiceListResponses[keyof FctBlockFastConfirmationByNodeServiceListResponses]; + +export type FctBlockFastConfirmationByNodeServiceGetData = { + body?: never; + path: { + /** + * The wall clock time when the slot started + */ + slot_start_date_time: number; + }; + query?: never; + url: '/api/v1/fct_block_fast_confirmation_by_node/{slot_start_date_time}'; +}; + +export type FctBlockFastConfirmationByNodeServiceGetErrors = { + /** + * Default error response + */ + default: Status; +}; + +export type FctBlockFastConfirmationByNodeServiceGetError = + FctBlockFastConfirmationByNodeServiceGetErrors[keyof FctBlockFastConfirmationByNodeServiceGetErrors]; + +export type FctBlockFastConfirmationByNodeServiceGetResponses = { + /** + * OK + */ + 200: GetFctBlockFastConfirmationByNodeResponse; +}; + +export type FctBlockFastConfirmationByNodeServiceGetResponse = + FctBlockFastConfirmationByNodeServiceGetResponses[keyof FctBlockFastConfirmationByNodeServiceGetResponses]; + export type FctBlockFirstSeenByNodeServiceListData = { body?: never; path?: never; diff --git a/src/api/zod.gen.ts b/src/api/zod.gen.ts index 89ed2b8d7..55e55ddd4 100644 --- a/src/api/zod.gen.ts +++ b/src/api/zod.gen.ts @@ -139297,3 +139297,3988 @@ export const zIntTransactionResourceGasServiceGetData = z.object({ * OK */ export const zIntTransactionResourceGasServiceGetResponse = zGetIntTransactionResourceGasResponse; + +export const zFctBlockFastConfirmationByClientDaily = z.object({ + avg_fast_confirmation_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_finality_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + day_start_date: z.optional(z.string()), + descendant_count: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + direct_count: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_fast_confirmation_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_finality_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + meta_consensus_implementation: z.optional(z.string()), + min_fast_confirmation_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_finality_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + node_count: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + observation_count: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + orphaned_count: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_fast_confirmation_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_finality_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_speedup: z.optional(z.number()), + p90_fast_confirmation_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_fast_confirmation_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_finality_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p99_fast_confirmation_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_count: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + unconfirmed_count: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), +}); + +export const zFctBlockFastConfirmationByClientHourly = z.object({ + avg_fast_confirmation_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_finality_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + descendant_count: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + direct_count: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + hour_start_date_time: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_fast_confirmation_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_finality_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + meta_consensus_implementation: z.optional(z.string()), + min_fast_confirmation_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_finality_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + node_count: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + observation_count: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + orphaned_count: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_fast_confirmation_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_finality_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_speedup: z.optional(z.number()), + p90_fast_confirmation_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_fast_confirmation_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_finality_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p99_fast_confirmation_ms: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_count: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + unconfirmed_count: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), +}); + +export const zFctBlockFastConfirmationByNode = z.object({ + block_root: z.optional(z.string()), + confirmation_type: z.optional(z.string()), + epoch: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_start_date_time: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + fast_confirmation_slot: z.optional( + z.union([ + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ), + z.null(), + ]) + ), + fast_confirmed_slot_start_diff: z.optional( + z.union([ + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ), + z.null(), + ]) + ), + finalized_epoch: z.optional( + z.union([ + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ), + z.null(), + ]) + ), + finalized_slot_start_diff: z.optional( + z.union([ + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ), + z.null(), + ]) + ), + meta_client_name: z.optional(z.string()), + meta_consensus_implementation: z.optional(z.string()), + meta_consensus_version: z.optional(z.string()), + slot: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_start_date_time: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + status: z.optional(z.string()), + updated_date_time: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), +}); + +export const zGetFctBlockFastConfirmationByClientDailyResponse = z.object({ + item: z.optional(zFctBlockFastConfirmationByClientDaily), +}); + +/** + * Response for getting a single fct_block_fast_confirmation_by_client_hourly record + */ +export const zGetFctBlockFastConfirmationByClientHourlyResponse = z.object({ + item: z.optional(zFctBlockFastConfirmationByClientHourly), +}); + +/** + * Response for getting a single fct_block_fast_confirmation_by_node record + */ +export const zGetFctBlockFastConfirmationByNodeResponse = z.object({ + item: z.optional(zFctBlockFastConfirmationByNode), +}); + +/** + * Response for getting a single fct_block_first_seen_by_node record + */ +export const zListFctBlockFastConfirmationByClientDailyResponse = z.object({ + fct_block_fast_confirmation_by_client_daily: z.optional(z.array(zFctBlockFastConfirmationByClientDaily)), + next_page_token: z.optional(z.string()), +}); + +/** + * Response for listing fct_block_fast_confirmation_by_client_hourly records + */ +export const zListFctBlockFastConfirmationByClientHourlyResponse = z.object({ + fct_block_fast_confirmation_by_client_hourly: z.optional(z.array(zFctBlockFastConfirmationByClientHourly)), + next_page_token: z.optional(z.string()), +}); + +/** + * Response for listing fct_block_fast_confirmation_by_node records + */ +export const zListFctBlockFastConfirmationByNodeResponse = z.object({ + fct_block_fast_confirmation_by_node: z.optional(z.array(zFctBlockFastConfirmationByNode)), + next_page_token: z.optional(z.string()), +}); + +/** + * Response for listing fct_block_first_seen_by_node records + */ +export const zFctBlockFastConfirmationByClientDailyServiceListData = z.object({ + body: z.optional(z.never()), + path: z.optional(z.never()), + query: z.optional( + z.object({ + day_start_date_eq: z.optional(z.string()), + day_start_date_ne: z.optional(z.string()), + day_start_date_contains: z.optional(z.string()), + day_start_date_starts_with: z.optional(z.string()), + day_start_date_ends_with: z.optional(z.string()), + day_start_date_like: z.optional(z.string()), + day_start_date_not_like: z.optional(z.string()), + day_start_date_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + day_start_date_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_consensus_implementation_eq: z.optional(z.string()), + meta_consensus_implementation_ne: z.optional(z.string()), + meta_consensus_implementation_contains: z.optional(z.string()), + meta_consensus_implementation_starts_with: z.optional(z.string()), + meta_consensus_implementation_ends_with: z.optional(z.string()), + meta_consensus_implementation_like: z.optional(z.string()), + meta_consensus_implementation_not_like: z.optional(z.string()), + meta_consensus_implementation_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_consensus_implementation_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + updated_date_time_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + node_count_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + node_count_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + node_count_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + node_count_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + node_count_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + node_count_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + node_count_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + node_count_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + node_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + node_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + slot_count_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_count_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_count_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_count_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_count_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_count_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_count_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_count_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + slot_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + observation_count_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + observation_count_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + observation_count_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + observation_count_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + observation_count_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + observation_count_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + observation_count_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + observation_count_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + observation_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + observation_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + direct_count_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + direct_count_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + direct_count_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + direct_count_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + direct_count_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + direct_count_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + direct_count_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + direct_count_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + direct_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + direct_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + descendant_count_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + descendant_count_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + descendant_count_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + descendant_count_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + descendant_count_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + descendant_count_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + descendant_count_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + descendant_count_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + descendant_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + descendant_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + unconfirmed_count_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + unconfirmed_count_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + unconfirmed_count_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + unconfirmed_count_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + unconfirmed_count_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + unconfirmed_count_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + unconfirmed_count_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + unconfirmed_count_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + unconfirmed_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + unconfirmed_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + orphaned_count_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + orphaned_count_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + orphaned_count_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + orphaned_count_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + orphaned_count_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + orphaned_count_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + orphaned_count_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + orphaned_count_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + orphaned_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + orphaned_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + avg_fast_confirmation_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_fast_confirmation_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_fast_confirmation_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_fast_confirmation_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_fast_confirmation_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_fast_confirmation_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_fast_confirmation_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_fast_confirmation_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_fast_confirmation_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + avg_fast_confirmation_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + min_fast_confirmation_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_fast_confirmation_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_fast_confirmation_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_fast_confirmation_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_fast_confirmation_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_fast_confirmation_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_fast_confirmation_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_fast_confirmation_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_fast_confirmation_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + min_fast_confirmation_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p50_fast_confirmation_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_fast_confirmation_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_fast_confirmation_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_fast_confirmation_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_fast_confirmation_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_fast_confirmation_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_fast_confirmation_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_fast_confirmation_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_fast_confirmation_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p50_fast_confirmation_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p90_fast_confirmation_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p90_fast_confirmation_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p90_fast_confirmation_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p90_fast_confirmation_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p90_fast_confirmation_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p90_fast_confirmation_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p90_fast_confirmation_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p90_fast_confirmation_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p90_fast_confirmation_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p90_fast_confirmation_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p95_fast_confirmation_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_fast_confirmation_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_fast_confirmation_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_fast_confirmation_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_fast_confirmation_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_fast_confirmation_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_fast_confirmation_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_fast_confirmation_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_fast_confirmation_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p95_fast_confirmation_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p99_fast_confirmation_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p99_fast_confirmation_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p99_fast_confirmation_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p99_fast_confirmation_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p99_fast_confirmation_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p99_fast_confirmation_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p99_fast_confirmation_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p99_fast_confirmation_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p99_fast_confirmation_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p99_fast_confirmation_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + max_fast_confirmation_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_fast_confirmation_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_fast_confirmation_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_fast_confirmation_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_fast_confirmation_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_fast_confirmation_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_fast_confirmation_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_fast_confirmation_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_fast_confirmation_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + max_fast_confirmation_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + avg_finality_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_finality_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_finality_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_finality_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_finality_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_finality_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_finality_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_finality_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_finality_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + avg_finality_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + min_finality_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_finality_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_finality_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_finality_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_finality_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_finality_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_finality_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_finality_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_finality_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + min_finality_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p50_finality_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_finality_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_finality_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_finality_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_finality_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_finality_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_finality_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_finality_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_finality_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p50_finality_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p95_finality_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_finality_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_finality_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_finality_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_finality_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_finality_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_finality_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_finality_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_finality_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p95_finality_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + max_finality_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_finality_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_finality_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_finality_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_finality_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_finality_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_finality_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_finality_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_finality_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + max_finality_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p50_speedup_value: z.optional(z.number()), + page_size: z.optional( + z + .int() + .check( + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + ) + ), + page_token: z.optional(z.string()), + order_by: z.optional(z.string()), + }) + ), +}); + +/** + * OK + */ +export const zFctBlockFastConfirmationByClientDailyServiceListResponse = + zListFctBlockFastConfirmationByClientDailyResponse; + +export const zFctBlockFastConfirmationByClientDailyServiceGetData = z.object({ + body: z.optional(z.never()), + path: z.object({ + day_start_date: z.string(), + }), + query: z.optional(z.never()), +}); + +/** + * OK + */ +export const zFctBlockFastConfirmationByClientDailyServiceGetResponse = + zGetFctBlockFastConfirmationByClientDailyResponse; + +export const zFctBlockFastConfirmationByClientHourlyServiceListData = z.object({ + body: z.optional(z.never()), + path: z.optional(z.never()), + query: z.optional( + z.object({ + hour_start_date_time_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + hour_start_date_time_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + hour_start_date_time_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + hour_start_date_time_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + hour_start_date_time_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + hour_start_date_time_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + hour_start_date_time_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + hour_start_date_time_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + hour_start_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + hour_start_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + meta_consensus_implementation_eq: z.optional(z.string()), + meta_consensus_implementation_ne: z.optional(z.string()), + meta_consensus_implementation_contains: z.optional(z.string()), + meta_consensus_implementation_starts_with: z.optional(z.string()), + meta_consensus_implementation_ends_with: z.optional(z.string()), + meta_consensus_implementation_like: z.optional(z.string()), + meta_consensus_implementation_not_like: z.optional(z.string()), + meta_consensus_implementation_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_consensus_implementation_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + updated_date_time_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + node_count_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + node_count_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + node_count_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + node_count_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + node_count_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + node_count_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + node_count_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + node_count_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + node_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + node_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + slot_count_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_count_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_count_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_count_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_count_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_count_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_count_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_count_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + slot_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + observation_count_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + observation_count_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + observation_count_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + observation_count_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + observation_count_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + observation_count_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + observation_count_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + observation_count_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + observation_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + observation_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + direct_count_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + direct_count_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + direct_count_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + direct_count_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + direct_count_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + direct_count_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + direct_count_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + direct_count_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + direct_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + direct_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + descendant_count_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + descendant_count_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + descendant_count_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + descendant_count_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + descendant_count_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + descendant_count_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + descendant_count_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + descendant_count_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + descendant_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + descendant_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + unconfirmed_count_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + unconfirmed_count_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + unconfirmed_count_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + unconfirmed_count_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + unconfirmed_count_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + unconfirmed_count_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + unconfirmed_count_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + unconfirmed_count_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + unconfirmed_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + unconfirmed_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + orphaned_count_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + orphaned_count_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + orphaned_count_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + orphaned_count_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + orphaned_count_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + orphaned_count_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + orphaned_count_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + orphaned_count_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + orphaned_count_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + orphaned_count_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + avg_fast_confirmation_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_fast_confirmation_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_fast_confirmation_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_fast_confirmation_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_fast_confirmation_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_fast_confirmation_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_fast_confirmation_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_fast_confirmation_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_fast_confirmation_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + avg_fast_confirmation_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + min_fast_confirmation_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_fast_confirmation_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_fast_confirmation_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_fast_confirmation_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_fast_confirmation_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_fast_confirmation_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_fast_confirmation_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_fast_confirmation_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_fast_confirmation_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + min_fast_confirmation_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p50_fast_confirmation_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_fast_confirmation_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_fast_confirmation_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_fast_confirmation_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_fast_confirmation_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_fast_confirmation_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_fast_confirmation_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_fast_confirmation_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_fast_confirmation_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p50_fast_confirmation_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p90_fast_confirmation_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p90_fast_confirmation_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p90_fast_confirmation_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p90_fast_confirmation_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p90_fast_confirmation_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p90_fast_confirmation_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p90_fast_confirmation_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p90_fast_confirmation_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p90_fast_confirmation_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p90_fast_confirmation_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p95_fast_confirmation_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_fast_confirmation_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_fast_confirmation_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_fast_confirmation_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_fast_confirmation_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_fast_confirmation_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_fast_confirmation_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_fast_confirmation_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_fast_confirmation_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p95_fast_confirmation_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p99_fast_confirmation_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p99_fast_confirmation_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p99_fast_confirmation_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p99_fast_confirmation_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p99_fast_confirmation_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p99_fast_confirmation_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p99_fast_confirmation_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p99_fast_confirmation_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p99_fast_confirmation_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p99_fast_confirmation_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + max_fast_confirmation_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_fast_confirmation_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_fast_confirmation_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_fast_confirmation_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_fast_confirmation_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_fast_confirmation_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_fast_confirmation_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_fast_confirmation_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_fast_confirmation_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + max_fast_confirmation_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + avg_finality_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_finality_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_finality_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_finality_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_finality_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_finality_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_finality_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_finality_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + avg_finality_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + avg_finality_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + min_finality_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_finality_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_finality_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_finality_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_finality_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_finality_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_finality_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_finality_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + min_finality_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + min_finality_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p50_finality_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_finality_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_finality_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_finality_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_finality_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_finality_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_finality_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_finality_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p50_finality_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p50_finality_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p95_finality_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_finality_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_finality_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_finality_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_finality_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_finality_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_finality_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_finality_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + p95_finality_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p95_finality_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + max_finality_ms_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_finality_ms_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_finality_ms_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_finality_ms_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_finality_ms_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_finality_ms_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_finality_ms_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_finality_ms_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + max_finality_ms_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + max_finality_ms_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + p50_speedup_value: z.optional(z.number()), + page_size: z.optional( + z + .int() + .check( + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + ) + ), + page_token: z.optional(z.string()), + order_by: z.optional(z.string()), + }) + ), +}); + +/** + * OK + */ +export const zFctBlockFastConfirmationByClientHourlyServiceListResponse = + zListFctBlockFastConfirmationByClientHourlyResponse; + +export const zFctBlockFastConfirmationByClientHourlyServiceGetData = z.object({ + body: z.optional(z.never()), + path: z.object({ + hour_start_date_time: z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ), + }), + query: z.optional(z.never()), +}); + +/** + * OK + */ +export const zFctBlockFastConfirmationByClientHourlyServiceGetResponse = + zGetFctBlockFastConfirmationByClientHourlyResponse; + +export const zFctBlockFastConfirmationByNodeServiceListData = z.object({ + body: z.optional(z.never()), + path: z.optional(z.never()), + query: z.optional( + z.object({ + slot_start_date_time_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_start_date_time_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_start_date_time_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_start_date_time_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_start_date_time_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_start_date_time_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_start_date_time_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_start_date_time_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_start_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + slot_start_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + meta_client_name_eq: z.optional(z.string()), + meta_client_name_ne: z.optional(z.string()), + meta_client_name_contains: z.optional(z.string()), + meta_client_name_starts_with: z.optional(z.string()), + meta_client_name_ends_with: z.optional(z.string()), + meta_client_name_like: z.optional(z.string()), + meta_client_name_not_like: z.optional(z.string()), + meta_client_name_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_client_name_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + block_root_eq: z.optional(z.string()), + block_root_ne: z.optional(z.string()), + block_root_contains: z.optional(z.string()), + block_root_starts_with: z.optional(z.string()), + block_root_ends_with: z.optional(z.string()), + block_root_like: z.optional(z.string()), + block_root_not_like: z.optional(z.string()), + block_root_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + block_root_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + updated_date_time_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + updated_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + updated_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + slot_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + slot_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + slot_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + epoch_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + epoch_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + epoch_start_date_time_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_start_date_time_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_start_date_time_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_start_date_time_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_start_date_time_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_start_date_time_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_start_date_time_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_start_date_time_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + epoch_start_date_time_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + epoch_start_date_time_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + status_eq: z.optional(z.string()), + status_ne: z.optional(z.string()), + status_contains: z.optional(z.string()), + status_starts_with: z.optional(z.string()), + status_ends_with: z.optional(z.string()), + status_like: z.optional(z.string()), + status_not_like: z.optional(z.string()), + status_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + status_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_consensus_implementation_eq: z.optional(z.string()), + meta_consensus_implementation_ne: z.optional(z.string()), + meta_consensus_implementation_contains: z.optional(z.string()), + meta_consensus_implementation_starts_with: z.optional(z.string()), + meta_consensus_implementation_ends_with: z.optional(z.string()), + meta_consensus_implementation_like: z.optional(z.string()), + meta_consensus_implementation_not_like: z.optional(z.string()), + meta_consensus_implementation_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_consensus_implementation_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_consensus_version_eq: z.optional(z.string()), + meta_consensus_version_ne: z.optional(z.string()), + meta_consensus_version_contains: z.optional(z.string()), + meta_consensus_version_starts_with: z.optional(z.string()), + meta_consensus_version_ends_with: z.optional(z.string()), + meta_consensus_version_like: z.optional(z.string()), + meta_consensus_version_not_like: z.optional(z.string()), + meta_consensus_version_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + meta_consensus_version_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + confirmation_type_eq: z.optional(z.string()), + confirmation_type_ne: z.optional(z.string()), + confirmation_type_contains: z.optional(z.string()), + confirmation_type_starts_with: z.optional(z.string()), + confirmation_type_ends_with: z.optional(z.string()), + confirmation_type_like: z.optional(z.string()), + confirmation_type_not_like: z.optional(z.string()), + confirmation_type_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + confirmation_type_not_in_values: z.optional(z.string().check(z.regex(/^[^,]+(,[^,]+)*$/))), + fast_confirmed_slot_start_diff_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + fast_confirmed_slot_start_diff_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + fast_confirmed_slot_start_diff_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + fast_confirmed_slot_start_diff_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + fast_confirmed_slot_start_diff_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + fast_confirmed_slot_start_diff_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + fast_confirmed_slot_start_diff_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + fast_confirmed_slot_start_diff_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + fast_confirmed_slot_start_diff_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + fast_confirmed_slot_start_diff_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + fast_confirmation_slot_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + fast_confirmation_slot_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + fast_confirmation_slot_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + fast_confirmation_slot_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + fast_confirmation_slot_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + fast_confirmation_slot_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + fast_confirmation_slot_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + fast_confirmation_slot_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + fast_confirmation_slot_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + fast_confirmation_slot_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + finalized_slot_start_diff_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + finalized_slot_start_diff_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + finalized_slot_start_diff_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + finalized_slot_start_diff_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + finalized_slot_start_diff_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + finalized_slot_start_diff_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + finalized_slot_start_diff_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + finalized_slot_start_diff_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + finalized_slot_start_diff_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + finalized_slot_start_diff_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + finalized_epoch_eq: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + finalized_epoch_ne: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + finalized_epoch_lt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + finalized_epoch_lte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + finalized_epoch_gt: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + finalized_epoch_gte: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + finalized_epoch_between_min: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + finalized_epoch_between_max_value: z.optional( + z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ) + ), + finalized_epoch_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + finalized_epoch_not_in_values: z.optional(z.string().check(z.regex(/^\d+(,\d+)*$/))), + page_size: z.optional( + z + .int() + .check( + z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), + z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }) + ) + ), + page_token: z.optional(z.string()), + order_by: z.optional(z.string()), + }) + ), +}); + +/** + * OK + */ +export const zFctBlockFastConfirmationByNodeServiceListResponse = zListFctBlockFastConfirmationByNodeResponse; + +export const zFctBlockFastConfirmationByNodeServiceGetData = z.object({ + body: z.optional(z.never()), + path: z.object({ + slot_start_date_time: z + .int() + .check( + z.minimum(0, { error: 'Invalid value: Expected uint32 to be >= 0' }), + z.maximum(4294967295, { error: 'Invalid value: Expected uint32 to be <= 4294967295' }) + ), + }), + query: z.optional(z.never()), +}); + +/** + * OK + */ +export const zFctBlockFastConfirmationByNodeServiceGetResponse = zGetFctBlockFastConfirmationByNodeResponse; diff --git a/src/components/Layout/Sidebar/Sidebar.tsx b/src/components/Layout/Sidebar/Sidebar.tsx index 51c80cea5..4e814654e 100644 --- a/src/components/Layout/Sidebar/Sidebar.tsx +++ b/src/components/Layout/Sidebar/Sidebar.tsx @@ -5,6 +5,7 @@ import { Link } from '@tanstack/react-router'; import clsx from 'clsx'; import { ArchiveBoxXMarkIcon, + BoltIcon, ChartBarIcon, ChevronLeftIcon, ChevronRightIcon, @@ -159,6 +160,7 @@ interface NavItem { const ethereumConsensusPages: NavItem[] = [ { name: 'Overview', to: '/ethereum/consensus/overview', icon: PresentationChartLineIcon }, { name: 'Live', to: '/ethereum/live', icon: PlayCircleIcon }, + { name: 'Fast Confirmation', to: '/ethereum/consensus/fast-confirmation', icon: BoltIcon }, { name: 'Epochs', to: '/ethereum/epochs', icon: ClockIcon }, { name: 'Slots', to: '/ethereum/slots', icon: Square3Stack3DIcon }, { name: 'Entities', to: '/ethereum/entities', icon: UserGroupIcon }, diff --git a/src/pages/ethereum/consensus/fast-confirmation/IndexPage.tsx b/src/pages/ethereum/consensus/fast-confirmation/IndexPage.tsx new file mode 100644 index 000000000..1b91f2c1b --- /dev/null +++ b/src/pages/ethereum/consensus/fast-confirmation/IndexPage.tsx @@ -0,0 +1,263 @@ +import { type JSX, useMemo } from 'react'; +import { useNavigate, useSearch } from '@tanstack/react-router'; +import { useQuery } from '@tanstack/react-query'; +import clsx from 'clsx'; +import { Container } from '@/components/Layout/Container'; +import { Card } from '@/components/Layout/Card'; +import { Header } from '@/components/Layout/Header'; +import { ClientLogo } from '@/components/Ethereum/ClientLogo'; +import { useNetwork } from '@/hooks/useNetwork'; +import { + fctBlockFastConfirmationByClientDailyServiceListOptions, + fctBlockFastConfirmationByClientHourlyServiceListOptions, + fctBlockFastConfirmationByNodeServiceListOptions, +} from '@/api/@tanstack/react-query.gen'; +import { + BlockField, + ClientTable, + ConfirmationDistribution, + EpochDetail, + FastConfirmationSkeleton, + ScarList, +} from './components'; +import { LATE_CONFIRMATION_MS, PAGE_SIZE, RECENT_BLOCK_HOURS } from './constants'; +import { toClientDay, toObservation } from './fast-confirmation.api'; +import { buildField, formatDurationMs, groupStallEpisodes, summarizeClients } from './fast-confirmation.utils'; + +function formatDay(day: string): string { + return new Date(`${day}T00:00:00Z`).toLocaleDateString('en-GB', { + day: 'numeric', + month: 'long', + year: 'numeric', + timeZone: 'UTC', + }); +} + +/** + * Fast Confirmation page: every epoch a fast confirmation node has scored, and how soon + * each block was safe to rely on compared to finality. + */ +export function IndexPage(): JSX.Element { + const navigate = useNavigate({ from: '/ethereum/consensus/fast-confirmation' }); + const search = useSearch({ from: '/ethereum/consensus/fast-confirmation' }); + const { currentNetwork } = useNetwork(); + const genesis = currentNetwork?.genesis_time ?? 0; + const nowSeconds = useMemo(() => Math.floor(Date.now() / 1000), []); + + const dailyQuery = useQuery({ + ...fctBlockFastConfirmationByClientDailyServiceListOptions({ + query: { day_start_date_like: '20%', order_by: 'day_start_date asc', page_size: PAGE_SIZE }, + }), + }); + + const clients = useMemo( + () => summarizeClients((dailyQuery.data?.fct_block_fast_confirmation_by_client_daily ?? []).map(toClientDay)), + [dailyQuery.data] + ); + const client = clients.find(c => c.client === search.client) ?? clients[0]; + + const hourlyQuery = useQuery({ + ...fctBlockFastConfirmationByClientHourlyServiceListOptions({ + query: { + hour_start_date_time_gte: 1, + meta_consensus_implementation_eq: client?.client, + order_by: 'hour_start_date_time asc', + page_size: PAGE_SIZE, + }, + }), + enabled: !!client, + }); + + const lateQuery = useQuery({ + ...fctBlockFastConfirmationByNodeServiceListOptions({ + query: { + slot_start_date_time_gte: 1, + meta_consensus_implementation_eq: client?.client, + fast_confirmed_slot_start_diff_gte: LATE_CONFIRMATION_MS, + order_by: 'slot_start_date_time asc', + page_size: PAGE_SIZE, + }, + }), + enabled: !!client, + }); + + const recentQuery = useQuery({ + ...fctBlockFastConfirmationByNodeServiceListOptions({ + query: { + slot_start_date_time_gte: nowSeconds - (RECENT_BLOCK_HOURS + 3) * 3600, + order_by: 'slot_start_date_time desc', + page_size: PAGE_SIZE, + }, + }), + }); + + const late = useMemo( + () => (lateQuery.data?.fct_block_fast_confirmation_by_node ?? []).map(toObservation), + [lateQuery.data] + ); + + const field = useMemo(() => { + const hours = (hourlyQuery.data?.fct_block_fast_confirmation_by_client_hourly ?? []) + .filter(r => (r.slot_count ?? 0) > 0) + .map(r => r.hour_start_date_time ?? 0); + return buildField(genesis, hours, late); + }, [genesis, hourlyQuery.data, late]); + + const episodes = useMemo(() => groupStallEpisodes(late), [late]); + + const selectedEpoch = useMemo(() => { + if (search.epoch !== undefined && field.byEpoch.has(search.epoch)) return search.epoch; + const worst = [...episodes].sort((a, b) => b.worstMs - a.worstMs)[0]; + return worst ? Math.floor(worst.startSlot / 32) : null; + }, [search.epoch, field, episodes]); + const selected = selectedEpoch !== null ? field.byEpoch.get(selectedEpoch) : undefined; + + const distribution = useMemo(() => { + const rows = (recentQuery.data?.fct_block_fast_confirmation_by_node ?? []).map(toObservation); + const newest = Math.max(0, ...rows.map(r => r.slotStartDateTime)); + const canonical = rows.filter( + r => r.status === 'canonical' && r.slotStartDateTime > newest - RECENT_BLOCK_HOURS * 3600 + ); + return { + fast: canonical.map(r => r.fastConfirmedMs).filter((v): v is number => v !== null), + finalized: canonical.map(r => r.finalizedMs).filter((v): v is number => v !== null), + }; + }, [recentQuery.data]); + + const setSearch = (next: { client?: string; epoch?: number }): void => { + navigate({ search: prev => ({ ...prev, ...next }), replace: true }); + }; + + const isLoading = dailyQuery.isLoading || hourlyQuery.isLoading || lateQuery.isLoading; + const error = dailyQuery.error ?? hourlyQuery.error ?? lateQuery.error; + + return ( + +
+ + {isLoading && } + + {error && ( + +

Failed to load data: {error.message}

+ + )} + + {!isLoading && !error && !client && ( + +

No fast confirmation data for this network yet.

+ + )} + + {!isLoading && client && ( +
+

+ Since {formatDay(client.since)}, our {client.client} node has fast + confirmed {client.blocks.toLocaleString()} blocks. Half of them were + safe to rely on within {formatDurationMs(client.fastMs)}{' '} + of their slot starting. Finality took{' '} + {formatDurationMs(client.finalityMs)}, which is{' '} + {Math.round(client.speedup)} times longer.{' '} + {client.reverted === 0 + ? 'None of those confirmations was ever reverted.' + : `${client.reverted} confirmed blocks were later reorged.`} +

+ +
+ {clients.map(c => ( + + ))} +
+ + +
+
+

Every epoch since {formatDay(client.since)}

+

+ One row per day (UTC), one column per epoch. Each cell is coloured by the slowest of its 32 blocks. + Click a cell to open its blocks. +

+
+ setSearch({ epoch: e.epoch })} /> + {selected && } +
+ + +
+ +
+
+

Scars

+

+ The worst runs of late confirmations. When conditions degrade, the rule waits instead of guessing, + and some blocks are only confirmed once they are final. +

+
+ setSearch({ epoch })} /> +
+ + +
+ + +
+

By client

+ setSearch({ client: c, epoch: undefined })} + /> +
+ + + +
+
+

What it measures

+

+ The time from a block's slot starting until the node's fast confirmation rule marks it + confirmed, either directly or by confirming a later block built on top of it. +

+
+
+

Not the same as finality

+

+ Finality is an economic guarantee: reverting a finalized block burns at least a third of all stake. + Fast confirmation assumes votes arrive on time and less than a quarter of stake is adversarial. +

+
+
+

Where the data comes from

+

+ ethPandaOps sentries subscribe to the beacon node fast confirmation event, joined with canonical + blocks and finalized checkpoints. +

+
+
+ +
+ )} + + ); +} diff --git a/src/pages/ethereum/consensus/fast-confirmation/components/BlockField/BlockField.tsx b/src/pages/ethereum/consensus/fast-confirmation/components/BlockField/BlockField.tsx new file mode 100644 index 000000000..0bbab42d2 --- /dev/null +++ b/src/pages/ethereum/consensus/fast-confirmation/components/BlockField/BlockField.tsx @@ -0,0 +1,175 @@ +import { type JSX, useEffect, useRef, useState } from 'react'; +import clsx from 'clsx'; +import { useThemeColors } from '@/hooks/useThemeColors'; +import { hexToRgba } from '@/utils/color'; +import { formatEpoch } from '@/utils'; +import { type FieldEpoch, type FieldModel, type FieldTier, formatDurationMs } from '../../fast-confirmation.utils'; + +export interface BlockFieldProps { + field: FieldModel; + selectedEpoch: number | null; + onSelect: (epoch: FieldEpoch) => void; +} + +const GUTTER = 64; +const HEADER = 22; + +const TIER_LABELS: Array<{ tier: FieldTier; label: string }> = [ + { tier: 'ok', label: 'Every block within a slot' }, + { tier: 'late', label: 'A block took up to 2 slots' }, + { tier: 'slow', label: 'Up to 2 minutes' }, + { tier: 'stalled', label: 'Stalled for minutes' }, + { tier: 'held', label: 'Held until finality' }, +]; + +function tierColors(colors: ReturnType): Record { + return { + none: 'transparent', + ok: hexToRgba(colors.success, 0.18), + late: hexToRgba(colors.warning, 0.5), + slow: hexToRgba(colors.warning, 0.9), + stalled: hexToRgba(colors.danger, 0.6), + held: colors.danger, + }; +} + +function utcDate(seconds: number): string { + return new Date(seconds * 1000).toLocaleDateString('en-GB', { day: 'numeric', month: 'short', timeZone: 'UTC' }); +} + +function utcTime(seconds: number): string { + return new Date(seconds * 1000).toISOString().slice(11, 16); +} + +/** + * Every epoch the node has scored, one row per UTC day and one column per epoch of the day, + * coloured by the slowest fast confirmation in that epoch. + */ +export function BlockField({ field, selectedEpoch, onSelect }: BlockFieldProps): JSX.Element { + const colors = useThemeColors(); + const wrapRef = useRef(null); + const canvasRef = useRef(null); + const [width, setWidth] = useState(0); + const [hover, setHover] = useState<{ epoch: FieldEpoch; x: number; y: number } | null>(null); + + useEffect(() => { + const el = wrapRef.current; + if (!el) return; + const observer = new ResizeObserver(entries => setWidth(entries[0].contentRect.width)); + observer.observe(el); + return () => observer.disconnect(); + }, []); + + const plotWidth = Math.max(0, width - GUTTER); + const cellW = plotWidth / field.columns; + const cellH = Math.max(3, Math.min(6, cellW)); + const gap = cellW >= 4 ? 1 : 0; + const height = HEADER + field.days.length * cellH; + + useEffect(() => { + const canvas = canvasRef.current; + if (!canvas || plotWidth === 0) return; + const ratio = window.devicePixelRatio || 1; + canvas.width = plotWidth * ratio; + canvas.height = field.days.length * cellH * ratio; + const ctx = canvas.getContext('2d'); + if (!ctx) return; + ctx.scale(ratio, ratio); + ctx.clearRect(0, 0, plotWidth, field.days.length * cellH); + const palette = tierColors(colors); + for (const e of field.epochs) { + if (e.tier === 'none') continue; + ctx.fillStyle = palette[e.tier]; + ctx.fillRect(e.column * cellW, e.day * cellH, Math.max(1, cellW - gap), Math.max(1, cellH - gap)); + } + const selected = selectedEpoch !== null ? field.byEpoch.get(selectedEpoch) : undefined; + if (selected) { + ctx.strokeStyle = colors.foreground; + ctx.lineWidth = 1.5; + ctx.strokeRect(selected.column * cellW - 1.5, selected.day * cellH - 1.5, cellW + 2, cellH + 2); + } + }, [field, colors, plotWidth, cellW, cellH, gap, selectedEpoch]); + + const epochAt = (clientX: number, clientY: number): FieldEpoch | null => { + const rect = canvasRef.current?.getBoundingClientRect(); + if (!rect) return null; + const column = Math.floor((clientX - rect.left) / cellW); + const day = Math.floor((clientY - rect.top) / cellH); + return field.epochs.find(e => e.day === day && e.column === column && e.tier !== 'none') ?? null; + }; + + const monthRows = field.days + .map((start, day) => ({ start, day })) + .filter(({ start }, i) => i === 0 || new Date(start * 1000).getUTCDate() === 1); + + return ( +
+
+ {[0, 6, 12, 18].map(h => ( + + {String(h).padStart(2, '0')}:00 + + ))} + {monthRows.map(({ start, day }) => ( + + {utcDate(start)} + + ))} + { + const epoch = epochAt(e.clientX, e.clientY); + setHover(epoch ? { epoch, x: e.nativeEvent.offsetX + GUTTER, y: e.nativeEvent.offsetY + HEADER } : null); + }} + onMouseLeave={() => setHover(null)} + onClick={e => { + const epoch = epochAt(e.clientX, e.clientY); + if (epoch) onSelect(epoch); + }} + /> + {hover && ( +
+
+ {utcDate(hover.epoch.startTime)}, {utcTime(hover.epoch.startTime)} UTC +
+
Epoch {formatEpoch(hover.epoch.epoch)}
+
+ {hover.epoch.lateBlocks + ? `${hover.epoch.lateBlocks} late block${hover.epoch.lateBlocks > 1 ? 's' : ''}, slowest ${formatDurationMs(hover.epoch.worstMs)}` + : 'Every block fast confirmed within its slot'} +
+
+ )} +
+ +
+ {TIER_LABELS.map(({ tier, label }) => ( + + + {label} + + ))} + + + Node not reporting + +
+
+ ); +} diff --git a/src/pages/ethereum/consensus/fast-confirmation/components/BlockField/index.ts b/src/pages/ethereum/consensus/fast-confirmation/components/BlockField/index.ts new file mode 100644 index 000000000..e158d947c --- /dev/null +++ b/src/pages/ethereum/consensus/fast-confirmation/components/BlockField/index.ts @@ -0,0 +1,2 @@ +export { BlockField } from './BlockField'; +export type { BlockFieldProps } from './BlockField'; diff --git a/src/pages/ethereum/consensus/fast-confirmation/components/ClientTable/ClientTable.tsx b/src/pages/ethereum/consensus/fast-confirmation/components/ClientTable/ClientTable.tsx new file mode 100644 index 000000000..f831ba387 --- /dev/null +++ b/src/pages/ethereum/consensus/fast-confirmation/components/ClientTable/ClientTable.tsx @@ -0,0 +1,62 @@ +import type { JSX } from 'react'; +import clsx from 'clsx'; +import { ClientLogo } from '@/components/Ethereum/ClientLogo'; +import { type ClientSummary, formatDurationMs } from '../../fast-confirmation.utils'; + +export interface ClientTableProps { + clients: ClientSummary[]; + selected: string; + onSelect: (client: string) => void; +} + +/** + * One row per consensus client running the fast confirmation rule, over its whole history. + */ +export function ClientTable({ clients, selected, onSelect }: ClientTableProps): JSX.Element { + return ( +
+ + + + + + + + + + + + + + + {clients.map(c => ( + onSelect(c.client)} + className={clsx( + 'cursor-pointer transition-colors hover:bg-primary/5', + selected === c.client && 'bg-primary/10' + )} + > + + + + + + + + + + ))} + +
ClientReporting sinceBlocksFast confirmedFinalizedSoonerConfirmed directlyReverted
+ + + {c.client} + + {c.since}{c.blocks.toLocaleString()}{formatDurationMs(c.fastMs)}{formatDurationMs(c.finalityMs)}{Math.round(c.speedup)}×{(c.directShare * 100).toFixed(2)}% + {c.reverted} +
+
+ ); +} diff --git a/src/pages/ethereum/consensus/fast-confirmation/components/ClientTable/index.ts b/src/pages/ethereum/consensus/fast-confirmation/components/ClientTable/index.ts new file mode 100644 index 000000000..bcf94a6f0 --- /dev/null +++ b/src/pages/ethereum/consensus/fast-confirmation/components/ClientTable/index.ts @@ -0,0 +1,2 @@ +export { ClientTable } from './ClientTable'; +export type { ClientTableProps } from './ClientTable'; diff --git a/src/pages/ethereum/consensus/fast-confirmation/components/ConfirmationDistribution/ConfirmationDistribution.tsx b/src/pages/ethereum/consensus/fast-confirmation/components/ConfirmationDistribution/ConfirmationDistribution.tsx new file mode 100644 index 000000000..a11cfc95b --- /dev/null +++ b/src/pages/ethereum/consensus/fast-confirmation/components/ConfirmationDistribution/ConfirmationDistribution.tsx @@ -0,0 +1,145 @@ +import { type JSX, useMemo } from 'react'; +import ReactECharts from 'echarts-for-react'; +import { PopoutCard } from '@/components/Layout/PopoutCard'; +import { useThemeColors } from '@/hooks/useThemeColors'; +import { hexToRgba } from '@/utils/color'; +import { formatDurationMs, logHistogram } from '../../fast-confirmation.utils'; + +const MIN_SECONDS = 5; +const MAX_SECONDS = 1800; +const BINS = 72; + +export interface ConfirmationDistributionProps { + fastConfirmedMs: number[]; + finalizedMs: number[]; + subtitle: string; +} + +function tickLabel(seconds: number): string { + if (seconds < 60) return `${seconds}s`; + return `${Math.round(seconds / 60)}m`; +} + +/** + * Log-scale histogram of time to fast confirmation against time to finality. + */ +export function ConfirmationDistribution({ + fastConfirmedMs, + finalizedMs, + subtitle, +}: ConfirmationDistributionProps): JSX.Element { + const colors = useThemeColors(); + + const option = useMemo(() => { + const fast = logHistogram(fastConfirmedMs, MIN_SECONDS, MAX_SECONDS, BINS); + const final = logHistogram(finalizedMs, MIN_SECONDS, MAX_SECONDS, BINS); + const fastTotal = fastConfirmedMs.length || 1; + const finalTotal = finalizedMs.length || 1; + const toShare = (count: number, total: number): number => (count / total) * 100; + + const series = (name: string, color: string, data: Array<[number, number]>): Record => ({ + name, + type: 'line', + smooth: 0.35, + symbol: 'none', + data, + lineStyle: { color, width: 2 }, + itemStyle: { color }, + areaStyle: { + color: { + type: 'linear', + x: 0, + y: 0, + x2: 0, + y2: 1, + colorStops: [ + { offset: 0, color: hexToRgba(color, 0.4) }, + { offset: 1, color: hexToRgba(color, 0.02) }, + ], + }, + }, + }); + + return { + grid: { left: 60, right: 24, top: 40, bottom: 50 }, + legend: { + top: 0, + textStyle: { color: colors.muted }, + data: ['Fast confirmation', 'Finality'], + }, + xAxis: { + type: 'log', + logBase: 10, + min: MIN_SECONDS, + max: MAX_SECONDS, + name: 'Time since slot start', + nameLocation: 'center', + nameGap: 30, + nameTextStyle: { color: colors.muted }, + axisLine: { show: true, lineStyle: { color: colors.border } }, + splitLine: { show: false }, + axisLabel: { color: colors.muted, formatter: (value: number) => tickLabel(value) }, + }, + yAxis: { + type: 'value', + name: 'Share of blocks (%)', + nameLocation: 'center', + nameGap: 40, + nameTextStyle: { color: colors.muted }, + axisLine: { show: true, lineStyle: { color: colors.border } }, + splitLine: { show: false }, + axisLabel: { color: colors.muted }, + }, + tooltip: { + trigger: 'axis', + backgroundColor: colors.surface, + borderColor: colors.border, + textStyle: { color: colors.foreground }, + formatter: (params: Array<{ seriesName: string; value: [number, number]; color: string }>) => { + if (!params.length) return ''; + const header = `${formatDurationMs(params[0].value[0] * 1000)}`; + const rows = params + .filter(p => p.value[1] > 0) + .map(p => `● ${p.seriesName}: ${p.value[1].toFixed(1)}%`); + return [header, ...rows].join('
'); + }, + }, + series: [ + { + ...series( + 'Fast confirmation', + colors.success, + fast.map(b => [b.center, toShare(b.count, fastTotal)]) + ), + markLine: { + silent: true, + symbol: 'none', + label: { color: colors.muted, formatter: '{b}', position: 'insideEndTop' }, + lineStyle: { color: colors.border, type: 'dashed' }, + data: [ + { name: '1 slot', xAxis: 12 }, + { name: '2 epochs', xAxis: 768 }, + ], + }, + }, + series( + 'Finality', + colors.primary, + final.map(b => [b.center, toShare(b.count, finalTotal)]) + ), + ], + }; + }, [colors, fastConfirmedMs, finalizedMs]); + + return ( + + {({ inModal }) => + fastConfirmedMs.length > 0 ? ( + + ) : ( +
No data
+ ) + } + + ); +} diff --git a/src/pages/ethereum/consensus/fast-confirmation/components/ConfirmationDistribution/index.ts b/src/pages/ethereum/consensus/fast-confirmation/components/ConfirmationDistribution/index.ts new file mode 100644 index 000000000..a523358e7 --- /dev/null +++ b/src/pages/ethereum/consensus/fast-confirmation/components/ConfirmationDistribution/index.ts @@ -0,0 +1,2 @@ +export { ConfirmationDistribution } from './ConfirmationDistribution'; +export type { ConfirmationDistributionProps } from './ConfirmationDistribution'; diff --git a/src/pages/ethereum/consensus/fast-confirmation/components/EpochDetail/EpochDetail.tsx b/src/pages/ethereum/consensus/fast-confirmation/components/EpochDetail/EpochDetail.tsx new file mode 100644 index 000000000..534447765 --- /dev/null +++ b/src/pages/ethereum/consensus/fast-confirmation/components/EpochDetail/EpochDetail.tsx @@ -0,0 +1,123 @@ +import type { JSX } from 'react'; +import { useQuery } from '@tanstack/react-query'; +import { Link } from '@tanstack/react-router'; +import clsx from 'clsx'; +import { ClientLogo } from '@/components/Ethereum/ClientLogo'; +import { fctBlockFastConfirmationByNodeServiceListOptions } from '@/api/@tanstack/react-query.gen'; +import { formatEpoch, formatSlot } from '@/utils'; +import { + type FieldEpoch, + EPOCH_SECONDS, + formatDurationMs, + summarizeSlots, + tierForMs, +} from '../../fast-confirmation.utils'; +import { toObservation } from '../../fast-confirmation.api'; + +export interface EpochDetailProps { + epoch: FieldEpoch; +} + +const TIER_CLASS = { + ok: 'bg-success/20', + late: 'bg-warning/50', + slow: 'bg-warning/90', + stalled: 'bg-danger/60', + held: 'bg-danger', + none: 'bg-transparent', +} as const; + +/** + * The 32 slots of one epoch, one row per consensus client, each cell showing how long + * that client took to fast confirm the block. + */ +export function EpochDetail({ epoch }: EpochDetailProps): JSX.Element { + const query = useQuery({ + ...fctBlockFastConfirmationByNodeServiceListOptions({ + query: { + slot_start_date_time_gte: epoch.startTime, + slot_start_date_time_lt: epoch.startTime + EPOCH_SECONDS, + page_size: 1000, + }, + }), + }); + + const slots = summarizeSlots((query.data?.fct_block_fast_confirmation_by_node ?? []).map(toObservation)); + const bySlot = new Map(slots.map(s => [s.slot, s])); + const clients = [...new Set(slots.flatMap(s => s.byClient.map(c => c.client)))].sort(); + const firstSlot = epoch.epoch * 32; + const finalized = slots.map(s => s.finalizedMs).filter((v): v is number => v !== null); + + return ( +
+
+
+ Epoch {formatEpoch(epoch.epoch)} + {new Date(epoch.startTime * 1000).toUTCString().slice(5, 22)} UTC +
+
+ {finalized.length > 0 && ( + <> + Finalized {formatDurationMs(Math.min(...finalized))} to {formatDurationMs(Math.max(...finalized))} after + each slot + + )} +
+
+ + {query.isLoading &&
} + + {!query.isLoading && ( +
+ +
+ {Array.from({ length: 32 }, (_, i) => ( + + {i} + + ))} +
+ {clients.map(client => ( +
+ + + {client} + +
+ {Array.from({ length: 32 }, (_, i) => { + const slot = bySlot.get(firstSlot + i); + const entry = slot?.byClient.find(c => c.client === client); + if (!slot) { + return ( +
+ ); + } + if (!entry) return
; + const tier = + entry.fastConfirmedMs === null + ? 'held' + : entry.fastConfirmedMs < 13_000 + ? 'ok' + : tierForMs(entry.fastConfirmedMs); + return ( +
+ ); + })} +
+
+ ))} +
+ )} +
+ ); +} diff --git a/src/pages/ethereum/consensus/fast-confirmation/components/EpochDetail/index.ts b/src/pages/ethereum/consensus/fast-confirmation/components/EpochDetail/index.ts new file mode 100644 index 000000000..45a279223 --- /dev/null +++ b/src/pages/ethereum/consensus/fast-confirmation/components/EpochDetail/index.ts @@ -0,0 +1,2 @@ +export { EpochDetail } from './EpochDetail'; +export type { EpochDetailProps } from './EpochDetail'; diff --git a/src/pages/ethereum/consensus/fast-confirmation/components/FastConfirmationSkeleton/FastConfirmationSkeleton.tsx b/src/pages/ethereum/consensus/fast-confirmation/components/FastConfirmationSkeleton/FastConfirmationSkeleton.tsx new file mode 100644 index 000000000..73830680c --- /dev/null +++ b/src/pages/ethereum/consensus/fast-confirmation/components/FastConfirmationSkeleton/FastConfirmationSkeleton.tsx @@ -0,0 +1,47 @@ +import type { JSX } from 'react'; +import { Card } from '@/components/Layout/Card'; +import { LoadingContainer } from '@/components/Layout/LoadingContainer'; + +function ChartCardSkeleton({ height }: { height: string }): JSX.Element { + return ( + +
+
+ + +
+ +
+ + ); +} + +/** + * Loading skeleton for the Fast Confirmation page: hero, lattice and chart grid. + */ +export function FastConfirmationSkeleton(): JSX.Element { + return ( +
+ +
+
+ + + +
+ + +
+
+ +
+ +
+ + + + +
+
+ ); +} diff --git a/src/pages/ethereum/consensus/fast-confirmation/components/FastConfirmationSkeleton/index.ts b/src/pages/ethereum/consensus/fast-confirmation/components/FastConfirmationSkeleton/index.ts new file mode 100644 index 000000000..94fac5041 --- /dev/null +++ b/src/pages/ethereum/consensus/fast-confirmation/components/FastConfirmationSkeleton/index.ts @@ -0,0 +1 @@ +export { FastConfirmationSkeleton } from './FastConfirmationSkeleton'; diff --git a/src/pages/ethereum/consensus/fast-confirmation/components/ScarList/ScarList.tsx b/src/pages/ethereum/consensus/fast-confirmation/components/ScarList/ScarList.tsx new file mode 100644 index 000000000..999512ddc --- /dev/null +++ b/src/pages/ethereum/consensus/fast-confirmation/components/ScarList/ScarList.tsx @@ -0,0 +1,58 @@ +import type { JSX } from 'react'; +import clsx from 'clsx'; +import { formatSlot } from '@/utils'; +import { HELD_TO_FINALITY_MS, type StallEpisode, formatDurationMs } from '../../fast-confirmation.utils'; + +export interface ScarListProps { + episodes: StallEpisode[]; + selectedEpoch: number | null; + onSelect: (epoch: number) => void; +} + +const MAX_ROWS = 14; + +/** + * The episodes where the node confirmed blocks late, worst first. Selecting one highlights + * its epoch in the block field. + */ +export function ScarList({ episodes, selectedEpoch, onSelect }: ScarListProps): JSX.Element { + const worst = [...episodes].sort((a, b) => b.worstMs - a.worstMs).slice(0, MAX_ROWS); + + if (!worst.length) { + return

No late confirmations yet.

; + } + + return ( +
    + {worst.map(e => { + const epoch = Math.floor(e.startSlot / 32); + const held = e.worstMs >= HELD_TO_FINALITY_MS; + return ( +
  1. + +
    2. + ); + })} +
+ ); +} diff --git a/src/pages/ethereum/consensus/fast-confirmation/components/ScarList/index.ts b/src/pages/ethereum/consensus/fast-confirmation/components/ScarList/index.ts new file mode 100644 index 000000000..b7f13cd74 --- /dev/null +++ b/src/pages/ethereum/consensus/fast-confirmation/components/ScarList/index.ts @@ -0,0 +1,2 @@ +export { ScarList } from './ScarList'; +export type { ScarListProps } from './ScarList'; diff --git a/src/pages/ethereum/consensus/fast-confirmation/components/index.ts b/src/pages/ethereum/consensus/fast-confirmation/components/index.ts new file mode 100644 index 000000000..688e72c95 --- /dev/null +++ b/src/pages/ethereum/consensus/fast-confirmation/components/index.ts @@ -0,0 +1,6 @@ +export { BlockField } from './BlockField'; +export { ClientTable } from './ClientTable'; +export { ConfirmationDistribution } from './ConfirmationDistribution'; +export { EpochDetail } from './EpochDetail'; +export { FastConfirmationSkeleton } from './FastConfirmationSkeleton'; +export { ScarList } from './ScarList'; diff --git a/src/pages/ethereum/consensus/fast-confirmation/constants.ts b/src/pages/ethereum/consensus/fast-confirmation/constants.ts new file mode 100644 index 000000000..eb64753bd --- /dev/null +++ b/src/pages/ethereum/consensus/fast-confirmation/constants.ts @@ -0,0 +1,20 @@ +import { z } from 'zod'; + +/** Zod schema for fast confirmation search params */ +export const fastConfirmationSearchSchema = z.object({ + client: z.string().optional(), + epoch: z.coerce.number().int().nonnegative().optional(), +}); +export type FastConfirmationSearch = z.infer; + +/** Page size for list queries */ +export const PAGE_SIZE = 10_000; + +/** Hours of per-block data fetched for the distribution */ +export const RECENT_BLOCK_HOURS = 3; + +/** A block fast confirmed later than this (ms after slot start) missed its own slot */ +export const LATE_CONFIRMATION_MS = 13_000; + +/** Late blocks within this many slots of each other belong to the same episode */ +export const STALL_EPISODE_GAP_SLOTS = 32; diff --git a/src/pages/ethereum/consensus/fast-confirmation/fast-confirmation.api.ts b/src/pages/ethereum/consensus/fast-confirmation/fast-confirmation.api.ts new file mode 100644 index 000000000..11191de91 --- /dev/null +++ b/src/pages/ethereum/consensus/fast-confirmation/fast-confirmation.api.ts @@ -0,0 +1,54 @@ +import type { FctBlockFastConfirmationByClientDaily, FctBlockFastConfirmationByNode } from '@/api/types.gen'; +import type { BlockObservation } from './fast-confirmation.utils'; + +/** One client's daily aggregate, with the fields the page uses */ +export interface ClientDay { + day: string; + client: string; + slots: number; + observations: number; + direct: number; + orphaned: number; + unconfirmed: number; + p50FastMs: number; + p99FastMs: number; + maxFastMs: number; + p50FinalityMs: number; +} + +/** + * Map a fct_block_fast_confirmation_by_node row onto a BlockObservation. + */ +export function toObservation(row: FctBlockFastConfirmationByNode): BlockObservation { + return { + slot: row.slot ?? 0, + slotStartDateTime: row.slot_start_date_time ?? 0, + blockRoot: row.block_root ?? '', + status: row.status ?? '', + client: row.meta_consensus_implementation ?? '', + node: row.meta_client_name ?? '', + confirmationType: row.confirmation_type ?? '', + fastConfirmedMs: row.fast_confirmed_slot_start_diff ?? null, + confirmationSlot: row.fast_confirmation_slot ?? null, + finalizedMs: row.finalized_slot_start_diff ?? null, + }; +} + +/** + * Map a fct_block_fast_confirmation_by_client_daily row onto a ClientDay. + */ +export function toClientDay(row: FctBlockFastConfirmationByClientDaily): ClientDay { + return { + day: row.day_start_date ?? '', + client: row.meta_consensus_implementation ?? '', + slots: row.slot_count ?? 0, + observations: row.observation_count ?? 0, + direct: row.direct_count ?? 0, + orphaned: row.orphaned_count ?? 0, + unconfirmed: row.unconfirmed_count ?? 0, + p50FastMs: row.p50_fast_confirmation_ms ?? 0, + p99FastMs: row.p99_fast_confirmation_ms ?? 0, + maxFastMs: row.max_fast_confirmation_ms ?? 0, + p50FinalityMs: row.p50_finality_ms ?? 0, + }; +} diff --git a/src/pages/ethereum/consensus/fast-confirmation/fast-confirmation.utils.test.ts b/src/pages/ethereum/consensus/fast-confirmation/fast-confirmation.utils.test.ts new file mode 100644 index 000000000..c4a9413dd --- /dev/null +++ b/src/pages/ethereum/consensus/fast-confirmation/fast-confirmation.utils.test.ts @@ -0,0 +1,174 @@ +import { describe, expect, it } from 'vitest'; +import { + type BlockObservation, + buildField, + formatDurationMs, + groupStallEpisodes, + logHistogram, + summarizeSlots, + tierForMs, + summarizeClients, +} from './fast-confirmation.utils'; +import type { ClientDay } from './fast-confirmation.api'; + +function obs(overrides: Partial): BlockObservation { + return { + slot: 100, + slotStartDateTime: 1_000, + blockRoot: '0xabc', + status: 'canonical', + client: 'lighthouse', + node: 'node-a', + confirmationType: 'direct', + fastConfirmedMs: 11_560, + confirmationSlot: 100, + finalizedMs: 950_000, + ...overrides, + }; +} + +describe('formatDurationMs', () => { + it('formats sub-second, seconds, minutes and hours', () => { + expect(formatDurationMs(450)).toBe('450ms'); + expect(formatDurationMs(11_563)).toBe('11.6s'); + expect(formatDurationMs(949_000)).toBe('15m 49s'); + expect(formatDurationMs(60_500)).toBe('1m 01s'); + expect(formatDurationMs(3_840_000)).toBe('1h 4m'); + }); + + it('returns a dash for missing values', () => { + expect(formatDurationMs(null)).toBe('-'); + expect(formatDurationMs(undefined)).toBe('-'); + expect(formatDurationMs(Number.NaN)).toBe('-'); + }); +}); + +describe('summarizeSlots', () => { + it('takes the earliest confirmation across nodes and ignores orphaned rows', () => { + const summaries = summarizeSlots([ + obs({ client: 'nimbus', node: 'node-b', fastConfirmedMs: 12_045 }), + obs({}), + obs({ slot: 101, confirmationType: 'descendant', fastConfirmedMs: 30_000 }), + obs({ slot: 101, blockRoot: '0xdef', status: 'orphaned' }), + ]); + + expect(summaries).toHaveLength(2); + expect(summaries[0]).toMatchObject({ slot: 100, epoch: 3, fastConfirmedMs: 11_560, viaDescendant: false }); + expect(summaries[0].byClient.map(c => c.client)).toEqual(['lighthouse', 'nimbus']); + expect(summaries[1]).toMatchObject({ slot: 101, fastConfirmedMs: 30_000, viaDescendant: true }); + }); + + it('keeps one entry per client using the earliest node', () => { + const [summary] = summarizeSlots([ + obs({ client: 'tysm', node: 'tysm-1', fastConfirmedMs: 12_300 }), + obs({ client: 'tysm', node: 'tysm-2', fastConfirmedMs: 12_080 }), + obs({ client: 'tysm', node: 'tysm-3', fastConfirmedMs: null, confirmationType: 'unconfirmed' }), + ]); + expect(summary.byClient).toEqual([{ client: 'tysm', fastConfirmedMs: 12_080, confirmationType: 'direct' }]); + }); + + it('keeps unconfirmed slots with a null confirmation time', () => { + const [summary] = summarizeSlots([obs({ confirmationType: 'unconfirmed', fastConfirmedMs: null })]); + expect(summary.fastConfirmedMs).toBeNull(); + expect(summary.unconfirmed).toBe(true); + }); +}); + +describe('groupStallEpisodes', () => { + it('merges slow slots within an epoch of each other per node, newest first', () => { + const episodes = groupStallEpisodes([ + obs({ slot: 10, fastConfirmedMs: 200_000 }), + obs({ slot: 11, fastConfirmedMs: 190_000 }), + obs({ slot: 13, fastConfirmedMs: 170_000 }), + obs({ slot: 40, fastConfirmedMs: 30_000 }), + obs({ slot: 100, fastConfirmedMs: 30_000 }), + obs({ slot: 12, node: 'node-b', client: 'nimbus', fastConfirmedMs: 25_000 }), + ]); + + expect(episodes.map(e => [e.node, e.startSlot, e.endSlot, e.blocks, e.worstMs])).toEqual([ + ['node-a', 100, 100, 1, 30_000], + ['node-b', 12, 12, 1, 25_000], + ['node-a', 10, 40, 4, 200_000], + ]); + }); +}); + +describe('logHistogram', () => { + it('buckets values into log-spaced bins and clamps outliers', () => { + const buckets = logHistogram([11_000, 12_000, 900_000, 1, 10_000_000], 1, 1000, 3); + expect(buckets.map(b => b.count)).toEqual([1, 2, 2]); + expect(buckets[0].center).toBeCloseTo(10 ** 0.5); + }); +}); + +describe('tierForMs', () => { + it('maps the slowest confirmation to a tier', () => { + expect(tierForMs(null)).toBe('ok'); + expect(tierForMs(13_000)).toBe('late'); + expect(tierForMs(30_000)).toBe('slow'); + expect(tierForMs(210_000)).toBe('stalled'); + expect(tierForMs(779_603)).toBe('held'); + }); +}); + +describe('buildField', () => { + const genesis = 1_606_824_023; + const hourOf = (epoch: number): number => Math.floor((genesis + epoch * 384) / 3600) * 3600; + + it('lays epochs out by UTC day and marks late epochs and gaps', () => { + const start = 478_000; + const hours = [hourOf(start), hourOf(start) + 3600, hourOf(start) + 3 * 3600]; + const field = buildField(genesis, hours, [ + obs({ slot: (start + 3) * 32 + 5, fastConfirmedMs: 30_000 }), + obs({ slot: (start + 3) * 32 + 6, fastConfirmedMs: 13_000 }), + obs({ slot: (start + 4) * 32, fastConfirmedMs: 779_603, status: 'orphaned' }), + ]); + + expect(field.columns).toBe(225); + const late = field.byEpoch.get(start + 3); + expect(late).toMatchObject({ tier: 'slow', worstMs: 30_000, lateBlocks: 2 }); + expect(field.byEpoch.get(start + 4)?.tier).toBe('ok'); + const gap = field.epochs.find(e => Math.floor(e.startTime / 3600) * 3600 === hourOf(start) + 2 * 3600); + expect(gap?.tier).toBe('none'); + for (const e of field.epochs) { + expect(e.column).toBeGreaterThanOrEqual(0); + expect(e.column).toBeLessThan(225); + expect(field.days[e.day]).toBe(Math.floor(e.startTime / 86_400) * 86_400); + } + }); + + it('returns an empty field without coverage', () => { + expect(buildField(genesis, [], []).epochs).toHaveLength(0); + }); +}); + +describe('summarizeClients', () => { + const day = (over: Partial): ClientDay => ({ + day: '2026-09-29', + client: 'lighthouse', + slots: 7000, + observations: 7000, + direct: 6990, + orphaned: 0, + unconfirmed: 0, + p50FastMs: 11_560, + p99FastMs: 12_000, + maxFastMs: 24_000, + p50FinalityMs: 947_000, + ...over, + }); + + it('weights medians by observations and orders clients by blocks', () => { + const [lh, nimbus] = summarizeClients([ + day({ day: '2026-05-14', slots: 1000, observations: 1000, p50FastMs: 11_700 }), + day({}), + day({ client: 'nimbus', slots: 300, observations: 300, direct: 290, p50FastMs: 12_045, maxFastMs: 84_000 }), + ]); + expect(lh.client).toBe('lighthouse'); + expect(lh.since).toBe('2026-05-14'); + expect(lh.blocks).toBe(8000); + expect(lh.fastMs).toBeCloseTo((11_700 * 1000 + 11_560 * 7000) / 8000); + expect(nimbus.directShare).toBeCloseTo(290 / 300); + expect(nimbus.worstMs).toBe(84_000); + }); +}); diff --git a/src/pages/ethereum/consensus/fast-confirmation/fast-confirmation.utils.ts b/src/pages/ethereum/consensus/fast-confirmation/fast-confirmation.utils.ts new file mode 100644 index 000000000..65d369498 --- /dev/null +++ b/src/pages/ethereum/consensus/fast-confirmation/fast-confirmation.utils.ts @@ -0,0 +1,320 @@ +import type { ClientDay } from './fast-confirmation.api'; +import { SLOTS_PER_EPOCH } from '@/utils/beacon'; +import { STALL_EPISODE_GAP_SLOTS } from './constants'; + +/** One (block, node) observation from fct_block_fast_confirmation_by_node */ +export interface BlockObservation { + slot: number; + slotStartDateTime: number; + blockRoot: string; + status: string; + client: string; + node: string; + confirmationType: string; + fastConfirmedMs: number | null; + confirmationSlot: number | null; + finalizedMs: number | null; +} + +/** Per-slot summary across every fast confirmation node */ +export interface SlotSummary { + slot: number; + epoch: number; + slotStartDateTime: number; + blockRoot: string; + /** Earliest fast confirmation across nodes, in ms after slot start */ + fastConfirmedMs: number | null; + finalizedMs: number | null; + /** True when at least one node only confirmed the block through a descendant */ + viaDescendant: boolean; + /** True when a node that was following the chain never fast confirmed the block */ + unconfirmed: boolean; + byClient: Array<{ client: string; fastConfirmedMs: number | null; confirmationType: string }>; +} + +/** A run of slow or indirect confirmations on one node */ +export interface StallEpisode { + node: string; + client: string; + startSlot: number; + endSlot: number; + startDateTime: number; + blocks: number; + worstMs: number; +} + +/** + * Format a duration in milliseconds for display, e.g. "11.6s", "15m 49s", "1h 4m". + */ +export function formatDurationMs(ms: number | null | undefined): string { + if (ms === null || ms === undefined || !Number.isFinite(ms)) return '-'; + if (ms < 1000) return `${Math.round(ms)}ms`; + + const seconds = ms / 1000; + if (seconds < 60) return `${seconds.toFixed(1)}s`; + + const totalSeconds = Math.round(seconds); + const hours = Math.floor(totalSeconds / 3600); + const minutes = Math.floor((totalSeconds % 3600) / 60); + const secs = totalSeconds % 60; + if (hours > 0) return `${hours}h ${minutes}m`; + + return `${minutes}m ${secs.toString().padStart(2, '0')}s`; +} + +/** + * Collapse per-node observations into one summary per canonical slot. + */ +export function summarizeSlots(observations: BlockObservation[]): SlotSummary[] { + const bySlot = new Map(); + for (const obs of observations) { + if (obs.status !== 'canonical') continue; + const list = bySlot.get(obs.slot); + if (list) list.push(obs); + else bySlot.set(obs.slot, [obs]); + } + + const summaries: SlotSummary[] = []; + for (const [slot, list] of bySlot) { + const confirmed = list.map(o => o.fastConfirmedMs).filter((v): v is number => v !== null); + const finalized = list.map(o => o.finalizedMs).filter((v): v is number => v !== null); + summaries.push({ + slot, + epoch: Math.floor(slot / SLOTS_PER_EPOCH), + slotStartDateTime: list[0].slotStartDateTime, + blockRoot: list[0].blockRoot, + fastConfirmedMs: confirmed.length ? Math.min(...confirmed) : null, + finalizedMs: finalized.length ? Math.min(...finalized) : null, + viaDescendant: list.some(o => o.confirmationType === 'descendant'), + unconfirmed: list.some(o => o.confirmationType === 'unconfirmed'), + byClient: earliestByClient(list), + }); + } + + return summaries.sort((a, b) => a.slot - b.slot); +} + +/** One entry per client with its earliest confirmation across that client's nodes. */ +function earliestByClient(list: BlockObservation[]): SlotSummary['byClient'] { + const byClient = new Map(); + for (const o of list) { + const current = byClient.get(o.client); + const earlier = + o.fastConfirmedMs !== null && + (current?.fastConfirmedMs === null || o.fastConfirmedMs < (current?.fastConfirmedMs ?? Infinity)); + if (!current || earlier) { + byClient.set(o.client, { + client: o.client, + fastConfirmedMs: o.fastConfirmedMs, + confirmationType: o.confirmationType, + }); + } + } + return [...byClient.values()].sort((a, b) => a.client.localeCompare(b.client)); +} + +/** + * Group slow or indirect confirmations into stall episodes per node, newest first. + */ +export function groupStallEpisodes(observations: BlockObservation[]): StallEpisode[] { + const byNode = new Map(); + for (const obs of observations) { + if (obs.status !== 'canonical') continue; + const list = byNode.get(obs.node); + if (list) list.push(obs); + else byNode.set(obs.node, [obs]); + } + + const episodes: StallEpisode[] = []; + for (const [node, list] of byNode) { + list.sort((a, b) => a.slot - b.slot); + let current: StallEpisode | null = null; + for (const obs of list) { + const ms = obs.fastConfirmedMs ?? Number.POSITIVE_INFINITY; + if (current && obs.slot - current.endSlot <= STALL_EPISODE_GAP_SLOTS) { + current.endSlot = obs.slot; + current.blocks += 1; + current.worstMs = Math.max(current.worstMs, ms); + continue; + } + current = { + node, + client: obs.client, + startSlot: obs.slot, + endSlot: obs.slot, + startDateTime: obs.slotStartDateTime, + blocks: 1, + worstMs: ms, + }; + episodes.push(current); + } + } + + return episodes.sort((a, b) => b.startSlot - a.startSlot); +} + +/** One bucket of a log-spaced histogram */ +export interface LogBucket { + /** Geometric centre of the bucket in seconds */ + center: number; + count: number; +} + +/** + * Bucket millisecond values into log-spaced bins between minSeconds and maxSeconds. + * Values outside the range are clamped into the edge bins. + */ +export function logHistogram(valuesMs: number[], minSeconds: number, maxSeconds: number, bins: number): LogBucket[] { + const logMin = Math.log10(minSeconds); + const logMax = Math.log10(maxSeconds); + const step = (logMax - logMin) / bins; + const counts = new Array(bins).fill(0); + + for (const ms of valuesMs) { + if (!Number.isFinite(ms) || ms <= 0) continue; + const idx = Math.floor((Math.log10(ms / 1000) - logMin) / step); + counts[Math.min(bins - 1, Math.max(0, idx))] += 1; + } + + return counts.map((count, i) => ({ center: 10 ** (logMin + step * (i + 0.5)), count })); +} + +/** Colour tier of one epoch in the block field */ +export type FieldTier = 'none' | 'ok' | 'late' | 'slow' | 'stalled' | 'held'; + +/** Seconds in one epoch */ +export const EPOCH_SECONDS = 384; + +/** A confirmation this slow means the node only confirmed the block once it was finalized */ +export const HELD_TO_FINALITY_MS = 700_000; + +/** + * Tier for the slowest fast confirmation seen in an epoch. + */ +export function tierForMs(worstMs: number | null): FieldTier { + if (worstMs === null) return 'ok'; + if (worstMs >= HELD_TO_FINALITY_MS) return 'held'; + if (worstMs >= 120_000) return 'stalled'; + if (worstMs >= 25_000) return 'slow'; + return 'late'; +} + +/** One epoch in the block field */ +export interface FieldEpoch { + epoch: number; + startTime: number; + day: number; + column: number; + tier: FieldTier; + worstMs: number | null; + lateBlocks: number; +} + +/** Every epoch between the first and last covered hour, laid out as UTC days by epoch of day */ +export interface FieldModel { + days: number[]; + columns: number; + epochs: FieldEpoch[]; + byEpoch: Map; +} + +/** + * Lay out every epoch covered by the node as rows of UTC days and columns of epoch-of-day. + * Coverage is hourly, taken from the hours where the node scored at least one block. + * Late observations (slow confirmations) set the tier of their epoch. + */ +export function buildField(genesis: number, coveredHours: number[], late: BlockObservation[]): FieldModel { + const covered = new Set(coveredHours); + const columns = Math.round(86_400 / EPOCH_SECONDS); + if (!covered.size) return { days: [], columns, epochs: [], byEpoch: new Map() }; + + const lateByEpoch = new Map }>(); + for (const o of late) { + if (o.status !== 'canonical') continue; + const epoch = Math.floor(o.slot / 32); + const entry = lateByEpoch.get(epoch) ?? { worstMs: 0, blocks: new Set() }; + entry.worstMs = Math.max(entry.worstMs, o.fastConfirmedMs ?? Number.POSITIVE_INFINITY); + entry.blocks.add(o.slot); + lateByEpoch.set(epoch, entry); + } + + const first = Math.min(...covered); + const last = Math.max(...covered) + 3600; + const firstEpoch = Math.ceil((first - genesis) / EPOCH_SECONDS); + const lastEpoch = Math.floor((last - genesis) / EPOCH_SECONDS) - 1; + const firstDay = Math.floor((genesis + firstEpoch * EPOCH_SECONDS) / 86_400) * 86_400; + + const epochs: FieldEpoch[] = []; + const dayStarts = new Set(); + for (let epoch = firstEpoch; epoch <= lastEpoch; epoch++) { + const startTime = genesis + epoch * EPOCH_SECONDS; + const hour = Math.floor(startTime / 3600) * 3600; + const dayStart = Math.floor(startTime / 86_400) * 86_400; + const lateEntry = lateByEpoch.get(epoch); + dayStarts.add(dayStart); + epochs.push({ + epoch, + startTime, + day: (dayStart - firstDay) / 86_400, + column: Math.min(columns - 1, Math.floor((startTime - dayStart) / EPOCH_SECONDS)), + tier: covered.has(hour) ? tierForMs(lateEntry ? lateEntry.worstMs : null) : 'none', + worstMs: lateEntry ? lateEntry.worstMs : null, + lateBlocks: lateEntry ? lateEntry.blocks.size : 0, + }); + } + + return { + days: [...dayStarts].sort((a, b) => a - b), + columns, + epochs, + byEpoch: new Map(epochs.map(e => [e.epoch, e])), + }; +} + +/** Whole-history summary of one client, built from its daily aggregates */ +export interface ClientSummary { + client: string; + since: string; + blocks: number; + fastMs: number; + finalityMs: number; + speedup: number; + directShare: number; + reverted: number; + worstMs: number; +} + +/** + * Summarise each client's daily aggregates, weighting daily medians by blocks scored. + */ +export function summarizeClients(days: ClientDay[]): ClientSummary[] { + const byClient = new Map(); + for (const d of days) { + if (!d.client || d.observations === 0) continue; + const list = byClient.get(d.client); + if (list) list.push(d); + else byClient.set(d.client, [d]); + } + + return [...byClient.entries()] + .map(([client, list]) => { + const blocks = list.reduce((sum, d) => sum + d.slots, 0); + const weight = list.reduce((sum, d) => sum + d.observations, 0); + const weighted = (pick: (d: ClientDay) => number): number => + list.reduce((sum, d) => sum + pick(d) * d.observations, 0) / weight; + const fastMs = weighted(d => d.p50FastMs); + const finalityMs = weighted(d => d.p50FinalityMs); + return { + client, + since: list.map(d => d.day).sort()[0], + blocks, + fastMs, + finalityMs, + speedup: fastMs > 0 ? finalityMs / fastMs : 0, + directShare: list.reduce((sum, d) => sum + d.direct, 0) / weight, + reverted: list.reduce((sum, d) => sum + d.orphaned, 0), + worstMs: Math.max(...list.map(d => d.maxFastMs)), + }; + }) + .sort((a, b) => b.blocks - a.blocks); +} diff --git a/src/pages/ethereum/consensus/fast-confirmation/index.ts b/src/pages/ethereum/consensus/fast-confirmation/index.ts new file mode 100644 index 000000000..b36af7308 --- /dev/null +++ b/src/pages/ethereum/consensus/fast-confirmation/index.ts @@ -0,0 +1 @@ +export { IndexPage } from './IndexPage'; diff --git a/src/routeTree.gen.ts b/src/routeTree.gen.ts index 7361d2b96..f4f01ff71 100644 --- a/src/routeTree.gen.ts +++ b/src/routeTree.gen.ts @@ -56,6 +56,7 @@ import { Route as EthereumDataAvailabilityProbesRouteImport } from './routes/eth import { Route as EthereumDataAvailabilityCustodyRouteImport } from './routes/ethereum/data-availability/custody' import { Route as EthereumContractsAddressRouteImport } from './routes/ethereum/contracts/$address' import { Route as EthereumConsensusOverviewRouteImport } from './routes/ethereum/consensus/overview' +import { Route as EthereumConsensusFastConfirmationRouteImport } from './routes/ethereum/consensus/fast-confirmation' import { Route as BeaconSlotLiveRouteImport } from './routes/beacon/slot/live' import { Route as BeaconBlockProductionLiveRouteImport } from './routes/beacon/block-production/live' import { Route as EthereumExecutionTimingsIndexRouteImport } from './routes/ethereum/execution/timings/index' @@ -318,6 +319,12 @@ const EthereumConsensusOverviewRoute = path: '/overview', getParentRoute: () => EthereumConsensusRoute, } as any) +const EthereumConsensusFastConfirmationRoute = + EthereumConsensusFastConfirmationRouteImport.update({ + id: '/fast-confirmation', + path: '/fast-confirmation', + getParentRoute: () => EthereumConsensusRoute, + } as any) const BeaconSlotLiveRoute = BeaconSlotLiveRouteImport.update({ id: '/beacon/slot/live', path: '/beacon/slot/live', @@ -412,6 +419,7 @@ export interface FileRoutesByFullPath { '/xatu-data/': typeof XatuDataIndexRoute '/beacon/block-production/live': typeof BeaconBlockProductionLiveRoute '/beacon/slot/live': typeof BeaconSlotLiveRoute + '/ethereum/consensus/fast-confirmation': typeof EthereumConsensusFastConfirmationRoute '/ethereum/consensus/overview': typeof EthereumConsensusOverviewRoute '/ethereum/contracts/$address': typeof EthereumContractsAddressRoute '/ethereum/data-availability/custody': typeof EthereumDataAvailabilityCustodyRouteWithChildren @@ -464,6 +472,7 @@ export interface FileRoutesByTo { '/xatu-data': typeof XatuDataIndexRoute '/beacon/block-production/live': typeof BeaconBlockProductionLiveRoute '/beacon/slot/live': typeof BeaconSlotLiveRoute + '/ethereum/consensus/fast-confirmation': typeof EthereumConsensusFastConfirmationRoute '/ethereum/consensus/overview': typeof EthereumConsensusOverviewRoute '/ethereum/contracts/$address': typeof EthereumContractsAddressRoute '/ethereum/entities/$entity': typeof EthereumEntitiesEntityRoute @@ -520,6 +529,7 @@ export interface FileRoutesById { '/xatu-data/': typeof XatuDataIndexRoute '/beacon/block-production/live': typeof BeaconBlockProductionLiveRoute '/beacon/slot/live': typeof BeaconSlotLiveRoute + '/ethereum/consensus/fast-confirmation': typeof EthereumConsensusFastConfirmationRoute '/ethereum/consensus/overview': typeof EthereumConsensusOverviewRoute '/ethereum/contracts/$address': typeof EthereumContractsAddressRoute '/ethereum/data-availability/custody': typeof EthereumDataAvailabilityCustodyRouteWithChildren @@ -582,6 +592,7 @@ export interface FileRouteTypes { | '/xatu-data/' | '/beacon/block-production/live' | '/beacon/slot/live' + | '/ethereum/consensus/fast-confirmation' | '/ethereum/consensus/overview' | '/ethereum/contracts/$address' | '/ethereum/data-availability/custody' @@ -634,6 +645,7 @@ export interface FileRouteTypes { | '/xatu-data' | '/beacon/block-production/live' | '/beacon/slot/live' + | '/ethereum/consensus/fast-confirmation' | '/ethereum/consensus/overview' | '/ethereum/contracts/$address' | '/ethereum/entities/$entity' @@ -689,6 +701,7 @@ export interface FileRouteTypes { | '/xatu-data/' | '/beacon/block-production/live' | '/beacon/slot/live' + | '/ethereum/consensus/fast-confirmation' | '/ethereum/consensus/overview' | '/ethereum/contracts/$address' | '/ethereum/data-availability/custody' @@ -1066,6 +1079,13 @@ declare module '@tanstack/react-router' { preLoaderRoute: typeof EthereumConsensusOverviewRouteImport parentRoute: typeof EthereumConsensusRoute } + '/ethereum/consensus/fast-confirmation': { + id: '/ethereum/consensus/fast-confirmation' + path: '/fast-confirmation' + fullPath: '/ethereum/consensus/fast-confirmation' + preLoaderRoute: typeof EthereumConsensusFastConfirmationRouteImport + parentRoute: typeof EthereumConsensusRoute + } '/beacon/slot/live': { id: '/beacon/slot/live' path: '/beacon/slot/live' @@ -1147,10 +1167,13 @@ declare module '@tanstack/react-router' { } interface EthereumConsensusRouteChildren { + EthereumConsensusFastConfirmationRoute: typeof EthereumConsensusFastConfirmationRoute EthereumConsensusOverviewRoute: typeof EthereumConsensusOverviewRoute } const EthereumConsensusRouteChildren: EthereumConsensusRouteChildren = { + EthereumConsensusFastConfirmationRoute: + EthereumConsensusFastConfirmationRoute, EthereumConsensusOverviewRoute: EthereumConsensusOverviewRoute, } diff --git a/src/routes/ethereum/consensus/fast-confirmation.tsx b/src/routes/ethereum/consensus/fast-confirmation.tsx new file mode 100644 index 000000000..388274778 --- /dev/null +++ b/src/routes/ethereum/consensus/fast-confirmation.tsx @@ -0,0 +1,41 @@ +import { createFileRoute } from '@tanstack/react-router'; +import { IndexPage } from '@/pages/ethereum/consensus/fast-confirmation'; +import { fastConfirmationSearchSchema } from '@/pages/ethereum/consensus/fast-confirmation/constants'; + +export const Route = createFileRoute('/ethereum/consensus/fast-confirmation')({ + component: IndexPage, + validateSearch: fastConfirmationSearchSchema, + beforeLoad: () => ({ + getBreadcrumb: () => ({ label: 'Fast Confirmation', clickable: false }), + }), + head: () => ({ + meta: [ + { title: `Fast Confirmation | ${import.meta.env.VITE_BASE_TITLE}` }, + { + name: 'description', + content: 'How quickly Ethereum blocks are fast confirmed compared to finality, measured live on mainnet', + }, + { property: 'og:url', content: `${import.meta.env.VITE_BASE_URL}/ethereum/consensus/fast-confirmation` }, + { property: 'og:type', content: 'website' }, + { property: 'og:title', content: `Fast Confirmation | ${import.meta.env.VITE_BASE_TITLE}` }, + { + property: 'og:description', + content: 'How quickly Ethereum blocks are fast confirmed compared to finality, measured live on mainnet', + }, + { + property: 'og:image', + content: `${import.meta.env.VITE_BASE_URL}/images/ethereum/consensus/fast-confirmation.png`, + }, + { name: 'twitter:url', content: `${import.meta.env.VITE_BASE_URL}/ethereum/consensus/fast-confirmation` }, + { name: 'twitter:title', content: `Fast Confirmation | ${import.meta.env.VITE_BASE_TITLE}` }, + { + name: 'twitter:description', + content: 'How quickly Ethereum blocks are fast confirmed compared to finality, measured live on mainnet', + }, + { + name: 'twitter:image', + content: `${import.meta.env.VITE_BASE_URL}/images/ethereum/consensus/fast-confirmation.png`, + }, + ], + }), +});