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

package/dist/shared/{protocol.e1dec68a.cjs → protocol.e39e40d6.cjs}

@@ -135,6 +135,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) };
 }
@@ -663,7 +700,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__default.Writer.create()) {
@@ -679,6 +716,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) {
@@ -712,6 +752,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;
@@ -725,7 +771,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) {
@@ -742,6 +789,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) {
@@ -753,6 +803,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;
   }
 };
@@ -925,6 +976,7 @@ const stream = {
   Cursor: Cursor$1,
   Data: Data$1,
   DataFinality: DataFinality$1,
+  DataProduction: DataProduction$1,
   DnaStreamDefinition: DnaStreamDefinition,
   Finalize: Finalize$1,
   Heartbeat: Heartbeat$1,
@@ -936,6 +988,8 @@ const stream = {
   SystemMessage: SystemMessage$1,
   dataFinalityFromJSON: dataFinalityFromJSON,
   dataFinalityToJSON: dataFinalityToJSON,
+  dataProductionFromJSON: dataProductionFromJSON,
+  dataProductionToJSON: dataProductionToJSON,
   protobufPackage: protobufPackage$1
 };
 
@@ -1097,6 +1151,21 @@ const CursorFromBytes = schema.Schema.transform(
 );
 const cursorToBytes = schema.Schema.encodeSync(CursorFromBytes);
 const cursorFromBytes = schema.Schema.decodeSync(CursorFromBytes);
+function isCursor(value) {
+  return schema.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.Schema.transform(
   schema.Schema.Enums(DataFinality$1),
@@ -1123,6 +1192,29 @@ const DataFinality = schema.Schema.transform(
     }
   }
 );
+const DataProduction = schema.Schema.transform(
+  schema.Schema.Enums(DataProduction$1),
+  schema.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.Schema.Struct({
   seconds: schema.Schema.BigIntFromSelf,
   nanos: schema.Schema.Number
@@ -1159,15 +1251,16 @@ const StdErr = schema.Schema.Struct({
 const SystemMessage = schema.Schema.Struct({
   _tag: tag("systemMessage"),
   systemMessage: schema.Schema.Struct({
-    output: schema.Schema.optional(schema.Schema.Union(StdOut, StdErr))
+    output: schema.Schema.Union(StdOut, StdErr)
   })
 });
 const Data = (schema$1) => schema.Schema.Struct({
   _tag: tag("data"),
   data: schema.Schema.Struct({
     cursor: schema.Schema.optional(Cursor),
-    endCursor: schema.Schema.optional(Cursor),
+    endCursor: Cursor,
     finality: DataFinality,
+    production: DataProduction,
     data: schema.Schema.Array(schema$1)
   })
 });
@@ -1225,6 +1318,7 @@ exports.Cursor = Cursor;
 exports.CursorFromBytes = CursorFromBytes;
 exports.Data = Data;
 exports.DataFinality = DataFinality;
+exports.DataProduction = DataProduction;
 exports.DnaStreamDefinition = DnaStreamDefinition;
 exports.Duration = Duration;
 exports.Finalize = Finalize;
@@ -1244,5 +1338,7 @@ exports.cursorFromBytes = cursorFromBytes;
 exports.cursorFromProto = cursorFromProto;
 exports.cursorToBytes = cursorToBytes;
 exports.cursorToProto = cursorToProto;
+exports.isCursor = isCursor;
+exports.normalizeCursor = normalizeCursor;
 exports.stream = stream;
 exports.testing = testing;

package/dist/testing/index.cjs

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

package/dist/testing/index.d.cts

@@ -1,4 +1,4 @@
-import { A as Client, q as StreamDataRequest, z as StreamDataOptions, w as StreamDataResponse, S as StatusRequest, y as ClientCallOptions, l as StatusResponse, x as StreamConfig, c as Cursor, C as CursorProto, K as DataFinality } from '../shared/protocol.8c2a685d.cjs';
+import { J as Client, u as StreamDataRequest, G as StreamDataOptions, z as StreamDataResponse, S as StatusRequest, E as ClientCallOptions, m as StatusResponse, A as StreamConfig, c as Cursor, C as CursorProto, O as DataFinality, P as DataProduction } from '../shared/protocol.4b1cfe2c.cjs';
 import { Schema } from '@effect/schema';
 import 'nice-grpc';
 import 'nice-grpc-common';
@@ -40,8 +40,9 @@ declare const MockStreamResponse: Schema.Union<[Schema.Struct<{
     _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>, 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>>;
@@ -61,13 +62,13 @@ declare const MockStreamResponse: 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 MockStreamResponse = typeof MockStreamResponse.Type;

package/dist/testing/index.d.mts

@@ -1,4 +1,4 @@
-import { A as Client, q as StreamDataRequest, z as StreamDataOptions, w as StreamDataResponse, S as StatusRequest, y as ClientCallOptions, l as StatusResponse, x as StreamConfig, c as Cursor, C as CursorProto, K as DataFinality } from '../shared/protocol.8c2a685d.mjs';
+import { J as Client, u as StreamDataRequest, G as StreamDataOptions, z as StreamDataResponse, S as StatusRequest, E as ClientCallOptions, m as StatusResponse, A as StreamConfig, c as Cursor, C as CursorProto, O as DataFinality, P as DataProduction } from '../shared/protocol.4b1cfe2c.mjs';
 import { Schema } from '@effect/schema';
 import 'nice-grpc';
 import 'nice-grpc-common';
@@ -40,8 +40,9 @@ declare const MockStreamResponse: Schema.Union<[Schema.Struct<{
     _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>, 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>>;
@@ -61,13 +62,13 @@ declare const MockStreamResponse: 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 MockStreamResponse = typeof MockStreamResponse.Type;

package/dist/testing/index.d.ts

@@ -1,4 +1,4 @@
-import { A as Client, q as StreamDataRequest, z as StreamDataOptions, w as StreamDataResponse, S as StatusRequest, y as ClientCallOptions, l as StatusResponse, x as StreamConfig, c as Cursor, C as CursorProto, K as DataFinality } from '../shared/protocol.8c2a685d.js';
+import { J as Client, u as StreamDataRequest, G as StreamDataOptions, z as StreamDataResponse, S as StatusRequest, E as ClientCallOptions, m as StatusResponse, A as StreamConfig, c as Cursor, C as CursorProto, O as DataFinality, P as DataProduction } from '../shared/protocol.4b1cfe2c.js';
 import { Schema } from '@effect/schema';
 import 'nice-grpc';
 import 'nice-grpc-common';
@@ -40,8 +40,9 @@ declare const MockStreamResponse: Schema.Union<[Schema.Struct<{
     _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>, 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>>;
@@ -61,13 +62,13 @@ declare const MockStreamResponse: 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 MockStreamResponse = typeof MockStreamResponse.Type;

package/dist/testing/index.mjs

@@ -1,5 +1,5 @@
 import { Schema } from '@effect/schema';
-import { M as MockFilter$1, p as MockBlock$1, o as StreamConfig, S as StreamDataResponse } from '../shared/protocol.d9596779.mjs';
+import { M as MockFilter$1, u as MockBlock$1, r as StreamConfig, S as StreamDataResponse } from '../shared/protocol.991ff9ad.mjs';
 import 'protobufjs/minimal.js';
 import 'effect';
 import 'viem';

package/package.json

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

package/src/client.ts

@@ -1,5 +1,7 @@
 import { Schema } from "@effect/schema";
 import {
+  type ChannelCredentials,
+  type ChannelOptions,
   type DefaultCallOptions,
   type NormalizedServiceDefinition,
   createChannel,
@@ -19,14 +21,27 @@ import {
 } from "./status";
 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. */
@@ -44,20 +59,32 @@ export interface Client<TFilter, TBlock> {
   ): AsyncIterable<StreamDataResponse<TBlock>>;
 }
 
+export type CreateClientOptions = {
+  defaultCallOptions?: DefaultCallOptions<
+    NormalizedServiceDefinition<proto.stream.DnaStreamDefinition>
+  >;
+  credentials?: ChannelCredentials;
+  channelOptions?: ChannelOptions;
+};
+
 /** Create a client connecting to the DNA grpc service. */
 export function createClient<TFilter, TBlock>(
   config: StreamConfig<TFilter, TBlock>,
   streamUrl: string,
-  defaultCallOptions?: DefaultCallOptions<
-    NormalizedServiceDefinition<proto.stream.DnaStreamDefinition>
-  >,
+  options: CreateClientOptions = {},
 ) {
-  const channel = createChannel(streamUrl);
+  const channel = createChannel(
+    streamUrl,
+    options?.credentials,
+    options?.channelOptions,
+  );
+
   const client: proto.stream.DnaStreamClient = grpcCreateClient(
     proto.stream.DnaStreamDefinition,
     channel,
-    defaultCallOptions,
+    options?.defaultCallOptions,
   );
+
   return new GrpcClient(config, client);
 }
 
@@ -96,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]);
 
-        const decodedMessage = decoder(value.message);
+          clearTimeout(clock);
 
-        if (endingCursor) {
-          assert(value.message.$case === "data");
-          assert(decodedMessage._tag === "data");
+          if (done || value.message === undefined) {
+            return { done: true, value: undefined };
+          }
+
+          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;
+            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/common.ts

@@ -63,3 +63,31 @@ export const CursorFromBytes = Schema.transform(
 
 export const cursorToBytes = Schema.encodeSync(CursorFromBytes);
 export const cursorFromBytes = Schema.decodeSync(CursorFromBytes);
+
+export function isCursor(value: unknown): value is Cursor {
+  return Schema.is(Cursor)(value);
+}
+
+/** 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
+ */
+export function normalizeCursor(cursor: {
+  orderKey: bigint;
+  uniqueKey: string | null;
+}): Cursor {
+  if (cursor.uniqueKey !== null && cursor.uniqueKey.length > 0) {
+    const uniqueKey = cursor.uniqueKey as `0x${string}`;
+    return {
+      orderKey: BigInt(cursor.orderKey),
+      uniqueKey,
+    };
+  }
+
+  return {
+    orderKey: BigInt(cursor.orderKey),
+  };
+}

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,11 @@ describe("StreamDataResponse", () => {
         data: {
           finality: "accepted",
           data: [{ value: "hello" }, { value: "world" }],
+          production: "backfill",
+          endCursor: {
+            orderKey: 5_000_000n,
+            uniqueKey: "0x1234567890",
+          },
         },
       } as const;
 
@@ -119,7 +124,18 @@ describe("StreamDataResponse", () => {
                 100,
               ],
             ],
+            "endCursor": {
+              "orderKey": 5000000n,
+              "uniqueKey": Uint8Array [
+                18,
+                52,
+                86,
+                120,
+                144,
+              ],
+            },
             "finality": 2,
+            "production": 1,
           },
         }
       `);