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

package/package.json

@@ -1,57 +1,24 @@
 {
   "name": "@apibara/protocol",
-  "version": "2.0.0-beta.2",
-  "description": "Apibara DNA protocol client",
-  "repository": "apibara/typescript-sdk",
-  "license": "Apache-2.0",
-  "sideEffects": false,
+  "version": "2.0.0-beta.4",
+  "type": "module",
   "source": "./src/index.ts",
   "main": "./dist/index.mjs",
   "exports": {
     ".": {
-      "import": {
-        "types": "./dist/index.d.mts",
-        "default": "./dist/index.mjs"
-      },
-      "require": {
-        "types": "./dist/index.d.cts",
-        "default": "./dist/index.cjs"
-      }
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.mjs"
     },
     "./testing": {
-      "import": {
-        "types": "./dist/testing/index.d.mts",
-        "default": "./dist/testing/index.mjs"
-      },
-      "require": {
-        "types": "./dist/testing/index.d.cts",
-        "default": "./dist/testing/index.cjs"
-      }
+      "types": "./dist/testing/index.d.ts",
+      "import": "./dist/testing/index.mjs",
+      "require": "./dist/testing/index.cjs",
+      "default": "./dist/testing/index.mjs"
     }
   },
-  "publishConfig": {
-    "files": [
-      "dist",
-      "src",
-      "README.md"
-    ]
-  },
-  "dependencies": {
-    "@effect/schema": "^0.67.15",
-    "effect": "^3.2.6",
-    "long": "^5.2.3",
-    "nice-grpc": "^2.1.8",
-    "nice-grpc-common": "^2.0.2",
-    "protobufjs": "^7.3.0",
-    "viem": "^2.13.2"
-  },
-  "devDependencies": {
-    "@bufbuild/buf": "^1.32.2",
-    "@types/long": "^5.0.0",
-    "@types/node": "^20.12.13",
-    "unbuild": "^2.0.0",
-    "vitest": "^1.6.0"
-  },
+  "publishConfig": {},
   "scripts": {
     "build": "pnpm build:proto && unbuild",
     "build:proto": "buf generate proto",
@@ -62,5 +29,26 @@
     "lint:fix": "pnpm lint --write",
     "format": "biome format . --write"
   },
+  "devDependencies": {
+    "@bufbuild/buf": "^1.32.2",
+    "@types/long": "^5.0.0",
+    "@types/node": "^20.12.13",
+    "unbuild": "^2.0.0",
+    "vitest": "^1.6.0"
+  },
+  "dependencies": {
+    "@effect/schema": "^0.67.15",
+    "effect": "^3.2.6",
+    "long": "^5.2.3",
+    "nice-grpc": "^2.1.8",
+    "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/common.ts

@@ -53,10 +53,10 @@ export const CursorFromBytes = Schema.transform(
   Cursor,
   {
     decode(value) {
-      return proto.common.Cursor.decode(value);
+      return proto.stream.Cursor.decode(value);
     },
     encode(value) {
-      return proto.common.Cursor.encode(value).finish();
+      return proto.stream.Cursor.encode(value).finish();
     },
   },
 );

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

@@ -0,0 +1,189 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v1.176.0
+//   protoc               unknown
+// source: google/protobuf/duration.proto
+
+/* eslint-disable */
+import Long from "long";
+import _m0 from "protobufjs/minimal";
+
+export const protobufPackage = "google.protobuf";
+
+/**
+ * A Duration represents a signed, fixed-length span of time represented
+ * as a count of seconds and fractions of seconds at nanosecond
+ * resolution. It is independent of any calendar and concepts like "day"
+ * or "month". It is related to Timestamp in that the difference between
+ * two Timestamp values is a Duration and it can be added or subtracted
+ * from a Timestamp. Range is approximately +-10,000 years.
+ *
+ * # Examples
+ *
+ * Example 1: Compute Duration from two Timestamps in pseudo code.
+ *
+ *     Timestamp start = ...;
+ *     Timestamp end = ...;
+ *     Duration duration = ...;
+ *
+ *     duration.seconds = end.seconds - start.seconds;
+ *     duration.nanos = end.nanos - start.nanos;
+ *
+ *     if (duration.seconds < 0 && duration.nanos > 0) {
+ *       duration.seconds += 1;
+ *       duration.nanos -= 1000000000;
+ *     } else if (duration.seconds > 0 && duration.nanos < 0) {
+ *       duration.seconds -= 1;
+ *       duration.nanos += 1000000000;
+ *     }
+ *
+ * Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
+ *
+ *     Timestamp start = ...;
+ *     Duration duration = ...;
+ *     Timestamp end = ...;
+ *
+ *     end.seconds = start.seconds + duration.seconds;
+ *     end.nanos = start.nanos + duration.nanos;
+ *
+ *     if (end.nanos < 0) {
+ *       end.seconds -= 1;
+ *       end.nanos += 1000000000;
+ *     } else if (end.nanos >= 1000000000) {
+ *       end.seconds += 1;
+ *       end.nanos -= 1000000000;
+ *     }
+ *
+ * Example 3: Compute Duration from datetime.timedelta in Python.
+ *
+ *     td = datetime.timedelta(days=3, minutes=10)
+ *     duration = Duration()
+ *     duration.FromTimedelta(td)
+ *
+ * # JSON Mapping
+ *
+ * In JSON format, the Duration type is encoded as a string rather than an
+ * object, where the string ends in the suffix "s" (indicating seconds) and
+ * is preceded by the number of seconds, with nanoseconds expressed as
+ * fractional seconds. For example, 3 seconds with 0 nanoseconds should be
+ * encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should
+ * be expressed in JSON format as "3.000000001s", and 3 seconds and 1
+ * microsecond should be expressed in JSON format as "3.000001s".
+ */
+export interface Duration {
+  /**
+   * Signed seconds of the span of time. Must be from -315,576,000,000
+   * 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;
+  /**
+   * Signed fractions of a second at nanosecond resolution of the span
+   * of time. Durations less than one second are represented with a 0
+   * `seconds` field and a positive or negative `nanos` field. For durations
+   * of one second or more, a non-zero value for the `nanos` field must be
+   * of the same sign as the `seconds` field. Must be from -999,999,999
+   * to +999,999,999 inclusive.
+   */
+  readonly nanos: number;
+}
+
+function createBaseDuration(): Duration {
+  return { seconds: BigInt("0"), nanos: 0 };
+}
+
+export const Duration = {
+  encode(message: Duration, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (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) {
+      writer.uint32(16).int32(message.nanos);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): Duration {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDuration() as any;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.seconds = longToBigint(reader.int64() as Long);
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+
+          message.nanos = reader.int32();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Duration {
+    return {
+      seconds: isSet(object.seconds) ? BigInt(object.seconds) : BigInt("0"),
+      nanos: isSet(object.nanos) ? globalThis.Number(object.nanos) : 0,
+    };
+  },
+
+  toJSON(message: Duration): unknown {
+    const obj: any = {};
+    if (message.seconds !== BigInt("0")) {
+      obj.seconds = message.seconds.toString();
+    }
+    if (message.nanos !== 0) {
+      obj.nanos = Math.round(message.nanos);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<Duration>): Duration {
+    return Duration.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<Duration>): Duration {
+    const message = createBaseDuration() as any;
+    message.seconds = object.seconds ?? BigInt("0");
+    message.nanos = object.nanos ?? 0;
+    return message;
+  },
+};
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends { readonly $case: string }
+    ? { [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]> } & { readonly $case: T["$case"] }
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+function longToBigint(long: Long) {
+  return BigInt(long.toString());
+}
+
+if (_m0.util.Long !== Long) {
+  _m0.util.Long = Long as any;
+  _m0.configure();
+}
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}

package/src/proto/index.ts

@@ -1,3 +1,2 @@
-export * as common from "./common";
 export * as stream from "./stream";
-export * as testing from "./testing";
+export * as testing from "./testing";