@apibara/protocol 2.1.0-beta.3 → 2.1.0-beta.31

package/src/common.ts

@@ -1,71 +1,88 @@
-import { Schema } from "@effect/schema";
-import { Option } from "effect";
 import { hexToBytes, toHex } from "viem";
 
+import type { Codec, CodecProto, CodecType } from "./codec";
 import * as proto from "./proto";
 
 /** Bytes encoded as a 0x-prefixed hex string. */
-export const Bytes = Schema.TemplateLiteral(
-  Schema.Literal("0x"),
-  Schema.String,
-);
+export type Bytes = `0x${string}`;
 
-export type Bytes = typeof Bytes.Type;
-
-export const BytesFromUint8Array = Schema.requiredToOptional(
-  Schema.Uint8ArrayFromSelf,
-  Bytes,
-  {
-    decode(value) {
-      if (value.length === 0) {
-        return Option.none();
-      }
-      return Option.some(toHex(value));
-    },
-    encode(value) {
-      return value.pipe(
-        Option.map(hexToBytes),
-        Option.getOrElse(() => new Uint8Array(0)),
-      );
-    },
+export const BytesFromUint8Array: Codec<
+  `0x${string}` | undefined,
+  Uint8Array | undefined
+> = {
+  decode(value) {
+    if (!value || value?.length === 0) {
+      return undefined;
+    }
+    return toHex(value);
+  },
+  encode(value) {
+    if (value === undefined) {
+      return new Uint8Array(0);
+    }
+    return hexToBytes(value);
   },
-);
+};
 
-/** Represent a position in the stream. */
-export const _Cursor = Schema.Struct({
-  /** The block number. */
-  orderKey: Schema.BigIntFromSelf,
-  /** The block hash, if any. */
-  uniqueKey: BytesFromUint8Array,
-});
+type _CursorApp = {
+  orderKey: bigint;
+  uniqueKey?: Bytes | undefined;
+};
+
+type _CursorProto = proto.stream.Cursor;
 
+/** Represent a position in the stream. */
+export const Cursor: Codec<_CursorApp, _CursorProto> = {
+  decode(value) {
+    const { orderKey, uniqueKey } = value;
+    return {
+      orderKey: orderKey ?? 0n,
+      uniqueKey: BytesFromUint8Array.decode(uniqueKey),
+    };
+  },
+  encode(value) {
+    const { orderKey, uniqueKey } = value;
+    return {
+      orderKey,
+      uniqueKey: BytesFromUint8Array.encode(uniqueKey),
+    };
+  },
+};
 /** The Cursor protobuf representation. */
-export interface CursorProto extends Schema.Schema.Encoded<typeof _Cursor> {}
-export interface Cursor extends Schema.Schema.Type<typeof _Cursor> {}
-export const Cursor: Schema.Schema<Cursor, CursorProto> = _Cursor;
+export type CursorProto = CodecProto<typeof Cursor>;
+export type Cursor = CodecType<typeof Cursor>;
 export const createCursor = (props: Cursor) => props;
 
-export const cursorToProto = Schema.encodeSync(Cursor);
-export const cursorFromProto = Schema.decodeSync(Cursor);
-
-export const CursorFromBytes = Schema.transform(
-  Schema.Uint8ArrayFromSelf,
-  Cursor,
-  {
-    decode(value) {
-      return proto.stream.Cursor.decode(value);
-    },
-    encode(value) {
-      return proto.stream.Cursor.encode(value).finish();
-    },
+export const CursorFromBytes: Codec<Cursor, Uint8Array> = {
+  encode(value) {
+    const { orderKey, uniqueKey } = value;
+    return proto.stream.Cursor.encode({
+      orderKey,
+      uniqueKey: BytesFromUint8Array.encode(uniqueKey),
+    }).finish();
   },
-);
-
-export const cursorToBytes = Schema.encodeSync(CursorFromBytes);
-export const cursorFromBytes = Schema.decodeSync(CursorFromBytes);
+  decode(value) {
+    const { orderKey, uniqueKey } = proto.stream.Cursor.decode(value);
+    return {
+      orderKey: orderKey ?? 0n,
+      uniqueKey: BytesFromUint8Array.decode(uniqueKey),
+    };
+  },
+};
 
 export function isCursor(value: unknown): value is Cursor {
-  return Schema.is(Cursor)(value);
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+
+  const { orderKey, uniqueKey } = value as Cursor;
+
+  return (
+    typeof orderKey === "bigint" &&
+    (uniqueKey === null ||
+      uniqueKey === undefined ||
+      (typeof uniqueKey === "string" && uniqueKey.startsWith("0x")))
+  );
 }
 
 /** Normalize a cursor.

package/src/config.ts

@@ -1,5 +1,4 @@
-import type { Schema } from "@effect/schema";
-
+import type { Codec } from "./codec";
 import { StreamDataRequest, StreamDataResponse } from "./stream";
 
 /** Configure a DNA stream. */
@@ -8,9 +7,10 @@ export class StreamConfig<TFilter, TBlock> {
   private response;
 
   constructor(
-    private filter: Schema.Schema<TFilter, Uint8Array, never>,
-    private block: Schema.Schema<TBlock | null, Uint8Array, never>,
+    private filter: Codec<TFilter, Uint8Array>,
+    private block: Codec<TBlock | null, Uint8Array>,
     public mergeFilter: (a: TFilter, b: TFilter) => TFilter,
+    public name: string,
   ) {
     this.request = StreamDataRequest(this.filter);
     this.response = StreamDataResponse(this.block);

package/src/proto/google/protobuf/duration.ts

@@ -76,7 +76,9 @@ export interface Duration {
    * to +315,576,000,000 inclusive. Note: these bounds are computed from:
    * 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
    */
-  readonly seconds: bigint;
+  readonly seconds?:
+    | bigint
+    | undefined;
   /**
    * Signed fractions of a second at nanosecond resolution of the span
    * of time. Durations less than one second are represented with a 0
@@ -85,7 +87,7 @@ export interface Duration {
    * of the same sign as the `seconds` field. Must be from -999,999,999
    * to +999,999,999 inclusive.
    */
-  readonly nanos: number;
+  readonly nanos?: number | undefined;
 }
 
 function createBaseDuration(): Duration {
@@ -94,13 +96,13 @@ function createBaseDuration(): Duration {
 
 export const Duration = {
   encode(message: Duration, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.seconds !== BigInt("0")) {
+    if (message.seconds !== undefined && message.seconds !== BigInt("0")) {
       if (BigInt.asIntN(64, message.seconds) !== message.seconds) {
         throw new globalThis.Error("value provided for field message.seconds of type int64 too large");
       }
       writer.uint32(8).int64(message.seconds.toString());
     }
-    if (message.nanos !== 0) {
+    if (message.nanos !== undefined && message.nanos !== 0) {
       writer.uint32(16).int32(message.nanos);
     }
     return writer;
@@ -145,10 +147,10 @@ export const Duration = {
 
   toJSON(message: Duration): unknown {
     const obj: any = {};
-    if (message.seconds !== BigInt("0")) {
+    if (message.seconds !== undefined && message.seconds !== BigInt("0")) {
       obj.seconds = message.seconds.toString();
     }
-    if (message.nanos !== 0) {
+    if (message.nanos !== undefined && message.nanos !== 0) {
       obj.nanos = Math.round(message.nanos);
     }
     return obj;

package/src/proto/stream.ts

@@ -112,13 +112,15 @@ export interface Cursor {
    *
    * This is usually the block or slot number.
    */
-  readonly orderKey: bigint;
+  readonly orderKey?:
+    | bigint
+    | undefined;
   /**
    * Key used to discriminate branches in the stream.
    *
    * This is usually the hash of the block.
    */
-  readonly uniqueKey: Uint8Array;
+  readonly uniqueKey?: Uint8Array | undefined;
 }
 
 /** Request for the `Status` method. */
@@ -163,7 +165,9 @@ export interface StreamDataRequest {
     | DataFinality
     | undefined;
   /** Filters used to generate data. */
-  readonly filter: readonly Uint8Array[];
+  readonly filter?:
+    | readonly Uint8Array[]
+    | undefined;
   /**
    * Heartbeat interval.
    *
@@ -195,7 +199,7 @@ export interface Invalidate {
     | Cursor
     | undefined;
   /** List of blocks that were removed from the chain. */
-  readonly removed: readonly Cursor[];
+  readonly removed?: readonly Cursor[] | undefined;
 }
 
 /** Move the finalized block forward. */
@@ -227,15 +231,19 @@ export interface Data {
     | Cursor
     | undefined;
   /** The finality status of the block. */
-  readonly finality: DataFinality;
+  readonly finality?:
+    | DataFinality
+    | undefined;
   /**
    * The block data.
    *
    * This message contains chain-specific data serialized using protobuf.
    */
-  readonly data: readonly Uint8Array[];
+  readonly data?:
+    | readonly Uint8Array[]
+    | undefined;
   /** The production mode of the block. */
-  readonly production: DataProduction;
+  readonly production?: DataProduction | undefined;
 }
 
 /** Sent to clients to check if stream is still connected. */
@@ -256,13 +264,13 @@ function createBaseCursor(): Cursor {
 
 export const Cursor = {
   encode(message: Cursor, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.orderKey !== BigInt("0")) {
+    if (message.orderKey !== undefined && message.orderKey !== BigInt("0")) {
       if (BigInt.asUintN(64, message.orderKey) !== message.orderKey) {
         throw new globalThis.Error("value provided for field message.orderKey of type uint64 too large");
       }
       writer.uint32(8).uint64(message.orderKey.toString());
     }
-    if (message.uniqueKey.length !== 0) {
+    if (message.uniqueKey !== undefined && message.uniqueKey.length !== 0) {
       writer.uint32(18).bytes(message.uniqueKey);
     }
     return writer;
@@ -307,10 +315,10 @@ export const Cursor = {
 
   toJSON(message: Cursor): unknown {
     const obj: any = {};
-    if (message.orderKey !== BigInt("0")) {
+    if (message.orderKey !== undefined && message.orderKey !== BigInt("0")) {
       obj.orderKey = message.orderKey.toString();
     }
-    if (message.uniqueKey.length !== 0) {
+    if (message.uniqueKey !== undefined && message.uniqueKey.length !== 0) {
       obj.uniqueKey = base64FromBytes(message.uniqueKey);
     }
     return obj;
@@ -494,8 +502,10 @@ export const StreamDataRequest = {
     if (message.finality !== undefined) {
       writer.uint32(16).int32(message.finality);
     }
-    for (const v of message.filter) {
-      writer.uint32(26).bytes(v!);
+    if (message.filter !== undefined && message.filter.length !== 0) {
+      for (const v of message.filter) {
+        writer.uint32(26).bytes(v!);
+      }
     }
     if (message.heartbeatInterval !== undefined) {
       Duration.encode(message.heartbeatInterval, writer.uint32(34).fork()).ldelim();
@@ -529,7 +539,7 @@ export const StreamDataRequest = {
             break;
           }
 
-          message.filter.push(reader.bytes());
+          message.filter!.push(reader.bytes());
           continue;
         case 4:
           if (tag !== 34) {
@@ -755,8 +765,10 @@ export const Invalidate = {
     if (message.cursor !== undefined) {
       Cursor.encode(message.cursor, writer.uint32(10).fork()).ldelim();
     }
-    for (const v of message.removed) {
-      Cursor.encode(v!, writer.uint32(18).fork()).ldelim();
+    if (message.removed !== undefined && message.removed.length !== 0) {
+      for (const v of message.removed) {
+        Cursor.encode(v!, writer.uint32(18).fork()).ldelim();
+      }
     }
     return writer;
   },
@@ -780,7 +792,7 @@ export const Invalidate = {
             break;
           }
 
-          message.removed.push(Cursor.decode(reader, reader.uint32()));
+          message.removed!.push(Cursor.decode(reader, reader.uint32()));
           continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
@@ -893,13 +905,15 @@ export const Data = {
     if (message.endCursor !== undefined) {
       Cursor.encode(message.endCursor, writer.uint32(18).fork()).ldelim();
     }
-    if (message.finality !== 0) {
+    if (message.finality !== undefined && message.finality !== 0) {
       writer.uint32(24).int32(message.finality);
     }
-    for (const v of message.data) {
-      writer.uint32(34).bytes(v!);
+    if (message.data !== undefined && message.data.length !== 0) {
+      for (const v of message.data) {
+        writer.uint32(34).bytes(v!);
+      }
     }
-    if (message.production !== 0) {
+    if (message.production !== undefined && message.production !== 0) {
       writer.uint32(40).int32(message.production);
     }
     return writer;
@@ -938,7 +952,7 @@ export const Data = {
             break;
           }
 
-          message.data.push(reader.bytes());
+          message.data!.push(reader.bytes());
           continue;
         case 5:
           if (tag !== 40) {
@@ -974,13 +988,13 @@ export const Data = {
     if (message.endCursor !== undefined) {
       obj.endCursor = Cursor.toJSON(message.endCursor);
     }
-    if (message.finality !== 0) {
+    if (message.finality !== undefined && message.finality !== 0) {
       obj.finality = dataFinalityToJSON(message.finality);
     }
     if (message.data?.length) {
       obj.data = message.data.map((e) => base64FromBytes(e));
     }
-    if (message.production !== 0) {
+    if (message.production !== undefined && message.production !== 0) {
       obj.production = dataProductionToJSON(message.production);
     }
     return obj;

package/src/status.ts

@@ -1,24 +1,17 @@
-import { Schema } from "@effect/schema";
-
+import { type CodecType, MessageCodec, OptionalCodec } from "./codec";
 import { Cursor } from "./common";
 
 /** The request to the `status` endpoint. */
-export const StatusRequest = Schema.Struct({});
-
-export type StatusRequest = typeof StatusRequest.Type;
+export const StatusRequest = MessageCodec({});
 
-export const statusRequestToProto = Schema.encodeSync(StatusRequest);
-export const statusRequestFromProto = Schema.decodeSync(StatusRequest);
+export type StatusRequest = CodecType<typeof StatusRequest>;
 
 /** The response from the `status` endpoint. */
-export const StatusResponse = Schema.Struct({
-  currentHead: Schema.optional(Cursor),
-  lastIngested: Schema.optional(Cursor),
-  finalized: Schema.optional(Cursor),
-  starting: Schema.optional(Cursor),
+export const StatusResponse = MessageCodec({
+  currentHead: OptionalCodec(Cursor),
+  lastIngested: OptionalCodec(Cursor),
+  finalized: OptionalCodec(Cursor),
+  starting: OptionalCodec(Cursor),
 });
 
-export type StatusResponse = typeof StatusResponse.Type;
-
-export const statusResponseToProto = Schema.encodeSync(StatusResponse);
-export const statusResponseFromProto = Schema.decodeSync(StatusResponse);
+export type StatusResponse = CodecType<typeof StatusResponse>;