@apibara/protocol 2.1.0-beta.5 → 2.1.0-beta.50

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

@@ -1,21 +1,20 @@
 import _m0 from 'protobufjs/minimal.js';
-import { Schema } from '@effect/schema';
-import { Option } from 'effect';
+import { MessageCodec, BigIntCodec, NumberCodec, OptionalCodec, MutableArrayCodec, UndefinedCodec, StringCodec, OneOfCodec, ArrayCodec } from '../codec.mjs';
 import { toHex, hexToBytes } from 'viem';
 import Long from 'long';
 
 function createBaseDuration() {
   return { seconds: BigInt("0"), nanos: 0 };
 }
-const Duration$1 = {
+const Duration = {
   encode(message, writer = _m0.Writer.create()) {
-    if (message.seconds !== BigInt("0")) {
+    if (message.seconds !== void 0 && 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 !== void 0 && message.nanos !== 0) {
       writer.uint32(16).int32(message.nanos);
     }
     return writer;
@@ -55,16 +54,16 @@ const Duration$1 = {
   },
   toJSON(message) {
     const obj = {};
-    if (message.seconds !== BigInt("0")) {
+    if (message.seconds !== void 0 && message.seconds !== BigInt("0")) {
       obj.seconds = message.seconds.toString();
     }
-    if (message.nanos !== 0) {
+    if (message.nanos !== void 0 && message.nanos !== 0) {
       obj.nanos = Math.round(message.nanos);
     }
     return obj;
   },
   create(base) {
-    return Duration$1.fromPartial(base ?? {});
+    return Duration.fromPartial(base ?? {});
   },
   fromPartial(object) {
     const message = createBaseDuration();
@@ -170,13 +169,13 @@ function createBaseCursor() {
 }
 const Cursor$1 = {
   encode(message, writer = _m0.Writer.create()) {
-    if (message.orderKey !== BigInt("0")) {
+    if (message.orderKey !== void 0 && 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 !== void 0 && message.uniqueKey.length !== 0) {
       writer.uint32(18).bytes(message.uniqueKey);
     }
     return writer;
@@ -216,10 +215,10 @@ const Cursor$1 = {
   },
   toJSON(message) {
     const obj = {};
-    if (message.orderKey !== BigInt("0")) {
+    if (message.orderKey !== void 0 && message.orderKey !== BigInt("0")) {
       obj.orderKey = message.orderKey.toString();
     }
-    if (message.uniqueKey.length !== 0) {
+    if (message.uniqueKey !== void 0 && message.uniqueKey.length !== 0) {
       obj.uniqueKey = base64FromBytes(message.uniqueKey);
     }
     return obj;
@@ -374,11 +373,13 @@ const StreamDataRequest$1 = {
     if (message.finality !== void 0) {
       writer.uint32(16).int32(message.finality);
     }
-    for (const v of message.filter) {
-      writer.uint32(26).bytes(v);
+    if (message.filter !== void 0 && message.filter.length !== 0) {
+      for (const v of message.filter) {
+        writer.uint32(26).bytes(v);
+      }
     }
     if (message.heartbeatInterval !== void 0) {
-      Duration$1.encode(message.heartbeatInterval, writer.uint32(34).fork()).ldelim();
+      Duration.encode(message.heartbeatInterval, writer.uint32(34).fork()).ldelim();
     }
     return writer;
   },
@@ -411,7 +412,7 @@ const StreamDataRequest$1 = {
           if (tag !== 34) {
             break;
           }
-          message.heartbeatInterval = Duration$1.decode(reader, reader.uint32());
+          message.heartbeatInterval = Duration.decode(reader, reader.uint32());
           continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
@@ -426,7 +427,7 @@ const StreamDataRequest$1 = {
       startingCursor: isSet$1(object.startingCursor) ? Cursor$1.fromJSON(object.startingCursor) : void 0,
       finality: isSet$1(object.finality) ? dataFinalityFromJSON(object.finality) : void 0,
       filter: globalThis.Array.isArray(object?.filter) ? object.filter.map((e) => bytesFromBase64(e)) : [],
-      heartbeatInterval: isSet$1(object.heartbeatInterval) ? Duration$1.fromJSON(object.heartbeatInterval) : void 0
+      heartbeatInterval: isSet$1(object.heartbeatInterval) ? Duration.fromJSON(object.heartbeatInterval) : void 0
     };
   },
   toJSON(message) {
@@ -441,7 +442,7 @@ const StreamDataRequest$1 = {
       obj.filter = message.filter.map((e) => base64FromBytes(e));
     }
     if (message.heartbeatInterval !== void 0) {
-      obj.heartbeatInterval = Duration$1.toJSON(message.heartbeatInterval);
+      obj.heartbeatInterval = Duration.toJSON(message.heartbeatInterval);
     }
     return obj;
   },
@@ -453,7 +454,7 @@ const StreamDataRequest$1 = {
     message.startingCursor = object.startingCursor !== void 0 && object.startingCursor !== null ? Cursor$1.fromPartial(object.startingCursor) : void 0;
     message.finality = object.finality ?? void 0;
     message.filter = object.filter?.map((e) => e) || [];
-    message.heartbeatInterval = object.heartbeatInterval !== void 0 && object.heartbeatInterval !== null ? Duration$1.fromPartial(object.heartbeatInterval) : void 0;
+    message.heartbeatInterval = object.heartbeatInterval !== void 0 && object.heartbeatInterval !== null ? Duration.fromPartial(object.heartbeatInterval) : void 0;
     return message;
   }
 };
@@ -584,8 +585,10 @@ const Invalidate$1 = {
     if (message.cursor !== void 0) {
       Cursor$1.encode(message.cursor, writer.uint32(10).fork()).ldelim();
     }
-    for (const v of message.removed) {
-      Cursor$1.encode(v, writer.uint32(18).fork()).ldelim();
+    if (message.removed !== void 0 && message.removed.length !== 0) {
+      for (const v of message.removed) {
+        Cursor$1.encode(v, writer.uint32(18).fork()).ldelim();
+      }
     }
     return writer;
   },
@@ -703,13 +706,15 @@ const Data$1 = {
     if (message.endCursor !== void 0) {
       Cursor$1.encode(message.endCursor, writer.uint32(18).fork()).ldelim();
     }
-    if (message.finality !== 0) {
+    if (message.finality !== void 0 && message.finality !== 0) {
       writer.uint32(24).int32(message.finality);
     }
-    for (const v of message.data) {
-      writer.uint32(34).bytes(v);
+    if (message.data !== void 0 && message.data.length !== 0) {
+      for (const v of message.data) {
+        writer.uint32(34).bytes(v);
+      }
     }
-    if (message.production !== 0) {
+    if (message.production !== void 0 && message.production !== 0) {
       writer.uint32(40).int32(message.production);
     }
     return writer;
@@ -776,13 +781,13 @@ const Data$1 = {
     if (message.endCursor !== void 0) {
       obj.endCursor = Cursor$1.toJSON(message.endCursor);
     }
-    if (message.finality !== 0) {
+    if (message.finality !== void 0 && 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 !== void 0 && message.production !== 0) {
       obj.production = dataProductionToJSON(message.production);
     }
     return obj;
@@ -1098,54 +1103,59 @@ const testing = {
   protobufPackage: protobufPackage
 };
 
-const Bytes = Schema.TemplateLiteral(
-  Schema.Literal("0x"),
-  Schema.String
-);
-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))
-      );
+const BytesFromUint8Array = {
+  decode(value) {
+    if (!value || value?.length === 0) {
+      return void 0;
+    }
+    return toHex(value);
+  },
+  encode(value) {
+    if (value === void 0) {
+      return new Uint8Array(0);
     }
+    return hexToBytes(value);
   }
-);
-const _Cursor = Schema.Struct({
-  /** The block number. */
-  orderKey: Schema.BigIntFromSelf,
-  /** The block hash, if any. */
-  uniqueKey: BytesFromUint8Array
-});
-const Cursor = _Cursor;
+};
+const Cursor = {
+  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)
+    };
+  }
+};
 const createCursor = (props) => props;
-const cursorToProto = Schema.encodeSync(Cursor);
-const cursorFromProto = Schema.decodeSync(Cursor);
-const CursorFromBytes = Schema.transform(
-  Schema.Uint8ArrayFromSelf,
-  Cursor,
-  {
-    decode(value) {
-      return Cursor$1.decode(value);
-    },
-    encode(value) {
-      return Cursor$1.encode(value).finish();
-    }
+const CursorFromBytes = {
+  encode(value) {
+    const { orderKey, uniqueKey } = value;
+    return Cursor$1.encode({
+      orderKey,
+      uniqueKey: BytesFromUint8Array.encode(uniqueKey)
+    }).finish();
+  },
+  decode(value) {
+    const { orderKey, uniqueKey } = Cursor$1.decode(value);
+    return {
+      orderKey: orderKey ?? 0n,
+      uniqueKey: BytesFromUint8Array.decode(uniqueKey)
+    };
   }
-);
-const cursorToBytes = Schema.encodeSync(CursorFromBytes);
-const cursorFromBytes = Schema.decodeSync(CursorFromBytes);
+};
 function isCursor(value) {
-  return Schema.is(Cursor)(value);
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const { orderKey, uniqueKey } = value;
+  return typeof orderKey === "bigint" && (uniqueKey === null || uniqueKey === void 0 || typeof uniqueKey === "string" && uniqueKey.startsWith("0x"));
 }
 function normalizeCursor(cursor) {
   if (cursor.uniqueKey !== null && cursor.uniqueKey.length > 0) {
@@ -1160,116 +1170,109 @@ function normalizeCursor(cursor) {
   };
 }
 
-const DataFinality = Schema.transform(
-  Schema.Enums(DataFinality$1),
-  Schema.Literal("finalized", "accepted", "pending", "unknown"),
-  {
-    decode(value) {
-      const enumMap = {
-        [DataFinality$1.FINALIZED]: "finalized",
-        [DataFinality$1.ACCEPTED]: "accepted",
-        [DataFinality$1.PENDING]: "pending",
-        [DataFinality$1.UNKNOWN]: "unknown",
-        [DataFinality$1.UNRECOGNIZED]: "unknown"
-      };
-      return enumMap[value] ?? "unknown";
-    },
-    encode(value) {
-      const enumMap = {
-        finalized: DataFinality$1.FINALIZED,
-        accepted: DataFinality$1.ACCEPTED,
-        pending: DataFinality$1.PENDING,
-        unknown: DataFinality$1.UNKNOWN
-      };
-      return enumMap[value] ?? DataFinality$1.UNKNOWN;
-    }
+const DataFinality = {
+  encode(x) {
+    const enumMap = {
+      finalized: DataFinality$1.FINALIZED,
+      accepted: DataFinality$1.ACCEPTED,
+      pending: DataFinality$1.PENDING,
+      unknown: DataFinality$1.UNKNOWN
+    };
+    return enumMap[x] ?? DataFinality$1.UNKNOWN;
+  },
+  decode(p) {
+    const enumMap = {
+      [DataFinality$1.FINALIZED]: "finalized",
+      [DataFinality$1.ACCEPTED]: "accepted",
+      [DataFinality$1.PENDING]: "pending",
+      [DataFinality$1.UNKNOWN]: "unknown",
+      [DataFinality$1.UNRECOGNIZED]: "unknown"
+    };
+    return enumMap[p] ?? "unknown";
   }
-);
-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 DataProduction = {
+  encode(x) {
+    switch (x) {
+      case "backfill":
+        return DataProduction$1.BACKFILL;
+      case "live":
+        return DataProduction$1.LIVE;
+      case "unknown":
+        return DataProduction$1.UNKNOWN;
+      default:
+        return DataProduction$1.UNRECOGNIZED;
+    }
+  },
+  decode(p) {
+    const enumMap = {
+      [DataProduction$1.BACKFILL]: "backfill",
+      [DataProduction$1.LIVE]: "live",
+      [DataProduction$1.UNKNOWN]: "unknown",
+      [DataProduction$1.UNRECOGNIZED]: "unknown"
+    };
+    return enumMap[p] ?? "unknown";
   }
-);
-const Duration = Schema.Struct({
-  seconds: Schema.BigIntFromSelf,
-  nanos: Schema.Number
+};
+const DurationCodec = MessageCodec({
+  seconds: BigIntCodec,
+  nanos: NumberCodec
 });
-const StreamDataRequest = (filter) => Schema.Struct({
-  finality: Schema.optional(DataFinality),
-  startingCursor: Schema.optional(Cursor),
-  filter: Schema.mutable(Schema.Array(filter)),
-  heartbeatInterval: Schema.optional(Duration)
+const StreamDataRequest = (filter) => MessageCodec({
+  finality: OptionalCodec(DataFinality),
+  startingCursor: OptionalCodec(Cursor),
+  filter: MutableArrayCodec(filter),
+  heartbeatInterval: OptionalCodec(DurationCodec)
 });
-const Invalidate = Schema.Struct({
-  _tag: tag("invalidate"),
-  invalidate: Schema.Struct({
-    cursor: Schema.optional(Cursor)
-  })
+const Invalidate = MessageCodec({
+  cursor: OptionalCodec(Cursor)
 });
-const Finalize = Schema.Struct({
-  _tag: tag("finalize"),
-  finalize: Schema.Struct({
-    cursor: Schema.optional(Cursor)
-  })
+const Finalize = MessageCodec({
+  cursor: OptionalCodec(Cursor)
 });
-const Heartbeat = Schema.Struct({
-  _tag: tag("heartbeat")
+const Heartbeat = UndefinedCodec;
+const StdOut = StringCodec;
+const StdErr = StringCodec;
+const SystemMessage = MessageCodec({
+  output: OneOfCodec({
+    stdout: StdOut,
+    stderr: StdErr
+  })
 });
-const StdOut = Schema.Struct({
-  _tag: tag("stdout"),
-  stdout: Schema.String
+const _DataOrNull = (schema) => ({
+  encode(x) {
+    if (x === null) {
+      return new Uint8Array();
+    }
+    return schema.encode(x);
+  },
+  decode(p) {
+    if (p.length === 0) {
+      return null;
+    }
+    return schema.decode(p);
+  }
 });
-const StdErr = Schema.Struct({
-  _tag: tag("stderr"),
-  stderr: Schema.String
+const Data = (schema) => MessageCodec({
+  cursor: OptionalCodec(Cursor),
+  endCursor: Cursor,
+  finality: DataFinality,
+  production: DataProduction,
+  data: ArrayCodec(_DataOrNull(schema))
 });
-const SystemMessage = Schema.Struct({
-  _tag: tag("systemMessage"),
-  systemMessage: Schema.Struct({
-    output: Schema.Union(StdOut, StdErr)
-  })
+const StreamDataResponse = (schema) => OneOfCodec({
+  data: Data(schema),
+  invalidate: Invalidate,
+  finalize: Finalize,
+  heartbeat: Heartbeat,
+  systemMessage: SystemMessage
 });
-const Data = (schema) => Schema.Struct({
-  _tag: tag("data"),
-  data: Schema.Struct({
-    cursor: Schema.optional(Cursor),
-    endCursor: Cursor,
-    finality: DataFinality,
-    production: DataProduction,
-    data: Schema.Array(schema)
-  })
+const ResponseWithoutData = OneOfCodec({
+  invalidate: Invalidate,
+  finalize: Finalize,
+  heartbeat: Heartbeat,
+  systemMessage: SystemMessage
 });
-const StreamDataResponse = (data) => Schema.Union(Data(data), Invalidate, Finalize, Heartbeat, SystemMessage);
-Schema.Union(
-  Invalidate,
-  Finalize,
-  Heartbeat,
-  SystemMessage
-);
-function tag(tag2) {
-  return Schema.Literal(tag2).pipe(
-    Schema.propertySignature,
-    Schema.fromKey("$case")
-  );
-}
 
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -1278,10 +1281,11 @@ var __publicField = (obj, key, value) => {
   return value;
 };
 class StreamConfig {
-  constructor(filter, block, mergeFilter) {
+  constructor(filter, block, mergeFilter, name) {
     this.filter = filter;
     this.block = block;
     this.mergeFilter = mergeFilter;
+    this.name = name;
     __publicField(this, "request");
     __publicField(this, "response");
     this.request = StreamDataRequest(this.filter);
@@ -1305,4 +1309,5 @@ 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, 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 };
+export { BytesFromUint8Array as B, Cursor as C, DnaStreamDefinition as D, Finalize as F, Heartbeat as H, Invalidate as I, MockFilter as M, ResponseWithoutData as R, StreamDataResponse as S, CursorFromBytes as a, DataFinality as b, createCursor as c, DataProduction as d, DurationCodec as e, StreamDataRequest as f, StdOut as g, StdErr as h, isCursor as i, SystemMessage as j, Data as k, StreamConfig as l, MockBlock as m, normalizeCursor as n, stream as s, testing as t };
+//# sourceMappingURL=protocol.68fdd897.mjs.map