@apibara/evm 2.0.0 → 2.0.1-beta.1

package/package.json

@@ -1,9 +1,14 @@
 {
   "name": "@apibara/evm",
-  "version": "2.0.0",
+  "version": "2.0.1-beta.1",
   "type": "module",
-  "source": "./src/index.ts",
+  "files": [
+    "dist",
+    "src",
+    "README.md"
+  ],
   "main": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -12,12 +17,15 @@
       "default": "./dist/index.mjs"
     }
   },
-  "publishConfig": {
-    "files": [
-      "dist",
-      "src",
-      "README.md"
-    ]
+  "scripts": {
+    "build": "pnpm build:proto && unbuild",
+    "build:proto": "buf generate proto",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest",
+    "test:ci": "vitest run",
+    "lint": "biome check .",
+    "lint:fix": "pnpm lint --write",
+    "format": "biome format . --write"
   },
   "devDependencies": {
     "@bufbuild/buf": "^1.32.1",
@@ -27,23 +35,12 @@
     "vitest": "^1.6.0"
   },
   "dependencies": {
+    "@apibara/protocol": "2.0.0-beta.9",
     "@effect/schema": "^0.67.15",
     "effect": "^3.2.6",
     "long": "^5.2.1",
     "nice-grpc-common": "^2.0.2",
     "protobufjs": "^7.1.2",
-    "viem": "^2.12.4",
-    "@apibara/protocol": "2.0.0-beta.1"
-  },
-  "scripts": {
-    "build": "pnpm build:proto && unbuild",
-    "build:proto": "buf generate proto",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest",
-    "test:ci": "vitest run",
-    "lint": "biome check .",
-    "lint:fix": "pnpm lint --write",
-    "format": "biome format . --write"
-  },
-  "types": "./dist/index.d.ts"
-}
+    "viem": "^2.12.4"
+  }
+}

package/src/block.ts

@@ -4,7 +4,7 @@ import { Schema } from "@effect/schema";
 import { Address, B256, U128, U256 } from "./common";
 import * as proto from "./proto";
 
-export const HexData = Schema.transform(
+export const Bloom = Schema.transform(
   Schema.Struct({
     value: BytesFromUint8Array,
   }),
@@ -15,64 +15,67 @@ export const HexData = Schema.transform(
       throw new Error("Not implemented");
     },
     decode({ value }) {
-      // return value;
-      throw new Error("Not implemented");
+      return value;
     },
   },
 );
 
-export const Bloom = Schema.transform(
-  Schema.Struct({
-    value: BytesFromUint8Array,
-  }),
-  Bytes,
+export const TransactionStatus = Schema.transform(
+  Schema.Enums(proto.data.TransactionStatus),
+  Schema.Literal("unknown", "succeeded", "reverted"),
   {
-    strict: false,
-    encode(value) {
-      throw new Error("Not implemented");
+    decode(value) {
+      const enumMap = {
+        [proto.data.TransactionStatus.SUCCEEDED]: "succeeded",
+        [proto.data.TransactionStatus.REVERTED]: "reverted",
+        [proto.data.TransactionStatus.UNSPECIFIED]: "unknown",
+        [proto.data.TransactionStatus.UNRECOGNIZED]: "unknown",
+      } as const;
+
+      return enumMap[value] ?? "unknown";
     },
-    decode({ value }) {
-      throw new Error("Not implemented");
-      // return value;
+    encode(value) {
+      throw new Error("encode: not implemented");
     },
   },
 );
 
+export type TransactionStatus = typeof TransactionStatus.Type;
+
 export const BlockHeader = Schema.Struct({
-  number: Schema.BigIntFromSelf,
-  hash: Schema.optional(B256),
-  parentHash: Schema.optional(B256),
-  uncleHash: Schema.optional(B256),
+  blockNumber: Schema.BigIntFromSelf,
+  blockHash: Schema.optional(B256),
+  parentBlockHash: Schema.optional(B256),
+  unclesHash: Schema.optional(B256),
   miner: Schema.optional(Address),
   stateRoot: Schema.optional(B256),
-  transactionRoot: Schema.optional(B256),
-  receiptRoot: Schema.optional(B256),
+  transactionsRoot: Schema.optional(B256),
+  receiptsRoot: Schema.optional(B256),
   logsBloom: Schema.optional(Bloom),
   difficulty: Schema.optional(U256),
-  gasLimit: Schema.optional(U256),
-  gasUsed: Schema.optional(U256),
+  gasLimit: Schema.optional(U128),
+  gasUsed: Schema.optional(U128),
   timestamp: Schema.optional(Schema.DateFromSelf),
-  // extraData: Schema.optional(HexData),
+  extraData: BytesFromUint8Array,
   mixHash: Schema.optional(B256),
-  nonce: Schema.BigIntFromSelf,
-  baseFeePerGas: Schema.optional(U256),
+  nonce: Schema.optional(Schema.BigIntFromSelf),
+  baseFeePerGas: Schema.optional(U128),
   withdrawalsRoot: Schema.optional(B256),
   totalDifficulty: Schema.optional(U256),
-  uncles: Schema.Array(B256),
-  size: Schema.optional(U256),
-  blobGasUsed: Schema.BigIntFromSelf,
-  excessBlobGas: Schema.BigIntFromSelf,
+  blobGasUsed: Schema.optional(U128),
+  excessBlobGas: Schema.optional(U128),
   parentBeaconBlockRoot: Schema.optional(B256),
 });
 
 export type BlockHeader = typeof BlockHeader.Type;
 
 export const Withdrawal = Schema.Struct({
+  filterIds: Schema.optional(Schema.Array(Schema.Number)),
+  withdrawalIndex: Schema.Number,
   index: Schema.BigIntFromSelf,
-  validatorIndex: Schema.BigIntFromSelf,
-  withdrawalIndex: Schema.BigIntFromSelf,
+  validatorIndex: Schema.Number,
   address: Schema.optional(Address),
-  amount: Schema.optional(U256),
+  amount: Schema.optional(Schema.BigIntFromSelf),
 });
 
 export const AccessListItem = Schema.Struct({
@@ -88,50 +91,53 @@ export const Signature = Schema.Struct({
 });
 
 export const Transaction = Schema.Struct({
-  hash: Schema.optional(B256),
-  nonce: Schema.BigIntFromSelf,
-  transactionIndex: Schema.BigIntFromSelf,
+  filterIds: Schema.optional(Schema.Array(Schema.Number)),
+  transactionIndex: Schema.Number,
+  transactionHash: Schema.optional(B256),
+  nonce: Schema.optional(Schema.BigIntFromSelf),
   from: Schema.optional(Address),
   to: Schema.optional(Address),
   value: Schema.optional(U256),
   gasPrice: Schema.optional(U128),
-  gas: Schema.optional(U256),
+  gas: Schema.optional(U128),
   maxFeePerGas: Schema.optional(U128),
   maxPriorityFeePerGas: Schema.optional(U128),
-  // TODO
-  // input: Schema.optional(HexData),
+  input: BytesFromUint8Array,
   signature: Schema.optional(Signature),
-  chainId: Schema.BigIntFromSelf,
+  chainId: Schema.optional(Schema.BigIntFromSelf),
   accessList: Schema.Array(AccessListItem),
-  transactionType: Schema.BigIntFromSelf,
+  transactionType: Schema.optional(Schema.BigIntFromSelf),
   maxFeePerBlobGas: Schema.optional(U128),
   blobVersionedHashes: Schema.Array(B256),
+  transactionStatus: Schema.optional(TransactionStatus),
 });
 
 export const TransactionReceipt = Schema.Struct({
+  filterIds: Schema.optional(Schema.Array(Schema.Number)),
+  transactionIndex: Schema.optional(Schema.Number),
   transactionHash: Schema.optional(B256),
-  transactionIndex: Schema.BigIntFromSelf,
-  cumulativeGasUsed: Schema.optional(U256),
-  gasUsed: Schema.optional(U256),
+  cumulativeGasUsed: Schema.optional(U128),
+  gasUsed: Schema.optional(U128),
   effectiveGasPrice: Schema.optional(U128),
   from: Schema.optional(Address),
   to: Schema.optional(Address),
   contractAddress: Schema.optional(Address),
   logsBloom: Schema.optional(Bloom),
-  statusCode: Schema.BigIntFromSelf,
-  transactionType: Schema.BigIntFromSelf,
+  transactionType: Schema.optional(Schema.BigIntFromSelf),
   blobGasUsed: Schema.optional(U128),
   blobGasPrice: Schema.optional(U128),
+  transactionStatus: Schema.optional(TransactionStatus),
 });
 
 export const Log = Schema.Struct({
+  filterIds: Schema.optional(Schema.Array(Schema.Number)),
   address: Schema.optional(Address),
   topics: Schema.Array(B256),
-  // TODO
-  // data: Bytes,
-  logIndex: Schema.BigIntFromSelf,
-  transactionIndex: Schema.BigIntFromSelf,
+  data: BytesFromUint8Array,
+  logIndex: Schema.Number,
+  transactionIndex: Schema.Number,
   transactionHash: Schema.optional(B256),
+  transactionStatus: Schema.optional(TransactionStatus),
 });
 
 export type Log = typeof Log.Type;

package/src/common.ts

@@ -35,7 +35,7 @@ export type Address = typeof Address.Type;
 const _B256 = Schema.TemplateLiteral(Schema.Literal("0x"), Schema.String);
 
 /** Wire representation of `B256`. */
-const B256Proto = Schema.Struct({
+export const B256Proto = Schema.Struct({
   x0: Schema.BigIntFromSelf,
   x1: Schema.BigIntFromSelf,
   x2: Schema.BigIntFromSelf,

package/src/filter.test.ts

@@ -87,23 +87,19 @@ describe("LogFilter", () => {
 
 describe("mergeFilter", () => {
   it("returns header.always if any has it", () => {
-    const fa = mergeFilter({}, { header: { always: true } });
+    const fa = mergeFilter({}, { header: "always" });
     expect(fa).toMatchInlineSnapshot(`
       {
-        "header": {
-          "always": true,
-        },
+        "header": "always",
         "logs": [],
         "transactions": [],
         "withdrawals": [],
       }
     `);
-    const fb = mergeFilter({ header: { always: true } }, {});
+    const fb = mergeFilter({ header: "always" }, {});
     expect(fb).toMatchInlineSnapshot(`
       {
-        "header": {
-          "always": true,
-        },
+        "header": "always",
         "logs": [],
         "transactions": [],
         "withdrawals": [],
@@ -169,8 +165,8 @@ describe("mergeFilter", () => {
 
   it("concatenates withdrawals", () => {
     const f = mergeFilter(
-      { withdrawals: [{ validatorIndex: 1n }] },
-      { withdrawals: [{ validatorIndex: 100n }] },
+      { withdrawals: [{ validatorIndex: 1 }] },
+      { withdrawals: [{ validatorIndex: 100 }] },
     );
     expect(f).toMatchInlineSnapshot(`
       {
@@ -179,10 +175,10 @@ describe("mergeFilter", () => {
         "transactions": [],
         "withdrawals": [
           {
-            "validatorIndex": 1n,
+            "validatorIndex": 1,
           },
           {
-            "validatorIndex": 100n,
+            "validatorIndex": 100,
           },
         ],
       }

package/src/filter.ts

@@ -1,51 +1,114 @@
 import { Schema } from "@effect/schema";
 
-import { Address, B256, b256FromProto, b256ToProto } from "./common";
+import { Address, B256, B256Proto } 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),
-});
+/** 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 type HeaderFilter = typeof HeaderFilter.Type;
 
 export const WithdrawalFilter = Schema.Struct({
-  validatorIndex: Schema.optional(Schema.BigIntFromSelf),
+  id: Schema.optional(Schema.Number),
+  validatorIndex: Schema.optional(Schema.Number),
   address: Schema.optional(Address),
 });
 
 export type WithdrawalFilter = typeof WithdrawalFilter.Type;
 
-// TODO: using the decoder inside decode/encode feels wrong.
+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 TransactionStatusFilter = typeof TransactionStatusFilter.Type;
+
 export const Topic = Schema.transform(
-  Schema.Struct({ value: Schema.UndefinedOr(B256) }),
+  Schema.Struct({ value: Schema.UndefinedOr(B256Proto) }),
   Schema.NullOr(B256),
   {
-    strict: false,
     decode({ value }) {
       if (value === undefined) {
         return null;
       }
-      return b256ToProto(value);
+      return value;
     },
     encode(value) {
       if (value === null) {
         return { value: undefined };
       }
-      return { value: b256FromProto(value) };
+      return { value };
     },
   },
 );
 
 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),
 });
@@ -53,9 +116,11 @@ export const LogFilter = Schema.Struct({
 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),
 });
@@ -65,8 +130,8 @@ export type TransactionFilter = typeof TransactionFilter.Type;
 export const Filter = Schema.Struct({
   header: Schema.optional(HeaderFilter),
   withdrawals: OptionalArray(WithdrawalFilter),
-  logs: OptionalArray(LogFilter),
   transactions: OptionalArray(TransactionFilter),
+  logs: OptionalArray(LogFilter),
 });
 
 export type Filter = typeof Filter.Type;
@@ -111,7 +176,14 @@ function mergeHeaderFilter(
   if (b === undefined) {
     return a;
   }
-  return {
-    always: a.always || b.always,
-  };
+
+  if (a === "always" || b === "always") {
+    return "always";
+  }
+
+  if (a === "on_data_or_on_new_block" || b === "on_data_or_on_new_block") {
+    return "on_data_or_on_new_block";
+  }
+
+  return "on_data";
 }

package/src/proto/common.ts

@@ -6,7 +6,7 @@
 
 /* eslint-disable */
 import Long from "long";
-import _m0 from "protobufjs/minimal";
+import _m0 from "protobufjs/minimal.js";
 
 export const protobufPackage = "evm.v2";