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

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

@@ -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 };

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

@@ -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 };

package/dist/shared/{protocol.d9596779.mjs → protocol.991ff9ad.mjs}

@@ -128,6 +128,43 @@ function dataFinalityToJSON(object) {
       return "UNRECOGNIZED";
   }
 }
+var DataProduction$1 = /* @__PURE__ */ ((DataProduction2) => {
+  DataProduction2[DataProduction2["UNKNOWN"] = 0] = "UNKNOWN";
+  DataProduction2[DataProduction2["BACKFILL"] = 1] = "BACKFILL";
+  DataProduction2[DataProduction2["LIVE"] = 2] = "LIVE";
+  DataProduction2[DataProduction2["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+  return DataProduction2;
+})(DataProduction$1 || {});
+function dataProductionFromJSON(object) {
+  switch (object) {
+    case 0:
+    case "DATA_PRODUCTION_UNKNOWN":
+      return 0 /* UNKNOWN */;
+    case 1:
+    case "DATA_PRODUCTION_BACKFILL":
+      return 1 /* BACKFILL */;
+    case 2:
+    case "DATA_PRODUCTION_LIVE":
+      return 2 /* LIVE */;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return -1 /* UNRECOGNIZED */;
+  }
+}
+function dataProductionToJSON(object) {
+  switch (object) {
+    case 0 /* UNKNOWN */:
+      return "DATA_PRODUCTION_UNKNOWN";
+    case 1 /* BACKFILL */:
+      return "DATA_PRODUCTION_BACKFILL";
+    case 2 /* LIVE */:
+      return "DATA_PRODUCTION_LIVE";
+    case -1 /* UNRECOGNIZED */:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
 function createBaseCursor() {
   return { orderKey: BigInt("0"), uniqueKey: new Uint8Array(0) };
 }
@@ -656,7 +693,7 @@ const Finalize$1 = {
   }
 };
 function createBaseData() {
-  return { cursor: void 0, endCursor: void 0, finality: 0, data: [] };
+  return { cursor: void 0, endCursor: void 0, finality: 0, data: [], production: 0 };
 }
 const Data$1 = {
   encode(message, writer = _m0.Writer.create()) {
@@ -672,6 +709,9 @@ const Data$1 = {
     for (const v of message.data) {
       writer.uint32(34).bytes(v);
     }
+    if (message.production !== 0) {
+      writer.uint32(40).int32(message.production);
+    }
     return writer;
   },
   decode(input, length) {
@@ -705,6 +745,12 @@ const Data$1 = {
           }
           message.data.push(reader.bytes());
           continue;
+        case 5:
+          if (tag !== 40) {
+            break;
+          }
+          message.production = reader.int32();
+          continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -718,7 +764,8 @@ const Data$1 = {
       cursor: isSet$1(object.cursor) ? Cursor$1.fromJSON(object.cursor) : void 0,
       endCursor: isSet$1(object.endCursor) ? Cursor$1.fromJSON(object.endCursor) : void 0,
       finality: isSet$1(object.finality) ? dataFinalityFromJSON(object.finality) : 0,
-      data: globalThis.Array.isArray(object?.data) ? object.data.map((e) => bytesFromBase64(e)) : []
+      data: globalThis.Array.isArray(object?.data) ? object.data.map((e) => bytesFromBase64(e)) : [],
+      production: isSet$1(object.production) ? dataProductionFromJSON(object.production) : 0
     };
   },
   toJSON(message) {
@@ -735,6 +782,9 @@ const Data$1 = {
     if (message.data?.length) {
       obj.data = message.data.map((e) => base64FromBytes(e));
     }
+    if (message.production !== 0) {
+      obj.production = dataProductionToJSON(message.production);
+    }
     return obj;
   },
   create(base) {
@@ -746,6 +796,7 @@ const Data$1 = {
     message.endCursor = object.endCursor !== void 0 && object.endCursor !== null ? Cursor$1.fromPartial(object.endCursor) : void 0;
     message.finality = object.finality ?? 0;
     message.data = object.data?.map((e) => e) || [];
+    message.production = object.production ?? 0;
     return message;
   }
 };
@@ -918,6 +969,7 @@ const stream = {
   Cursor: Cursor$1,
   Data: Data$1,
   DataFinality: DataFinality$1,
+  DataProduction: DataProduction$1,
   DnaStreamDefinition: DnaStreamDefinition,
   Finalize: Finalize$1,
   Heartbeat: Heartbeat$1,
@@ -929,6 +981,8 @@ const stream = {
   SystemMessage: SystemMessage$1,
   dataFinalityFromJSON: dataFinalityFromJSON,
   dataFinalityToJSON: dataFinalityToJSON,
+  dataProductionFromJSON: dataProductionFromJSON,
+  dataProductionToJSON: dataProductionToJSON,
   protobufPackage: protobufPackage$1
 };
 
@@ -1090,6 +1144,21 @@ const CursorFromBytes = Schema.transform(
 );
 const cursorToBytes = Schema.encodeSync(CursorFromBytes);
 const cursorFromBytes = Schema.decodeSync(CursorFromBytes);
+function isCursor(value) {
+  return Schema.is(Cursor)(value);
+}
+function normalizeCursor(cursor) {
+  if (cursor.uniqueKey !== null && cursor.uniqueKey.length > 0) {
+    const uniqueKey = cursor.uniqueKey;
+    return {
+      orderKey: BigInt(cursor.orderKey),
+      uniqueKey
+    };
+  }
+  return {
+    orderKey: BigInt(cursor.orderKey)
+  };
+}
 
 const DataFinality = Schema.transform(
   Schema.Enums(DataFinality$1),
@@ -1116,6 +1185,29 @@ const DataFinality = Schema.transform(
     }
   }
 );
+const DataProduction = Schema.transform(
+  Schema.Enums(DataProduction$1),
+  Schema.Literal("backfill", "live", "unknown"),
+  {
+    decode(value) {
+      const enumMap = {
+        [DataProduction$1.BACKFILL]: "backfill",
+        [DataProduction$1.LIVE]: "live",
+        [DataProduction$1.UNKNOWN]: "unknown",
+        [DataProduction$1.UNRECOGNIZED]: "unknown"
+      };
+      return enumMap[value] ?? "unknown";
+    },
+    encode(value) {
+      const enumMap = {
+        backfill: DataProduction$1.BACKFILL,
+        live: DataProduction$1.LIVE,
+        unknown: DataProduction$1.UNKNOWN
+      };
+      return enumMap[value] ?? DataProduction$1.UNKNOWN;
+    }
+  }
+);
 const Duration = Schema.Struct({
   seconds: Schema.BigIntFromSelf,
   nanos: Schema.Number
@@ -1152,15 +1244,16 @@ const StdErr = Schema.Struct({
 const SystemMessage = Schema.Struct({
   _tag: tag("systemMessage"),
   systemMessage: Schema.Struct({
-    output: Schema.optional(Schema.Union(StdOut, StdErr))
+    output: Schema.Union(StdOut, StdErr)
   })
 });
 const Data = (schema) => Schema.Struct({
   _tag: tag("data"),
   data: Schema.Struct({
     cursor: Schema.optional(Cursor),
-    endCursor: Schema.optional(Cursor),
+    endCursor: Cursor,
     finality: DataFinality,
+    production: DataProduction,
     data: Schema.Array(schema)
   })
 });
@@ -1212,4 +1305,4 @@ class StreamConfig {
   }
 }
 
-export { Bytes as B, Cursor as C, DnaStreamDefinition as D, Finalize as F, Heartbeat as H, Invalidate as I, MockFilter as M, StreamDataResponse as S, _Cursor as _, BytesFromUint8Array as a, cursorToProto as b, createCursor as c, cursorFromProto as d, CursorFromBytes as e, cursorToBytes as f, cursorFromBytes as g, DataFinality as h, Duration as i, StreamDataRequest as j, StdOut as k, StdErr as l, SystemMessage as m, Data as n, StreamConfig as o, MockBlock as p, stream as s, testing as t };
+export { Bytes as B, Cursor as C, DnaStreamDefinition as D, Finalize as F, Heartbeat as H, Invalidate as I, MockFilter as M, StreamDataResponse as S, _Cursor as _, BytesFromUint8Array as a, cursorToProto as b, createCursor as c, cursorFromProto as d, CursorFromBytes as e, cursorToBytes as f, cursorFromBytes as g, DataFinality as h, isCursor as i, DataProduction as j, Duration as k, StreamDataRequest as l, StdOut as m, normalizeCursor as n, StdErr as o, SystemMessage as p, Data as q, StreamConfig as r, stream as s, testing as t, MockBlock as u };