@apibara/protocol 2.0.0-beta.32 → 2.0.0-beta.34

package/dist/shared/{protocol.f9e14c27.d.cts → protocol.ef662c22.d.mts}

@@ -115,6 +115,17 @@ declare enum DataFinality$1 {
 }
 declare function dataFinalityFromJSON(object: any): DataFinality$1;
 declare function dataFinalityToJSON(object: DataFinality$1): string;
+/** Data production mode. */
+declare enum DataProduction$1 {
+    UNKNOWN = 0,
+    /** BACKFILL - Data is for a backfilled block. */
+    BACKFILL = 1,
+    /** LIVE - Data is for a live block. */
+    LIVE = 2,
+    UNRECOGNIZED = -1
+}
+declare function dataProductionFromJSON(object: any): DataProduction$1;
+declare function dataProductionToJSON(object: DataProduction$1): string;
 /** A cursor over the stream content. */
 interface Cursor$1 {
     /**
@@ -286,6 +297,8 @@ interface Data$1 {
      * This message contains chain-specific data serialized using protobuf.
      */
     readonly data: readonly Uint8Array[];
+    /** The production mode of the block. */
+    readonly production: DataProduction$1;
 }
 declare const Data$1: {
     encode(message: Data$1, writer?: _m0.Writer): _m0.Writer;
@@ -410,9 +423,11 @@ type stream_DnaStreamServiceImplementation<CallContextExt = {}> = DnaStreamServi
 type stream_ServerStreamingMethodResult<Response> = ServerStreamingMethodResult<Response>;
 declare const stream_dataFinalityFromJSON: typeof dataFinalityFromJSON;
 declare const stream_dataFinalityToJSON: typeof dataFinalityToJSON;
+declare const stream_dataProductionFromJSON: typeof dataProductionFromJSON;
+declare const stream_dataProductionToJSON: typeof dataProductionToJSON;
 declare const stream_protobufPackage: typeof protobufPackage;
 declare namespace stream {
-  export { Cursor$1 as Cursor, Data$1 as Data, DataFinality$1 as DataFinality, type stream_DeepPartial as DeepPartial, type stream_DnaStreamClient as DnaStreamClient, stream_DnaStreamDefinition as DnaStreamDefinition, type stream_DnaStreamServiceImplementation as DnaStreamServiceImplementation, Finalize$1 as Finalize, Heartbeat$1 as Heartbeat, Invalidate$1 as Invalidate, type stream_ServerStreamingMethodResult as ServerStreamingMethodResult, StatusRequest$1 as StatusRequest, StatusResponse$1 as StatusResponse, StreamDataRequest$1 as StreamDataRequest, StreamDataResponse$1 as StreamDataResponse, SystemMessage$1 as SystemMessage, stream_dataFinalityFromJSON as dataFinalityFromJSON, stream_dataFinalityToJSON as dataFinalityToJSON, stream_protobufPackage as protobufPackage };
+  export { Cursor$1 as Cursor, Data$1 as Data, DataFinality$1 as DataFinality, DataProduction$1 as DataProduction, type stream_DeepPartial as DeepPartial, type stream_DnaStreamClient as DnaStreamClient, stream_DnaStreamDefinition as DnaStreamDefinition, type stream_DnaStreamServiceImplementation as DnaStreamServiceImplementation, Finalize$1 as Finalize, Heartbeat$1 as Heartbeat, Invalidate$1 as Invalidate, type stream_ServerStreamingMethodResult as ServerStreamingMethodResult, StatusRequest$1 as StatusRequest, StatusResponse$1 as StatusResponse, StreamDataRequest$1 as StreamDataRequest, StreamDataResponse$1 as StreamDataResponse, SystemMessage$1 as SystemMessage, stream_dataFinalityFromJSON as dataFinalityFromJSON, stream_dataFinalityToJSON as dataFinalityToJSON, stream_dataProductionFromJSON as dataProductionFromJSON, stream_dataProductionToJSON as dataProductionToJSON, stream_protobufPackage as protobufPackage };
 }
 
 /** Bytes encoded as a 0x-prefixed hex string. */
@@ -479,6 +494,9 @@ declare const statusResponseFromProto: (i: {
 /** Data finality. */
 declare const DataFinality: Schema.transform<Schema.Enums<typeof DataFinality$1>, Schema.Literal<["finalized", "accepted", "pending", "unknown"]>>;
 type DataFinality = typeof DataFinality.Type;
+/** Data production mode. */
+declare const DataProduction: Schema.transform<Schema.Enums<typeof DataProduction$1>, Schema.Literal<["backfill", "live", "unknown"]>>;
+type DataProduction = typeof DataProduction.Type;
 declare const Duration: Schema.Struct<{
     seconds: typeof Schema.BigIntFromSelf;
     nanos: typeof Schema.Number;
@@ -545,6 +563,7 @@ declare const Data: <TA, TR>(schema: Schema.Schema<TA | null, Uint8Array, TR>) =
         cursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
         endCursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
         finality: Schema.transform<Schema.Enums<typeof DataFinality$1>, Schema.Literal<["finalized", "accepted", "pending", "unknown"]>>;
+        production: Schema.transform<Schema.Enums<typeof DataProduction$1>, Schema.Literal<["backfill", "live", "unknown"]>>;
         data: Schema.Array$<Schema.Schema<TA | null, Uint8Array, TR>>;
     }>;
 }>;
@@ -579,6 +598,7 @@ declare const StreamDataResponse: <TA, TR>(data: Schema.Schema<TA | null, Uint8A
         cursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
         endCursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
         finality: Schema.transform<Schema.Enums<typeof DataFinality$1>, Schema.Literal<["finalized", "accepted", "pending", "unknown"]>>;
+        production: Schema.transform<Schema.Enums<typeof DataProduction$1>, Schema.Literal<["backfill", "live", "unknown"]>>;
         data: Schema.Array$<Schema.Schema<TA | null, Uint8Array, TR>>;
     }>;
 }>, Schema.Struct<{
@@ -611,6 +631,7 @@ type StreamDataResponse<TA> = ResponseWithoutData | {
         cursor?: Cursor | undefined;
         endCursor?: Cursor | undefined;
         finality: DataFinality;
+        production: DataProduction;
         data: readonly (TA | null)[];
     };
 };
@@ -644,6 +665,7 @@ declare class StreamConfig<TFilter, TBlock> {
             cursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
             endCursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
             finality: Schema.transform<Schema.Enums<typeof DataFinality$1>, Schema.Literal<["finalized", "accepted", "pending", "unknown"]>>;
+            production: Schema.transform<Schema.Enums<typeof DataProduction$1>, Schema.Literal<["backfill", "live", "unknown"]>>;
             data: Schema.Array$<Schema.Schema<TBlock | null, Uint8Array, never>>;
         }>;
     }>, Schema.Struct<{
@@ -672,13 +694,18 @@ declare class StreamConfig<TFilter, TBlock> {
     }>]>;
 }
 
+declare class TimeoutError extends Error {
+    constructor(timeout: number);
+}
 /** Client call options. */
 interface ClientCallOptions {
     signal?: AbortSignal;
 }
 interface StreamDataOptions extends ClientCallOptions {
-    /** Stop at the specified cursor (inclusive) */
+    /** Stop at the specified cursor (inclusive). */
     endingCursor?: Cursor;
+    /** Timeout between messages, in milliseconds. */
+    timeout?: number;
 }
 /** DNA client. */
 interface Client<TFilter, TBlock> {
@@ -715,4 +742,4 @@ declare class StreamDataIterable<TBlock> {
     [Symbol.asyncIterator](): AsyncIterator<StreamDataResponse<TBlock>>;
 }
 
-export { type StreamDataOptions as A, Bytes as B, type CursorProto as C, type DnaStreamClient as D, type Client as E, Finalize as F, type CreateClientOptions as G, Heartbeat as H, Invalidate as I, createClient as J, GrpcClient as K, StreamDataIterable as L, DataFinality$1 as M, StatusRequest as S, _Cursor as _, DnaStreamDefinition as a, BytesFromUint8Array as b, Cursor as c, createCursor as d, cursorToProto as e, cursorFromProto as f, CursorFromBytes as g, cursorToBytes as h, cursorFromBytes as i, isCursor as j, statusRequestToProto as k, statusRequestFromProto as l, StatusResponse as m, statusResponseToProto as n, statusResponseFromProto as o, DataFinality as p, Duration as q, StreamDataRequest as r, stream as s, StdOut as t, StdErr as u, SystemMessage as v, Data as w, StreamDataResponse as x, StreamConfig as y, type ClientCallOptions as z };
+export { type ClientCallOptions as A, Bytes as B, type CursorProto as C, type DnaStreamClient as D, type StreamDataOptions as E, Finalize as F, type Client as G, Heartbeat as H, Invalidate as I, type CreateClientOptions as J, createClient as K, GrpcClient as L, StreamDataIterable as M, DataFinality$1 as N, DataProduction$1 as O, StatusRequest as S, TimeoutError as T, _Cursor as _, DnaStreamDefinition as a, BytesFromUint8Array as b, Cursor as c, createCursor as d, cursorToProto as e, cursorFromProto as f, CursorFromBytes as g, cursorToBytes as h, cursorFromBytes as i, isCursor as j, statusRequestToProto as k, statusRequestFromProto as l, StatusResponse as m, statusResponseToProto as n, statusResponseFromProto as o, DataFinality as p, DataProduction as q, Duration as r, stream as s, StreamDataRequest as t, StdOut as u, StdErr as v, SystemMessage as w, Data as x, StreamDataResponse as y, StreamConfig as z };

package/dist/shared/{protocol.f9e14c27.d.mts → protocol.ef662c22.d.ts}

@@ -115,6 +115,17 @@ declare enum DataFinality$1 {
 }
 declare function dataFinalityFromJSON(object: any): DataFinality$1;
 declare function dataFinalityToJSON(object: DataFinality$1): string;
+/** Data production mode. */
+declare enum DataProduction$1 {
+    UNKNOWN = 0,
+    /** BACKFILL - Data is for a backfilled block. */
+    BACKFILL = 1,
+    /** LIVE - Data is for a live block. */
+    LIVE = 2,
+    UNRECOGNIZED = -1
+}
+declare function dataProductionFromJSON(object: any): DataProduction$1;
+declare function dataProductionToJSON(object: DataProduction$1): string;
 /** A cursor over the stream content. */
 interface Cursor$1 {
     /**
@@ -286,6 +297,8 @@ interface Data$1 {
      * This message contains chain-specific data serialized using protobuf.
      */
     readonly data: readonly Uint8Array[];
+    /** The production mode of the block. */
+    readonly production: DataProduction$1;
 }
 declare const Data$1: {
     encode(message: Data$1, writer?: _m0.Writer): _m0.Writer;
@@ -410,9 +423,11 @@ type stream_DnaStreamServiceImplementation<CallContextExt = {}> = DnaStreamServi
 type stream_ServerStreamingMethodResult<Response> = ServerStreamingMethodResult<Response>;
 declare const stream_dataFinalityFromJSON: typeof dataFinalityFromJSON;
 declare const stream_dataFinalityToJSON: typeof dataFinalityToJSON;
+declare const stream_dataProductionFromJSON: typeof dataProductionFromJSON;
+declare const stream_dataProductionToJSON: typeof dataProductionToJSON;
 declare const stream_protobufPackage: typeof protobufPackage;
 declare namespace stream {
-  export { Cursor$1 as Cursor, Data$1 as Data, DataFinality$1 as DataFinality, type stream_DeepPartial as DeepPartial, type stream_DnaStreamClient as DnaStreamClient, stream_DnaStreamDefinition as DnaStreamDefinition, type stream_DnaStreamServiceImplementation as DnaStreamServiceImplementation, Finalize$1 as Finalize, Heartbeat$1 as Heartbeat, Invalidate$1 as Invalidate, type stream_ServerStreamingMethodResult as ServerStreamingMethodResult, StatusRequest$1 as StatusRequest, StatusResponse$1 as StatusResponse, StreamDataRequest$1 as StreamDataRequest, StreamDataResponse$1 as StreamDataResponse, SystemMessage$1 as SystemMessage, stream_dataFinalityFromJSON as dataFinalityFromJSON, stream_dataFinalityToJSON as dataFinalityToJSON, stream_protobufPackage as protobufPackage };
+  export { Cursor$1 as Cursor, Data$1 as Data, DataFinality$1 as DataFinality, DataProduction$1 as DataProduction, type stream_DeepPartial as DeepPartial, type stream_DnaStreamClient as DnaStreamClient, stream_DnaStreamDefinition as DnaStreamDefinition, type stream_DnaStreamServiceImplementation as DnaStreamServiceImplementation, Finalize$1 as Finalize, Heartbeat$1 as Heartbeat, Invalidate$1 as Invalidate, type stream_ServerStreamingMethodResult as ServerStreamingMethodResult, StatusRequest$1 as StatusRequest, StatusResponse$1 as StatusResponse, StreamDataRequest$1 as StreamDataRequest, StreamDataResponse$1 as StreamDataResponse, SystemMessage$1 as SystemMessage, stream_dataFinalityFromJSON as dataFinalityFromJSON, stream_dataFinalityToJSON as dataFinalityToJSON, stream_dataProductionFromJSON as dataProductionFromJSON, stream_dataProductionToJSON as dataProductionToJSON, stream_protobufPackage as protobufPackage };
 }
 
 /** Bytes encoded as a 0x-prefixed hex string. */
@@ -479,6 +494,9 @@ declare const statusResponseFromProto: (i: {
 /** Data finality. */
 declare const DataFinality: Schema.transform<Schema.Enums<typeof DataFinality$1>, Schema.Literal<["finalized", "accepted", "pending", "unknown"]>>;
 type DataFinality = typeof DataFinality.Type;
+/** Data production mode. */
+declare const DataProduction: Schema.transform<Schema.Enums<typeof DataProduction$1>, Schema.Literal<["backfill", "live", "unknown"]>>;
+type DataProduction = typeof DataProduction.Type;
 declare const Duration: Schema.Struct<{
     seconds: typeof Schema.BigIntFromSelf;
     nanos: typeof Schema.Number;
@@ -545,6 +563,7 @@ declare const Data: <TA, TR>(schema: Schema.Schema<TA | null, Uint8Array, TR>) =
         cursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
         endCursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
         finality: Schema.transform<Schema.Enums<typeof DataFinality$1>, Schema.Literal<["finalized", "accepted", "pending", "unknown"]>>;
+        production: Schema.transform<Schema.Enums<typeof DataProduction$1>, Schema.Literal<["backfill", "live", "unknown"]>>;
         data: Schema.Array$<Schema.Schema<TA | null, Uint8Array, TR>>;
     }>;
 }>;
@@ -579,6 +598,7 @@ declare const StreamDataResponse: <TA, TR>(data: Schema.Schema<TA | null, Uint8A
         cursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
         endCursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
         finality: Schema.transform<Schema.Enums<typeof DataFinality$1>, Schema.Literal<["finalized", "accepted", "pending", "unknown"]>>;
+        production: Schema.transform<Schema.Enums<typeof DataProduction$1>, Schema.Literal<["backfill", "live", "unknown"]>>;
         data: Schema.Array$<Schema.Schema<TA | null, Uint8Array, TR>>;
     }>;
 }>, Schema.Struct<{
@@ -611,6 +631,7 @@ type StreamDataResponse<TA> = ResponseWithoutData | {
         cursor?: Cursor | undefined;
         endCursor?: Cursor | undefined;
         finality: DataFinality;
+        production: DataProduction;
         data: readonly (TA | null)[];
     };
 };
@@ -644,6 +665,7 @@ declare class StreamConfig<TFilter, TBlock> {
             cursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
             endCursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
             finality: Schema.transform<Schema.Enums<typeof DataFinality$1>, Schema.Literal<["finalized", "accepted", "pending", "unknown"]>>;
+            production: Schema.transform<Schema.Enums<typeof DataProduction$1>, Schema.Literal<["backfill", "live", "unknown"]>>;
             data: Schema.Array$<Schema.Schema<TBlock | null, Uint8Array, never>>;
         }>;
     }>, Schema.Struct<{
@@ -672,13 +694,18 @@ declare class StreamConfig<TFilter, TBlock> {
     }>]>;
 }
 
+declare class TimeoutError extends Error {
+    constructor(timeout: number);
+}
 /** Client call options. */
 interface ClientCallOptions {
     signal?: AbortSignal;
 }
 interface StreamDataOptions extends ClientCallOptions {
-    /** Stop at the specified cursor (inclusive) */
+    /** Stop at the specified cursor (inclusive). */
     endingCursor?: Cursor;
+    /** Timeout between messages, in milliseconds. */
+    timeout?: number;
 }
 /** DNA client. */
 interface Client<TFilter, TBlock> {
@@ -715,4 +742,4 @@ declare class StreamDataIterable<TBlock> {
     [Symbol.asyncIterator](): AsyncIterator<StreamDataResponse<TBlock>>;
 }
 
-export { type StreamDataOptions as A, Bytes as B, type CursorProto as C, type DnaStreamClient as D, type Client as E, Finalize as F, type CreateClientOptions as G, Heartbeat as H, Invalidate as I, createClient as J, GrpcClient as K, StreamDataIterable as L, DataFinality$1 as M, StatusRequest as S, _Cursor as _, DnaStreamDefinition as a, BytesFromUint8Array as b, Cursor as c, createCursor as d, cursorToProto as e, cursorFromProto as f, CursorFromBytes as g, cursorToBytes as h, cursorFromBytes as i, isCursor as j, statusRequestToProto as k, statusRequestFromProto as l, StatusResponse as m, statusResponseToProto as n, statusResponseFromProto as o, DataFinality as p, Duration as q, StreamDataRequest as r, stream as s, StdOut as t, StdErr as u, SystemMessage as v, Data as w, StreamDataResponse as x, StreamConfig as y, type ClientCallOptions as z };
+export { type ClientCallOptions as A, Bytes as B, type CursorProto as C, type DnaStreamClient as D, type StreamDataOptions as E, Finalize as F, type Client as G, Heartbeat as H, Invalidate as I, type CreateClientOptions as J, createClient as K, GrpcClient as L, StreamDataIterable as M, DataFinality$1 as N, DataProduction$1 as O, StatusRequest as S, TimeoutError as T, _Cursor as _, DnaStreamDefinition as a, BytesFromUint8Array as b, Cursor as c, createCursor as d, cursorToProto as e, cursorFromProto as f, CursorFromBytes as g, cursorToBytes as h, cursorFromBytes as i, isCursor as j, statusRequestToProto as k, statusRequestFromProto as l, StatusResponse as m, statusResponseToProto as n, statusResponseFromProto as o, DataFinality as p, DataProduction as q, Duration as r, stream as s, StreamDataRequest as t, StdOut as u, StdErr as v, SystemMessage as w, Data as x, StreamDataResponse as y, StreamConfig as z };

package/dist/testing/index.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
 const schema = require('@effect/schema');
-const config = require('../shared/protocol.74b3c596.cjs');
+const config = require('../shared/protocol.2d8d950d.cjs');
 require('protobufjs/minimal.js');
 require('effect');
 require('viem');

package/dist/testing/index.d.cts

@@ -1,4 +1,4 @@
-import { E as Client, r as StreamDataRequest, A as StreamDataOptions, x as StreamDataResponse, S as StatusRequest, z as ClientCallOptions, m as StatusResponse, y as StreamConfig, c as Cursor, C as CursorProto, M as DataFinality } from '../shared/protocol.f9e14c27.cjs';
+import { G as Client, t as StreamDataRequest, E as StreamDataOptions, y as StreamDataResponse, S as StatusRequest, A as ClientCallOptions, m as StatusResponse, z as StreamConfig, c as Cursor, C as CursorProto, N as DataFinality, O as DataProduction } from '../shared/protocol.ef662c22.cjs';
 import { Schema } from '@effect/schema';
 import 'nice-grpc';
 import 'nice-grpc-common';
@@ -42,6 +42,7 @@ declare const MockStreamResponse: Schema.Union<[Schema.Struct<{
         cursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
         endCursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
         finality: Schema.transform<Schema.Enums<typeof DataFinality>, Schema.Literal<["finalized", "accepted", "pending", "unknown"]>>;
+        production: Schema.transform<Schema.Enums<typeof DataProduction>, Schema.Literal<["backfill", "live", "unknown"]>>;
         data: Schema.Array$<Schema.Schema<{
             readonly data?: string | undefined;
         } | null, Uint8Array, never>>;

package/dist/testing/index.d.mts

@@ -1,4 +1,4 @@
-import { E as Client, r as StreamDataRequest, A as StreamDataOptions, x as StreamDataResponse, S as StatusRequest, z as ClientCallOptions, m as StatusResponse, y as StreamConfig, c as Cursor, C as CursorProto, M as DataFinality } from '../shared/protocol.f9e14c27.mjs';
+import { G as Client, t as StreamDataRequest, E as StreamDataOptions, y as StreamDataResponse, S as StatusRequest, A as ClientCallOptions, m as StatusResponse, z as StreamConfig, c as Cursor, C as CursorProto, N as DataFinality, O as DataProduction } from '../shared/protocol.ef662c22.mjs';
 import { Schema } from '@effect/schema';
 import 'nice-grpc';
 import 'nice-grpc-common';
@@ -42,6 +42,7 @@ declare const MockStreamResponse: Schema.Union<[Schema.Struct<{
         cursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
         endCursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
         finality: Schema.transform<Schema.Enums<typeof DataFinality>, Schema.Literal<["finalized", "accepted", "pending", "unknown"]>>;
+        production: Schema.transform<Schema.Enums<typeof DataProduction>, Schema.Literal<["backfill", "live", "unknown"]>>;
         data: Schema.Array$<Schema.Schema<{
             readonly data?: string | undefined;
         } | null, Uint8Array, never>>;

package/dist/testing/index.d.ts

@@ -1,4 +1,4 @@
-import { E as Client, r as StreamDataRequest, A as StreamDataOptions, x as StreamDataResponse, S as StatusRequest, z as ClientCallOptions, m as StatusResponse, y as StreamConfig, c as Cursor, C as CursorProto, M as DataFinality } from '../shared/protocol.f9e14c27.js';
+import { G as Client, t as StreamDataRequest, E as StreamDataOptions, y as StreamDataResponse, S as StatusRequest, A as ClientCallOptions, m as StatusResponse, z as StreamConfig, c as Cursor, C as CursorProto, N as DataFinality, O as DataProduction } from '../shared/protocol.ef662c22.js';
 import { Schema } from '@effect/schema';
 import 'nice-grpc';
 import 'nice-grpc-common';
@@ -42,6 +42,7 @@ declare const MockStreamResponse: Schema.Union<[Schema.Struct<{
         cursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
         endCursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
         finality: Schema.transform<Schema.Enums<typeof DataFinality>, Schema.Literal<["finalized", "accepted", "pending", "unknown"]>>;
+        production: Schema.transform<Schema.Enums<typeof DataProduction>, Schema.Literal<["backfill", "live", "unknown"]>>;
         data: Schema.Array$<Schema.Schema<{
             readonly data?: string | undefined;
         } | null, Uint8Array, never>>;

package/dist/testing/index.mjs

@@ -1,5 +1,5 @@
 import { Schema } from '@effect/schema';
-import { M as MockFilter$1, q as MockBlock$1, p as StreamConfig, S as StreamDataResponse } from '../shared/protocol.32079ba8.mjs';
+import { M as MockFilter$1, r as MockBlock$1, q as StreamConfig, S as StreamDataResponse } from '../shared/protocol.91527bce.mjs';
 import 'protobufjs/minimal.js';
 import 'effect';
 import 'viem';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apibara/protocol",
-  "version": "2.0.0-beta.32",
+  "version": "2.0.0-beta.34",
   "type": "module",
   "files": [
     "dist",

package/src/client.ts

@@ -23,14 +23,25 @@ import { type StreamDataRequest, StreamDataResponse } from "./stream";
 
 export { ClientError, Status } from "nice-grpc";
 
+const DEFAULT_TIMEOUT_MS = 45_000;
+
+export class TimeoutError extends Error {
+  constructor(timeout: number) {
+    super(`No message received in ${timeout}ms`);
+    this.name = "TimeoutError";
+  }
+}
+
 /** Client call options. */
 export interface ClientCallOptions {
   signal?: AbortSignal;
 }
 
 export interface StreamDataOptions extends ClientCallOptions {
-  /** Stop at the specified cursor (inclusive) */
+  /** Stop at the specified cursor (inclusive). */
   endingCursor?: Cursor;
+  /** Timeout between messages, in milliseconds. */
+  timeout?: number;
 }
 
 /** DNA client. */
@@ -112,44 +123,61 @@ export class StreamDataIterable<TBlock> {
     const inner = this.it[Symbol.asyncIterator]();
     const schema = StreamDataResponse(this.schema);
     const decoder = Schema.decodeSync(schema);
-    const { endingCursor } = this.options ?? {};
+    const { endingCursor, timeout = DEFAULT_TIMEOUT_MS } = this.options ?? {};
     let shouldStop = false;
 
+    let clock: string | number | NodeJS.Timeout | undefined;
+
     return {
       async next() {
         if (shouldStop) {
           return { done: true, value: undefined };
         }
 
-        const { done, value } = await inner.next();
+        // biome-ignore lint/suspicious/noExplicitAny: any is ok
+        const t: Promise<{ done: boolean; value: any }> = new Promise(
+          (_, reject) => {
+            clock = setTimeout(() => {
+              reject(new TimeoutError(timeout));
+            }, timeout);
+          },
+        );
 
-        if (done || value.message === undefined) {
-          return { done: true, value: undefined };
-        }
+        try {
+          const { done, value } = await Promise.race([inner.next(), t]);
+
+          clearTimeout(clock);
+
+          if (done || value.message === undefined) {
+            return { done: true, value: undefined };
+          }
 
-        const decodedMessage = decoder(value.message);
+          const decodedMessage = decoder(value.message);
 
-        if (endingCursor) {
-          assert(value.message.$case === "data");
-          assert(decodedMessage._tag === "data");
+          if (endingCursor) {
+            assert(value.message.$case === "data");
+            assert(decodedMessage._tag === "data");
 
-          const { orderKey, uniqueKey } = endingCursor;
-          const endCursor = decodedMessage.data.endCursor;
+            const { orderKey, uniqueKey } = endingCursor;
+            const endCursor = decodedMessage.data.endCursor;
 
-          // Check if the orderKey matches
-          if (orderKey === endCursor?.orderKey) {
-            // If a uniqueKey is specified, it must also match
-            if (!uniqueKey || uniqueKey === endCursor.uniqueKey) {
-              shouldStop = true;
-              return { done: false, value: decodedMessage };
+            // Check if the orderKey matches
+            if (orderKey === endCursor?.orderKey) {
+              // If a uniqueKey is specified, it must also match
+              if (!uniqueKey || uniqueKey === endCursor.uniqueKey) {
+                shouldStop = true;
+                return { done: false, value: decodedMessage };
+              }
             }
           }
-        }
 
-        return {
-          done: false,
-          value: decodedMessage,
-        };
+          return {
+            done: false,
+            value: decodedMessage,
+          };
+        } finally {
+          clearTimeout(clock);
+        }
       },
     };
   }

package/src/proto/stream.ts

@@ -63,6 +63,48 @@ export function dataFinalityToJSON(object: DataFinality): string {
   }
 }
 
+/** Data production mode. */
+export enum DataProduction {
+  UNKNOWN = 0,
+  /** BACKFILL - Data is for a backfilled block. */
+  BACKFILL = 1,
+  /** LIVE - Data is for a live block. */
+  LIVE = 2,
+  UNRECOGNIZED = -1,
+}
+
+export function dataProductionFromJSON(object: any): DataProduction {
+  switch (object) {
+    case 0:
+    case "DATA_PRODUCTION_UNKNOWN":
+      return DataProduction.UNKNOWN;
+    case 1:
+    case "DATA_PRODUCTION_BACKFILL":
+      return DataProduction.BACKFILL;
+    case 2:
+    case "DATA_PRODUCTION_LIVE":
+      return DataProduction.LIVE;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return DataProduction.UNRECOGNIZED;
+  }
+}
+
+export function dataProductionToJSON(object: DataProduction): string {
+  switch (object) {
+    case DataProduction.UNKNOWN:
+      return "DATA_PRODUCTION_UNKNOWN";
+    case DataProduction.BACKFILL:
+      return "DATA_PRODUCTION_BACKFILL";
+    case DataProduction.LIVE:
+      return "DATA_PRODUCTION_LIVE";
+    case DataProduction.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
 /** A cursor over the stream content. */
 export interface Cursor {
   /**
@@ -192,6 +234,8 @@ export interface Data {
    * This message contains chain-specific data serialized using protobuf.
    */
   readonly data: readonly Uint8Array[];
+  /** The production mode of the block. */
+  readonly production: DataProduction;
 }
 
 /** Sent to clients to check if stream is still connected. */
@@ -838,7 +882,7 @@ export const Finalize = {
 };
 
 function createBaseData(): Data {
-  return { cursor: undefined, endCursor: undefined, finality: 0, data: [] };
+  return { cursor: undefined, endCursor: undefined, finality: 0, data: [], production: 0 };
 }
 
 export const Data = {
@@ -855,6 +899,9 @@ export const Data = {
     for (const v of message.data) {
       writer.uint32(34).bytes(v!);
     }
+    if (message.production !== 0) {
+      writer.uint32(40).int32(message.production);
+    }
     return writer;
   },
 
@@ -893,6 +940,13 @@ export const Data = {
 
           message.data.push(reader.bytes());
           continue;
+        case 5:
+          if (tag !== 40) {
+            break;
+          }
+
+          message.production = reader.int32() as any;
+          continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -908,6 +962,7 @@ export const Data = {
       endCursor: isSet(object.endCursor) ? Cursor.fromJSON(object.endCursor) : undefined,
       finality: isSet(object.finality) ? dataFinalityFromJSON(object.finality) : 0,
       data: globalThis.Array.isArray(object?.data) ? object.data.map((e: any) => bytesFromBase64(e)) : [],
+      production: isSet(object.production) ? dataProductionFromJSON(object.production) : 0,
     };
   },
 
@@ -925,6 +980,9 @@ export const Data = {
     if (message.data?.length) {
       obj.data = message.data.map((e) => base64FromBytes(e));
     }
+    if (message.production !== 0) {
+      obj.production = dataProductionToJSON(message.production);
+    }
     return obj;
   },
 
@@ -941,6 +999,7 @@ export const Data = {
       : undefined;
     message.finality = object.finality ?? 0;
     message.data = object.data?.map((e) => e) || [];
+    message.production = object.production ?? 0;
     return message;
   },
 };

package/src/stream.test.ts

@@ -95,6 +95,7 @@ describe("StreamDataResponse", () => {
         data: {
           finality: "accepted",
           data: [{ value: "hello" }, { value: "world" }],
+          production: "backfill",
         },
       } as const;
 
@@ -120,6 +121,7 @@ describe("StreamDataResponse", () => {
               ],
             ],
             "finality": 2,
+            "production": 1,
           },
         }
       `);

package/src/stream.ts

@@ -34,6 +34,35 @@ export const DataFinality = Schema.transform(
 
 export type DataFinality = typeof DataFinality.Type;
 
+/** Data production mode. */
+export const DataProduction = Schema.transform(
+  Schema.Enums(proto.stream.DataProduction),
+  Schema.Literal("backfill", "live", "unknown"),
+  {
+    decode(value) {
+      const enumMap = {
+        [proto.stream.DataProduction.BACKFILL]: "backfill",
+        [proto.stream.DataProduction.LIVE]: "live",
+        [proto.stream.DataProduction.UNKNOWN]: "unknown",
+        [proto.stream.DataProduction.UNRECOGNIZED]: "unknown",
+      } as const;
+
+      return enumMap[value] ?? "unknown";
+    },
+    encode(value) {
+      const enumMap = {
+        backfill: proto.stream.DataProduction.BACKFILL,
+        live: proto.stream.DataProduction.LIVE,
+        unknown: proto.stream.DataProduction.UNKNOWN,
+      };
+
+      return enumMap[value] ?? proto.stream.DataProduction.UNKNOWN;
+    },
+  },
+);
+
+export type DataProduction = typeof DataProduction.Type;
+
 export const Duration = Schema.Struct({
   seconds: Schema.BigIntFromSelf,
   nanos: Schema.Number,
@@ -112,6 +141,7 @@ export const Data = <TA, TR>(
       cursor: Schema.optional(Cursor),
       endCursor: Schema.optional(Cursor),
       finality: DataFinality,
+      production: DataProduction,
       data: Schema.Array(schema),
     }),
   });
@@ -136,6 +166,7 @@ export type StreamDataResponse<TA> =
         cursor?: Cursor | undefined;
         endCursor?: Cursor | undefined;
         finality: DataFinality;
+        production: DataProduction;
         data: readonly (TA | null)[];
       };
     };

package/src/testing/client.test.ts

@@ -9,7 +9,11 @@ describe("MockClient", () => {
       return [
         {
           _tag: "data",
-          data: { finality: "finalized", data: [{ data: "hello" }] },
+          data: {
+            finality: "finalized",
+            data: [{ data: "hello" }],
+            production: "backfill",
+          },
         },
       ];
     });
@@ -30,6 +34,7 @@ describe("MockClient", () => {
               },
             ],
             "finality": "finalized",
+            "production": "backfill",
           },
         },
       ]
@@ -41,7 +46,11 @@ describe("MockClient", () => {
       return [
         {
           _tag: "data",
-          data: { finality: "finalized", data: [{ data: "hello" }, null] },
+          data: {
+            finality: "finalized",
+            data: [{ data: "hello" }, null],
+            production: "backfill",
+          },
         },
       ];
     });
@@ -63,6 +72,7 @@ describe("MockClient", () => {
               null,
             ],
             "finality": "finalized",
+            "production": "backfill",
           },
         },
       ]