@apibara/evm 2.1.0-beta.18 → 2.1.0-beta.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apibara/evm",
-  "version": "2.1.0-beta.18",
+  "version": "2.1.0-beta.19",
   "type": "module",
   "files": [
     "dist",
@@ -35,7 +35,7 @@
     "vitest": "^1.6.0"
   },
   "dependencies": {
-    "@apibara/protocol": "2.1.0-beta.18",
+    "@apibara/protocol": "2.1.0-beta.19",
     "@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(
@@ -155,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/filter.ts

@@ -113,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;
@@ -125,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"),
+  );
+}