@apibara/protocol 2.0.0-beta.9 → 2.1.0-beta.2

package/dist/index.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-const config = require('./shared/protocol.e1dec68a.cjs');
+const config = require('./shared/protocol.e39e40d6.cjs');
 const schema = require('@effect/schema');
 const niceGrpc = require('nice-grpc');
 require('protobufjs/minimal.js');
@@ -37,12 +37,23 @@ var __publicField$1 = (obj, key, value) => {
   __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
-function createClient(config$1, streamUrl, defaultCallOptions) {
-  const channel = niceGrpc.createChannel(streamUrl);
+const DEFAULT_TIMEOUT_MS = 45e3;
+class TimeoutError extends Error {
+  constructor(timeout) {
+    super(`No message received in ${timeout}ms`);
+    this.name = "TimeoutError";
+  }
+}
+function createClient(config$1, streamUrl, options = {}) {
+  const channel = niceGrpc.createChannel(
+    streamUrl,
+    options?.credentials,
+    options?.channelOptions
+  );
   const client = niceGrpc.createClient(
     config.DnaStreamDefinition,
     channel,
-    defaultCallOptions
+    options?.defaultCallOptions
   );
   return new GrpcClient(config$1, client);
 }
@@ -75,34 +86,47 @@ class StreamDataIterable {
     const inner = this.it[Symbol.asyncIterator]();
     const schema$1 = config.StreamDataResponse(this.schema);
     const decoder = schema.Schema.decodeSync(schema$1);
-    const { endingCursor } = this.options ?? {};
+    const { endingCursor, timeout = DEFAULT_TIMEOUT_MS } = this.options ?? {};
     let shouldStop = false;
+    let clock;
     return {
       async next() {
         if (shouldStop) {
           return { done: true, value: void 0 };
         }
-        const { done, value } = await inner.next();
-        if (done || value.message === void 0) {
-          return { done: true, value: void 0 };
-        }
-        const decodedMessage = decoder(value.message);
-        if (endingCursor) {
-          assert__default(value.message.$case === "data");
-          assert__default(decodedMessage._tag === "data");
-          const { orderKey, uniqueKey } = endingCursor;
-          const endCursor = decodedMessage.data.endCursor;
-          if (orderKey === endCursor?.orderKey) {
-            if (!uniqueKey || uniqueKey === endCursor.uniqueKey) {
-              shouldStop = true;
-              return { done: false, value: decodedMessage };
+        const t = new Promise(
+          (_, reject) => {
+            clock = setTimeout(() => {
+              reject(new TimeoutError(timeout));
+            }, timeout);
+          }
+        );
+        try {
+          const { done, value } = await Promise.race([inner.next(), t]);
+          clearTimeout(clock);
+          if (done || value.message === void 0) {
+            return { done: true, value: void 0 };
+          }
+          const decodedMessage = decoder(value.message);
+          if (endingCursor) {
+            assert__default(value.message.$case === "data");
+            assert__default(decodedMessage._tag === "data");
+            const { orderKey, uniqueKey } = endingCursor;
+            const endCursor = decodedMessage.data.endCursor;
+            if (orderKey === endCursor?.orderKey) {
+              if (!uniqueKey || uniqueKey === endCursor.uniqueKey) {
+                shouldStop = true;
+                return { done: false, value: decodedMessage };
+              }
             }
           }
+          return {
+            done: false,
+            value: decodedMessage
+          };
+        } finally {
+          clearTimeout(clock);
         }
-        return {
-          done: false,
-          value: decodedMessage
-        };
       }
     };
   }
@@ -162,6 +186,7 @@ exports.Cursor = config.Cursor;
 exports.CursorFromBytes = config.CursorFromBytes;
 exports.Data = config.Data;
 exports.DataFinality = config.DataFinality;
+exports.DataProduction = config.DataProduction;
 exports.DnaStreamDefinition = config.DnaStreamDefinition;
 exports.Duration = config.Duration;
 exports.Finalize = config.Finalize;
@@ -179,11 +204,16 @@ exports.cursorFromBytes = config.cursorFromBytes;
 exports.cursorFromProto = config.cursorFromProto;
 exports.cursorToBytes = config.cursorToBytes;
 exports.cursorToProto = config.cursorToProto;
+exports.isCursor = config.isCursor;
+exports.normalizeCursor = config.normalizeCursor;
+exports.ClientError = niceGrpc.ClientError;
+exports.Status = niceGrpc.Status;
 exports.GrpcClient = GrpcClient;
 exports.RateGauge = RateGauge;
 exports.StatusRequest = StatusRequest;
 exports.StatusResponse = StatusResponse;
 exports.StreamDataIterable = StreamDataIterable;
+exports.TimeoutError = TimeoutError;
 exports.createClient = createClient;
 exports.proto = index;
 exports.statusRequestFromProto = statusRequestFromProto;

package/dist/index.d.cts

@@ -1,8 +1,8 @@
-import { s as stream } from './shared/protocol.8c2a685d.cjs';
-export { B as Bytes, b as BytesFromUint8Array, A as Client, y as ClientCallOptions, c as Cursor, g as CursorFromBytes, C as CursorProto, v as Data, o as DataFinality, D as DnaStreamClient, a as DnaStreamDefinition, p as Duration, F as Finalize, G as GrpcClient, H as Heartbeat, I as Invalidate, S as StatusRequest, l as StatusResponse, t as StdErr, r as StdOut, x as StreamConfig, J as StreamDataIterable, z as StreamDataOptions, q as StreamDataRequest, w as StreamDataResponse, u as SystemMessage, _ as _Cursor, E as createClient, d as createCursor, i as cursorFromBytes, f as cursorFromProto, h as cursorToBytes, e as cursorToProto, k as statusRequestFromProto, j as statusRequestToProto, n as statusResponseFromProto, m as statusResponseToProto } from './shared/protocol.8c2a685d.cjs';
+import { s as stream } from './shared/protocol.4b1cfe2c.cjs';
+export { B as Bytes, b as BytesFromUint8Array, J as Client, E as ClientCallOptions, K as CreateClientOptions, c as Cursor, g as CursorFromBytes, C as CursorProto, y as Data, q as DataFinality, r as DataProduction, D as DnaStreamClient, a as DnaStreamDefinition, t as Duration, F as Finalize, M as GrpcClient, H as Heartbeat, I as Invalidate, S as StatusRequest, m as StatusResponse, w as StdErr, v as StdOut, A as StreamConfig, N as StreamDataIterable, G as StreamDataOptions, u as StreamDataRequest, z as StreamDataResponse, x as SystemMessage, T as TimeoutError, _ as _Cursor, L as createClient, d as createCursor, i as cursorFromBytes, f as cursorFromProto, h as cursorToBytes, e as cursorToProto, j as isCursor, n as normalizeCursor, l as statusRequestFromProto, k as statusRequestToProto, p as statusResponseFromProto, o as statusResponseToProto } from './shared/protocol.4b1cfe2c.cjs';
 import _m0 from 'protobufjs/minimal.js';
+export { ClientError, Status } from 'nice-grpc';
 import '@effect/schema';
-import 'nice-grpc';
 import 'nice-grpc-common';
 import '@effect/schema/AST';
 

package/dist/index.d.mts

@@ -1,8 +1,8 @@
-import { s as stream } from './shared/protocol.8c2a685d.mjs';
-export { B as Bytes, b as BytesFromUint8Array, A as Client, y as ClientCallOptions, c as Cursor, g as CursorFromBytes, C as CursorProto, v as Data, o as DataFinality, D as DnaStreamClient, a as DnaStreamDefinition, p as Duration, F as Finalize, G as GrpcClient, H as Heartbeat, I as Invalidate, S as StatusRequest, l as StatusResponse, t as StdErr, r as StdOut, x as StreamConfig, J as StreamDataIterable, z as StreamDataOptions, q as StreamDataRequest, w as StreamDataResponse, u as SystemMessage, _ as _Cursor, E as createClient, d as createCursor, i as cursorFromBytes, f as cursorFromProto, h as cursorToBytes, e as cursorToProto, k as statusRequestFromProto, j as statusRequestToProto, n as statusResponseFromProto, m as statusResponseToProto } from './shared/protocol.8c2a685d.mjs';
+import { s as stream } from './shared/protocol.4b1cfe2c.mjs';
+export { B as Bytes, b as BytesFromUint8Array, J as Client, E as ClientCallOptions, K as CreateClientOptions, c as Cursor, g as CursorFromBytes, C as CursorProto, y as Data, q as DataFinality, r as DataProduction, D as DnaStreamClient, a as DnaStreamDefinition, t as Duration, F as Finalize, M as GrpcClient, H as Heartbeat, I as Invalidate, S as StatusRequest, m as StatusResponse, w as StdErr, v as StdOut, A as StreamConfig, N as StreamDataIterable, G as StreamDataOptions, u as StreamDataRequest, z as StreamDataResponse, x as SystemMessage, T as TimeoutError, _ as _Cursor, L as createClient, d as createCursor, i as cursorFromBytes, f as cursorFromProto, h as cursorToBytes, e as cursorToProto, j as isCursor, n as normalizeCursor, l as statusRequestFromProto, k as statusRequestToProto, p as statusResponseFromProto, o as statusResponseToProto } from './shared/protocol.4b1cfe2c.mjs';
 import _m0 from 'protobufjs/minimal.js';
+export { ClientError, Status } from 'nice-grpc';
 import '@effect/schema';
-import 'nice-grpc';
 import 'nice-grpc-common';
 import '@effect/schema/AST';
 

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-import { s as stream } from './shared/protocol.8c2a685d.js';
-export { B as Bytes, b as BytesFromUint8Array, A as Client, y as ClientCallOptions, c as Cursor, g as CursorFromBytes, C as CursorProto, v as Data, o as DataFinality, D as DnaStreamClient, a as DnaStreamDefinition, p as Duration, F as Finalize, G as GrpcClient, H as Heartbeat, I as Invalidate, S as StatusRequest, l as StatusResponse, t as StdErr, r as StdOut, x as StreamConfig, J as StreamDataIterable, z as StreamDataOptions, q as StreamDataRequest, w as StreamDataResponse, u as SystemMessage, _ as _Cursor, E as createClient, d as createCursor, i as cursorFromBytes, f as cursorFromProto, h as cursorToBytes, e as cursorToProto, k as statusRequestFromProto, j as statusRequestToProto, n as statusResponseFromProto, m as statusResponseToProto } from './shared/protocol.8c2a685d.js';
+import { s as stream } from './shared/protocol.4b1cfe2c.js';
+export { B as Bytes, b as BytesFromUint8Array, J as Client, E as ClientCallOptions, K as CreateClientOptions, c as Cursor, g as CursorFromBytes, C as CursorProto, y as Data, q as DataFinality, r as DataProduction, D as DnaStreamClient, a as DnaStreamDefinition, t as Duration, F as Finalize, M as GrpcClient, H as Heartbeat, I as Invalidate, S as StatusRequest, m as StatusResponse, w as StdErr, v as StdOut, A as StreamConfig, N as StreamDataIterable, G as StreamDataOptions, u as StreamDataRequest, z as StreamDataResponse, x as SystemMessage, T as TimeoutError, _ as _Cursor, L as createClient, d as createCursor, i as cursorFromBytes, f as cursorFromProto, h as cursorToBytes, e as cursorToProto, j as isCursor, n as normalizeCursor, l as statusRequestFromProto, k as statusRequestToProto, p as statusResponseFromProto, o as statusResponseToProto } from './shared/protocol.4b1cfe2c.js';
 import _m0 from 'protobufjs/minimal.js';
+export { ClientError, Status } from 'nice-grpc';
 import '@effect/schema';
-import 'nice-grpc';
 import 'nice-grpc-common';
 import '@effect/schema/AST';
 

package/dist/index.mjs

@@ -1,7 +1,8 @@
-import { s as stream, t as testing, C as Cursor, D as DnaStreamDefinition, S as StreamDataResponse } from './shared/protocol.d9596779.mjs';
-export { B as Bytes, a as BytesFromUint8Array, e as CursorFromBytes, n as Data, h as DataFinality, i as Duration, F as Finalize, H as Heartbeat, I as Invalidate, l as StdErr, k as StdOut, o as StreamConfig, j as StreamDataRequest, m as SystemMessage, _ as _Cursor, c as createCursor, g as cursorFromBytes, d as cursorFromProto, f as cursorToBytes, b as cursorToProto } from './shared/protocol.d9596779.mjs';
+import { s as stream, t as testing, C as Cursor, D as DnaStreamDefinition, S as StreamDataResponse } from './shared/protocol.991ff9ad.mjs';
+export { B as Bytes, a as BytesFromUint8Array, e as CursorFromBytes, q as Data, h as DataFinality, j as DataProduction, k as Duration, F as Finalize, H as Heartbeat, I as Invalidate, o as StdErr, m as StdOut, r as StreamConfig, l as StreamDataRequest, p as SystemMessage, _ as _Cursor, c as createCursor, g as cursorFromBytes, d as cursorFromProto, f as cursorToBytes, b as cursorToProto, i as isCursor, n as normalizeCursor } from './shared/protocol.991ff9ad.mjs';
 import { Schema } from '@effect/schema';
 import { createChannel, createClient as createClient$1 } from 'nice-grpc';
+export { ClientError, Status } from 'nice-grpc';
 import 'protobufjs/minimal.js';
 import assert from 'node:assert';
 import 'effect';
@@ -32,12 +33,23 @@ var __publicField$1 = (obj, key, value) => {
   __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
-function createClient(config, streamUrl, defaultCallOptions) {
-  const channel = createChannel(streamUrl);
+const DEFAULT_TIMEOUT_MS = 45e3;
+class TimeoutError extends Error {
+  constructor(timeout) {
+    super(`No message received in ${timeout}ms`);
+    this.name = "TimeoutError";
+  }
+}
+function createClient(config, streamUrl, options = {}) {
+  const channel = createChannel(
+    streamUrl,
+    options?.credentials,
+    options?.channelOptions
+  );
   const client = createClient$1(
     DnaStreamDefinition,
     channel,
-    defaultCallOptions
+    options?.defaultCallOptions
   );
   return new GrpcClient(config, client);
 }
@@ -70,34 +82,47 @@ class StreamDataIterable {
     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;
     return {
       async next() {
         if (shouldStop) {
           return { done: true, value: void 0 };
         }
-        const { done, value } = await inner.next();
-        if (done || value.message === void 0) {
-          return { done: true, value: void 0 };
-        }
-        const decodedMessage = decoder(value.message);
-        if (endingCursor) {
-          assert(value.message.$case === "data");
-          assert(decodedMessage._tag === "data");
-          const { orderKey, uniqueKey } = endingCursor;
-          const endCursor = decodedMessage.data.endCursor;
-          if (orderKey === endCursor?.orderKey) {
-            if (!uniqueKey || uniqueKey === endCursor.uniqueKey) {
-              shouldStop = true;
-              return { done: false, value: decodedMessage };
+        const t = new Promise(
+          (_, reject) => {
+            clock = setTimeout(() => {
+              reject(new TimeoutError(timeout));
+            }, timeout);
+          }
+        );
+        try {
+          const { done, value } = await Promise.race([inner.next(), t]);
+          clearTimeout(clock);
+          if (done || value.message === void 0) {
+            return { done: true, value: void 0 };
+          }
+          const decodedMessage = decoder(value.message);
+          if (endingCursor) {
+            assert(value.message.$case === "data");
+            assert(decodedMessage._tag === "data");
+            const { orderKey, uniqueKey } = endingCursor;
+            const endCursor = decodedMessage.data.endCursor;
+            if (orderKey === endCursor?.orderKey) {
+              if (!uniqueKey || uniqueKey === endCursor.uniqueKey) {
+                shouldStop = true;
+                return { done: false, value: decodedMessage };
+              }
             }
           }
+          return {
+            done: false,
+            value: decodedMessage
+          };
+        } finally {
+          clearTimeout(clock);
         }
-        return {
-          done: false,
-          value: decodedMessage
-        };
       }
     };
   }
@@ -151,4 +176,4 @@ class RateGauge {
   }
 }
 
-export { Cursor, DnaStreamDefinition, GrpcClient, RateGauge, StatusRequest, StatusResponse, StreamDataIterable, StreamDataResponse, createClient, index as proto, statusRequestFromProto, statusRequestToProto, statusResponseFromProto, statusResponseToProto };
+export { Cursor, DnaStreamDefinition, GrpcClient, RateGauge, StatusRequest, StatusResponse, StreamDataIterable, StreamDataResponse, TimeoutError, createClient, index as proto, statusRequestFromProto, statusRequestToProto, statusResponseFromProto, statusResponseToProto };

package/dist/shared/{protocol.8c2a685d.d.cts → protocol.4b1cfe2c.d.cts}

@@ -1,5 +1,5 @@
 import { Schema } from '@effect/schema';
-import { DefaultCallOptions, NormalizedServiceDefinition } from 'nice-grpc';
+import { DefaultCallOptions, NormalizedServiceDefinition, ChannelCredentials, ChannelOptions } from 'nice-grpc';
 import { CallContext, CallOptions } from 'nice-grpc-common';
 import _m0 from 'protobufjs/minimal.js';
 import * as _effect_schema_AST from '@effect/schema/AST';
@@ -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. */
@@ -438,6 +453,18 @@ declare const cursorFromProto: (i: CursorProto, overrideOptions?: _effect_schema
 declare const CursorFromBytes: Schema.transform<Schema.Schema<Uint8Array, Uint8Array, never>, Schema.Schema<Cursor, CursorProto, never>>;
 declare const cursorToBytes: (a: Cursor, overrideOptions?: _effect_schema_AST.ParseOptions) => Uint8Array;
 declare const cursorFromBytes: (i: Uint8Array, overrideOptions?: _effect_schema_AST.ParseOptions) => Cursor;
+declare function isCursor(value: unknown): value is Cursor;
+/** Normalize a cursor.
+ *
+ * The challenge is that the `Cursor` validator expects `uniqueKey` to be either a `0x${string}`
+ * or not present at all. Setting the field to `undefined` will result in a validation error.
+ *
+ * @param cursor The cursor to normalize
+ */
+declare function normalizeCursor(cursor: {
+    orderKey: bigint;
+    uniqueKey: string | null;
+}): Cursor;
 
 /** The request to the `status` endpoint. */
 declare const StatusRequest: Schema.Struct<{}>;
@@ -478,6 +505,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;
@@ -528,13 +558,13 @@ type StdErr = typeof StdErr.Type;
 declare const SystemMessage: Schema.Struct<{
     _tag: Schema.PropertySignature<":", "systemMessage", "$case", ":", "systemMessage", false, never>;
     systemMessage: Schema.Struct<{
-        output: Schema.optional<Schema.Union<[Schema.Struct<{
+        output: Schema.Union<[Schema.Struct<{
             _tag: Schema.PropertySignature<":", "stdout", "$case", ":", "stdout", false, never>;
             stdout: typeof Schema.String;
         }>, Schema.Struct<{
             _tag: Schema.PropertySignature<":", "stderr", "$case", ":", "stderr", false, never>;
             stderr: typeof Schema.String;
-        }>]>>;
+        }>]>;
     }>;
 }>;
 type SystemMessage = typeof SystemMessage.Type;
@@ -542,8 +572,9 @@ declare const Data: <TA, TR>(schema: Schema.Schema<TA | null, Uint8Array, TR>) =
     _tag: Schema.PropertySignature<":", "data", "$case", ":", "data", false, never>;
     data: Schema.Struct<{
         cursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
-        endCursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
+        endCursor: 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>>;
     }>;
 }>;
@@ -562,13 +593,13 @@ declare const ResponseWithoutData: Schema.Union<[Schema.Struct<{
 }>, Schema.Struct<{
     _tag: Schema.PropertySignature<":", "systemMessage", "$case", ":", "systemMessage", false, never>;
     systemMessage: Schema.Struct<{
-        output: Schema.optional<Schema.Union<[Schema.Struct<{
+        output: Schema.Union<[Schema.Struct<{
             _tag: Schema.PropertySignature<":", "stdout", "$case", ":", "stdout", false, never>;
             stdout: typeof Schema.String;
         }>, Schema.Struct<{
             _tag: Schema.PropertySignature<":", "stderr", "$case", ":", "stderr", false, never>;
             stderr: typeof Schema.String;
-        }>]>>;
+        }>]>;
     }>;
 }>]>;
 type ResponseWithoutData = typeof ResponseWithoutData.Type;
@@ -576,8 +607,9 @@ declare const StreamDataResponse: <TA, TR>(data: Schema.Schema<TA | null, Uint8A
     _tag: Schema.PropertySignature<":", "data", "$case", ":", "data", false, never>;
     data: Schema.Struct<{
         cursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
-        endCursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
+        endCursor: 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<{
@@ -595,21 +627,22 @@ declare const StreamDataResponse: <TA, TR>(data: Schema.Schema<TA | null, Uint8A
 }>, Schema.Struct<{
     _tag: Schema.PropertySignature<":", "systemMessage", "$case", ":", "systemMessage", false, never>;
     systemMessage: Schema.Struct<{
-        output: Schema.optional<Schema.Union<[Schema.Struct<{
+        output: Schema.Union<[Schema.Struct<{
             _tag: Schema.PropertySignature<":", "stdout", "$case", ":", "stdout", false, never>;
             stdout: typeof Schema.String;
         }>, Schema.Struct<{
             _tag: Schema.PropertySignature<":", "stderr", "$case", ":", "stderr", false, never>;
             stderr: typeof Schema.String;
-        }>]>>;
+        }>]>;
     }>;
 }>]>;
 type StreamDataResponse<TA> = ResponseWithoutData | {
     _tag: "data";
     data: {
         cursor?: Cursor | undefined;
-        endCursor?: Cursor | undefined;
+        endCursor: Cursor;
         finality: DataFinality;
+        production: DataProduction;
         data: readonly (TA | null)[];
     };
 };
@@ -641,8 +674,9 @@ declare class StreamConfig<TFilter, TBlock> {
         _tag: Schema.PropertySignature<":", "data", "$case", ":", "data", false, never>;
         data: Schema.Struct<{
             cursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
-            endCursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
+            endCursor: 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<{
@@ -660,24 +694,29 @@ declare class StreamConfig<TFilter, TBlock> {
     }>, Schema.Struct<{
         _tag: Schema.PropertySignature<":", "systemMessage", "$case", ":", "systemMessage", false, never>;
         systemMessage: Schema.Struct<{
-            output: Schema.optional<Schema.Union<[Schema.Struct<{
+            output: Schema.Union<[Schema.Struct<{
                 _tag: Schema.PropertySignature<":", "stdout", "$case", ":", "stdout", false, never>;
                 stdout: typeof Schema.String;
             }>, Schema.Struct<{
                 _tag: Schema.PropertySignature<":", "stderr", "$case", ":", "stderr", false, never>;
                 stderr: typeof Schema.String;
-            }>]>>;
+            }>]>;
         }>;
     }>]>;
 }
 
+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> {
@@ -686,8 +725,13 @@ interface Client<TFilter, TBlock> {
     /** Start streaming data from the DNA server. */
     streamData(request: StreamDataRequest<TFilter>, options?: StreamDataOptions): AsyncIterable<StreamDataResponse<TBlock>>;
 }
+type CreateClientOptions = {
+    defaultCallOptions?: DefaultCallOptions<NormalizedServiceDefinition<DnaStreamDefinition>>;
+    credentials?: ChannelCredentials;
+    channelOptions?: ChannelOptions;
+};
 /** Create a client connecting to the DNA grpc service. */
-declare function createClient<TFilter, TBlock>(config: StreamConfig<TFilter, TBlock>, streamUrl: string, defaultCallOptions?: DefaultCallOptions<NormalizedServiceDefinition<DnaStreamDefinition>>): GrpcClient<TFilter, TBlock>;
+declare function createClient<TFilter, TBlock>(config: StreamConfig<TFilter, TBlock>, streamUrl: string, options?: CreateClientOptions): GrpcClient<TFilter, TBlock>;
 declare class GrpcClient<TFilter, TBlock> implements Client<TFilter, TBlock> {
     private config;
     private client;
@@ -709,4 +753,4 @@ declare class StreamDataIterable<TBlock> {
     [Symbol.asyncIterator](): AsyncIterator<StreamDataResponse<TBlock>>;
 }
 
-export { type Client as A, Bytes as B, type CursorProto as C, type DnaStreamClient as D, createClient as E, Finalize as F, GrpcClient as G, Heartbeat as H, Invalidate as I, StreamDataIterable as J, DataFinality$1 as K, 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, statusRequestToProto as j, statusRequestFromProto as k, StatusResponse as l, statusResponseToProto as m, statusResponseFromProto as n, DataFinality as o, Duration as p, StreamDataRequest as q, StdOut as r, stream as s, StdErr as t, SystemMessage as u, Data as v, StreamDataResponse as w, StreamConfig as x, type ClientCallOptions as y, type StreamDataOptions as z };
+export { StreamConfig as A, Bytes as B, type CursorProto as C, type DnaStreamClient as D, type ClientCallOptions as E, Finalize as F, type StreamDataOptions as G, Heartbeat as H, Invalidate as I, type Client as J, type CreateClientOptions as K, createClient as L, GrpcClient as M, StreamDataIterable as N, DataFinality$1 as O, DataProduction$1 as P, 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, normalizeCursor as n, statusResponseToProto as o, statusResponseFromProto as p, DataFinality as q, DataProduction as r, stream as s, Duration as t, StreamDataRequest as u, StdOut as v, StdErr as w, SystemMessage as x, Data as y, StreamDataResponse as z };