@apibara/evm 2.1.0-beta.3 → 2.1.0-beta.31

package/src/common.ts

@@ -1,117 +1,86 @@
-import { Schema } from "@effect/schema";
-import { hexToBytes, pad } from "viem";
+import type { Codec, CodecType } from "@apibara/protocol/codec";
+import type * as proto from "./proto";
 
 const MAX_U64 = 0xffffffffffffffffn;
-
-const _Address = Schema.TemplateLiteral(Schema.Literal("0x"), Schema.String);
-
-/** Wire representation of `Address`. */
-const AddressProto = Schema.Struct({
-  x0: Schema.BigIntFromSelf,
-  x1: Schema.BigIntFromSelf,
-  x2: Schema.Number,
-});
+const MAX_U32 = 0xffffffffn;
 
 /** An Ethereum address. */
-export const Address = Schema.transform(AddressProto, _Address, {
-  decode(value) {
-    const x0 = value.x0.toString(16).padStart(16, "0");
-    const x1 = value.x1.toString(16).padStart(16, "0");
-    const x2 = value.x2.toString(16).padStart(8, "0");
-    return `0x${x0}${x1}${x2}` as `0x${string}`;
+export const Address: Codec<`0x${string}`, proto.common.Address> = {
+  encode(x) {
+    const bn = BigInt(x);
+    // Ethereum address is 20 bytes (160 bits)
+    // Splitting into two 64-bit chunks and one 32-bit chunk
+    const x2 = bn & MAX_U32;
+    const x1 = (bn >> 32n) & MAX_U64;
+    const x0 = (bn >> 96n) & MAX_U64;
+    return { x0, x1, x2: Number(x2) };
   },
-  encode(value) {
-    const bytes = hexToBytes(pad(value, { size: 20, dir: "left" }));
-    const dv = new DataView(bytes.buffer);
-    const x0 = dv.getBigUint64(0);
-    const x1 = dv.getBigUint64(8);
-    const x2 = dv.getUint32(16);
-    return { x0, x1, x2 };
+  decode(p) {
+    const x0 = p.x0 ?? 0n;
+    const x1 = p.x1 ?? 0n;
+    const x2 = BigInt(p.x2 ?? 0);
+    const bn = x2 + (x1 << 32n) + (x0 << 96n);
+    return `0x${bn.toString(16).padStart(40, "0")}` as `0x${string}`;
   },
-});
-
-export type Address = typeof Address.Type;
+};
 
-const _B256 = Schema.TemplateLiteral(Schema.Literal("0x"), Schema.String);
-
-/** Wire representation of `B256`. */
-export const B256Proto = Schema.Struct({
-  x0: Schema.BigIntFromSelf,
-  x1: Schema.BigIntFromSelf,
-  x2: Schema.BigIntFromSelf,
-  x3: Schema.BigIntFromSelf,
-});
+export type Address = CodecType<typeof Address>;
 
 /** Data with length 256 bits. */
-export const B256 = Schema.transform(B256Proto, _B256, {
-  decode(value) {
-    const x0 = value.x0.toString(16).padStart(16, "0");
-    const x1 = value.x1.toString(16).padStart(16, "0");
-    const x2 = value.x2.toString(16).padStart(16, "0");
-    const x3 = value.x3.toString(16).padStart(16, "0");
-    return `0x${x0}${x1}${x2}${x3}` as `0x${string}`;
-  },
-  encode(value) {
-    const bytes = hexToBytes(pad(value, { size: 32, dir: "left" }));
-    const dv = new DataView(bytes.buffer);
-    const x0 = dv.getBigUint64(0);
-    const x1 = dv.getBigUint64(8);
-    const x2 = dv.getBigUint64(16);
-    const x3 = dv.getBigUint64(24);
+export const B256: Codec<`0x${string}`, proto.common.B256> = {
+  encode(x) {
+    const bn = BigInt(x);
+    const x3 = bn & MAX_U64;
+    const x2 = (bn >> 64n) & MAX_U64;
+    const x1 = (bn >> 128n) & MAX_U64;
+    const x0 = (bn >> 192n) & MAX_U64;
     return { x0, x1, x2, x3 };
   },
-});
-
-export const b256ToProto = Schema.encodeSync(B256);
-export const b256FromProto = Schema.decodeSync(B256);
+  decode(p) {
+    const x0 = p.x0 ?? 0n;
+    const x1 = p.x1 ?? 0n;
+    const x2 = p.x2 ?? 0n;
+    const x3 = p.x3 ?? 0n;
+    const bn = x3 + (x2 << 64n) + (x1 << 128n) + (x0 << 192n);
+    return `0x${bn.toString(16).padStart(64, "0")}` as `0x${string}`;
+  },
+};
 
-/** Wire representation of `U256`. */
-const U256Proto = Schema.Struct({
-  x0: Schema.BigIntFromSelf,
-  x1: Schema.BigIntFromSelf,
-  x2: Schema.BigIntFromSelf,
-  x3: Schema.BigIntFromSelf,
-});
+export type B256 = CodecType<typeof B256>;
 
 /** Data with length 256 bits. */
-export const U256 = Schema.transform(U256Proto, Schema.BigIntFromSelf, {
-  decode(value) {
-    return (
-      (value.x0 << (8n * 24n)) +
-      (value.x1 << (8n * 16n)) +
-      (value.x2 << (8n * 8n)) +
-      value.x3
-    );
-  },
-  encode(value) {
-    const x0 = (value >> (8n * 24n)) & MAX_U64;
-    const x1 = (value >> (8n * 16n)) & MAX_U64;
-    const x2 = (value >> (8n * 8n)) & MAX_U64;
-    const x3 = value & MAX_U64;
+export const U256: Codec<bigint, proto.common.U256> = {
+  encode(x) {
+    const bn = BigInt(x);
+    const x3 = bn & MAX_U64;
+    const x2 = (bn >> 64n) & MAX_U64;
+    const x1 = (bn >> 128n) & MAX_U64;
+    const x0 = (bn >> 192n) & MAX_U64;
     return { x0, x1, x2, x3 };
   },
-});
-
-export const u256ToProto = Schema.encodeSync(U256);
-export const u256FromProto = Schema.decodeSync(U256);
+  decode(p) {
+    const x0 = p.x0 ?? 0n;
+    const x1 = p.x1 ?? 0n;
+    const x2 = p.x2 ?? 0n;
+    const x3 = p.x3 ?? 0n;
+    return x3 + (x2 << 64n) + (x1 << 128n) + (x0 << 192n);
+  },
+};
 
-/** Wire representation of `U128`. */
-const U128Proto = Schema.Struct({
-  x0: Schema.BigIntFromSelf,
-  x1: Schema.BigIntFromSelf,
-});
+export type U256 = CodecType<typeof U256>;
 
 /** Data with length 128 bits. */
-export const U128 = Schema.transform(U128Proto, Schema.BigIntFromSelf, {
-  decode(value) {
-    return (value.x0 << (8n * 8n)) + value.x1;
-  },
-  encode(value) {
-    const x0 = (value >> (8n * 8n)) & MAX_U64;
-    const x1 = value & MAX_U64;
+export const U128: Codec<bigint, proto.common.U128> = {
+  encode(x) {
+    const x1 = x & MAX_U64;
+    const x0 = (x >> 64n) & MAX_U64;
     return { x0, x1 };
   },
-});
+  decode(p) {
+    const x0 = p.x0 ?? 0n;
+    const x1 = p.x1 ?? 0n;
+    return x1 + (x0 << 64n);
+  },
+};
 
-export const u128ToProto = Schema.encodeSync(U128);
-export const u128FromProto = Schema.decodeSync(U128);
+export type U128 = CodecType<typeof U128>;

package/src/filter.ts

@@ -1,160 +1,154 @@
-import { Schema } from "@effect/schema";
-
-import { Address, B256, B256Proto } from "./common";
-
+import { Address, B256 } from "./common";
+
+import {
+  ArrayCodec,
+  BooleanCodec,
+  type Codec,
+  type CodecType,
+  MessageCodec,
+  NumberCodec,
+  OptionalCodec,
+} from "@apibara/protocol/codec";
 import * as proto from "./proto";
 
-const OptionalArray = <TSchema extends Schema.Schema.Any>(schema: TSchema) =>
-  Schema.optional(Schema.Array(schema));
-
 /** Header options.
  *
  * - `always`: receive all block headers.
  * - `on_data`: receive headers only if any other filter matches.
  * - `on_data_or_on_new_block`: receive headers only if any other filter matches and for "live" blocks.
  */
-export const HeaderFilter = Schema.transform(
-  Schema.Enums(proto.filter.HeaderFilter),
-  Schema.Literal("always", "on_data", "on_data_or_on_new_block", "unknown"),
-  {
-    decode(value) {
-      const enumMap = {
-        [proto.filter.HeaderFilter.ALWAYS]: "always",
-        [proto.filter.HeaderFilter.ON_DATA]: "on_data",
-        [proto.filter.HeaderFilter.ON_DATA_OR_ON_NEW_BLOCK]:
-          "on_data_or_on_new_block",
-        [proto.filter.HeaderFilter.UNSPECIFIED]: "unknown",
-        [proto.filter.HeaderFilter.UNRECOGNIZED]: "unknown",
-      } as const;
-      return enumMap[value] ?? "unknown";
-    },
-    encode(value) {
-      switch (value) {
-        case "always":
-          return proto.filter.HeaderFilter.ALWAYS;
-        case "on_data":
-          return proto.filter.HeaderFilter.ON_DATA;
-        case "on_data_or_on_new_block":
-          return proto.filter.HeaderFilter.ON_DATA_OR_ON_NEW_BLOCK;
-        default:
-          return proto.filter.HeaderFilter.UNSPECIFIED;
-      }
-    },
+export const HeaderFilter: Codec<
+  "always" | "on_data" | "on_data_or_on_new_block" | "unknown",
+  proto.filter.HeaderFilter
+> = {
+  encode(x) {
+    switch (x) {
+      case "always":
+        return proto.filter.HeaderFilter.ALWAYS;
+      case "on_data":
+        return proto.filter.HeaderFilter.ON_DATA;
+      case "on_data_or_on_new_block":
+        return proto.filter.HeaderFilter.ON_DATA_OR_ON_NEW_BLOCK;
+      default:
+        return proto.filter.HeaderFilter.UNSPECIFIED;
+    }
   },
-);
+  decode(p) {
+    const enumMap = {
+      [proto.filter.HeaderFilter.ALWAYS]: "always",
+      [proto.filter.HeaderFilter.ON_DATA]: "on_data",
+      [proto.filter.HeaderFilter.ON_DATA_OR_ON_NEW_BLOCK]:
+        "on_data_or_on_new_block",
+      [proto.filter.HeaderFilter.UNSPECIFIED]: "unknown",
+      [proto.filter.HeaderFilter.UNRECOGNIZED]: "unknown",
+    } as const;
+    return enumMap[p] ?? "unknown";
+  },
+};
 
-export type HeaderFilter = typeof HeaderFilter.Type;
+export type HeaderFilter = CodecType<typeof HeaderFilter>;
 
-export const WithdrawalFilter = Schema.Struct({
-  id: Schema.optional(Schema.Number),
-  validatorIndex: Schema.optional(Schema.Number),
-  address: Schema.optional(Address),
+export const WithdrawalFilter = MessageCodec({
+  id: OptionalCodec(NumberCodec),
+  validatorIndex: OptionalCodec(NumberCodec),
+  address: OptionalCodec(Address),
 });
 
-export type WithdrawalFilter = typeof WithdrawalFilter.Type;
-
-export const TransactionStatusFilter = Schema.transform(
-  Schema.Enums(proto.filter.TransactionStatusFilter),
-  Schema.Literal("succeeded", "reverted", "all", "unknown"),
-  {
-    decode(value) {
-      const enumMap = {
-        [proto.filter.TransactionStatusFilter.SUCCEEDED]: "succeeded",
-        [proto.filter.TransactionStatusFilter.REVERTED]: "reverted",
-        [proto.filter.TransactionStatusFilter.ALL]: "all",
-        [proto.filter.TransactionStatusFilter.UNSPECIFIED]: "unknown",
-        [proto.filter.TransactionStatusFilter.UNRECOGNIZED]: "unknown",
-      } as const;
-      return enumMap[value] ?? "unknown";
-    },
-    encode(value) {
-      switch (value) {
-        case "succeeded":
-          return proto.filter.TransactionStatusFilter.SUCCEEDED;
-        case "reverted":
-          return proto.filter.TransactionStatusFilter.REVERTED;
-        case "all":
-          return proto.filter.TransactionStatusFilter.ALL;
-        default:
-          return proto.filter.TransactionStatusFilter.UNSPECIFIED;
-      }
-    },
+export type WithdrawalFilter = CodecType<typeof WithdrawalFilter>;
+
+export const TransactionStatusFilter: Codec<
+  "succeeded" | "reverted" | "all" | "unknown",
+  proto.filter.TransactionStatusFilter
+> = {
+  decode(value) {
+    const enumMap = {
+      [proto.filter.TransactionStatusFilter.SUCCEEDED]: "succeeded",
+      [proto.filter.TransactionStatusFilter.REVERTED]: "reverted",
+      [proto.filter.TransactionStatusFilter.ALL]: "all",
+      [proto.filter.TransactionStatusFilter.UNSPECIFIED]: "unknown",
+      [proto.filter.TransactionStatusFilter.UNRECOGNIZED]: "unknown",
+    } as const;
+    return enumMap[value] ?? "unknown";
+  },
+  encode(value) {
+    switch (value) {
+      case "succeeded":
+        return proto.filter.TransactionStatusFilter.SUCCEEDED;
+      case "reverted":
+        return proto.filter.TransactionStatusFilter.REVERTED;
+      case "all":
+        return proto.filter.TransactionStatusFilter.ALL;
+      default:
+        return proto.filter.TransactionStatusFilter.UNSPECIFIED;
+    }
   },
-);
-
-export type TransactionStatusFilter = typeof TransactionStatusFilter.Type;
-
-export const Topic = Schema.transform(
-  Schema.Struct({ value: Schema.UndefinedOr(B256Proto) }),
-  Schema.NullOr(B256),
-  {
-    decode({ value }) {
-      if (value === undefined) {
-        return null;
-      }
-      return value;
-    },
-    encode(value) {
-      if (value === null) {
-        return { value: undefined };
-      }
-      return { value };
-    },
+};
+
+export type TransactionStatusFilter = CodecType<typeof TransactionStatusFilter>;
+
+export const Topic: Codec<
+  B256 | null,
+  { value?: proto.common.B256 | undefined }
+> = {
+  encode(x) {
+    if (x === null) {
+      return { value: undefined };
+    }
+    return { value: B256.encode(x) };
   },
-);
-
-export const LogFilter = Schema.Struct({
-  id: Schema.optional(Schema.Number),
-  address: Schema.optional(Address),
-  topics: OptionalArray(Topic),
-  strict: Schema.optional(Schema.Boolean),
-  transactionStatus: Schema.optional(TransactionStatusFilter),
-  includeTransaction: Schema.optional(Schema.Boolean),
-  includeReceipt: Schema.optional(Schema.Boolean),
+  decode({ value }) {
+    if (value === undefined) {
+      return null;
+    }
+    return B256.decode(value);
+  },
+};
+
+export type Topic = CodecType<typeof Topic>;
+
+export const LogFilter = MessageCodec({
+  id: OptionalCodec(NumberCodec),
+  address: OptionalCodec(Address),
+  topics: OptionalCodec(ArrayCodec(Topic)),
+  strict: OptionalCodec(BooleanCodec),
+  transactionStatus: OptionalCodec(TransactionStatusFilter),
+  includeTransaction: OptionalCodec(BooleanCodec),
+  includeReceipt: OptionalCodec(BooleanCodec),
+  includeTransactionTrace: OptionalCodec(BooleanCodec),
 });
 
-export type LogFilter = typeof LogFilter.Type;
-
-export const TransactionFilter = Schema.Struct({
-  id: Schema.optional(Schema.Number),
-  from: Schema.optional(Address),
-  to: Schema.optional(Address),
-  create: Schema.optional(Schema.Boolean),
-  transactionStatus: Schema.optional(TransactionStatusFilter),
-  includeReceipt: Schema.optional(Schema.Boolean),
-  includeLogs: Schema.optional(Schema.Boolean),
+export type LogFilter = Readonly<CodecType<typeof LogFilter>>;
+
+export const TransactionFilter = MessageCodec({
+  id: OptionalCodec(NumberCodec),
+  from: OptionalCodec(Address),
+  to: OptionalCodec(Address),
+  create: OptionalCodec(BooleanCodec),
+  transactionStatus: OptionalCodec(TransactionStatusFilter),
+  includeReceipt: OptionalCodec(BooleanCodec),
+  includeLogs: OptionalCodec(BooleanCodec),
+  includeTransactionTrace: OptionalCodec(BooleanCodec),
 });
 
-export type TransactionFilter = typeof TransactionFilter.Type;
+export type TransactionFilter = Readonly<CodecType<typeof TransactionFilter>>;
 
-export const Filter = Schema.Struct({
-  header: Schema.optional(HeaderFilter),
-  withdrawals: OptionalArray(WithdrawalFilter),
-  transactions: OptionalArray(TransactionFilter),
-  logs: OptionalArray(LogFilter),
+export const Filter = MessageCodec({
+  header: OptionalCodec(HeaderFilter),
+  withdrawals: OptionalCodec(ArrayCodec(WithdrawalFilter)),
+  transactions: OptionalCodec(ArrayCodec(TransactionFilter)),
+  logs: OptionalCodec(ArrayCodec(LogFilter)),
 });
 
-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 type Filter = Readonly<CodecType<typeof Filter>>;
 
-export const filterToBytes = Schema.encodeSync(FilterFromBytes);
-export const filterFromBytes = Schema.decodeSync(FilterFromBytes);
+export const FilterFromBytes: Codec<Filter, Uint8Array> = {
+  encode(x) {
+    return proto.filter.Filter.encode(Filter.encode(x)).finish();
+  },
+  decode(p) {
+    return Filter.decode(proto.filter.Filter.decode(p));
+  },
+};
 
 export function mergeFilter(a: Filter, b: Filter): Filter {
   const header = mergeHeaderFilter(a.header, b.header);

package/src/index.ts

@@ -12,4 +12,5 @@ export const EvmStream = new StreamConfig(
   FilterFromBytes,
   BlockFromBytes,
   mergeFilter,
+  "evm",
 );