@apibara/evm 2.0.0

package/src/filter.test.ts

@@ -0,0 +1,191 @@
+import { encodeEventTopics, pad, parseAbi } from "viem";
+import { describe, expect, it } from "vitest";
+
+import { Schema } from "@effect/schema";
+import {
+  Filter,
+  LogFilter,
+  filterFromProto,
+  filterToProto,
+  mergeFilter,
+} from "./filter";
+
+const abi = parseAbi([
+  "event Transfer(address indexed from, address indexed to, uint256 value)",
+]);
+
+describe("Filter", () => {
+  it("all filters are optional", () => {
+    const filter = Filter.make({});
+
+    const proto = filterToProto(filter);
+    const back = filterFromProto(proto);
+    expect(back).toEqual(filter);
+  });
+
+  it("accepts logs filter", () => {
+    const filter = Filter.make({
+      logs: [
+        {
+          address: "0x123456789012",
+          strict: true,
+          topics: encodeEventTopics({
+            abi,
+            eventName: "Transfer",
+            args: { from: null, to: null },
+          }) as `0x${string}`[],
+        },
+      ],
+    });
+
+    expect(filter.logs).toHaveLength(1);
+
+    const proto = filterToProto(filter);
+    const back = filterFromProto(proto);
+
+    expect(back).toBeDefined();
+    expect(back.logs).toHaveLength(1);
+  });
+});
+
+describe("LogFilter", () => {
+  const encode = Schema.encodeSync(LogFilter);
+  const decode = Schema.decodeSync(LogFilter);
+
+  it("can be empty", () => {
+    const filter = LogFilter.make({});
+
+    const proto = encode(filter);
+    const back = decode(proto);
+    expect(back).toEqual(filter);
+  });
+
+  it("can have null topics", () => {
+    const filter = LogFilter.make({
+      topics: [null, pad("0x1"), null, pad("0x3")],
+    });
+
+    const proto = encode(filter);
+    const back = decode(proto);
+    expect(back).toEqual(filter);
+  });
+
+  it("can have all optional fields", () => {
+    const filter = LogFilter.make({
+      address: pad("0xa", { size: 20 }),
+      topics: [null, pad("0x1"), null, pad("0x3")],
+      includeTransaction: true,
+      includeReceipt: true,
+      strict: true,
+    });
+
+    const proto = encode(filter);
+    const back = decode(proto);
+    expect(back).toEqual(filter);
+  });
+});
+
+describe("mergeFilter", () => {
+  it("returns header.always if any has it", () => {
+    const fa = mergeFilter({}, { header: { always: true } });
+    expect(fa).toMatchInlineSnapshot(`
+      {
+        "header": {
+          "always": true,
+        },
+        "logs": [],
+        "transactions": [],
+        "withdrawals": [],
+      }
+    `);
+    const fb = mergeFilter({ header: { always: true } }, {});
+    expect(fb).toMatchInlineSnapshot(`
+      {
+        "header": {
+          "always": true,
+        },
+        "logs": [],
+        "transactions": [],
+        "withdrawals": [],
+      }
+    `);
+  });
+
+  it("returns an empty header by default", () => {
+    const f = mergeFilter({}, {});
+    expect(f).toMatchInlineSnapshot(`
+      {
+        "header": undefined,
+        "logs": [],
+        "transactions": [],
+        "withdrawals": [],
+      }
+    `);
+  });
+
+  it("concatenates logs", () => {
+    const f = mergeFilter(
+      { logs: [{ address: "0xAAAAAAAAAAAAAAAAAAAAAA" }] },
+      { logs: [{ address: "0xBBBBBBBBBBBBBBBBBBBBBB" }] },
+    );
+    expect(f).toMatchInlineSnapshot(`
+      {
+        "header": undefined,
+        "logs": [
+          {
+            "address": "0xAAAAAAAAAAAAAAAAAAAAAA",
+          },
+          {
+            "address": "0xBBBBBBBBBBBBBBBBBBBBBB",
+          },
+        ],
+        "transactions": [],
+        "withdrawals": [],
+      }
+    `);
+  });
+
+  it("concatenates transactions", () => {
+    const f = mergeFilter(
+      { transactions: [{ from: "0xAAAAAAAAAAAAAAAAAAAAAA" }] },
+      { transactions: [{ from: "0xBBBBBBBBBBBBBBBBBBBBBB" }] },
+    );
+    expect(f).toMatchInlineSnapshot(`
+      {
+        "header": undefined,
+        "logs": [],
+        "transactions": [
+          {
+            "from": "0xAAAAAAAAAAAAAAAAAAAAAA",
+          },
+          {
+            "from": "0xBBBBBBBBBBBBBBBBBBBBBB",
+          },
+        ],
+        "withdrawals": [],
+      }
+    `);
+  });
+
+  it("concatenates withdrawals", () => {
+    const f = mergeFilter(
+      { withdrawals: [{ validatorIndex: 1n }] },
+      { withdrawals: [{ validatorIndex: 100n }] },
+    );
+    expect(f).toMatchInlineSnapshot(`
+      {
+        "header": undefined,
+        "logs": [],
+        "transactions": [],
+        "withdrawals": [
+          {
+            "validatorIndex": 1n,
+          },
+          {
+            "validatorIndex": 100n,
+          },
+        ],
+      }
+    `);
+  });
+});

package/src/filter.ts

@@ -0,0 +1,117 @@
+import { Schema } from "@effect/schema";
+
+import { Address, B256, b256FromProto, b256ToProto } from "./common";
+
+import * as proto from "./proto";
+
+const OptionalArray = <TSchema extends Schema.Schema.Any>(schema: TSchema) =>
+  Schema.optional(Schema.Array(schema));
+
+export const HeaderFilter = Schema.Struct({
+  always: Schema.optional(Schema.Boolean),
+});
+
+export type HeaderFilter = typeof HeaderFilter.Type;
+
+export const WithdrawalFilter = Schema.Struct({
+  validatorIndex: Schema.optional(Schema.BigIntFromSelf),
+  address: Schema.optional(Address),
+});
+
+export type WithdrawalFilter = typeof WithdrawalFilter.Type;
+
+// TODO: using the decoder inside decode/encode feels wrong.
+export const Topic = Schema.transform(
+  Schema.Struct({ value: Schema.UndefinedOr(B256) }),
+  Schema.NullOr(B256),
+  {
+    strict: false,
+    decode({ value }) {
+      if (value === undefined) {
+        return null;
+      }
+      return b256ToProto(value);
+    },
+    encode(value) {
+      if (value === null) {
+        return { value: undefined };
+      }
+      return { value: b256FromProto(value) };
+    },
+  },
+);
+
+export const LogFilter = Schema.Struct({
+  address: Schema.optional(Address),
+  topics: OptionalArray(Topic),
+
+  strict: Schema.optional(Schema.Boolean),
+  includeTransaction: Schema.optional(Schema.Boolean),
+  includeReceipt: Schema.optional(Schema.Boolean),
+});
+
+export type LogFilter = typeof LogFilter.Type;
+
+export const TransactionFilter = Schema.Struct({
+  from: Schema.optional(Address),
+  to: Schema.optional(Address),
+
+  includeReceipt: Schema.optional(Schema.Boolean),
+  includeLogs: Schema.optional(Schema.Boolean),
+});
+
+export type TransactionFilter = typeof TransactionFilter.Type;
+
+export const Filter = Schema.Struct({
+  header: Schema.optional(HeaderFilter),
+  withdrawals: OptionalArray(WithdrawalFilter),
+  logs: OptionalArray(LogFilter),
+  transactions: OptionalArray(TransactionFilter),
+});
+
+export type Filter = typeof Filter.Type;
+
+export const filterToProto = Schema.encodeSync(Filter);
+export const filterFromProto = Schema.decodeSync(Filter);
+
+export const FilterFromBytes = Schema.transform(
+  Schema.Uint8ArrayFromSelf,
+  Filter,
+  {
+    strict: false,
+    decode(value) {
+      return proto.filter.Filter.decode(value);
+    },
+    encode(value) {
+      return proto.filter.Filter.encode(value).finish();
+    },
+  },
+);
+
+export const filterToBytes = Schema.encodeSync(FilterFromBytes);
+export const filterFromBytes = Schema.decodeSync(FilterFromBytes);
+
+export function mergeFilter(a: Filter, b: Filter): Filter {
+  const header = mergeHeaderFilter(a.header, b.header);
+  return {
+    header,
+    withdrawals: [...(a.withdrawals ?? []), ...(b.withdrawals ?? [])],
+    logs: [...(a.logs ?? []), ...(b.logs ?? [])],
+    transactions: [...(a.transactions ?? []), ...(b.transactions ?? [])],
+  };
+}
+
+function mergeHeaderFilter(
+  a?: HeaderFilter,
+  b?: HeaderFilter,
+): HeaderFilter | undefined {
+  if (a === undefined) {
+    return b;
+  }
+  if (b === undefined) {
+    return a;
+  }
+  return {
+    always: a.always || b.always,
+  };
+}

package/src/index.ts

@@ -0,0 +1,15 @@
+import { StreamConfig } from "@apibara/protocol";
+import { BlockFromBytes } from "./block";
+import { FilterFromBytes, mergeFilter } from "./filter";
+
+export * as proto from "./proto";
+
+export * from "./common";
+export * from "./filter";
+export * from "./block";
+
+export const EvmStream = new StreamConfig(
+  FilterFromBytes,
+  BlockFromBytes,
+  mergeFilter,
+);