@apibara/protocol 2.1.0-beta.4 → 2.1.0-beta.40

package/dist/shared/{protocol.e39e40d6.cjs → protocol.53f81a1e.cjs}

@@ -1,8 +1,7 @@
 'use strict';
 
 const _m0 = require('protobufjs/minimal.js');
-const schema = require('@effect/schema');
-const effect = require('effect');
+const codec = require('../codec.cjs');
 const viem = require('viem');
 const Long = require('long');
 
@@ -14,15 +13,15 @@ const Long__default = /*#__PURE__*/_interopDefaultCompat(Long);
 function createBaseDuration() {
   return { seconds: BigInt("0"), nanos: 0 };
 }
-const Duration$1 = {
+const Duration = {
   encode(message, writer = _m0__default.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;
@@ -62,16 +61,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();
@@ -177,13 +176,13 @@ function createBaseCursor() {
 }
 const Cursor$1 = {
   encode(message, writer = _m0__default.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;
@@ -223,10 +222,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;
@@ -381,11 +380,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;
   },
@@ -418,7 +419,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) {
@@ -433,7 +434,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) {
@@ -448,7 +449,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;
   },
@@ -460,7 +461,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;
   }
 };
@@ -591,8 +592,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;
   },
@@ -710,13 +713,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;
@@ -783,13 +788,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;
@@ -1105,54 +1110,59 @@ const testing = {
   protobufPackage: protobufPackage
 };
 
-const Bytes = schema.Schema.TemplateLiteral(
-  schema.Schema.Literal("0x"),
-  schema.Schema.String
-);
-const BytesFromUint8Array = schema.Schema.requiredToOptional(
-  schema.Schema.Uint8ArrayFromSelf,
-  Bytes,
-  {
-    decode(value) {
-      if (value.length === 0) {
-        return effect.Option.none();
-      }
-      return effect.Option.some(viem.toHex(value));
-    },
-    encode(value) {
-      return value.pipe(
-        effect.Option.map(viem.hexToBytes),
-        effect.Option.getOrElse(() => new Uint8Array(0))
-      );
+const BytesFromUint8Array = {
+  decode(value) {
+    if (!value || value?.length === 0) {
+      return void 0;
+    }
+    return viem.toHex(value);
+  },
+  encode(value) {
+    if (value === void 0) {
+      return new Uint8Array(0);
     }
+    return viem.hexToBytes(value);
   }
-);
-const _Cursor = schema.Schema.Struct({
-  /** The block number. */
-  orderKey: schema.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.Schema.encodeSync(Cursor);
-const cursorFromProto = schema.Schema.decodeSync(Cursor);
-const CursorFromBytes = schema.Schema.transform(
-  schema.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.Schema.encodeSync(CursorFromBytes);
-const cursorFromBytes = schema.Schema.decodeSync(CursorFromBytes);
+};
 function isCursor(value) {
-  return schema.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) {
@@ -1167,116 +1177,109 @@ function normalizeCursor(cursor) {
   };
 }
 
-const DataFinality = schema.Schema.transform(
-  schema.Schema.Enums(DataFinality$1),
-  schema.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.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 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.Schema.Struct({
-  seconds: schema.Schema.BigIntFromSelf,
-  nanos: schema.Schema.Number
+};
+const DurationCodec = codec.MessageCodec({
+  seconds: codec.BigIntCodec,
+  nanos: codec.NumberCodec
 });
-const StreamDataRequest = (filter) => schema.Schema.Struct({
-  finality: schema.Schema.optional(DataFinality),
-  startingCursor: schema.Schema.optional(Cursor),
-  filter: schema.Schema.mutable(schema.Schema.Array(filter)),
-  heartbeatInterval: schema.Schema.optional(Duration)
+const StreamDataRequest = (filter) => codec.MessageCodec({
+  finality: codec.OptionalCodec(DataFinality),
+  startingCursor: codec.OptionalCodec(Cursor),
+  filter: codec.MutableArrayCodec(filter),
+  heartbeatInterval: codec.OptionalCodec(DurationCodec)
 });
-const Invalidate = schema.Schema.Struct({
-  _tag: tag("invalidate"),
-  invalidate: schema.Schema.Struct({
-    cursor: schema.Schema.optional(Cursor)
-  })
+const Invalidate = codec.MessageCodec({
+  cursor: codec.OptionalCodec(Cursor)
 });
-const Finalize = schema.Schema.Struct({
-  _tag: tag("finalize"),
-  finalize: schema.Schema.Struct({
-    cursor: schema.Schema.optional(Cursor)
-  })
+const Finalize = codec.MessageCodec({
+  cursor: codec.OptionalCodec(Cursor)
 });
-const Heartbeat = schema.Schema.Struct({
-  _tag: tag("heartbeat")
+const Heartbeat = codec.UndefinedCodec;
+const StdOut = codec.StringCodec;
+const StdErr = codec.StringCodec;
+const SystemMessage = codec.MessageCodec({
+  output: codec.OneOfCodec({
+    stdout: StdOut,
+    stderr: StdErr
+  })
 });
-const StdOut = schema.Schema.Struct({
-  _tag: tag("stdout"),
-  stdout: schema.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.Schema.Struct({
-  _tag: tag("stderr"),
-  stderr: schema.Schema.String
+const Data = (schema) => codec.MessageCodec({
+  cursor: codec.OptionalCodec(Cursor),
+  endCursor: Cursor,
+  finality: DataFinality,
+  production: DataProduction,
+  data: codec.ArrayCodec(_DataOrNull(schema))
 });
-const SystemMessage = schema.Schema.Struct({
-  _tag: tag("systemMessage"),
-  systemMessage: schema.Schema.Struct({
-    output: schema.Schema.Union(StdOut, StdErr)
-  })
+const StreamDataResponse = (schema) => codec.OneOfCodec({
+  data: Data(schema),
+  invalidate: Invalidate,
+  finalize: Finalize,
+  heartbeat: Heartbeat,
+  systemMessage: SystemMessage
 });
-const Data = (schema$1) => schema.Schema.Struct({
-  _tag: tag("data"),
-  data: schema.Schema.Struct({
-    cursor: schema.Schema.optional(Cursor),
-    endCursor: Cursor,
-    finality: DataFinality,
-    production: DataProduction,
-    data: schema.Schema.Array(schema$1)
-  })
+const ResponseWithoutData = codec.OneOfCodec({
+  invalidate: Invalidate,
+  finalize: Finalize,
+  heartbeat: Heartbeat,
+  systemMessage: SystemMessage
 });
-const StreamDataResponse = (data) => schema.Schema.Union(Data(data), Invalidate, Finalize, Heartbeat, SystemMessage);
-schema.Schema.Union(
-  Invalidate,
-  Finalize,
-  Heartbeat,
-  SystemMessage
-);
-function tag(tag2) {
-  return schema.Schema.Literal(tag2).pipe(
-    schema.Schema.propertySignature,
-    schema.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;
@@ -1285,10 +1288,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);
@@ -1312,7 +1316,6 @@ class StreamConfig {
   }
 }
 
-exports.Bytes = Bytes;
 exports.BytesFromUint8Array = BytesFromUint8Array;
 exports.Cursor = Cursor;
 exports.CursorFromBytes = CursorFromBytes;
@@ -1320,25 +1323,22 @@ exports.Data = Data;
 exports.DataFinality = DataFinality;
 exports.DataProduction = DataProduction;
 exports.DnaStreamDefinition = DnaStreamDefinition;
-exports.Duration = Duration;
+exports.DurationCodec = DurationCodec;
 exports.Finalize = Finalize;
 exports.Heartbeat = Heartbeat;
 exports.Invalidate = Invalidate;
 exports.MockBlock = MockBlock;
 exports.MockFilter = MockFilter;
+exports.ResponseWithoutData = ResponseWithoutData;
 exports.StdErr = StdErr;
 exports.StdOut = StdOut;
 exports.StreamConfig = StreamConfig;
 exports.StreamDataRequest = StreamDataRequest;
 exports.StreamDataResponse = StreamDataResponse;
 exports.SystemMessage = SystemMessage;
-exports._Cursor = _Cursor;
 exports.createCursor = createCursor;
-exports.cursorFromBytes = cursorFromBytes;
-exports.cursorFromProto = cursorFromProto;
-exports.cursorToBytes = cursorToBytes;
-exports.cursorToProto = cursorToProto;
 exports.isCursor = isCursor;
 exports.normalizeCursor = normalizeCursor;
 exports.stream = stream;
 exports.testing = testing;
+//# sourceMappingURL=protocol.53f81a1e.cjs.map