@apibara/protocol 2.1.0-beta.22 → 2.1.0-beta.24

package/dist/testing/index.cjs

@@ -1,9 +1,8 @@
 'use strict';
 
-const schema = require('@effect/schema');
-const config = require('../shared/protocol.e39e40d6.cjs');
+const codec = require('../codec.cjs');
+const config = require('../shared/protocol.d8bad371.cjs');
 require('protobufjs/minimal.js');
-require('effect');
 require('viem');
 require('long');
 
@@ -41,44 +40,31 @@ class StreamDataIterable {
   }
 }
 
-const MockFilter = schema.Schema.Struct({
-  filter: schema.Schema.optional(schema.Schema.String)
+const MockFilter = codec.MessageCodec({
+  filter: codec.OptionalCodec(codec.StringCodec)
 });
-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 MockFilterFromBytes = {
+  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();
+};
+const MockBlockFromBytes = {
+  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) {

package/dist/testing/index.d.cts

@@ -1,9 +1,8 @@
-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 { w as Client, l as StreamDataRequest, v as StreamDataOptions, r as StreamDataResponse, S as StatusRequest, u as ClientCallOptions, f as StatusResponse, t as StreamConfig, B as Bytes, A as Cursor, E as DataFinality, J as DataProduction } from '../shared/protocol.f52df848.cjs';
+import { MessageCodec, Codec, CodecType } from '../codec.cjs';
 import 'nice-grpc-common';
 import 'protobufjs/minimal.js';
-import '@effect/schema/AST';
+import 'nice-grpc';
 
 declare class MockClient<TFilter, TBlock> implements Client<TFilter, TBlock> {
     private messageFactory;
@@ -17,60 +16,114 @@ declare class StreamDataIterable<TBlock> {
     [Symbol.asyncIterator](): AsyncIterator<StreamDataResponse<TBlock>>;
 }
 
-declare const MockFilter: Schema.Struct<{
-    filter: Schema.optional<typeof Schema.String>;
+declare const MockFilter: MessageCodec<{
+    filter: Codec<string | undefined, string | undefined>;
 }>;
-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 MockFilter = CodecType<typeof MockFilter>;
+declare const MockFilterFromBytes: Codec<MockFilter, Uint8Array>;
+declare const MockBlock: MessageCodec<{
+    data: Codec<string | undefined, string | undefined>;
 }>;
-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>;
-}>>>;
+type MockBlock = CodecType<typeof MockBlock>;
+declare const MockBlockFromBytes: Codec<MockBlock | null, Uint8Array>;
 declare const MockStream: StreamConfig<{
-    readonly filter?: string | undefined;
+    filter?: string | undefined;
 }, {
-    readonly data?: string | undefined;
+    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;
+declare const MockStreamResponse: Codec<{
+    _tag: "heartbeat";
+} | ({
+    _tag: "data";
+} & {
+    data: {
+        cursor?: {
+            orderKey: bigint;
+            uniqueKey?: Bytes | undefined;
+        } | undefined;
+        endCursor: {
+            orderKey: bigint;
+            uniqueKey?: Bytes | undefined;
+        };
+        finality: "finalized" | "accepted" | "pending" | "unknown";
+        production: "unknown" | "backfill" | "live";
+        data: readonly ({
+            data?: string | undefined;
+        } | null)[];
+    };
+}) | ({
+    _tag: "invalidate";
+} & {
+    invalidate: {
+        cursor?: {
+            orderKey: bigint;
+            uniqueKey?: Bytes | undefined;
+        } | undefined;
+    };
+}) | ({
+    _tag: "finalize";
+} & {
+    finalize: {
+        cursor?: {
+            orderKey: bigint;
+            uniqueKey?: Bytes | undefined;
+        } | undefined;
+    };
+}) | ({
+    _tag: "systemMessage";
+} & {
+    systemMessage: {
+        output: ({
+            _tag: "stdout";
+        } & {
+            stdout: string;
+        }) | ({
+            _tag: "stderr";
+        } & {
+            stderr: string;
+        });
+    };
+}), ({
+    $case: "data";
+} & {
+    data: {
+        cursor?: Cursor | undefined;
+        endCursor: Cursor;
+        finality: DataFinality;
+        production: DataProduction;
+        data?: readonly Uint8Array[] | undefined;
+    };
+}) | ({
+    $case: "invalidate";
+} & {
+    invalidate: {
+        cursor?: Cursor | undefined;
+    };
+}) | ({
+    $case: "finalize";
+} & {
+    finalize: {
+        cursor?: Cursor | undefined;
+    };
+}) | ({
+    $case: "heartbeat";
+} & {
+    heartbeat: undefined;
+}) | ({
+    $case: "systemMessage";
+} & {
+    systemMessage: {
+        output: ({
+            $case: "stdout";
+        } & {
+            stdout: string;
+        }) | ({
+            $case: "stderr";
+        } & {
+            stderr: string;
+        });
+    };
+})>;
+type MockStreamResponse = CodecType<typeof MockStreamResponse>;
 
 export { MockBlock, MockBlockFromBytes, MockClient, MockFilter, MockFilterFromBytes, MockStream, MockStreamResponse, StreamDataIterable };

package/dist/testing/index.d.mts

@@ -1,9 +1,8 @@
-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 { w as Client, l as StreamDataRequest, v as StreamDataOptions, r as StreamDataResponse, S as StatusRequest, u as ClientCallOptions, f as StatusResponse, t as StreamConfig, B as Bytes, A as Cursor, E as DataFinality, J as DataProduction } from '../shared/protocol.68a15d69.mjs';
+import { MessageCodec, Codec, CodecType } from '../codec.mjs';
 import 'nice-grpc-common';
 import 'protobufjs/minimal.js';
-import '@effect/schema/AST';
+import 'nice-grpc';
 
 declare class MockClient<TFilter, TBlock> implements Client<TFilter, TBlock> {
     private messageFactory;
@@ -17,60 +16,114 @@ declare class StreamDataIterable<TBlock> {
     [Symbol.asyncIterator](): AsyncIterator<StreamDataResponse<TBlock>>;
 }
 
-declare const MockFilter: Schema.Struct<{
-    filter: Schema.optional<typeof Schema.String>;
+declare const MockFilter: MessageCodec<{
+    filter: Codec<string | undefined, string | undefined>;
 }>;
-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 MockFilter = CodecType<typeof MockFilter>;
+declare const MockFilterFromBytes: Codec<MockFilter, Uint8Array>;
+declare const MockBlock: MessageCodec<{
+    data: Codec<string | undefined, string | undefined>;
 }>;
-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>;
-}>>>;
+type MockBlock = CodecType<typeof MockBlock>;
+declare const MockBlockFromBytes: Codec<MockBlock | null, Uint8Array>;
 declare const MockStream: StreamConfig<{
-    readonly filter?: string | undefined;
+    filter?: string | undefined;
 }, {
-    readonly data?: string | undefined;
+    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;
+declare const MockStreamResponse: Codec<{
+    _tag: "heartbeat";
+} | ({
+    _tag: "data";
+} & {
+    data: {
+        cursor?: {
+            orderKey: bigint;
+            uniqueKey?: Bytes | undefined;
+        } | undefined;
+        endCursor: {
+            orderKey: bigint;
+            uniqueKey?: Bytes | undefined;
+        };
+        finality: "finalized" | "accepted" | "pending" | "unknown";
+        production: "unknown" | "backfill" | "live";
+        data: readonly ({
+            data?: string | undefined;
+        } | null)[];
+    };
+}) | ({
+    _tag: "invalidate";
+} & {
+    invalidate: {
+        cursor?: {
+            orderKey: bigint;
+            uniqueKey?: Bytes | undefined;
+        } | undefined;
+    };
+}) | ({
+    _tag: "finalize";
+} & {
+    finalize: {
+        cursor?: {
+            orderKey: bigint;
+            uniqueKey?: Bytes | undefined;
+        } | undefined;
+    };
+}) | ({
+    _tag: "systemMessage";
+} & {
+    systemMessage: {
+        output: ({
+            _tag: "stdout";
+        } & {
+            stdout: string;
+        }) | ({
+            _tag: "stderr";
+        } & {
+            stderr: string;
+        });
+    };
+}), ({
+    $case: "data";
+} & {
+    data: {
+        cursor?: Cursor | undefined;
+        endCursor: Cursor;
+        finality: DataFinality;
+        production: DataProduction;
+        data?: readonly Uint8Array[] | undefined;
+    };
+}) | ({
+    $case: "invalidate";
+} & {
+    invalidate: {
+        cursor?: Cursor | undefined;
+    };
+}) | ({
+    $case: "finalize";
+} & {
+    finalize: {
+        cursor?: Cursor | undefined;
+    };
+}) | ({
+    $case: "heartbeat";
+} & {
+    heartbeat: undefined;
+}) | ({
+    $case: "systemMessage";
+} & {
+    systemMessage: {
+        output: ({
+            $case: "stdout";
+        } & {
+            stdout: string;
+        }) | ({
+            $case: "stderr";
+        } & {
+            stderr: string;
+        });
+    };
+})>;
+type MockStreamResponse = CodecType<typeof MockStreamResponse>;
 
 export { MockBlock, MockBlockFromBytes, MockClient, MockFilter, MockFilterFromBytes, MockStream, MockStreamResponse, StreamDataIterable };

package/dist/testing/index.d.ts

@@ -1,9 +1,8 @@
-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 { w as Client, l as StreamDataRequest, v as StreamDataOptions, r as StreamDataResponse, S as StatusRequest, u as ClientCallOptions, f as StatusResponse, t as StreamConfig, B as Bytes, A as Cursor, E as DataFinality, J as DataProduction } from '../shared/protocol.8b5e318a.js';
+import { MessageCodec, Codec, CodecType } from '../codec.js';
 import 'nice-grpc-common';
 import 'protobufjs/minimal.js';
-import '@effect/schema/AST';
+import 'nice-grpc';
 
 declare class MockClient<TFilter, TBlock> implements Client<TFilter, TBlock> {
     private messageFactory;
@@ -17,60 +16,114 @@ declare class StreamDataIterable<TBlock> {
     [Symbol.asyncIterator](): AsyncIterator<StreamDataResponse<TBlock>>;
 }
 
-declare const MockFilter: Schema.Struct<{
-    filter: Schema.optional<typeof Schema.String>;
+declare const MockFilter: MessageCodec<{
+    filter: Codec<string | undefined, string | undefined>;
 }>;
-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 MockFilter = CodecType<typeof MockFilter>;
+declare const MockFilterFromBytes: Codec<MockFilter, Uint8Array>;
+declare const MockBlock: MessageCodec<{
+    data: Codec<string | undefined, string | undefined>;
 }>;
-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>;
-}>>>;
+type MockBlock = CodecType<typeof MockBlock>;
+declare const MockBlockFromBytes: Codec<MockBlock | null, Uint8Array>;
 declare const MockStream: StreamConfig<{
-    readonly filter?: string | undefined;
+    filter?: string | undefined;
 }, {
-    readonly data?: string | undefined;
+    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;
+declare const MockStreamResponse: Codec<{
+    _tag: "heartbeat";
+} | ({
+    _tag: "data";
+} & {
+    data: {
+        cursor?: {
+            orderKey: bigint;
+            uniqueKey?: Bytes | undefined;
+        } | undefined;
+        endCursor: {
+            orderKey: bigint;
+            uniqueKey?: Bytes | undefined;
+        };
+        finality: "finalized" | "accepted" | "pending" | "unknown";
+        production: "unknown" | "backfill" | "live";
+        data: readonly ({
+            data?: string | undefined;
+        } | null)[];
+    };
+}) | ({
+    _tag: "invalidate";
+} & {
+    invalidate: {
+        cursor?: {
+            orderKey: bigint;
+            uniqueKey?: Bytes | undefined;
+        } | undefined;
+    };
+}) | ({
+    _tag: "finalize";
+} & {
+    finalize: {
+        cursor?: {
+            orderKey: bigint;
+            uniqueKey?: Bytes | undefined;
+        } | undefined;
+    };
+}) | ({
+    _tag: "systemMessage";
+} & {
+    systemMessage: {
+        output: ({
+            _tag: "stdout";
+        } & {
+            stdout: string;
+        }) | ({
+            _tag: "stderr";
+        } & {
+            stderr: string;
+        });
+    };
+}), ({
+    $case: "data";
+} & {
+    data: {
+        cursor?: Cursor | undefined;
+        endCursor: Cursor;
+        finality: DataFinality;
+        production: DataProduction;
+        data?: readonly Uint8Array[] | undefined;
+    };
+}) | ({
+    $case: "invalidate";
+} & {
+    invalidate: {
+        cursor?: Cursor | undefined;
+    };
+}) | ({
+    $case: "finalize";
+} & {
+    finalize: {
+        cursor?: Cursor | undefined;
+    };
+}) | ({
+    $case: "heartbeat";
+} & {
+    heartbeat: undefined;
+}) | ({
+    $case: "systemMessage";
+} & {
+    systemMessage: {
+        output: ({
+            $case: "stdout";
+        } & {
+            stdout: string;
+        }) | ({
+            $case: "stderr";
+        } & {
+            stderr: string;
+        });
+    };
+})>;
+type MockStreamResponse = CodecType<typeof MockStreamResponse>;
 
 export { MockBlock, MockBlockFromBytes, MockClient, MockFilter, MockFilterFromBytes, MockStream, MockStreamResponse, StreamDataIterable };