tapimo 0.0.0 → 0.0.2

package/dist/apps/blocks.d.ts

@@ -0,0 +1,931 @@
+import { type Context } from 'hono';
+import { Hex } from 'ox';
+import * as z from 'zod/mini';
+import type * as App from '../App.js';
+import * as Response from '../internal/Response.js';
+import * as Schema from '../internal/Schema.js';
+/** The EVM block tags accepted by the `:block` selector. */
+declare const blockTags: readonly ['latest', 'finalized'];
+/** Zod schemas owned by the block handlers. */
+export declare namespace schema {
+    /** The verbatim JSON-RPC payloads, surfaced under each resource's `rpc` field. */
+    namespace Rpc {
+        /** A JSON-RPC block, passed through verbatim. */
+        const Block: z.ZodMiniObject<{
+            baseFeePerGas: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniTemplateLiteral<`0x${string}`>>>;
+            difficulty: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
+            extraData: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<`0x${string}`, string>>>;
+            gasLimit: z.ZodMiniTemplateLiteral<`0x${string}`>;
+            gasUsed: z.ZodMiniTemplateLiteral<`0x${string}`>;
+            hash: z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
+            logsBloom: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<`0x${string}`, string>>>>;
+            miner: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+            mixHash: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
+            nonce: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<`0x${string}`, string>>>>;
+            number: z.ZodMiniNullable<z.ZodMiniTemplateLiteral<`0x${string}`>>;
+            parentHash: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+            receiptsRoot: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+            sha3Uncles: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
+            size: z.ZodMiniTemplateLiteral<`0x${string}`>;
+            stateRoot: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+            timestamp: z.ZodMiniTemplateLiteral<`0x${string}`>;
+            totalDifficulty: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
+            transactions: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
+            transactionsRoot: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+            uncles: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>>;
+            withdrawals: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniObject<{}, z.core.$loose>>>;
+            withdrawalsRoot: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
+        }, z.core.$loose>;
+    }
+    /**
+     * Metadata for a block: the verbatim JSON-RPC block (always present). Held in
+     * a `meta` envelope so future opt-in `include` resources (e.g. embedded
+     * transactions) can layer in without breaking the response shape.
+     */
+    const BlockMeta: z.ZodMiniObject<{
+        rpc: z.ZodMiniObject<{
+            baseFeePerGas: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniTemplateLiteral<`0x${string}`>>>;
+            difficulty: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
+            extraData: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<`0x${string}`, string>>>;
+            gasLimit: z.ZodMiniTemplateLiteral<`0x${string}`>;
+            gasUsed: z.ZodMiniTemplateLiteral<`0x${string}`>;
+            hash: z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
+            logsBloom: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<`0x${string}`, string>>>>;
+            miner: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+            mixHash: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
+            nonce: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<`0x${string}`, string>>>>;
+            number: z.ZodMiniNullable<z.ZodMiniTemplateLiteral<`0x${string}`>>;
+            parentHash: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+            receiptsRoot: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+            sha3Uncles: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
+            size: z.ZodMiniTemplateLiteral<`0x${string}`>;
+            stateRoot: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+            timestamp: z.ZodMiniTemplateLiteral<`0x${string}`>;
+            totalDifficulty: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
+            transactions: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
+            transactionsRoot: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+            uncles: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>>;
+            withdrawals: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniObject<{}, z.core.$loose>>>;
+            withdrawalsRoot: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
+        }, z.core.$loose>;
+    }, z.core.$strip>;
+    /**
+     * A humanized block: decimal-string amounts, ISO 8601 timestamps, and plain
+     * numbers for block fields. The verbatim JSON-RPC payload is always
+     * available under `meta.rpc`. Transactions are omitted from the response —
+     * clients fetch them via `GET /blocks/:block/transactions`.
+     */
+    const Block: z.ZodMiniObject<{
+        baseFeePerGas: z.ZodMiniNullable<z.ZodMiniString<string>>;
+        gasLimit: z.ZodMiniNumber<number>;
+        gasUsed: z.ZodMiniNumber<number>;
+        hash: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+        id: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+        meta: z.ZodMiniObject<{
+            rpc: z.ZodMiniObject<{
+                baseFeePerGas: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniTemplateLiteral<`0x${string}`>>>;
+                difficulty: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
+                extraData: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<`0x${string}`, string>>>;
+                gasLimit: z.ZodMiniTemplateLiteral<`0x${string}`>;
+                gasUsed: z.ZodMiniTemplateLiteral<`0x${string}`>;
+                hash: z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
+                logsBloom: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<`0x${string}`, string>>>>;
+                miner: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+                mixHash: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
+                nonce: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<`0x${string}`, string>>>>;
+                number: z.ZodMiniNullable<z.ZodMiniTemplateLiteral<`0x${string}`>>;
+                parentHash: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+                receiptsRoot: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+                sha3Uncles: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
+                size: z.ZodMiniTemplateLiteral<`0x${string}`>;
+                stateRoot: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+                timestamp: z.ZodMiniTemplateLiteral<`0x${string}`>;
+                totalDifficulty: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
+                transactions: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
+                transactionsRoot: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+                uncles: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>>;
+                withdrawals: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniObject<{}, z.core.$loose>>>;
+                withdrawalsRoot: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
+            }, z.core.$loose>;
+        }, z.core.$strip>;
+        miner: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+        number: z.ZodMiniNumber<number>;
+        parentHash: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+        size: z.ZodMiniNumber<number>;
+        timestamp: z.ZodMiniISODateTime;
+        transactionCount: z.ZodMiniNumber<number>;
+    }, z.core.$strip>;
+    /**
+     * A lightweight block row, returned by the `/blocks` list endpoint. Full
+     * fields (parentHash, miner, gasUsed/gasLimit, …) would require one RPC
+     * roundtrip per row; the list endpoint stays cheap and clients fetch
+     * `/blocks/:block` for individual blocks they care about. The block hash is
+     * selected from the index so `id` stays tied to the resolved block identity.
+     */
+    const BlockSummary: z.ZodMiniObject<{
+        hash: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+        id: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+        number: z.ZodMiniNumber<number>;
+        timestamp: z.ZodMiniISODateTime;
+        transactionCount: z.ZodMiniNumber<number>;
+    }, z.core.$strip>;
+    /** Schemas for the getBlocks operation. */
+    namespace getBlocks {
+        /** Query parameters for `GET /blocks`. */
+        const Query: z.ZodMiniObject<{
+            chainId: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniEnum<{
+                mainnet: "mainnet";
+                testnet: "testnet";
+            }>, z.ZodMiniTransform<4217 | 42431, "mainnet" | "testnet">>, z.ZodMiniNumber<unknown>]>, z.ZodMiniNumber<number>>>;
+            cursor: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            limit: z.ZodMiniDefault<z.ZodMiniNumber<unknown>>;
+            order: z.ZodMiniDefault<z.ZodMiniEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+            page: z.ZodMiniOptional<z.ZodMiniNumber<unknown>>;
+        }, z.core.$strict>;
+        /** Page of lightweight block rows, including empty blocks. */
+        const Response: z.ZodMiniObject<{
+            data: z.ZodMiniArray<z.ZodMiniObject<{
+                hash: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+                id: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+                number: z.ZodMiniNumber<number>;
+                timestamp: z.ZodMiniISODateTime;
+                transactionCount: z.ZodMiniNumber<number>;
+            }, z.core.$strip>>;
+            nextCursor: z.ZodMiniNullable<z.ZodMiniString<string>>;
+        }, z.core.$strip>;
+    }
+    /** Schemas for the getBlock operation. */
+    namespace getBlock {
+        /**
+         * Path parameter for block requests. Resolves a single block from any of:
+         * a block tag (`latest`, `finalized`); a decimal or `0x`-prefixed hex block
+         * number; a `0x`-prefixed 32-byte block hash; or an ISO 8601 timestamp
+         * (`2023-11-14T22:13:20Z`), which resolves to the first block at or after
+         * that instant.
+         */
+        const Params: z.ZodMiniObject<{
+            block: z.ZodMiniUnion<readonly [z.ZodMiniEnum<{
+                finalized: "finalized";
+                latest: "latest";
+            }>, z.ZodMiniString<string>, z.ZodMiniISODateTime]>;
+        }, z.core.$strip>;
+        /** Query parameters for `GET /blocks/:block`. */
+        const Query: z.ZodMiniObject<{
+            chainId: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniEnum<{
+                mainnet: "mainnet";
+                testnet: "testnet";
+            }>, z.ZodMiniTransform<4217 | 42431, "mainnet" | "testnet">>, z.ZodMiniNumber<unknown>]>, z.ZodMiniNumber<number>>>;
+        }, z.core.$strict>;
+        /** A humanized block, with the verbatim JSON-RPC payload under `meta.rpc`. */
+        const Response: z.ZodMiniObject<{
+            baseFeePerGas: z.ZodMiniNullable<z.ZodMiniString<string>>;
+            gasLimit: z.ZodMiniNumber<number>;
+            gasUsed: z.ZodMiniNumber<number>;
+            hash: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+            id: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+            meta: z.ZodMiniObject<{
+                rpc: z.ZodMiniObject<{
+                    baseFeePerGas: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniTemplateLiteral<`0x${string}`>>>;
+                    difficulty: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
+                    extraData: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<`0x${string}`, string>>>;
+                    gasLimit: z.ZodMiniTemplateLiteral<`0x${string}`>;
+                    gasUsed: z.ZodMiniTemplateLiteral<`0x${string}`>;
+                    hash: z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
+                    logsBloom: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<`0x${string}`, string>>>>;
+                    miner: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+                    mixHash: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
+                    nonce: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<`0x${string}`, string>>>>;
+                    number: z.ZodMiniNullable<z.ZodMiniTemplateLiteral<`0x${string}`>>;
+                    parentHash: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+                    receiptsRoot: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+                    sha3Uncles: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
+                    size: z.ZodMiniTemplateLiteral<`0x${string}`>;
+                    stateRoot: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+                    timestamp: z.ZodMiniTemplateLiteral<`0x${string}`>;
+                    totalDifficulty: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
+                    transactions: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
+                    transactionsRoot: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+                    uncles: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>>;
+                    withdrawals: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniObject<{}, z.core.$loose>>>;
+                    withdrawalsRoot: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
+                }, z.core.$loose>;
+            }, z.core.$strip>;
+            miner: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+            number: z.ZodMiniNumber<number>;
+            parentHash: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
+            size: z.ZodMiniNumber<number>;
+            timestamp: z.ZodMiniISODateTime;
+            transactionCount: z.ZodMiniNumber<number>;
+        }, z.core.$strip>;
+    }
+    /**
+     * Schemas for the legacy `getBlockByTimestamp` compatibility operation
+     * (`GET /chains/:chainId/blocks/by-timestamp`). Hidden from the docs; kept to
+     * keep pre-existing clients of the prior Tempo API working unchanged.
+     */
+    namespace getBlockByTimestamp {
+        /** Path parameters: the numeric Tempo chain id. */
+        const Params: z.ZodMiniObject<{
+            chainId: z.ZodMiniPipe<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniEnum<{
+                mainnet: "mainnet";
+                testnet: "testnet";
+            }>, z.ZodMiniTransform<4217 | 42431, "mainnet" | "testnet">>, z.ZodMiniNumber<unknown>]>, z.ZodMiniNumber<number>>;
+        }, z.core.$strip>;
+        /** Query parameters: a required unix timestamp and the search direction. */
+        const Query: z.ZodMiniObject<{
+            closest: z.ZodMiniDefault<z.ZodMiniEnum<{
+                after: "after";
+                before: "before";
+            }>>;
+            timestamp: z.ZodMiniNumber<unknown>;
+        }, z.core.$strict>;
+        /** The legacy response envelope: `{ block: { blockNumber, blockTimestamp } }`. */
+        const Response: z.ZodMiniObject<{
+            block: z.ZodMiniObject<{
+                blockNumber: z.ZodMiniNumber<number>;
+                blockTimestamp: z.ZodMiniNumber<number>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }
+}
+/** Creates block handlers. */
+export declare function blocks(): import("hono/hono-base").HonoBase<App.Environment, {
+    "/": {
+        $get: {
+            output: null;
+            outputFormat: "body";
+            status: 402;
+            input: {
+                query?: {
+                    chainId?: string | string[];
+                    cursor?: string | string[];
+                    limit?: string | string[];
+                    order?: string | string[];
+                    page?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                error: {
+                    code: "api_key_malformed";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 400;
+            input: {
+                query?: {
+                    chainId?: string | string[];
+                    cursor?: string | string[];
+                    limit?: string | string[];
+                    order?: string | string[];
+                    page?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                error: {
+                    code: "api_key_invalid" | "api_key_missing";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 401;
+            input: {
+                query?: {
+                    chainId?: string | string[];
+                    cursor?: string | string[];
+                    limit?: string | string[];
+                    order?: string | string[];
+                    page?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                error: {
+                    code: "api_key_forbidden";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 403;
+            input: {
+                query?: {
+                    chainId?: string | string[];
+                    cursor?: string | string[];
+                    limit?: string | string[];
+                    order?: string | string[];
+                    page?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                error: {
+                    code: "payment_required" | "rate_limit_exceeded";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 429;
+            input: {
+                query?: {
+                    chainId?: string | string[];
+                    cursor?: string | string[];
+                    limit?: string | string[];
+                    order?: string | string[];
+                    page?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                error: {
+                    code: "query_invalid";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 400;
+            input: {
+                query?: {
+                    chainId?: string | string[];
+                    cursor?: string | string[];
+                    limit?: string | string[];
+                    order?: string | string[];
+                    page?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                error: {
+                    code: "upstream_error";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 502;
+            input: {
+                query?: {
+                    chainId?: string | string[];
+                    cursor?: string | string[];
+                    limit?: string | string[];
+                    order?: string | string[];
+                    page?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                data: {
+                    hash: `0x${string}`;
+                    id: `0x${string}`;
+                    number: number;
+                    timestamp: string;
+                    transactionCount: number;
+                }[];
+                nextCursor: string | null;
+            };
+            outputFormat: "json";
+            status: 200;
+            input: {
+                query?: {
+                    chainId?: string | string[];
+                    cursor?: string | string[];
+                    limit?: string | string[];
+                    order?: string | string[];
+                    page?: string | string[];
+                } | undefined;
+            };
+        };
+    };
+} & {
+    "/:block": {
+        $get: {
+            output: null;
+            outputFormat: "body";
+            status: 402;
+            input: {
+                param: {
+                    block: string;
+                };
+            } & {
+                query?: {
+                    chainId?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                error: {
+                    code: "api_key_malformed";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 400;
+            input: {
+                param: {
+                    block: string;
+                };
+            } & {
+                query?: {
+                    chainId?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                error: {
+                    code: "api_key_invalid" | "api_key_missing";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 401;
+            input: {
+                param: {
+                    block: string;
+                };
+            } & {
+                query?: {
+                    chainId?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                error: {
+                    code: "api_key_forbidden";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 403;
+            input: {
+                param: {
+                    block: string;
+                };
+            } & {
+                query?: {
+                    chainId?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                error: {
+                    code: "payment_required" | "rate_limit_exceeded";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 429;
+            input: {
+                param: {
+                    block: string;
+                };
+            } & {
+                query?: {
+                    chainId?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                error: {
+                    code: "query_invalid";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 400;
+            input: {
+                param: {
+                    block: string;
+                };
+            } & {
+                query?: {
+                    chainId?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                error: {
+                    code: "upstream_error";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 502;
+            input: {
+                param: {
+                    block: string;
+                };
+            } & {
+                query?: {
+                    chainId?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                error: {
+                    code: "block_invalid";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 400;
+            input: {
+                param: {
+                    block: string;
+                };
+            } & {
+                query?: {
+                    chainId?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                error: {
+                    code: "block_not_found";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 404;
+            input: {
+                param: {
+                    block: string;
+                };
+            } & {
+                query?: {
+                    chainId?: string | string[];
+                } | undefined;
+            };
+        } | {
+            output: {
+                baseFeePerGas: string | null;
+                gasLimit: number;
+                gasUsed: number;
+                hash: `0x${string}`;
+                id: `0x${string}`;
+                meta: {
+                    rpc: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                        baseFeePerGas?: `0x${string}` | null | undefined;
+                        difficulty?: `0x${string}` | undefined;
+                        extraData?: `0x${string}` | undefined;
+                        gasLimit: `0x${string}`;
+                        gasUsed: `0x${string}`;
+                        hash: `0x${string}` | null;
+                        logsBloom?: `0x${string}` | null | undefined;
+                        miner: `0x${string}`;
+                        mixHash?: `0x${string}` | undefined;
+                        nonce?: `0x${string}` | null | undefined;
+                        number: `0x${string}` | null;
+                        parentHash: `0x${string}`;
+                        receiptsRoot: `0x${string}`;
+                        sha3Uncles?: `0x${string}` | undefined;
+                        size: `0x${string}`;
+                        stateRoot: `0x${string}`;
+                        timestamp: `0x${string}`;
+                        totalDifficulty?: `0x${string}` | undefined;
+                        transactions: `0x${string}`[];
+                        transactionsRoot: `0x${string}`;
+                        uncles?: `0x${string}`[] | undefined;
+                        withdrawals?: {
+                            [x: string]: import("hono/utils/types").JSONValue;
+                        }[] | undefined;
+                        withdrawalsRoot?: `0x${string}` | undefined;
+                    };
+                };
+                miner: `0x${string}`;
+                number: number;
+                parentHash: `0x${string}`;
+                size: number;
+                timestamp: string;
+                transactionCount: number;
+            };
+            outputFormat: "json";
+            status: 200;
+            input: {
+                param: {
+                    block: string;
+                };
+            } & {
+                query?: {
+                    chainId?: string | string[];
+                } | undefined;
+            };
+        };
+    };
+}, "/", "/:block">;
+/**
+ * Mounts the hidden legacy `GET /chains/:chainId/blocks/by-timestamp`
+ * compatibility route at the app root. The prior Tempo API exposed this shape
+ * (chain id in the path, a required unix `timestamp`, and a `closest` direction)
+ * and returned `{ block: { blockNumber, blockTimestamp } }`; this preserves it
+ * so existing clients keep working while the canonical surface is
+ * `GET /v1/blocks/:block` with an ISO 8601 selector.
+ *
+ * Like the original it searches a ±{@link byTimestampWindowSeconds}s window and
+ * returns `404` when no indexed block falls within it. Because the chain id is a
+ * path parameter (not the `chainId` query the global guard inspects), this
+ * validates it against the deployment's supported chains itself.
+ */
+export declare function blocksByTimestampCompat(): import("hono/hono-base").HonoBase<App.Environment, {
+    "/:chainId/blocks/by-timestamp": {
+        $get: {
+            output: null;
+            outputFormat: "body";
+            status: 402;
+            input: {
+                param: {
+                    chainId: string;
+                };
+            } & {
+                query: {
+                    closest?: string | string[];
+                    timestamp: string | string[];
+                };
+            };
+        } | {
+            output: {
+                error: {
+                    code: "api_key_malformed";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 400;
+            input: {
+                param: {
+                    chainId: string;
+                };
+            } & {
+                query: {
+                    closest?: string | string[];
+                    timestamp: string | string[];
+                };
+            };
+        } | {
+            output: {
+                error: {
+                    code: "api_key_invalid" | "api_key_missing";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 401;
+            input: {
+                param: {
+                    chainId: string;
+                };
+            } & {
+                query: {
+                    closest?: string | string[];
+                    timestamp: string | string[];
+                };
+            };
+        } | {
+            output: {
+                error: {
+                    code: "api_key_forbidden";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 403;
+            input: {
+                param: {
+                    chainId: string;
+                };
+            } & {
+                query: {
+                    closest?: string | string[];
+                    timestamp: string | string[];
+                };
+            };
+        } | {
+            output: {
+                error: {
+                    code: "payment_required" | "rate_limit_exceeded";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 429;
+            input: {
+                param: {
+                    chainId: string;
+                };
+            } & {
+                query: {
+                    closest?: string | string[];
+                    timestamp: string | string[];
+                };
+            };
+        } | {
+            output: {
+                error: {
+                    code: "query_invalid";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 400;
+            input: {
+                param: {
+                    chainId: string;
+                };
+            } & {
+                query: {
+                    closest?: string | string[];
+                    timestamp: string | string[];
+                };
+            };
+        } | {
+            output: {
+                error: {
+                    code: "upstream_error";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 502;
+            input: {
+                param: {
+                    chainId: string;
+                };
+            } & {
+                query: {
+                    closest?: string | string[];
+                    timestamp: string | string[];
+                };
+            };
+        } | {
+            output: {
+                error: {
+                    code: "block_not_found";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 404;
+            input: {
+                param: {
+                    chainId: string;
+                };
+            } & {
+                query: {
+                    closest?: string | string[];
+                    timestamp: string | string[];
+                };
+            };
+        } | {
+            output: {
+                error: {
+                    code: "chain_id_unsupported";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 400;
+            input: {
+                param: {
+                    chainId: string;
+                };
+            } & {
+                query: {
+                    closest?: string | string[];
+                    timestamp: string | string[];
+                };
+            };
+        } | {
+            output: {
+                block: {
+                    blockNumber: number;
+                    blockTimestamp: number;
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+            input: {
+                param: {
+                    chainId: string;
+                };
+            } & {
+                query: {
+                    closest?: string | string[];
+                    timestamp: string | string[];
+                };
+            };
+        };
+    };
+}, "/", "/:chainId/blocks/by-timestamp">;
+export declare namespace findBlockByTimestamp {
+    type Options = {
+        chainId: z.output<typeof Schema.ChainId>;
+        closest: 'before' | 'after';
+        timestamp: number;
+    };
+}
+/**
+ * Parses a `:block` path parameter, dispatching by shape. Returns the
+ * discriminated identifier, or `undefined` when the input matches no known
+ * shape (the schema should have caught this earlier; this guards the type at
+ * the use site).
+ *
+ * Selectors are unambiguous by shape: a block tag is a fixed keyword; the
+ * 66-char `0x`-prefixed length identifies a 32-byte hash; any other
+ * `0x`-prefixed hex (or plain decimal) is a block number; and an ISO 8601
+ * timestamp (validated with the same {@link blockTimestamp} schema as the
+ * route) is resolved to its UTC instant.
+ */
+export declare function parseBlockIdentifier(value: string): parseBlockIdentifier.Result | undefined;
+export declare namespace parseBlockIdentifier {
+    /** An EVM block tag accepted by the `:block` selector. */
+    type BlockTag = (typeof blockTags)[number];
+    /** A parsed block identifier, dispatching by shape. */
+    type Result = {
+        kind: 'tag';
+        tag: BlockTag;
+    } | {
+        kind: 'hash';
+        hash: Hex.Hex;
+    } | {
+        kind: 'number';
+        number: bigint;
+    } | {
+        kind: 'timestamp';
+        iso: string;
+    };
+}
+/**
+ * Lists blocks from the indexer. Reads every block from the `blocks` table
+ * (so empty blocks are included) and resolves transaction counts via a
+ * second narrow `txs` query keyed to the page's block numbers.
+ */
+export declare function listBlocks(c: Context<App.Environment>, options: listBlocks.Options): Promise<{
+    data: {
+        hash: `0x${string}`;
+        id: `0x${string}`;
+        number: number;
+        timestamp: string;
+        transactionCount: number;
+    }[];
+    nextCursor: string | null;
+}>;
+export declare namespace listBlocks {
+    type Options = {
+        chainId: z.output<typeof Schema.ChainId>;
+        /** Opaque keyset cursor anchoring the page; omit for the head page. */
+        cursor?: string | undefined;
+        limit: number;
+        /** 1-indexed page number (positional pagination; exclusive with `cursor`). */
+        page?: number | undefined;
+        order: 'asc' | 'desc';
+    };
+}
+export {};
+//# sourceMappingURL=blocks.d.ts.map