@apibara/evm 2.1.0-beta.2 → 2.1.0-beta.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apibara/evm",
-  "version": "2.1.0-beta.2",
+  "version": "2.1.0-beta.20",
   "type": "module",
   "files": [
     "dist",
@@ -35,7 +35,7 @@
     "vitest": "^1.6.0"
   },
   "dependencies": {
-    "@apibara/protocol": "2.1.0-beta.2",
+    "@apibara/protocol": "2.1.0-beta.20",
     "@effect/schema": "^0.67.15",
     "effect": "^3.2.6",
     "long": "^5.2.1",

package/src/block.ts

@@ -2,6 +2,7 @@ import { Bytes, BytesFromUint8Array } from "@apibara/protocol";
 import { Schema } from "@effect/schema";
 
 import { Address, B256, U128, U256 } from "./common";
+import { tag } from "./helpers";
 import * as proto from "./proto";
 
 export const Bloom = Schema.transform(
@@ -20,6 +21,8 @@ export const Bloom = Schema.transform(
   },
 );
 
+export type Bloom = typeof Bloom.Type;
+
 export const TransactionStatus = Schema.transform(
   Schema.Enums(proto.data.TransactionStatus),
   Schema.Literal("unknown", "succeeded", "reverted"),
@@ -78,11 +81,15 @@ export const Withdrawal = Schema.Struct({
   amount: Schema.BigIntFromSelf,
 });
 
+export type Withdrawal = typeof Withdrawal.Type;
+
 export const AccessListItem = Schema.Struct({
   address: Address,
   storageKeys: Schema.Array(B256),
 });
 
+export type AccessListItem = typeof AccessListItem.Type;
+
 export const Signature = Schema.Struct({
   r: U256,
   s: U256,
@@ -90,6 +97,8 @@ export const Signature = Schema.Struct({
   YParity: Schema.optional(Schema.Boolean),
 });
 
+export type Signature = typeof Signature.Type;
+
 export const Transaction = Schema.Struct({
   filterIds: Schema.Array(Schema.Number),
   transactionIndex: Schema.Number,
@@ -112,6 +121,8 @@ export const Transaction = Schema.Struct({
   transactionStatus: TransactionStatus,
 });
 
+export type Transaction = typeof Transaction.Type;
+
 export const TransactionReceipt = Schema.Struct({
   filterIds: Schema.Array(Schema.Number),
   transactionIndex: Schema.Number,
@@ -129,6 +140,8 @@ export const TransactionReceipt = Schema.Struct({
   transactionStatus: TransactionStatus,
 });
 
+export type TransactionReceipt = typeof TransactionReceipt.Type;
+
 export const Log = Schema.Struct({
   filterIds: Schema.Array(Schema.Number),
   address: Address,
@@ -143,12 +156,185 @@ export const Log = Schema.Struct({
 
 export type Log = typeof Log.Type;
 
+export const CallType = Schema.transform(
+  Schema.Enums(proto.data.CallType),
+  Schema.Literal(
+    "unknown",
+    "call",
+    "delegateCall",
+    "callCode",
+    "delegateCall",
+    "staticCall",
+    "authCall",
+  ),
+  {
+    decode(value) {
+      const enumMap = {
+        [proto.data.CallType.CALL]: "call",
+        [proto.data.CallType.CALL_CODE]: "callCode",
+        [proto.data.CallType.DELEGATE_CALL]: "delegateCall",
+        [proto.data.CallType.STATIC_CALL]: "staticCall",
+        [proto.data.CallType.AUTH_CALL]: "authCall",
+        [proto.data.CallType.UNSPECIFIED]: "unknown",
+        [proto.data.CallType.UNRECOGNIZED]: "unknown",
+      } as const;
+
+      return enumMap[value] ?? "unknown";
+    },
+    encode(value) {
+      throw new Error("encode: not implemented");
+    },
+  },
+);
+
+export type CallType = typeof CallType.Type;
+
+export const CreationMethod = Schema.transform(
+  Schema.Enums(proto.data.CreationMethod),
+  Schema.Literal("unknown", "create", "create2", "eofCreate"),
+  {
+    decode(value) {
+      const enumMap = {
+        [proto.data.CreationMethod.CREATE]: "create",
+        [proto.data.CreationMethod.CREATE2]: "create2",
+        [proto.data.CreationMethod.EOF_CREATE]: "eofCreate",
+        [proto.data.CallType.UNSPECIFIED]: "unknown",
+        [proto.data.CallType.UNRECOGNIZED]: "unknown",
+      } as const;
+
+      return enumMap[value] ?? "unknown";
+    },
+    encode(value) {
+      throw new Error("encode: not implemented");
+    },
+  },
+);
+
+export type CreationMethod = typeof CreationMethod.Type;
+
+export const CallAction = Schema.Struct({
+  _tag: tag("call"),
+  call: Schema.Struct({
+    fromAddress: Address,
+    type: CallType,
+    gas: Schema.BigIntFromSelf,
+    input: BytesFromUint8Array,
+    toAddress: Address,
+    value: U256,
+  }),
+});
+
+export type CallAction = typeof CallAction.Type;
+
+export const CreateAction = Schema.Struct({
+  _tag: tag("create"),
+  create: Schema.Struct({
+    fromAddress: Address,
+    gas: Schema.BigIntFromSelf,
+    init: BytesFromUint8Array,
+    value: U256,
+    creationMethod: CreationMethod,
+  }),
+});
+
+export type CreateAction = typeof CreateAction.Type;
+
+export const SelfDestructAction = Schema.Struct({
+  _tag: tag("selfDestruct"),
+  selfDestruct: Schema.Struct({
+    address: Address,
+    balance: U256,
+    refundAddress: Address,
+  }),
+});
+
+export type SelfDestructAction = typeof SelfDestructAction.Type;
+
+export const RewardType = Schema.transform(
+  Schema.Enums(proto.data.RewardType),
+  Schema.Literal("unknown", "block", "uncle"),
+  {
+    decode(value) {
+      const enumMap = {
+        [proto.data.RewardType.BLOCK]: "block",
+        [proto.data.RewardType.UNCLE]: "uncle",
+        [proto.data.RewardType.UNSPECIFIED]: "unknown",
+        [proto.data.RewardType.UNRECOGNIZED]: "unknown",
+      } as const;
+
+      return enumMap[value] ?? "unknown";
+    },
+    encode(value) {
+      throw new Error("encode: not implemented");
+    },
+  },
+);
+
+export type RewardType = typeof RewardType.Type;
+
+export const RewardAction = Schema.Struct({
+  _tag: tag("reward"),
+  reward: Schema.Struct({
+    author: Address,
+    type: RewardType,
+    value: U256,
+  }),
+});
+
+export type RewardAction = typeof RewardAction.Type;
+
+export const CallOutput = Schema.Struct({
+  _tag: tag("callOutput"),
+  callOutput: Schema.Struct({
+    gasUsed: Schema.BigIntFromSelf,
+    output: BytesFromUint8Array,
+  }),
+});
+
+export type CallOutput = typeof CallOutput.Type;
+
+export const CreateOutput = Schema.Struct({
+  _tag: tag("createOutput"),
+  createOutput: Schema.Struct({
+    address: Address,
+    code: BytesFromUint8Array,
+    gasUsed: Schema.BigIntFromSelf,
+  }),
+});
+
+export type CreateOutput = typeof CreateOutput.Type;
+
+export const Trace = Schema.Struct({
+  action: Schema.Union(
+    CallAction,
+    CreateAction,
+    SelfDestructAction,
+    RewardAction,
+  ),
+  error: Schema.optional(Schema.String),
+  output: Schema.optional(Schema.Union(CallOutput, CreateOutput)),
+  subtraces: Schema.Number,
+  traceAddress: Schema.Array(Schema.Number),
+});
+
+export type Trace = typeof Trace.Type;
+
+export const TransactionTrace = Schema.Struct({
+  filterIds: Schema.Array(Schema.Number),
+  transactionIndex: Schema.Number,
+  transactionHash: B256,
+  traces: Schema.Array(Trace),
+});
+
+export type TransactionTrace = typeof TransactionTrace.Type;
+
 export const Block = Schema.Struct({
   header: BlockHeader,
   withdrawals: Schema.Array(Withdrawal),
   transactions: Schema.Array(Transaction),
   receipts: Schema.Array(TransactionReceipt),
   logs: Schema.Array(Log),
+  traces: Schema.Array(TransactionTrace),
 });
 
 export type Block = typeof Block.Type;

package/src/common.ts

@@ -62,6 +62,8 @@ export const B256 = Schema.transform(B256Proto, _B256, {
   },
 });
 
+export type B256 = typeof B256.Type;
+
 export const b256ToProto = Schema.encodeSync(B256);
 export const b256FromProto = Schema.decodeSync(B256);
 
@@ -92,6 +94,8 @@ export const U256 = Schema.transform(U256Proto, Schema.BigIntFromSelf, {
   },
 });
 
+export type U256 = typeof U256.Type;
+
 export const u256ToProto = Schema.encodeSync(U256);
 export const u256FromProto = Schema.decodeSync(U256);
 
@@ -113,5 +117,7 @@ export const U128 = Schema.transform(U128Proto, Schema.BigIntFromSelf, {
   },
 });
 
+export type U128 = typeof U128.Type;
+
 export const u128ToProto = Schema.encodeSync(U128);
 export const u128FromProto = Schema.decodeSync(U128);

package/src/filter.ts

@@ -103,6 +103,8 @@ export const Topic = Schema.transform(
   },
 );
 
+export type Topic = typeof Topic.Type;
+
 export const LogFilter = Schema.Struct({
   id: Schema.optional(Schema.Number),
   address: Schema.optional(Address),
@@ -111,6 +113,7 @@ export const LogFilter = Schema.Struct({
   transactionStatus: Schema.optional(TransactionStatusFilter),
   includeTransaction: Schema.optional(Schema.Boolean),
   includeReceipt: Schema.optional(Schema.Boolean),
+  includeTransactionTrace: Schema.optional(Schema.Boolean),
 });
 
 export type LogFilter = typeof LogFilter.Type;
@@ -123,6 +126,7 @@ export const TransactionFilter = Schema.Struct({
   transactionStatus: Schema.optional(TransactionStatusFilter),
   includeReceipt: Schema.optional(Schema.Boolean),
   includeLogs: Schema.optional(Schema.Boolean),
+  includeTransactionTrace: Schema.optional(Schema.Boolean),
 });
 
 export type TransactionFilter = typeof TransactionFilter.Type;

package/src/helpers.ts

@@ -0,0 +1,8 @@
+import { Schema } from "@effect/schema";
+
+export function tag<T extends string>(tag: T) {
+  return Schema.Literal(tag).pipe(
+    Schema.propertySignature,
+    Schema.fromKey("$case"),
+  );
+}