@apibara/protocol 2.0.0-beta.4 → 2.0.0-beta.41

package/dist/testing/index.cjs

@@ -0,0 +1,105 @@
+'use strict';
+
+const schema = require('@effect/schema');
+const config = require('../shared/protocol.e39e40d6.cjs');
+require('protobufjs/minimal.js');
+require('effect');
+require('viem');
+require('long');
+
+class MockClient {
+  constructor(messageFactory) {
+    this.messageFactory = messageFactory;
+  }
+  async status(request, options) {
+    throw new Error("Client.status is not implemented for VcrClient");
+  }
+  streamData(request, options) {
+    const messages = this.messageFactory(request, options);
+    return new StreamDataIterable(messages);
+  }
+}
+class StreamDataIterable {
+  constructor(messages) {
+    this.messages = messages;
+  }
+  [Symbol.asyncIterator]() {
+    let index = 0;
+    const messages = this.messages;
+    return {
+      async next() {
+        if (index >= messages.length) {
+          return { done: true, value: void 0 };
+        }
+        const message = messages[index++];
+        if (message instanceof Error) {
+          throw message;
+        }
+        return { done: false, value: message };
+      }
+    };
+  }
+}
+
+const MockFilter = schema.Schema.Struct({
+  filter: schema.Schema.optional(schema.Schema.String)
+});
+const MockFilterFromBytes = schema.Schema.transform(
+  schema.Schema.Uint8ArrayFromSelf,
+  MockFilter,
+  {
+    strict: false,
+    decode(value) {
+      return config.MockFilter.decode(value);
+    },
+    encode(value) {
+      return config.MockFilter.encode(value).finish();
+    }
+  }
+);
+const MockBlock = schema.Schema.Struct({
+  data: schema.Schema.optional(schema.Schema.String)
+});
+const MockBlockFromBytes = schema.Schema.transform(
+  schema.Schema.Uint8ArrayFromSelf,
+  schema.Schema.NullOr(MockBlock),
+  {
+    strict: false,
+    decode(value) {
+      if (value.length === 0) {
+        return null;
+      }
+      return config.MockBlock.decode(value);
+    },
+    encode(value) {
+      if (value === null) {
+        return new Uint8Array();
+      }
+      return config.MockBlock.encode(value).finish();
+    }
+  }
+);
+function mergeMockFilter(a, b) {
+  let filter = "";
+  if (a.filter) {
+    filter += a.filter;
+  }
+  if (b.filter) {
+    filter += b.filter;
+  }
+  return { filter };
+}
+const MockStream = new config.StreamConfig(
+  MockFilterFromBytes,
+  MockBlockFromBytes,
+  mergeMockFilter
+);
+const MockStreamResponse = config.StreamDataResponse(MockBlockFromBytes);
+
+exports.MockBlockFromBytes = MockBlockFromBytes;
+exports.MockClient = MockClient;
+exports.MockFilter = MockFilter;
+exports.MockFilterFromBytes = MockFilterFromBytes;
+exports.MockStream = MockStream;
+exports.MockStreamResponse = MockStreamResponse;
+exports.StreamDataIterable = StreamDataIterable;

package/dist/testing/index.d.cts

@@ -0,0 +1,76 @@
+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';
+import 'protobufjs/minimal.js';
+import '@effect/schema/AST';
+
+declare class MockClient<TFilter, TBlock> implements Client<TFilter, TBlock> {
+    private messageFactory;
+    constructor(messageFactory: (request: StreamDataRequest<TFilter>, options?: StreamDataOptions) => (StreamDataResponse<TBlock> | Error)[]);
+    status(request?: StatusRequest, options?: ClientCallOptions): Promise<StatusResponse>;
+    streamData(request: StreamDataRequest<TFilter>, options?: StreamDataOptions): StreamDataIterable<TBlock>;
+}
+declare class StreamDataIterable<TBlock> {
+    private messages;
+    constructor(messages: (StreamDataResponse<TBlock> | Error)[]);
+    [Symbol.asyncIterator](): AsyncIterator<StreamDataResponse<TBlock>>;
+}
+
+declare const MockFilter: Schema.Struct<{
+    filter: Schema.optional<typeof Schema.String>;
+}>;
+type MockFilter = typeof MockFilter.Type;
+declare const MockFilterFromBytes: Schema.transform<Schema.Schema<Uint8Array, Uint8Array, never>, Schema.Struct<{
+    filter: Schema.optional<typeof Schema.String>;
+}>>;
+declare const MockBlock: Schema.Struct<{
+    data: Schema.optional<typeof Schema.String>;
+}>;
+type MockBlock = typeof MockBlock.Type;
+declare const MockBlockFromBytes: Schema.transform<Schema.Schema<Uint8Array, Uint8Array, never>, Schema.NullOr<Schema.Struct<{
+    data: Schema.optional<typeof Schema.String>;
+}>>>;
+declare const MockStream: StreamConfig<{
+    readonly filter?: string | undefined;
+}, {
+    readonly data?: string | undefined;
+}>;
+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.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>>;
+    }>;
+}>, Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "invalidate", "$case", ":", "invalidate", false, never>;
+    invalidate: Schema.Struct<{
+        cursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
+    }>;
+}>, Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "finalize", "$case", ":", "finalize", false, never>;
+    finalize: Schema.Struct<{
+        cursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
+    }>;
+}>, Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "heartbeat", "$case", ":", "heartbeat", false, never>;
+}>, Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "systemMessage", "$case", ":", "systemMessage", false, never>;
+    systemMessage: 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;
+
+export { MockBlock, MockBlockFromBytes, MockClient, MockFilter, MockFilterFromBytes, MockStream, MockStreamResponse, StreamDataIterable };

package/dist/testing/index.d.mts

@@ -0,0 +1,76 @@
+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';
+import 'protobufjs/minimal.js';
+import '@effect/schema/AST';
+
+declare class MockClient<TFilter, TBlock> implements Client<TFilter, TBlock> {
+    private messageFactory;
+    constructor(messageFactory: (request: StreamDataRequest<TFilter>, options?: StreamDataOptions) => (StreamDataResponse<TBlock> | Error)[]);
+    status(request?: StatusRequest, options?: ClientCallOptions): Promise<StatusResponse>;
+    streamData(request: StreamDataRequest<TFilter>, options?: StreamDataOptions): StreamDataIterable<TBlock>;
+}
+declare class StreamDataIterable<TBlock> {
+    private messages;
+    constructor(messages: (StreamDataResponse<TBlock> | Error)[]);
+    [Symbol.asyncIterator](): AsyncIterator<StreamDataResponse<TBlock>>;
+}
+
+declare const MockFilter: Schema.Struct<{
+    filter: Schema.optional<typeof Schema.String>;
+}>;
+type MockFilter = typeof MockFilter.Type;
+declare const MockFilterFromBytes: Schema.transform<Schema.Schema<Uint8Array, Uint8Array, never>, Schema.Struct<{
+    filter: Schema.optional<typeof Schema.String>;
+}>>;
+declare const MockBlock: Schema.Struct<{
+    data: Schema.optional<typeof Schema.String>;
+}>;
+type MockBlock = typeof MockBlock.Type;
+declare const MockBlockFromBytes: Schema.transform<Schema.Schema<Uint8Array, Uint8Array, never>, Schema.NullOr<Schema.Struct<{
+    data: Schema.optional<typeof Schema.String>;
+}>>>;
+declare const MockStream: StreamConfig<{
+    readonly filter?: string | undefined;
+}, {
+    readonly data?: string | undefined;
+}>;
+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.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>>;
+    }>;
+}>, Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "invalidate", "$case", ":", "invalidate", false, never>;
+    invalidate: Schema.Struct<{
+        cursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
+    }>;
+}>, Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "finalize", "$case", ":", "finalize", false, never>;
+    finalize: Schema.Struct<{
+        cursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
+    }>;
+}>, Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "heartbeat", "$case", ":", "heartbeat", false, never>;
+}>, Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "systemMessage", "$case", ":", "systemMessage", false, never>;
+    systemMessage: 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;
+
+export { MockBlock, MockBlockFromBytes, MockClient, MockFilter, MockFilterFromBytes, MockStream, MockStreamResponse, StreamDataIterable };

package/dist/testing/index.d.ts

@@ -0,0 +1,76 @@
+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';
+import 'protobufjs/minimal.js';
+import '@effect/schema/AST';
+
+declare class MockClient<TFilter, TBlock> implements Client<TFilter, TBlock> {
+    private messageFactory;
+    constructor(messageFactory: (request: StreamDataRequest<TFilter>, options?: StreamDataOptions) => (StreamDataResponse<TBlock> | Error)[]);
+    status(request?: StatusRequest, options?: ClientCallOptions): Promise<StatusResponse>;
+    streamData(request: StreamDataRequest<TFilter>, options?: StreamDataOptions): StreamDataIterable<TBlock>;
+}
+declare class StreamDataIterable<TBlock> {
+    private messages;
+    constructor(messages: (StreamDataResponse<TBlock> | Error)[]);
+    [Symbol.asyncIterator](): AsyncIterator<StreamDataResponse<TBlock>>;
+}
+
+declare const MockFilter: Schema.Struct<{
+    filter: Schema.optional<typeof Schema.String>;
+}>;
+type MockFilter = typeof MockFilter.Type;
+declare const MockFilterFromBytes: Schema.transform<Schema.Schema<Uint8Array, Uint8Array, never>, Schema.Struct<{
+    filter: Schema.optional<typeof Schema.String>;
+}>>;
+declare const MockBlock: Schema.Struct<{
+    data: Schema.optional<typeof Schema.String>;
+}>;
+type MockBlock = typeof MockBlock.Type;
+declare const MockBlockFromBytes: Schema.transform<Schema.Schema<Uint8Array, Uint8Array, never>, Schema.NullOr<Schema.Struct<{
+    data: Schema.optional<typeof Schema.String>;
+}>>>;
+declare const MockStream: StreamConfig<{
+    readonly filter?: string | undefined;
+}, {
+    readonly data?: string | undefined;
+}>;
+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.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>>;
+    }>;
+}>, Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "invalidate", "$case", ":", "invalidate", false, never>;
+    invalidate: Schema.Struct<{
+        cursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
+    }>;
+}>, Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "finalize", "$case", ":", "finalize", false, never>;
+    finalize: Schema.Struct<{
+        cursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
+    }>;
+}>, Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "heartbeat", "$case", ":", "heartbeat", false, never>;
+}>, Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "systemMessage", "$case", ":", "systemMessage", false, never>;
+    systemMessage: 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;
+
+export { MockBlock, MockBlockFromBytes, MockClient, MockFilter, MockFilterFromBytes, MockStream, MockStreamResponse, StreamDataIterable };

package/dist/testing/index.mjs

@@ -0,0 +1,97 @@
+import { Schema } from '@effect/schema';
+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';
+import 'long';
+
+class MockClient {
+  constructor(messageFactory) {
+    this.messageFactory = messageFactory;
+  }
+  async status(request, options) {
+    throw new Error("Client.status is not implemented for VcrClient");
+  }
+  streamData(request, options) {
+    const messages = this.messageFactory(request, options);
+    return new StreamDataIterable(messages);
+  }
+}
+class StreamDataIterable {
+  constructor(messages) {
+    this.messages = messages;
+  }
+  [Symbol.asyncIterator]() {
+    let index = 0;
+    const messages = this.messages;
+    return {
+      async next() {
+        if (index >= messages.length) {
+          return { done: true, value: void 0 };
+        }
+        const message = messages[index++];
+        if (message instanceof Error) {
+          throw message;
+        }
+        return { done: false, value: message };
+      }
+    };
+  }
+}
+
+const MockFilter = Schema.Struct({
+  filter: Schema.optional(Schema.String)
+});
+const MockFilterFromBytes = Schema.transform(
+  Schema.Uint8ArrayFromSelf,
+  MockFilter,
+  {
+    strict: false,
+    decode(value) {
+      return MockFilter$1.decode(value);
+    },
+    encode(value) {
+      return MockFilter$1.encode(value).finish();
+    }
+  }
+);
+const MockBlock = Schema.Struct({
+  data: Schema.optional(Schema.String)
+});
+const MockBlockFromBytes = Schema.transform(
+  Schema.Uint8ArrayFromSelf,
+  Schema.NullOr(MockBlock),
+  {
+    strict: false,
+    decode(value) {
+      if (value.length === 0) {
+        return null;
+      }
+      return MockBlock$1.decode(value);
+    },
+    encode(value) {
+      if (value === null) {
+        return new Uint8Array();
+      }
+      return MockBlock$1.encode(value).finish();
+    }
+  }
+);
+function mergeMockFilter(a, b) {
+  let filter = "";
+  if (a.filter) {
+    filter += a.filter;
+  }
+  if (b.filter) {
+    filter += b.filter;
+  }
+  return { filter };
+}
+const MockStream = new StreamConfig(
+  MockFilterFromBytes,
+  MockBlockFromBytes,
+  mergeMockFilter
+);
+const MockStreamResponse = StreamDataResponse(MockBlockFromBytes);
+
+export { MockBlockFromBytes, MockClient, MockFilter, MockFilterFromBytes, MockStream, MockStreamResponse, StreamDataIterable };

package/package.json

@@ -1,9 +1,14 @@
 {
   "name": "@apibara/protocol",
-  "version": "2.0.0-beta.4",
+  "version": "2.0.0-beta.41",
   "type": "module",
-  "source": "./src/index.ts",
+  "files": [
+    "dist",
+    "src",
+    "README.md"
+  ],
   "main": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -18,7 +23,6 @@
       "default": "./dist/testing/index.mjs"
     }
   },
-  "publishConfig": {},
   "scripts": {
     "build": "pnpm build:proto && unbuild",
     "build:proto": "buf generate proto",
@@ -44,11 +48,5 @@
     "nice-grpc-common": "^2.0.2",
     "protobufjs": "^7.3.0",
     "viem": "^2.13.2"
-  },
-  "files": [
-    "dist",
-    "src",
-    "README.md"
-  ],
-  "types": "./dist/index.d.ts"
+  }
 }

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/google/protobuf/duration.ts

@@ -6,7 +6,7 @@
 
 /* eslint-disable */
 import Long from "long";
-import _m0 from "protobufjs/minimal";
+import _m0 from "protobufjs/minimal.js";
 
 export const protobufPackage = "google.protobuf";