@berachain/graphql 0.1.0-alpha.1 → 0.1.0-alpha.11

package/dist/chain/chain.codegen.d.mts

@@ -0,0 +1,376 @@
+import * as _apollo_client from '@apollo/client';
+
+type Maybe<T> = T | null;
+type InputMaybe<T> = Maybe<T>;
+type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+type MakeEmpty<T extends {
+    [key: string]: unknown;
+}, K extends keyof T> = {
+    [_ in K]?: never;
+};
+type Incremental<T> = T | {
+    [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
+};
+/** All built-in and custom scalars, mapped to their actual values */
+type Scalars = {
+    ID: {
+        input: string;
+        output: string;
+    };
+    String: {
+        input: string;
+        output: string;
+    };
+    Boolean: {
+        input: boolean;
+        output: boolean;
+    };
+    Int: {
+        input: number;
+        output: number;
+    };
+    Float: {
+        input: number;
+        output: number;
+    };
+    BigDecimal: {
+        input: any;
+        output: any;
+    };
+    BigInt: {
+        input: any;
+        output: any;
+    };
+    Bytes: {
+        input: any;
+        output: any;
+    };
+    Int8: {
+        input: any;
+        output: any;
+    };
+    Timestamp: {
+        input: any;
+        output: any;
+    };
+};
+declare enum Aggregation_Interval {
+    Day = "day",
+    Hour = "hour"
+}
+type Block = {
+    __typename?: 'Block';
+    author: Scalars['Bytes']['output'];
+    baseFeePerGas?: Maybe<Scalars['BigInt']['output']>;
+    difficulty: Scalars['BigInt']['output'];
+    gasLimit: Scalars['BigInt']['output'];
+    gasUsed: Scalars['BigInt']['output'];
+    hash: Scalars['Bytes']['output'];
+    id: Scalars['Bytes']['output'];
+    number: Scalars['BigInt']['output'];
+    parentHash: Scalars['Bytes']['output'];
+    receiptsRoot: Scalars['Bytes']['output'];
+    size?: Maybe<Scalars['BigInt']['output']>;
+    stateRoot: Scalars['Bytes']['output'];
+    timestamp: Scalars['BigInt']['output'];
+    totalDifficulty: Scalars['BigInt']['output'];
+    transactionsRoot: Scalars['Bytes']['output'];
+    unclesHash: Scalars['Bytes']['output'];
+};
+type BlockChangedFilter = {
+    number_gte: Scalars['Int']['input'];
+};
+type Block_Filter = {
+    /** Filter for the block changed event. */
+    _change_block?: InputMaybe<BlockChangedFilter>;
+    and?: InputMaybe<Array<InputMaybe<Block_Filter>>>;
+    author?: InputMaybe<Scalars['Bytes']['input']>;
+    author_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    author_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    author_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    author_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    author_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    author_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    author_not?: InputMaybe<Scalars['Bytes']['input']>;
+    author_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    author_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    baseFeePerGas?: InputMaybe<Scalars['BigInt']['input']>;
+    baseFeePerGas_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    baseFeePerGas_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    baseFeePerGas_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    baseFeePerGas_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    baseFeePerGas_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    baseFeePerGas_not?: InputMaybe<Scalars['BigInt']['input']>;
+    baseFeePerGas_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    difficulty?: InputMaybe<Scalars['BigInt']['input']>;
+    difficulty_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    difficulty_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    difficulty_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    difficulty_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    difficulty_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    difficulty_not?: InputMaybe<Scalars['BigInt']['input']>;
+    difficulty_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    gasLimit?: InputMaybe<Scalars['BigInt']['input']>;
+    gasLimit_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    gasLimit_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    gasLimit_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    gasLimit_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    gasLimit_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    gasLimit_not?: InputMaybe<Scalars['BigInt']['input']>;
+    gasLimit_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    gasUsed?: InputMaybe<Scalars['BigInt']['input']>;
+    gasUsed_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    gasUsed_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    gasUsed_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    gasUsed_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    gasUsed_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    gasUsed_not?: InputMaybe<Scalars['BigInt']['input']>;
+    gasUsed_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    hash?: InputMaybe<Scalars['Bytes']['input']>;
+    hash_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    hash_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    hash_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    hash_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    hash_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    hash_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    hash_not?: InputMaybe<Scalars['Bytes']['input']>;
+    hash_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    hash_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    id?: InputMaybe<Scalars['Bytes']['input']>;
+    id_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    id_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    id_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    id_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    id_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    id_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    number?: InputMaybe<Scalars['BigInt']['input']>;
+    number_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    number_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    number_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    number_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    number_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    number_not?: InputMaybe<Scalars['BigInt']['input']>;
+    number_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    or?: InputMaybe<Array<InputMaybe<Block_Filter>>>;
+    parentHash?: InputMaybe<Scalars['Bytes']['input']>;
+    parentHash_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    parentHash_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    parentHash_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    parentHash_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    parentHash_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    parentHash_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    parentHash_not?: InputMaybe<Scalars['Bytes']['input']>;
+    parentHash_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    parentHash_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    receiptsRoot?: InputMaybe<Scalars['Bytes']['input']>;
+    receiptsRoot_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    receiptsRoot_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    receiptsRoot_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    receiptsRoot_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    receiptsRoot_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    receiptsRoot_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    receiptsRoot_not?: InputMaybe<Scalars['Bytes']['input']>;
+    receiptsRoot_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    receiptsRoot_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    size?: InputMaybe<Scalars['BigInt']['input']>;
+    size_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    size_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    size_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    size_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    size_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    size_not?: InputMaybe<Scalars['BigInt']['input']>;
+    size_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    stateRoot?: InputMaybe<Scalars['Bytes']['input']>;
+    stateRoot_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    stateRoot_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    stateRoot_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    stateRoot_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    stateRoot_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    stateRoot_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    stateRoot_not?: InputMaybe<Scalars['Bytes']['input']>;
+    stateRoot_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    stateRoot_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    timestamp?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    timestamp_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_not?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    totalDifficulty?: InputMaybe<Scalars['BigInt']['input']>;
+    totalDifficulty_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    totalDifficulty_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    totalDifficulty_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    totalDifficulty_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    totalDifficulty_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    totalDifficulty_not?: InputMaybe<Scalars['BigInt']['input']>;
+    totalDifficulty_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    transactionsRoot?: InputMaybe<Scalars['Bytes']['input']>;
+    transactionsRoot_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    transactionsRoot_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    transactionsRoot_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    transactionsRoot_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    transactionsRoot_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    transactionsRoot_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    transactionsRoot_not?: InputMaybe<Scalars['Bytes']['input']>;
+    transactionsRoot_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    transactionsRoot_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    unclesHash?: InputMaybe<Scalars['Bytes']['input']>;
+    unclesHash_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    unclesHash_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    unclesHash_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    unclesHash_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    unclesHash_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    unclesHash_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    unclesHash_not?: InputMaybe<Scalars['Bytes']['input']>;
+    unclesHash_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    unclesHash_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+};
+type Block_Height = {
+    hash?: InputMaybe<Scalars['Bytes']['input']>;
+    number?: InputMaybe<Scalars['Int']['input']>;
+    number_gte?: InputMaybe<Scalars['Int']['input']>;
+};
+declare enum Block_OrderBy {
+    Author = "author",
+    BaseFeePerGas = "baseFeePerGas",
+    Difficulty = "difficulty",
+    GasLimit = "gasLimit",
+    GasUsed = "gasUsed",
+    Hash = "hash",
+    Id = "id",
+    Number = "number",
+    ParentHash = "parentHash",
+    ReceiptsRoot = "receiptsRoot",
+    Size = "size",
+    StateRoot = "stateRoot",
+    Timestamp = "timestamp",
+    TotalDifficulty = "totalDifficulty",
+    TransactionsRoot = "transactionsRoot",
+    UnclesHash = "unclesHash"
+}
+/** Defines the order direction, either ascending or descending */
+declare enum OrderDirection {
+    Asc = "asc",
+    Desc = "desc"
+}
+type Query = {
+    __typename?: 'Query';
+    /** Access to subgraph metadata */
+    _meta?: Maybe<_Meta_>;
+    block?: Maybe<Block>;
+    blocks: Array<Block>;
+};
+type Query_MetaArgs = {
+    block?: InputMaybe<Block_Height>;
+};
+type QueryBlockArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type QueryBlocksArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Block_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<Block_Filter>;
+};
+type Subscription = {
+    __typename?: 'Subscription';
+    /** Access to subgraph metadata */
+    _meta?: Maybe<_Meta_>;
+    block?: Maybe<Block>;
+    blocks: Array<Block>;
+};
+type Subscription_MetaArgs = {
+    block?: InputMaybe<Block_Height>;
+};
+type SubscriptionBlockArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type SubscriptionBlocksArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Block_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<Block_Filter>;
+};
+type _Block_ = {
+    __typename?: '_Block_';
+    /** The hash of the block */
+    hash?: Maybe<Scalars['Bytes']['output']>;
+    /** The block number */
+    number: Scalars['Int']['output'];
+    /** The hash of the parent block */
+    parentHash?: Maybe<Scalars['Bytes']['output']>;
+    /** Integer representation of the timestamp stored in blocks for the chain */
+    timestamp?: Maybe<Scalars['Int']['output']>;
+};
+/** The type for the top-level _meta field */
+type _Meta_ = {
+    __typename?: '_Meta_';
+    /**
+     * Information about a specific subgraph block. The hash of the block
+     * will be null if the _meta field has a block constraint that asks for
+     * a block number. It will be filled if the _meta field has no block constraint
+     * and therefore asks for the latest  block
+     *
+     */
+    block: _Block_;
+    /** The deployment ID */
+    deployment: Scalars['String']['output'];
+    /** If `true`, the subgraph encountered indexing errors at some past block */
+    hasIndexingErrors: Scalars['Boolean']['output'];
+};
+declare enum _SubgraphErrorPolicy_ {
+    /** Data will be returned even if the subgraph has indexing errors */
+    Allow = "allow",
+    /** If the subgraph has indexing errors, data will be omitted. The default. */
+    Deny = "deny"
+}
+type GetBlocksTimeStampQueryVariables = Exact<{
+    skip: Scalars['Int']['input'];
+}>;
+type GetBlocksTimeStampQuery = {
+    __typename?: 'Query';
+    newest: Array<{
+        __typename?: 'Block';
+        timestamp: any;
+        number: any;
+    }>;
+    oldest: Array<{
+        __typename?: 'Block';
+        timestamp: any;
+        number: any;
+    }>;
+};
+declare const GetBlocksTimeStamp: _apollo_client.DocumentNode;
+interface PossibleTypesResultData {
+    possibleTypes: {
+        [key: string]: string[];
+    };
+}
+declare const result: PossibleTypesResultData;
+
+export { Aggregation_Interval, type Block, type BlockChangedFilter, type Block_Filter, type Block_Height, Block_OrderBy, type Exact, GetBlocksTimeStamp, type GetBlocksTimeStampQuery, type GetBlocksTimeStampQueryVariables, type Incremental, type InputMaybe, type MakeEmpty, type MakeMaybe, type MakeOptional, type Maybe, OrderDirection, type PossibleTypesResultData, type Query, type QueryBlockArgs, type QueryBlocksArgs, type Query_MetaArgs, type Scalars, type Subscription, type SubscriptionBlockArgs, type SubscriptionBlocksArgs, type Subscription_MetaArgs, type _Block_, type _Meta_, _SubgraphErrorPolicy_, result as default };

package/dist/chain/chain.codegen.js

@@ -1,4 +1,4 @@
-import{gql as n}from"@apollo/client";var e=(a=>(a.Day="day",a.Hour="hour",a))(e||{}),s=(t=>(t.Author="author",t.BaseFeePerGas="baseFeePerGas",t.Difficulty="difficulty",t.GasLimit="gasLimit",t.GasUsed="gasUsed",t.Hash="hash",t.Id="id",t.Number="number",t.ParentHash="parentHash",t.ReceiptsRoot="receiptsRoot",t.Size="size",t.StateRoot="stateRoot",t.Timestamp="timestamp",t.TotalDifficulty="totalDifficulty",t.TransactionsRoot="transactionsRoot",t.UnclesHash="unclesHash",t))(s||{}),p=(a=>(a.Asc="asc",a.Desc="desc",a))(p||{}),u=(a=>(a.Allow="allow",a.Deny="deny",a))(u||{}),y=n`
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _client = require('@apollo/client');var e=(a=>(a.Day="day",a.Hour="hour",a))(e||{}),s= exports.Block_OrderBy =(t=>(t.Author="author",t.BaseFeePerGas="baseFeePerGas",t.Difficulty="difficulty",t.GasLimit="gasLimit",t.GasUsed="gasUsed",t.Hash="hash",t.Id="id",t.Number="number",t.ParentHash="parentHash",t.ReceiptsRoot="receiptsRoot",t.Size="size",t.StateRoot="stateRoot",t.Timestamp="timestamp",t.TotalDifficulty="totalDifficulty",t.TransactionsRoot="transactionsRoot",t.UnclesHash="unclesHash",t))(s||{}),p= exports.OrderDirection =(a=>(a.Asc="asc",a.Desc="desc",a))(p||{}),u= exports._SubgraphErrorPolicy_ =(a=>(a.Allow="allow",a.Deny="deny",a))(u||{}),y= exports.GetBlocksTimeStamp =_client.gql`
     query GetBlocksTimeStamp($skip: Int!) {
   newest: blocks(first: 1, orderBy: timestamp, orderDirection: desc) {
     timestamp
@@ -9,4 +9,4 @@ import{gql as n}from"@apollo/client";var e=(a=>(a.Day="day",a.Hour="hour",a))(e|
     number
   }
 }
-    `,i={possibleTypes:{}},o=i;export{e as Aggregation_Interval,s as Block_OrderBy,y as GetBlocksTimeStamp,p as OrderDirection,u as _SubgraphErrorPolicy_,o as default};
+    `,i={possibleTypes:{}},o= exports.default =i;exports.Aggregation_Interval = e; exports.Block_OrderBy = s; exports.GetBlocksTimeStamp = y; exports.OrderDirection = p; exports._SubgraphErrorPolicy_ = u; exports.default = o;

package/dist/chain/chain.codegen.mjs

@@ -0,0 +1,12 @@
+import{gql as n}from"@apollo/client";var e=(a=>(a.Day="day",a.Hour="hour",a))(e||{}),s=(t=>(t.Author="author",t.BaseFeePerGas="baseFeePerGas",t.Difficulty="difficulty",t.GasLimit="gasLimit",t.GasUsed="gasUsed",t.Hash="hash",t.Id="id",t.Number="number",t.ParentHash="parentHash",t.ReceiptsRoot="receiptsRoot",t.Size="size",t.StateRoot="stateRoot",t.Timestamp="timestamp",t.TotalDifficulty="totalDifficulty",t.TransactionsRoot="transactionsRoot",t.UnclesHash="unclesHash",t))(s||{}),p=(a=>(a.Asc="asc",a.Desc="desc",a))(p||{}),u=(a=>(a.Allow="allow",a.Deny="deny",a))(u||{}),y=n`
+    query GetBlocksTimeStamp($skip: Int!) {
+  newest: blocks(first: 1, orderBy: timestamp, orderDirection: desc) {
+    timestamp
+    number
+  }
+  oldest: blocks(first: 1, orderBy: timestamp, orderDirection: desc, skip: $skip) {
+    timestamp
+    number
+  }
+}
+    `,i={possibleTypes:{}},o=i;export{e as Aggregation_Interval,s as Block_OrderBy,y as GetBlocksTimeStamp,p as OrderDirection,u as _SubgraphErrorPolicy_,o as default};