@apibara/starknet 2.1.0-beta.4 → 2.1.0-beta.41

package/dist/index.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
 const protocol = require('@apibara/protocol');
-const schema = require('@effect/schema');
+const codec = require('@apibara/protocol/codec');
 const Long = require('long');
 const _m0 = require('protobufjs/minimal.js');
 const starknet = require('@scure/starknet');
@@ -12,44 +12,25 @@ function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'defau
 const Long__default = /*#__PURE__*/_interopDefaultCompat(Long);
 const _m0__default = /*#__PURE__*/_interopDefaultCompat(_m0);
 
-const _FieldElement = schema.Schema.TemplateLiteral(
-  schema.Schema.Literal("0x"),
-  schema.Schema.String
-);
-const FieldElementProto = schema.Schema.Struct({
-  x0: schema.Schema.BigIntFromSelf,
-  x1: schema.Schema.BigIntFromSelf,
-  x2: schema.Schema.BigIntFromSelf,
-  x3: schema.Schema.BigIntFromSelf
-});
-const FieldElement$1 = schema.Schema.transform(FieldElementProto, _FieldElement, {
-  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}`;
-  },
-  encode(value) {
-    const bn = BigInt(value);
-    const hex = bn.toString(16).padStart(64, "0");
-    const s = hex.length;
-    const x3 = BigInt(`0x${hex.slice(s - 16, s)}`);
-    const x2 = BigInt(`0x${hex.slice(s - 32, s - 16)}`);
-    const x1 = BigInt(`0x${hex.slice(s - 48, s - 32)}`);
-    const x0 = BigInt(`0x${hex.slice(s - 64, s - 48)}`);
+const MAX_U64 = 0xffffffffffffffffn;
+const FieldElement$1 = {
+  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 };
+  },
+  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")}`;
   }
-});
-const feltToProto = schema.Schema.encodeSync(FieldElement$1);
-const feltFromProto = schema.Schema.decodeSync(FieldElement$1);
-
-function tag(tag2) {
-  return schema.Schema.Literal(tag2).pipe(
-    schema.Schema.propertySignature,
-    schema.Schema.fromKey("$case")
-  );
-}
+};
 
 const protobufPackage$2 = "starknet.v2";
 function createBaseFieldElement() {
@@ -441,6 +422,49 @@ function dataAvailabilityModeToJSON(object) {
       return "UNRECOGNIZED";
   }
 }
+var CallType$1 = /* @__PURE__ */ ((CallType2) => {
+  CallType2[CallType2["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+  CallType2[CallType2["LIBRARY_CALL"] = 1] = "LIBRARY_CALL";
+  CallType2[CallType2["CALL"] = 2] = "CALL";
+  CallType2[CallType2["DELEGATE"] = 3] = "DELEGATE";
+  CallType2[CallType2["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+  return CallType2;
+})(CallType$1 || {});
+function callTypeFromJSON(object) {
+  switch (object) {
+    case 0:
+    case "CALL_TYPE_UNSPECIFIED":
+      return 0 /* UNSPECIFIED */;
+    case 1:
+    case "CALL_TYPE_LIBRARY_CALL":
+      return 1 /* LIBRARY_CALL */;
+    case 2:
+    case "CALL_TYPE_CALL":
+      return 2 /* CALL */;
+    case 3:
+    case "CALL_TYPE_DELEGATE":
+      return 3 /* DELEGATE */;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return -1 /* UNRECOGNIZED */;
+  }
+}
+function callTypeToJSON(object) {
+  switch (object) {
+    case 0 /* UNSPECIFIED */:
+      return "CALL_TYPE_UNSPECIFIED";
+    case 1 /* LIBRARY_CALL */:
+      return "CALL_TYPE_LIBRARY_CALL";
+    case 2 /* CALL */:
+      return "CALL_TYPE_CALL";
+    case 3 /* DELEGATE */:
+      return "CALL_TYPE_DELEGATE";
+    case -1 /* UNRECOGNIZED */:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
 function createBaseBlock() {
   return {
     header: void 0,
@@ -450,7 +474,8 @@ function createBaseBlock() {
     messages: [],
     storageDiffs: [],
     contractChanges: [],
-    nonceUpdates: []
+    nonceUpdates: [],
+    traces: []
   };
 }
 const Block$1 = {
@@ -493,6 +518,11 @@ const Block$1 = {
         NonceUpdate$1.encode(v, writer.uint32(66).fork()).ldelim();
       }
     }
+    if (message.traces !== void 0 && message.traces.length !== 0) {
+      for (const v of message.traces) {
+        TransactionTrace$1.encode(v, writer.uint32(74).fork()).ldelim();
+      }
+    }
     return writer;
   },
   decode(input, length) {
@@ -550,6 +580,12 @@ const Block$1 = {
           }
           message.nonceUpdates.push(NonceUpdate$1.decode(reader, reader.uint32()));
           continue;
+        case 9:
+          if (tag !== 74) {
+            break;
+          }
+          message.traces.push(TransactionTrace$1.decode(reader, reader.uint32()));
+          continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -567,7 +603,8 @@ const Block$1 = {
       messages: globalThis.Array.isArray(object?.messages) ? object.messages.map((e) => MessageToL1$1.fromJSON(e)) : [],
       storageDiffs: globalThis.Array.isArray(object?.storageDiffs) ? object.storageDiffs.map((e) => StorageDiff$1.fromJSON(e)) : [],
       contractChanges: globalThis.Array.isArray(object?.contractChanges) ? object.contractChanges.map((e) => ContractChange$1.fromJSON(e)) : [],
-      nonceUpdates: globalThis.Array.isArray(object?.nonceUpdates) ? object.nonceUpdates.map((e) => NonceUpdate$1.fromJSON(e)) : []
+      nonceUpdates: globalThis.Array.isArray(object?.nonceUpdates) ? object.nonceUpdates.map((e) => NonceUpdate$1.fromJSON(e)) : [],
+      traces: globalThis.Array.isArray(object?.traces) ? object.traces.map((e) => TransactionTrace$1.fromJSON(e)) : []
     };
   },
   toJSON(message) {
@@ -596,6 +633,9 @@ const Block$1 = {
     if (message.nonceUpdates?.length) {
       obj.nonceUpdates = message.nonceUpdates.map((e) => NonceUpdate$1.toJSON(e));
     }
+    if (message.traces?.length) {
+      obj.traces = message.traces.map((e) => TransactionTrace$1.toJSON(e));
+    }
     return obj;
   },
   create(base) {
@@ -611,6 +651,7 @@ const Block$1 = {
     message.storageDiffs = object.storageDiffs?.map((e) => StorageDiff$1.fromPartial(e)) || [];
     message.contractChanges = object.contractChanges?.map((e) => ContractChange$1.fromPartial(e)) || [];
     message.nonceUpdates = object.nonceUpdates?.map((e) => NonceUpdate$1.fromPartial(e)) || [];
+    message.traces = object.traces?.map((e) => TransactionTrace$1.fromPartial(e)) || [];
     return message;
   }
 };
@@ -4926,39 +4967,810 @@ const NonceUpdate$1 = {
     return message;
   }
 };
-function bytesFromBase64(b64) {
-  if (globalThis.Buffer) {
-    return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
-  } else {
-    const bin = globalThis.atob(b64);
-    const arr = new Uint8Array(bin.length);
-    for (let i = 0; i < bin.length; ++i) {
-      arr[i] = bin.charCodeAt(i);
+function createBaseTransactionTrace() {
+  return { filterIds: [], transactionIndex: 0, transactionHash: void 0, traceRoot: void 0 };
+}
+const TransactionTrace$1 = {
+  encode(message, writer = _m0__default.Writer.create()) {
+    if (message.filterIds !== void 0 && message.filterIds.length !== 0) {
+      writer.uint32(10).fork();
+      for (const v of message.filterIds) {
+        writer.uint32(v);
+      }
+      writer.ldelim();
     }
-    return arr;
+    if (message.transactionIndex !== void 0 && message.transactionIndex !== 0) {
+      writer.uint32(16).uint32(message.transactionIndex);
+    }
+    if (message.transactionHash !== void 0) {
+      FieldElement.encode(message.transactionHash, writer.uint32(26).fork()).ldelim();
+    }
+    switch (message.traceRoot?.$case) {
+      case "invoke":
+        InvokeTransactionTrace$1.encode(message.traceRoot.invoke, writer.uint32(34).fork()).ldelim();
+        break;
+      case "declare":
+        DeclareTransactionTrace$1.encode(message.traceRoot.declare, writer.uint32(42).fork()).ldelim();
+        break;
+      case "deployAccount":
+        DeployAccountTransactionTrace$1.encode(message.traceRoot.deployAccount, writer.uint32(50).fork()).ldelim();
+        break;
+      case "l1Handler":
+        L1HandlerTransactionTrace$1.encode(message.traceRoot.l1Handler, writer.uint32(58).fork()).ldelim();
+        break;
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof _m0__default.Reader ? input : _m0__default.Reader.create(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseTransactionTrace();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag === 8) {
+            message.filterIds.push(reader.uint32());
+            continue;
+          }
+          if (tag === 10) {
+            const end2 = reader.uint32() + reader.pos;
+            while (reader.pos < end2) {
+              message.filterIds.push(reader.uint32());
+            }
+            continue;
+          }
+          break;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+          message.transactionIndex = reader.uint32();
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+          message.transactionHash = FieldElement.decode(reader, reader.uint32());
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+          message.traceRoot = { $case: "invoke", invoke: InvokeTransactionTrace$1.decode(reader, reader.uint32()) };
+          continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
+          message.traceRoot = { $case: "declare", declare: DeclareTransactionTrace$1.decode(reader, reader.uint32()) };
+          continue;
+        case 6:
+          if (tag !== 50) {
+            break;
+          }
+          message.traceRoot = {
+            $case: "deployAccount",
+            deployAccount: DeployAccountTransactionTrace$1.decode(reader, reader.uint32())
+          };
+          continue;
+        case 7:
+          if (tag !== 58) {
+            break;
+          }
+          message.traceRoot = {
+            $case: "l1Handler",
+            l1Handler: L1HandlerTransactionTrace$1.decode(reader, reader.uint32())
+          };
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      filterIds: globalThis.Array.isArray(object?.filterIds) ? object.filterIds.map((e) => globalThis.Number(e)) : [],
+      transactionIndex: isSet$1(object.transactionIndex) ? globalThis.Number(object.transactionIndex) : 0,
+      transactionHash: isSet$1(object.transactionHash) ? FieldElement.fromJSON(object.transactionHash) : void 0,
+      traceRoot: isSet$1(object.invoke) ? { $case: "invoke", invoke: InvokeTransactionTrace$1.fromJSON(object.invoke) } : isSet$1(object.declare) ? { $case: "declare", declare: DeclareTransactionTrace$1.fromJSON(object.declare) } : isSet$1(object.deployAccount) ? { $case: "deployAccount", deployAccount: DeployAccountTransactionTrace$1.fromJSON(object.deployAccount) } : isSet$1(object.l1Handler) ? { $case: "l1Handler", l1Handler: L1HandlerTransactionTrace$1.fromJSON(object.l1Handler) } : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.filterIds?.length) {
+      obj.filterIds = message.filterIds.map((e) => Math.round(e));
+    }
+    if (message.transactionIndex !== void 0 && message.transactionIndex !== 0) {
+      obj.transactionIndex = Math.round(message.transactionIndex);
+    }
+    if (message.transactionHash !== void 0) {
+      obj.transactionHash = FieldElement.toJSON(message.transactionHash);
+    }
+    if (message.traceRoot?.$case === "invoke") {
+      obj.invoke = InvokeTransactionTrace$1.toJSON(message.traceRoot.invoke);
+    }
+    if (message.traceRoot?.$case === "declare") {
+      obj.declare = DeclareTransactionTrace$1.toJSON(message.traceRoot.declare);
+    }
+    if (message.traceRoot?.$case === "deployAccount") {
+      obj.deployAccount = DeployAccountTransactionTrace$1.toJSON(message.traceRoot.deployAccount);
+    }
+    if (message.traceRoot?.$case === "l1Handler") {
+      obj.l1Handler = L1HandlerTransactionTrace$1.toJSON(message.traceRoot.l1Handler);
+    }
+    return obj;
+  },
+  create(base) {
+    return TransactionTrace$1.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseTransactionTrace();
+    message.filterIds = object.filterIds?.map((e) => e) || [];
+    message.transactionIndex = object.transactionIndex ?? 0;
+    message.transactionHash = object.transactionHash !== void 0 && object.transactionHash !== null ? FieldElement.fromPartial(object.transactionHash) : void 0;
+    if (object.traceRoot?.$case === "invoke" && object.traceRoot?.invoke !== void 0 && object.traceRoot?.invoke !== null) {
+      message.traceRoot = { $case: "invoke", invoke: InvokeTransactionTrace$1.fromPartial(object.traceRoot.invoke) };
+    }
+    if (object.traceRoot?.$case === "declare" && object.traceRoot?.declare !== void 0 && object.traceRoot?.declare !== null) {
+      message.traceRoot = { $case: "declare", declare: DeclareTransactionTrace$1.fromPartial(object.traceRoot.declare) };
+    }
+    if (object.traceRoot?.$case === "deployAccount" && object.traceRoot?.deployAccount !== void 0 && object.traceRoot?.deployAccount !== null) {
+      message.traceRoot = {
+        $case: "deployAccount",
+        deployAccount: DeployAccountTransactionTrace$1.fromPartial(object.traceRoot.deployAccount)
+      };
+    }
+    if (object.traceRoot?.$case === "l1Handler" && object.traceRoot?.l1Handler !== void 0 && object.traceRoot?.l1Handler !== null) {
+      message.traceRoot = {
+        $case: "l1Handler",
+        l1Handler: L1HandlerTransactionTrace$1.fromPartial(object.traceRoot.l1Handler)
+      };
+    }
+    return message;
   }
+};
+function createBaseInvokeTransactionTrace() {
+  return { validateInvocation: void 0, executeInvocation: void 0, feeTransferInvocation: void 0 };
 }
-function base64FromBytes(arr) {
-  if (globalThis.Buffer) {
-    return globalThis.Buffer.from(arr).toString("base64");
-  } else {
-    const bin = [];
-    arr.forEach((byte) => {
-      bin.push(globalThis.String.fromCharCode(byte));
-    });
-    return globalThis.btoa(bin.join(""));
+const InvokeTransactionTrace$1 = {
+  encode(message, writer = _m0__default.Writer.create()) {
+    if (message.validateInvocation !== void 0) {
+      FunctionInvocation.encode(message.validateInvocation, writer.uint32(10).fork()).ldelim();
+    }
+    switch (message.executeInvocation?.$case) {
+      case "success":
+        FunctionInvocation.encode(message.executeInvocation.success, writer.uint32(18).fork()).ldelim();
+        break;
+      case "reverted":
+        ExecutionReverted$1.encode(message.executeInvocation.reverted, writer.uint32(26).fork()).ldelim();
+        break;
+    }
+    if (message.feeTransferInvocation !== void 0) {
+      FunctionInvocation.encode(message.feeTransferInvocation, writer.uint32(34).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof _m0__default.Reader ? input : _m0__default.Reader.create(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseInvokeTransactionTrace();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+          message.validateInvocation = FunctionInvocation.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+          message.executeInvocation = { $case: "success", success: FunctionInvocation.decode(reader, reader.uint32()) };
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+          message.executeInvocation = {
+            $case: "reverted",
+            reverted: ExecutionReverted$1.decode(reader, reader.uint32())
+          };
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+          message.feeTransferInvocation = FunctionInvocation.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      validateInvocation: isSet$1(object.validateInvocation) ? FunctionInvocation.fromJSON(object.validateInvocation) : void 0,
+      executeInvocation: isSet$1(object.success) ? { $case: "success", success: FunctionInvocation.fromJSON(object.success) } : isSet$1(object.reverted) ? { $case: "reverted", reverted: ExecutionReverted$1.fromJSON(object.reverted) } : void 0,
+      feeTransferInvocation: isSet$1(object.feeTransferInvocation) ? FunctionInvocation.fromJSON(object.feeTransferInvocation) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.validateInvocation !== void 0) {
+      obj.validateInvocation = FunctionInvocation.toJSON(message.validateInvocation);
+    }
+    if (message.executeInvocation?.$case === "success") {
+      obj.success = FunctionInvocation.toJSON(message.executeInvocation.success);
+    }
+    if (message.executeInvocation?.$case === "reverted") {
+      obj.reverted = ExecutionReverted$1.toJSON(message.executeInvocation.reverted);
+    }
+    if (message.feeTransferInvocation !== void 0) {
+      obj.feeTransferInvocation = FunctionInvocation.toJSON(message.feeTransferInvocation);
+    }
+    return obj;
+  },
+  create(base) {
+    return InvokeTransactionTrace$1.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseInvokeTransactionTrace();
+    message.validateInvocation = object.validateInvocation !== void 0 && object.validateInvocation !== null ? FunctionInvocation.fromPartial(object.validateInvocation) : void 0;
+    if (object.executeInvocation?.$case === "success" && object.executeInvocation?.success !== void 0 && object.executeInvocation?.success !== null) {
+      message.executeInvocation = {
+        $case: "success",
+        success: FunctionInvocation.fromPartial(object.executeInvocation.success)
+      };
+    }
+    if (object.executeInvocation?.$case === "reverted" && object.executeInvocation?.reverted !== void 0 && object.executeInvocation?.reverted !== null) {
+      message.executeInvocation = {
+        $case: "reverted",
+        reverted: ExecutionReverted$1.fromPartial(object.executeInvocation.reverted)
+      };
+    }
+    message.feeTransferInvocation = object.feeTransferInvocation !== void 0 && object.feeTransferInvocation !== null ? FunctionInvocation.fromPartial(object.feeTransferInvocation) : void 0;
+    return message;
   }
+};
+function createBaseDeclareTransactionTrace() {
+  return { validateInvocation: void 0, feeTransferInvocation: void 0 };
+}
+const DeclareTransactionTrace$1 = {
+  encode(message, writer = _m0__default.Writer.create()) {
+    if (message.validateInvocation !== void 0) {
+      FunctionInvocation.encode(message.validateInvocation, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.feeTransferInvocation !== void 0) {
+      FunctionInvocation.encode(message.feeTransferInvocation, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof _m0__default.Reader ? input : _m0__default.Reader.create(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseDeclareTransactionTrace();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+          message.validateInvocation = FunctionInvocation.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+          message.feeTransferInvocation = FunctionInvocation.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      validateInvocation: isSet$1(object.validateInvocation) ? FunctionInvocation.fromJSON(object.validateInvocation) : void 0,
+      feeTransferInvocation: isSet$1(object.feeTransferInvocation) ? FunctionInvocation.fromJSON(object.feeTransferInvocation) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.validateInvocation !== void 0) {
+      obj.validateInvocation = FunctionInvocation.toJSON(message.validateInvocation);
+    }
+    if (message.feeTransferInvocation !== void 0) {
+      obj.feeTransferInvocation = FunctionInvocation.toJSON(message.feeTransferInvocation);
+    }
+    return obj;
+  },
+  create(base) {
+    return DeclareTransactionTrace$1.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseDeclareTransactionTrace();
+    message.validateInvocation = object.validateInvocation !== void 0 && object.validateInvocation !== null ? FunctionInvocation.fromPartial(object.validateInvocation) : void 0;
+    message.feeTransferInvocation = object.feeTransferInvocation !== void 0 && object.feeTransferInvocation !== null ? FunctionInvocation.fromPartial(object.feeTransferInvocation) : void 0;
+    return message;
+  }
+};
+function createBaseDeployAccountTransactionTrace() {
+  return { validateInvocation: void 0, constructorInvocation: void 0, feeTransferInvocation: void 0 };
+}
+const DeployAccountTransactionTrace$1 = {
+  encode(message, writer = _m0__default.Writer.create()) {
+    if (message.validateInvocation !== void 0) {
+      FunctionInvocation.encode(message.validateInvocation, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.constructorInvocation !== void 0) {
+      FunctionInvocation.encode(message.constructorInvocation, writer.uint32(18).fork()).ldelim();
+    }
+    if (message.feeTransferInvocation !== void 0) {
+      FunctionInvocation.encode(message.feeTransferInvocation, writer.uint32(26).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof _m0__default.Reader ? input : _m0__default.Reader.create(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseDeployAccountTransactionTrace();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+          message.validateInvocation = FunctionInvocation.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+          message.constructorInvocation = FunctionInvocation.decode(reader, reader.uint32());
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+          message.feeTransferInvocation = FunctionInvocation.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      validateInvocation: isSet$1(object.validateInvocation) ? FunctionInvocation.fromJSON(object.validateInvocation) : void 0,
+      constructorInvocation: isSet$1(object.constructorInvocation) ? FunctionInvocation.fromJSON(object.constructorInvocation) : void 0,
+      feeTransferInvocation: isSet$1(object.feeTransferInvocation) ? FunctionInvocation.fromJSON(object.feeTransferInvocation) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.validateInvocation !== void 0) {
+      obj.validateInvocation = FunctionInvocation.toJSON(message.validateInvocation);
+    }
+    if (message.constructorInvocation !== void 0) {
+      obj.constructorInvocation = FunctionInvocation.toJSON(message.constructorInvocation);
+    }
+    if (message.feeTransferInvocation !== void 0) {
+      obj.feeTransferInvocation = FunctionInvocation.toJSON(message.feeTransferInvocation);
+    }
+    return obj;
+  },
+  create(base) {
+    return DeployAccountTransactionTrace$1.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseDeployAccountTransactionTrace();
+    message.validateInvocation = object.validateInvocation !== void 0 && object.validateInvocation !== null ? FunctionInvocation.fromPartial(object.validateInvocation) : void 0;
+    message.constructorInvocation = object.constructorInvocation !== void 0 && object.constructorInvocation !== null ? FunctionInvocation.fromPartial(object.constructorInvocation) : void 0;
+    message.feeTransferInvocation = object.feeTransferInvocation !== void 0 && object.feeTransferInvocation !== null ? FunctionInvocation.fromPartial(object.feeTransferInvocation) : void 0;
+    return message;
+  }
+};
+function createBaseL1HandlerTransactionTrace() {
+  return { functionInvocation: void 0 };
+}
+const L1HandlerTransactionTrace$1 = {
+  encode(message, writer = _m0__default.Writer.create()) {
+    if (message.functionInvocation !== void 0) {
+      FunctionInvocation.encode(message.functionInvocation, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof _m0__default.Reader ? input : _m0__default.Reader.create(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseL1HandlerTransactionTrace();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+          message.functionInvocation = FunctionInvocation.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      functionInvocation: isSet$1(object.functionInvocation) ? FunctionInvocation.fromJSON(object.functionInvocation) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.functionInvocation !== void 0) {
+      obj.functionInvocation = FunctionInvocation.toJSON(message.functionInvocation);
+    }
+    return obj;
+  },
+  create(base) {
+    return L1HandlerTransactionTrace$1.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseL1HandlerTransactionTrace();
+    message.functionInvocation = object.functionInvocation !== void 0 && object.functionInvocation !== null ? FunctionInvocation.fromPartial(object.functionInvocation) : void 0;
+    return message;
+  }
+};
+function createBaseFunctionInvocation() {
+  return {
+    contractAddress: void 0,
+    entryPointSelector: void 0,
+    calldata: [],
+    callerAddress: void 0,
+    classHash: void 0,
+    callType: 0,
+    result: [],
+    calls: [],
+    events: [],
+    messages: []
+  };
+}
+const FunctionInvocation = {
+  encode(message, writer = _m0__default.Writer.create()) {
+    if (message.contractAddress !== void 0) {
+      FieldElement.encode(message.contractAddress, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.entryPointSelector !== void 0) {
+      FieldElement.encode(message.entryPointSelector, writer.uint32(18).fork()).ldelim();
+    }
+    if (message.calldata !== void 0 && message.calldata.length !== 0) {
+      for (const v of message.calldata) {
+        FieldElement.encode(v, writer.uint32(26).fork()).ldelim();
+      }
+    }
+    if (message.callerAddress !== void 0) {
+      FieldElement.encode(message.callerAddress, writer.uint32(34).fork()).ldelim();
+    }
+    if (message.classHash !== void 0) {
+      FieldElement.encode(message.classHash, writer.uint32(42).fork()).ldelim();
+    }
+    if (message.callType !== void 0 && message.callType !== 0) {
+      writer.uint32(48).int32(message.callType);
+    }
+    if (message.result !== void 0 && message.result.length !== 0) {
+      for (const v of message.result) {
+        FieldElement.encode(v, writer.uint32(58).fork()).ldelim();
+      }
+    }
+    if (message.calls !== void 0 && message.calls.length !== 0) {
+      for (const v of message.calls) {
+        FunctionInvocation.encode(v, writer.uint32(66).fork()).ldelim();
+      }
+    }
+    if (message.events !== void 0 && message.events.length !== 0) {
+      writer.uint32(74).fork();
+      for (const v of message.events) {
+        writer.uint32(v);
+      }
+      writer.ldelim();
+    }
+    if (message.messages !== void 0 && message.messages.length !== 0) {
+      writer.uint32(82).fork();
+      for (const v of message.messages) {
+        writer.uint32(v);
+      }
+      writer.ldelim();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof _m0__default.Reader ? input : _m0__default.Reader.create(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseFunctionInvocation();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+          message.contractAddress = FieldElement.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+          message.entryPointSelector = FieldElement.decode(reader, reader.uint32());
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+          message.calldata.push(FieldElement.decode(reader, reader.uint32()));
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+          message.callerAddress = FieldElement.decode(reader, reader.uint32());
+          continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
+          message.classHash = FieldElement.decode(reader, reader.uint32());
+          continue;
+        case 6:
+          if (tag !== 48) {
+            break;
+          }
+          message.callType = reader.int32();
+          continue;
+        case 7:
+          if (tag !== 58) {
+            break;
+          }
+          message.result.push(FieldElement.decode(reader, reader.uint32()));
+          continue;
+        case 8:
+          if (tag !== 66) {
+            break;
+          }
+          message.calls.push(FunctionInvocation.decode(reader, reader.uint32()));
+          continue;
+        case 9:
+          if (tag === 72) {
+            message.events.push(reader.uint32());
+            continue;
+          }
+          if (tag === 74) {
+            const end2 = reader.uint32() + reader.pos;
+            while (reader.pos < end2) {
+              message.events.push(reader.uint32());
+            }
+            continue;
+          }
+          break;
+        case 10:
+          if (tag === 80) {
+            message.messages.push(reader.uint32());
+            continue;
+          }
+          if (tag === 82) {
+            const end2 = reader.uint32() + reader.pos;
+            while (reader.pos < end2) {
+              message.messages.push(reader.uint32());
+            }
+            continue;
+          }
+          break;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      contractAddress: isSet$1(object.contractAddress) ? FieldElement.fromJSON(object.contractAddress) : void 0,
+      entryPointSelector: isSet$1(object.entryPointSelector) ? FieldElement.fromJSON(object.entryPointSelector) : void 0,
+      calldata: globalThis.Array.isArray(object?.calldata) ? object.calldata.map((e) => FieldElement.fromJSON(e)) : [],
+      callerAddress: isSet$1(object.callerAddress) ? FieldElement.fromJSON(object.callerAddress) : void 0,
+      classHash: isSet$1(object.classHash) ? FieldElement.fromJSON(object.classHash) : void 0,
+      callType: isSet$1(object.callType) ? callTypeFromJSON(object.callType) : 0,
+      result: globalThis.Array.isArray(object?.result) ? object.result.map((e) => FieldElement.fromJSON(e)) : [],
+      calls: globalThis.Array.isArray(object?.calls) ? object.calls.map((e) => FunctionInvocation.fromJSON(e)) : [],
+      events: globalThis.Array.isArray(object?.events) ? object.events.map((e) => globalThis.Number(e)) : [],
+      messages: globalThis.Array.isArray(object?.messages) ? object.messages.map((e) => globalThis.Number(e)) : []
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.contractAddress !== void 0) {
+      obj.contractAddress = FieldElement.toJSON(message.contractAddress);
+    }
+    if (message.entryPointSelector !== void 0) {
+      obj.entryPointSelector = FieldElement.toJSON(message.entryPointSelector);
+    }
+    if (message.calldata?.length) {
+      obj.calldata = message.calldata.map((e) => FieldElement.toJSON(e));
+    }
+    if (message.callerAddress !== void 0) {
+      obj.callerAddress = FieldElement.toJSON(message.callerAddress);
+    }
+    if (message.classHash !== void 0) {
+      obj.classHash = FieldElement.toJSON(message.classHash);
+    }
+    if (message.callType !== void 0 && message.callType !== 0) {
+      obj.callType = callTypeToJSON(message.callType);
+    }
+    if (message.result?.length) {
+      obj.result = message.result.map((e) => FieldElement.toJSON(e));
+    }
+    if (message.calls?.length) {
+      obj.calls = message.calls.map((e) => FunctionInvocation.toJSON(e));
+    }
+    if (message.events?.length) {
+      obj.events = message.events.map((e) => Math.round(e));
+    }
+    if (message.messages?.length) {
+      obj.messages = message.messages.map((e) => Math.round(e));
+    }
+    return obj;
+  },
+  create(base) {
+    return FunctionInvocation.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseFunctionInvocation();
+    message.contractAddress = object.contractAddress !== void 0 && object.contractAddress !== null ? FieldElement.fromPartial(object.contractAddress) : void 0;
+    message.entryPointSelector = object.entryPointSelector !== void 0 && object.entryPointSelector !== null ? FieldElement.fromPartial(object.entryPointSelector) : void 0;
+    message.calldata = object.calldata?.map((e) => FieldElement.fromPartial(e)) || [];
+    message.callerAddress = object.callerAddress !== void 0 && object.callerAddress !== null ? FieldElement.fromPartial(object.callerAddress) : void 0;
+    message.classHash = object.classHash !== void 0 && object.classHash !== null ? FieldElement.fromPartial(object.classHash) : void 0;
+    message.callType = object.callType ?? 0;
+    message.result = object.result?.map((e) => FieldElement.fromPartial(e)) || [];
+    message.calls = object.calls?.map((e) => FunctionInvocation.fromPartial(e)) || [];
+    message.events = object.events?.map((e) => e) || [];
+    message.messages = object.messages?.map((e) => e) || [];
+    return message;
+  }
+};
+function createBaseFunctionCall() {
+  return { contractAddress: void 0, entryPointSelector: void 0, calldata: [] };
+}
+const FunctionCall = {
+  encode(message, writer = _m0__default.Writer.create()) {
+    if (message.contractAddress !== void 0) {
+      FieldElement.encode(message.contractAddress, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.entryPointSelector !== void 0) {
+      FieldElement.encode(message.entryPointSelector, writer.uint32(18).fork()).ldelim();
+    }
+    if (message.calldata !== void 0 && message.calldata.length !== 0) {
+      for (const v of message.calldata) {
+        FieldElement.encode(v, writer.uint32(26).fork()).ldelim();
+      }
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof _m0__default.Reader ? input : _m0__default.Reader.create(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseFunctionCall();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+          message.contractAddress = FieldElement.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+          message.entryPointSelector = FieldElement.decode(reader, reader.uint32());
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+          message.calldata.push(FieldElement.decode(reader, reader.uint32()));
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      contractAddress: isSet$1(object.contractAddress) ? FieldElement.fromJSON(object.contractAddress) : void 0,
+      entryPointSelector: isSet$1(object.entryPointSelector) ? FieldElement.fromJSON(object.entryPointSelector) : void 0,
+      calldata: globalThis.Array.isArray(object?.calldata) ? object.calldata.map((e) => FieldElement.fromJSON(e)) : []
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.contractAddress !== void 0) {
+      obj.contractAddress = FieldElement.toJSON(message.contractAddress);
+    }
+    if (message.entryPointSelector !== void 0) {
+      obj.entryPointSelector = FieldElement.toJSON(message.entryPointSelector);
+    }
+    if (message.calldata?.length) {
+      obj.calldata = message.calldata.map((e) => FieldElement.toJSON(e));
+    }
+    return obj;
+  },
+  create(base) {
+    return FunctionCall.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseFunctionCall();
+    message.contractAddress = object.contractAddress !== void 0 && object.contractAddress !== null ? FieldElement.fromPartial(object.contractAddress) : void 0;
+    message.entryPointSelector = object.entryPointSelector !== void 0 && object.entryPointSelector !== null ? FieldElement.fromPartial(object.entryPointSelector) : void 0;
+    message.calldata = object.calldata?.map((e) => FieldElement.fromPartial(e)) || [];
+    return message;
+  }
+};
+function bytesFromBase64(b64) {
+  if (globalThis.Buffer) {
+    return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
+  } else {
+    const bin = globalThis.atob(b64);
+    const arr = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; ++i) {
+      arr[i] = bin.charCodeAt(i);
+    }
+    return arr;
+  }
+}
+function base64FromBytes(arr) {
+  if (globalThis.Buffer) {
+    return globalThis.Buffer.from(arr).toString("base64");
+  } else {
+    const bin = [];
+    arr.forEach((byte) => {
+      bin.push(globalThis.String.fromCharCode(byte));
+    });
+    return globalThis.btoa(bin.join(""));
+  }
+}
+function toTimestamp(date) {
+  const seconds = BigInt(Math.trunc(date.getTime() / 1e3));
+  const nanos = date.getTime() % 1e3 * 1e6;
+  return { seconds, nanos };
+}
+function fromTimestamp(t) {
+  let millis = (globalThis.Number(t.seconds?.toString()) || 0) * 1e3;
+  millis += (t.nanos || 0) / 1e6;
+  return new globalThis.Date(millis);
 }
-function toTimestamp(date) {
-  const seconds = BigInt(Math.trunc(date.getTime() / 1e3));
-  const nanos = date.getTime() % 1e3 * 1e6;
-  return { seconds, nanos };
-}
-function fromTimestamp(t) {
-  let millis = (globalThis.Number(t.seconds?.toString()) || 0) * 1e3;
-  millis += (t.nanos || 0) / 1e6;
-  return new globalThis.Date(millis);
-}
 function fromJsonTimestamp(o) {
   if (o instanceof globalThis.Date) {
     return o;
@@ -4983,17 +5795,20 @@ const data = {
   __proto__: null,
   Block: Block$1,
   BlockHeader: BlockHeader$1,
+  CallType: CallType$1,
   ComputationResources: ComputationResources$1,
   ContractChange: ContractChange$1,
   DataAvailabilityMode: DataAvailabilityMode$1,
   DataAvailabilityResources: DataAvailabilityResources$1,
   DeclareTransactionReceipt: DeclareTransactionReceipt$1,
+  DeclareTransactionTrace: DeclareTransactionTrace$1,
   DeclareTransactionV0: DeclareTransactionV0$1,
   DeclareTransactionV1: DeclareTransactionV1$1,
   DeclareTransactionV2: DeclareTransactionV2$1,
   DeclareTransactionV3: DeclareTransactionV3$1,
   DeclaredClass: DeclaredClass$1,
   DeployAccountTransactionReceipt: DeployAccountTransactionReceipt$1,
+  DeployAccountTransactionTrace: DeployAccountTransactionTrace$1,
   DeployAccountTransactionV1: DeployAccountTransactionV1$1,
   DeployAccountTransactionV3: DeployAccountTransactionV3$1,
   DeployTransaction: DeployTransaction$1,
@@ -5005,13 +5820,17 @@ const data = {
   ExecutionStatus: ExecutionStatus,
   ExecutionSucceeded: ExecutionSucceeded$1,
   FeePayment: FeePayment$1,
+  FunctionCall: FunctionCall,
+  FunctionInvocation: FunctionInvocation,
   InvokeTransactionReceipt: InvokeTransactionReceipt$1,
+  InvokeTransactionTrace: InvokeTransactionTrace$1,
   InvokeTransactionV0: InvokeTransactionV0$1,
   InvokeTransactionV1: InvokeTransactionV1$1,
   InvokeTransactionV3: InvokeTransactionV3$1,
   L1DataAvailabilityMode: L1DataAvailabilityMode$1,
   L1HandlerTransaction: L1HandlerTransaction$1,
   L1HandlerTransactionReceipt: L1HandlerTransactionReceipt$1,
+  L1HandlerTransactionTrace: L1HandlerTransactionTrace$1,
   MessageToL1: MessageToL1$1,
   NonceUpdate: NonceUpdate$1,
   PriceUnit: PriceUnit$1,
@@ -5026,7 +5845,10 @@ const data = {
   TransactionReceipt: TransactionReceipt$1,
   TransactionReceiptMeta: TransactionReceiptMeta$1,
   TransactionStatus: TransactionStatus$1,
+  TransactionTrace: TransactionTrace$1,
   Uint128: Uint128,
+  callTypeFromJSON: callTypeFromJSON,
+  callTypeToJSON: callTypeToJSON,
   dataAvailabilityModeFromJSON: dataAvailabilityModeFromJSON,
   dataAvailabilityModeToJSON: dataAvailabilityModeToJSON,
   executionStatusFromJSON: executionStatusFromJSON,
@@ -5293,7 +6115,8 @@ function createBaseEventFilter() {
     includeTransaction: void 0,
     includeReceipt: void 0,
     includeMessages: void 0,
-    includeSiblings: void 0
+    includeSiblings: void 0,
+    includeTransactionTrace: void 0
   };
 }
 const EventFilter$1 = {
@@ -5327,6 +6150,9 @@ const EventFilter$1 = {
     if (message.includeSiblings !== void 0) {
       writer.uint32(72).bool(message.includeSiblings);
     }
+    if (message.includeTransactionTrace !== void 0) {
+      writer.uint32(80).bool(message.includeTransactionTrace);
+    }
     return writer;
   },
   decode(input, length) {
@@ -5390,6 +6216,12 @@ const EventFilter$1 = {
           }
           message.includeSiblings = reader.bool();
           continue;
+        case 10:
+          if (tag !== 80) {
+            break;
+          }
+          message.includeTransactionTrace = reader.bool();
+          continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -5408,7 +6240,8 @@ const EventFilter$1 = {
       includeTransaction: isSet(object.includeTransaction) ? globalThis.Boolean(object.includeTransaction) : void 0,
       includeReceipt: isSet(object.includeReceipt) ? globalThis.Boolean(object.includeReceipt) : void 0,
       includeMessages: isSet(object.includeMessages) ? globalThis.Boolean(object.includeMessages) : void 0,
-      includeSiblings: isSet(object.includeSiblings) ? globalThis.Boolean(object.includeSiblings) : void 0
+      includeSiblings: isSet(object.includeSiblings) ? globalThis.Boolean(object.includeSiblings) : void 0,
+      includeTransactionTrace: isSet(object.includeTransactionTrace) ? globalThis.Boolean(object.includeTransactionTrace) : void 0
     };
   },
   toJSON(message) {
@@ -5440,6 +6273,9 @@ const EventFilter$1 = {
     if (message.includeSiblings !== void 0) {
       obj.includeSiblings = message.includeSiblings;
     }
+    if (message.includeTransactionTrace !== void 0) {
+      obj.includeTransactionTrace = message.includeTransactionTrace;
+    }
     return obj;
   },
   create(base) {
@@ -5456,6 +6292,7 @@ const EventFilter$1 = {
     message.includeReceipt = object.includeReceipt ?? void 0;
     message.includeMessages = object.includeMessages ?? void 0;
     message.includeSiblings = object.includeSiblings ?? void 0;
+    message.includeTransactionTrace = object.includeTransactionTrace ?? void 0;
     return message;
   }
 };
@@ -5518,7 +6355,8 @@ function createBaseMessageToL1Filter() {
     includeTransaction: void 0,
     includeReceipt: void 0,
     includeEvents: void 0,
-    includeSiblings: void 0
+    includeSiblings: void 0,
+    includeTransactionTrace: void 0
   };
 }
 const MessageToL1Filter$1 = {
@@ -5547,6 +6385,9 @@ const MessageToL1Filter$1 = {
     if (message.includeSiblings !== void 0) {
       writer.uint32(64).bool(message.includeSiblings);
     }
+    if (message.includeTransactionTrace !== void 0) {
+      writer.uint32(72).bool(message.includeTransactionTrace);
+    }
     return writer;
   },
   decode(input, length) {
@@ -5604,6 +6445,12 @@ const MessageToL1Filter$1 = {
           }
           message.includeSiblings = reader.bool();
           continue;
+        case 9:
+          if (tag !== 72) {
+            break;
+          }
+          message.includeTransactionTrace = reader.bool();
+          continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -5621,7 +6468,8 @@ const MessageToL1Filter$1 = {
       includeTransaction: isSet(object.includeTransaction) ? globalThis.Boolean(object.includeTransaction) : void 0,
       includeReceipt: isSet(object.includeReceipt) ? globalThis.Boolean(object.includeReceipt) : void 0,
       includeEvents: isSet(object.includeEvents) ? globalThis.Boolean(object.includeEvents) : void 0,
-      includeSiblings: isSet(object.includeSiblings) ? globalThis.Boolean(object.includeSiblings) : void 0
+      includeSiblings: isSet(object.includeSiblings) ? globalThis.Boolean(object.includeSiblings) : void 0,
+      includeTransactionTrace: isSet(object.includeTransactionTrace) ? globalThis.Boolean(object.includeTransactionTrace) : void 0
     };
   },
   toJSON(message) {
@@ -5650,6 +6498,9 @@ const MessageToL1Filter$1 = {
     if (message.includeSiblings !== void 0) {
       obj.includeSiblings = message.includeSiblings;
     }
+    if (message.includeTransactionTrace !== void 0) {
+      obj.includeTransactionTrace = message.includeTransactionTrace;
+    }
     return obj;
   },
   create(base) {
@@ -5665,6 +6516,7 @@ const MessageToL1Filter$1 = {
     message.includeReceipt = object.includeReceipt ?? void 0;
     message.includeEvents = object.includeEvents ?? void 0;
     message.includeSiblings = object.includeSiblings ?? void 0;
+    message.includeTransactionTrace = object.includeTransactionTrace ?? void 0;
     return message;
   }
 };
@@ -5675,7 +6527,8 @@ function createBaseTransactionFilter() {
     includeReceipt: void 0,
     includeEvents: void 0,
     includeMessages: void 0,
-    inner: void 0
+    inner: void 0,
+    includeTrace: void 0
   };
 }
 const TransactionFilter$1 = {
@@ -5730,6 +6583,9 @@ const TransactionFilter$1 = {
         DeployAccountV3TransactionFilter$1.encode(message.inner.deployAccountV3, writer.uint32(130).fork()).ldelim();
         break;
     }
+    if (message.includeTrace !== void 0) {
+      writer.uint32(136).bool(message.includeTrace);
+    }
     return writer;
   },
   decode(input, length) {
@@ -5841,6 +6697,12 @@ const TransactionFilter$1 = {
             deployAccountV3: DeployAccountV3TransactionFilter$1.decode(reader, reader.uint32())
           };
           continue;
+        case 17:
+          if (tag !== 136) {
+            break;
+          }
+          message.includeTrace = reader.bool();
+          continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -5862,7 +6724,8 @@ const TransactionFilter$1 = {
       } : isSet(object.deployAccountV3) ? {
         $case: "deployAccountV3",
         deployAccountV3: DeployAccountV3TransactionFilter$1.fromJSON(object.deployAccountV3)
-      } : void 0
+      } : void 0,
+      includeTrace: isSet(object.includeTrace) ? globalThis.Boolean(object.includeTrace) : void 0
     };
   },
   toJSON(message) {
@@ -5915,6 +6778,9 @@ const TransactionFilter$1 = {
     if (message.inner?.$case === "deployAccountV3") {
       obj.deployAccountV3 = DeployAccountV3TransactionFilter$1.toJSON(message.inner.deployAccountV3);
     }
+    if (message.includeTrace !== void 0) {
+      obj.includeTrace = message.includeTrace;
+    }
     return obj;
   },
   create(base) {
@@ -5966,6 +6832,7 @@ const TransactionFilter$1 = {
         deployAccountV3: DeployAccountV3TransactionFilter$1.fromPartial(object.inner.deployAccountV3)
       };
     }
+    message.includeTrace = object.includeTrace ?? void 0;
     return message;
   }
 };
@@ -6753,651 +7620,642 @@ const index = {
   filter: filter
 };
 
-const ResourcePrice = schema.Schema.Struct({
-  priceInFri: schema.Schema.optional(FieldElement$1),
-  priceInWei: schema.Schema.optional(FieldElement$1)
+const ResourcePrice = codec.MessageCodec({
+  priceInFri: codec.OptionalCodec(FieldElement$1),
+  priceInWei: codec.OptionalCodec(FieldElement$1)
 });
-const L1DataAvailabilityMode = schema.Schema.transform(
-  schema.Schema.Enums(L1DataAvailabilityMode$1),
-  schema.Schema.Literal("blob", "calldata", "unknown"),
-  {
-    decode(value) {
-      const enumMap = {
-        [L1DataAvailabilityMode$1.CALLDATA]: "calldata",
-        [L1DataAvailabilityMode$1.BLOB]: "blob",
-        [L1DataAvailabilityMode$1.UNSPECIFIED]: "unknown",
-        [L1DataAvailabilityMode$1.UNRECOGNIZED]: "unknown"
-      };
-      return enumMap[value] ?? "unknown";
-    },
-    encode(value) {
-      throw new Error("encode: not implemented");
-    }
+const L1DataAvailabilityMode = {
+  encode(x) {
+    switch (x) {
+      case "calldata":
+        return L1DataAvailabilityMode$1.CALLDATA;
+      case "blob":
+        return L1DataAvailabilityMode$1.BLOB;
+      case "unknown":
+        return L1DataAvailabilityMode$1.UNSPECIFIED;
+      default:
+        return L1DataAvailabilityMode$1.UNRECOGNIZED;
+    }
+  },
+  decode(p) {
+    const enumMap = {
+      [L1DataAvailabilityMode$1.CALLDATA]: "calldata",
+      [L1DataAvailabilityMode$1.BLOB]: "blob",
+      [L1DataAvailabilityMode$1.UNSPECIFIED]: "unknown",
+      [L1DataAvailabilityMode$1.UNRECOGNIZED]: "unknown"
+    };
+    return enumMap[p] ?? "unknown";
   }
-);
-const TransactionStatus = schema.Schema.transform(
-  schema.Schema.Enums(TransactionStatus$1),
-  schema.Schema.Literal("unknown", "succeeded", "reverted"),
-  {
-    decode(value) {
-      const enumMap = {
-        [TransactionStatus$1.SUCCEEDED]: "succeeded",
-        [TransactionStatus$1.REVERTED]: "reverted",
-        [TransactionStatus$1.UNSPECIFIED]: "unknown",
-        [TransactionStatus$1.UNRECOGNIZED]: "unknown"
-      };
-      return enumMap[value] ?? "unknown";
-    },
-    encode(value) {
-      throw new Error("encode: not implemented");
-    }
+};
+const TransactionStatus = {
+  encode(x) {
+    switch (x) {
+      case "succeeded":
+        return TransactionStatus$1.SUCCEEDED;
+      case "reverted":
+        return TransactionStatus$1.REVERTED;
+      case "unknown":
+        return TransactionStatus$1.UNSPECIFIED;
+      default:
+        return TransactionStatus$1.UNRECOGNIZED;
+    }
+  },
+  decode(p) {
+    const enumMap = {
+      [TransactionStatus$1.SUCCEEDED]: "succeeded",
+      [TransactionStatus$1.REVERTED]: "reverted",
+      [TransactionStatus$1.UNSPECIFIED]: "unknown",
+      [TransactionStatus$1.UNRECOGNIZED]: "unknown"
+    };
+    return enumMap[p] ?? "unknown";
   }
-);
-const U128 = schema.Schema.transform(
-  schema.Schema.Struct({
-    x0: schema.Schema.BigIntFromSelf,
-    x1: schema.Schema.BigIntFromSelf
-  }),
-  schema.Schema.BigIntFromSelf,
-  {
-    decode(value) {
-      const low = value.x0.toString(16).padStart(16, "0");
-      const high = value.x1.toString(16).padStart(16, "0");
-      return BigInt(`0x${low}${high}`);
-    },
-    encode(value) {
-      throw new Error("encode: not implemented");
-    }
+};
+const U128 = {
+  // TODO: double check if this is correct
+  encode(x) {
+    const low = x.toString(16).padStart(16, "0");
+    const high = (x >> 128n).toString(16).padStart(16, "0");
+    return { x0: BigInt(`0x${low}`), x1: BigInt(`0x${high}`) };
+  },
+  decode(p) {
+    const low = (p.x0 ?? 0n).toString(16).padStart(16, "0");
+    const high = (p.x1 ?? 0n).toString(16).padStart(16, "0");
+    return BigInt(`0x${low}${high}`);
   }
-);
-const ResourceBounds = schema.Schema.Struct({
-  maxAmount: schema.Schema.BigIntFromSelf,
-  maxPricePerUnit: U128
+};
+const ResourceBounds = codec.MessageCodec({
+  maxAmount: codec.RequiredCodec(codec.BigIntCodec),
+  maxPricePerUnit: codec.RequiredCodec(U128)
 });
-const ResourceBoundsMapping = schema.Schema.Struct({
-  l1Gas: ResourceBounds,
-  l2Gas: ResourceBounds
+const ResourceBoundsMapping = codec.MessageCodec({
+  l1Gas: codec.RequiredCodec(ResourceBounds),
+  l2Gas: codec.RequiredCodec(ResourceBounds)
 });
-const DataAvailabilityMode = schema.Schema.transform(
-  schema.Schema.Enums(DataAvailabilityMode$1),
-  schema.Schema.Literal("l1", "l2", "unknown"),
-  {
-    decode(value) {
-      const enumMap = {
-        [DataAvailabilityMode$1.L1]: "l1",
-        [DataAvailabilityMode$1.L2]: "l2",
-        [DataAvailabilityMode$1.UNSPECIFIED]: "unknown",
-        [DataAvailabilityMode$1.UNRECOGNIZED]: "unknown"
-      };
-      return enumMap[value] ?? "unknown";
-    },
-    encode(value) {
-      throw new Error("encode: not implemented");
-    }
+const DataAvailabilityMode = {
+  encode(x) {
+    switch (x) {
+      case "l1":
+        return DataAvailabilityMode$1.L1;
+      case "l2":
+        return DataAvailabilityMode$1.L2;
+      case "unknown":
+        return DataAvailabilityMode$1.UNSPECIFIED;
+      default:
+        return DataAvailabilityMode$1.UNRECOGNIZED;
+    }
+  },
+  decode(p) {
+    const enumMap = {
+      [DataAvailabilityMode$1.L1]: "l1",
+      [DataAvailabilityMode$1.L2]: "l2",
+      [DataAvailabilityMode$1.UNSPECIFIED]: "unknown",
+      [DataAvailabilityMode$1.UNRECOGNIZED]: "unknown"
+    };
+    return enumMap[p] ?? "unknown";
   }
-);
-const BlockHeader = schema.Schema.Struct({
-  blockHash: schema.Schema.optional(FieldElement$1),
-  parentBlockHash: FieldElement$1,
-  blockNumber: schema.Schema.BigIntFromSelf,
-  sequencerAddress: FieldElement$1,
-  newRoot: schema.Schema.optional(FieldElement$1),
-  timestamp: schema.Schema.DateFromSelf,
-  starknetVersion: schema.Schema.String,
-  l1GasPrice: ResourcePrice,
-  l1DataGasPrice: ResourcePrice,
-  l1DataAvailabilityMode: L1DataAvailabilityMode
+};
+const BlockHeader = codec.MessageCodec({
+  blockHash: codec.OptionalCodec(FieldElement$1),
+  parentBlockHash: codec.RequiredCodec(FieldElement$1),
+  blockNumber: codec.RequiredCodec(codec.BigIntCodec),
+  sequencerAddress: codec.RequiredCodec(FieldElement$1),
+  newRoot: codec.OptionalCodec(FieldElement$1),
+  timestamp: codec.RequiredCodec(codec.DateCodec),
+  starknetVersion: codec.RequiredCodec(codec.StringCodec),
+  l1GasPrice: codec.RequiredCodec(ResourcePrice),
+  l1DataGasPrice: codec.RequiredCodec(ResourcePrice),
+  l1DataAvailabilityMode: codec.RequiredCodec(L1DataAvailabilityMode)
 });
-const TransactionMeta = schema.Schema.Struct({
-  transactionIndex: schema.Schema.Number,
-  transactionHash: FieldElement$1,
-  transactionStatus: TransactionStatus
+const TransactionMeta = codec.MessageCodec({
+  transactionIndex: codec.RequiredCodec(codec.NumberCodec),
+  transactionHash: codec.RequiredCodec(FieldElement$1),
+  transactionStatus: codec.RequiredCodec(TransactionStatus)
 });
-const InvokeTransactionV0 = schema.Schema.Struct({
-  _tag: tag("invokeV0"),
-  invokeV0: schema.Schema.Struct({
-    maxFee: FieldElement$1,
-    signature: schema.Schema.Array(FieldElement$1),
-    contractAddress: FieldElement$1,
-    entryPointSelector: FieldElement$1,
-    calldata: schema.Schema.Array(FieldElement$1)
-  })
+const InvokeTransactionV0 = codec.MessageCodec({
+  maxFee: codec.RequiredCodec(FieldElement$1),
+  signature: codec.ArrayCodec(FieldElement$1),
+  contractAddress: codec.RequiredCodec(FieldElement$1),
+  entryPointSelector: codec.RequiredCodec(FieldElement$1),
+  calldata: codec.ArrayCodec(FieldElement$1)
 });
-const InvokeTransactionV1 = schema.Schema.Struct({
-  _tag: tag("invokeV1"),
-  invokeV1: schema.Schema.Struct({
-    senderAddress: FieldElement$1,
-    calldata: schema.Schema.Array(FieldElement$1),
-    maxFee: FieldElement$1,
-    signature: schema.Schema.Array(FieldElement$1),
-    nonce: FieldElement$1
-  })
+const InvokeTransactionV1 = codec.MessageCodec({
+  senderAddress: codec.RequiredCodec(FieldElement$1),
+  calldata: codec.ArrayCodec(FieldElement$1),
+  maxFee: codec.RequiredCodec(FieldElement$1),
+  signature: codec.ArrayCodec(FieldElement$1),
+  nonce: codec.RequiredCodec(FieldElement$1)
 });
-const InvokeTransactionV3 = schema.Schema.Struct({
-  _tag: tag("invokeV3"),
-  invokeV3: schema.Schema.Struct({
-    senderAddress: FieldElement$1,
-    calldata: schema.Schema.Array(FieldElement$1),
-    signature: schema.Schema.Array(FieldElement$1),
-    nonce: FieldElement$1,
-    resourceBounds: ResourceBoundsMapping,
-    tip: schema.Schema.BigIntFromSelf,
-    paymasterData: schema.Schema.Array(FieldElement$1),
-    accountDeploymentData: schema.Schema.Array(FieldElement$1),
-    nonceDataAvailabilityMode: DataAvailabilityMode,
-    feeDataAvailabilityMode: DataAvailabilityMode
-  })
+const InvokeTransactionV3 = codec.MessageCodec({
+  senderAddress: codec.RequiredCodec(FieldElement$1),
+  calldata: codec.ArrayCodec(FieldElement$1),
+  signature: codec.ArrayCodec(FieldElement$1),
+  nonce: codec.RequiredCodec(FieldElement$1),
+  resourceBounds: codec.RequiredCodec(ResourceBoundsMapping),
+  tip: codec.RequiredCodec(codec.BigIntCodec),
+  paymasterData: codec.ArrayCodec(FieldElement$1),
+  accountDeploymentData: codec.ArrayCodec(FieldElement$1),
+  nonceDataAvailabilityMode: codec.RequiredCodec(DataAvailabilityMode),
+  feeDataAvailabilityMode: codec.RequiredCodec(DataAvailabilityMode)
 });
-const L1HandlerTransaction = schema.Schema.Struct({
-  _tag: tag("l1Handler"),
-  l1Handler: schema.Schema.Struct({
-    nonce: schema.Schema.BigIntFromSelf,
-    contractAddress: FieldElement$1,
-    entryPointSelector: FieldElement$1,
-    calldata: schema.Schema.Array(FieldElement$1)
-  })
+const L1HandlerTransaction = codec.MessageCodec({
+  nonce: codec.RequiredCodec(codec.BigIntCodec),
+  contractAddress: codec.RequiredCodec(FieldElement$1),
+  entryPointSelector: codec.RequiredCodec(FieldElement$1),
+  calldata: codec.ArrayCodec(FieldElement$1)
 });
-const DeployTransaction = schema.Schema.Struct({
-  _tag: tag("deploy"),
-  deploy: schema.Schema.Struct({
-    contractAddressSalt: FieldElement$1,
-    constructorCalldata: schema.Schema.Array(FieldElement$1),
-    classHash: FieldElement$1
-  })
+const DeployTransaction = codec.MessageCodec({
+  contractAddressSalt: codec.RequiredCodec(FieldElement$1),
+  constructorCalldata: codec.ArrayCodec(FieldElement$1),
+  classHash: codec.RequiredCodec(FieldElement$1)
 });
-const DeclareTransactionV0 = schema.Schema.Struct({
-  _tag: tag("declareV0"),
-  declareV0: schema.Schema.Struct({
-    senderAddress: FieldElement$1,
-    maxFee: FieldElement$1,
-    signature: schema.Schema.Array(FieldElement$1),
-    classHash: FieldElement$1
-  })
+const DeclareTransactionV0 = codec.MessageCodec({
+  senderAddress: codec.RequiredCodec(FieldElement$1),
+  maxFee: codec.RequiredCodec(FieldElement$1),
+  signature: codec.ArrayCodec(FieldElement$1),
+  classHash: codec.RequiredCodec(FieldElement$1)
 });
-const DeclareTransactionV1 = schema.Schema.Struct({
-  _tag: tag("declareV1"),
-  declareV1: schema.Schema.Struct({
-    senderAddress: FieldElement$1,
-    maxFee: FieldElement$1,
-    signature: schema.Schema.Array(FieldElement$1),
-    nonce: FieldElement$1,
-    classHash: FieldElement$1
-  })
+const DeclareTransactionV1 = codec.MessageCodec({
+  senderAddress: codec.RequiredCodec(FieldElement$1),
+  maxFee: codec.RequiredCodec(FieldElement$1),
+  signature: codec.ArrayCodec(FieldElement$1),
+  nonce: codec.RequiredCodec(FieldElement$1),
+  classHash: codec.RequiredCodec(FieldElement$1)
 });
-const DeclareTransactionV2 = schema.Schema.Struct({
-  _tag: tag("declareV2"),
-  declareV2: schema.Schema.Struct({
-    senderAddress: FieldElement$1,
-    compiledClassHash: FieldElement$1,
-    maxFee: FieldElement$1,
-    signature: schema.Schema.Array(FieldElement$1),
-    nonce: FieldElement$1,
-    classHash: FieldElement$1
-  })
+const DeclareTransactionV2 = codec.MessageCodec({
+  senderAddress: codec.RequiredCodec(FieldElement$1),
+  compiledClassHash: codec.RequiredCodec(FieldElement$1),
+  maxFee: codec.RequiredCodec(FieldElement$1),
+  signature: codec.ArrayCodec(FieldElement$1),
+  nonce: codec.RequiredCodec(FieldElement$1),
+  classHash: codec.RequiredCodec(FieldElement$1)
 });
-const DeclareTransactionV3 = schema.Schema.Struct({
-  _tag: tag("declareV3"),
-  declareV3: schema.Schema.Struct({
-    senderAddress: FieldElement$1,
-    compiledClassHash: FieldElement$1,
-    signature: schema.Schema.Array(FieldElement$1),
-    nonce: FieldElement$1,
-    classHash: FieldElement$1,
-    resourceBounds: ResourceBoundsMapping,
-    tip: schema.Schema.BigIntFromSelf,
-    paymasterData: schema.Schema.Array(FieldElement$1),
-    accountDeploymentData: schema.Schema.Array(FieldElement$1),
-    nonceDataAvailabilityMode: DataAvailabilityMode,
-    feeDataAvailabilityMode: DataAvailabilityMode
-  })
+const DeclareTransactionV3 = codec.MessageCodec({
+  senderAddress: codec.RequiredCodec(FieldElement$1),
+  compiledClassHash: codec.RequiredCodec(FieldElement$1),
+  signature: codec.ArrayCodec(FieldElement$1),
+  nonce: codec.RequiredCodec(FieldElement$1),
+  classHash: codec.RequiredCodec(FieldElement$1),
+  resourceBounds: codec.RequiredCodec(ResourceBoundsMapping),
+  tip: codec.RequiredCodec(codec.BigIntCodec),
+  paymasterData: codec.ArrayCodec(FieldElement$1),
+  accountDeploymentData: codec.ArrayCodec(FieldElement$1),
+  nonceDataAvailabilityMode: codec.RequiredCodec(DataAvailabilityMode),
+  feeDataAvailabilityMode: codec.RequiredCodec(DataAvailabilityMode)
 });
-const DeployAccountTransactionV1 = schema.Schema.Struct({
-  _tag: tag("deployAccountV1"),
-  deployAccountV1: schema.Schema.Struct({
-    maxFee: FieldElement$1,
-    signature: schema.Schema.Array(FieldElement$1),
-    nonce: FieldElement$1,
-    contractAddressSalt: FieldElement$1,
-    constructorCalldata: schema.Schema.Array(FieldElement$1),
-    classHash: FieldElement$1
-  })
+const DeployAccountTransactionV1 = codec.MessageCodec({
+  maxFee: codec.RequiredCodec(FieldElement$1),
+  signature: codec.ArrayCodec(FieldElement$1),
+  nonce: codec.RequiredCodec(FieldElement$1),
+  contractAddressSalt: codec.RequiredCodec(FieldElement$1),
+  constructorCalldata: codec.ArrayCodec(FieldElement$1),
+  classHash: codec.RequiredCodec(FieldElement$1)
 });
-const DeployAccountTransactionV3 = schema.Schema.Struct({
-  _tag: tag("deployAccountV3"),
-  deployAccountV3: schema.Schema.Struct({
-    signature: schema.Schema.Array(FieldElement$1),
-    nonce: FieldElement$1,
-    contractAddressSalt: FieldElement$1,
-    constructorCalldata: schema.Schema.Array(FieldElement$1),
-    classHash: FieldElement$1,
-    resourceBounds: ResourceBoundsMapping,
-    tip: schema.Schema.BigIntFromSelf,
-    paymasterData: schema.Schema.Array(FieldElement$1),
-    nonceDataAvailabilityMode: DataAvailabilityMode,
-    feeDataAvailabilityMode: DataAvailabilityMode
-  })
+const DeployAccountTransactionV3 = codec.MessageCodec({
+  signature: codec.ArrayCodec(FieldElement$1),
+  nonce: codec.RequiredCodec(FieldElement$1),
+  contractAddressSalt: codec.RequiredCodec(FieldElement$1),
+  constructorCalldata: codec.ArrayCodec(FieldElement$1),
+  classHash: codec.RequiredCodec(FieldElement$1),
+  resourceBounds: codec.RequiredCodec(ResourceBoundsMapping),
+  tip: codec.RequiredCodec(codec.BigIntCodec),
+  paymasterData: codec.ArrayCodec(FieldElement$1),
+  nonceDataAvailabilityMode: codec.RequiredCodec(DataAvailabilityMode),
+  feeDataAvailabilityMode: codec.RequiredCodec(DataAvailabilityMode)
 });
-const Transaction = schema.Schema.Struct({
-  filterIds: schema.Schema.Array(schema.Schema.Number),
-  meta: TransactionMeta,
-  transaction: schema.Schema.Union(
-    InvokeTransactionV0,
-    InvokeTransactionV1,
-    InvokeTransactionV3,
-    L1HandlerTransaction,
-    DeployTransaction,
-    DeclareTransactionV0,
-    DeclareTransactionV1,
-    DeclareTransactionV2,
-    DeclareTransactionV3,
-    DeployAccountTransactionV1,
-    DeployAccountTransactionV3
+const Transaction = codec.MessageCodec({
+  filterIds: codec.ArrayCodec(codec.NumberCodec),
+  meta: codec.RequiredCodec(TransactionMeta),
+  transaction: codec.RequiredCodec(
+    codec.OneOfCodec({
+      invokeV0: InvokeTransactionV0,
+      invokeV1: InvokeTransactionV1,
+      invokeV3: InvokeTransactionV3,
+      l1Handler: L1HandlerTransaction,
+      deploy: DeployTransaction,
+      declareV0: DeclareTransactionV0,
+      declareV1: DeclareTransactionV1,
+      declareV2: DeclareTransactionV2,
+      declareV3: DeclareTransactionV3,
+      deployAccountV1: DeployAccountTransactionV1,
+      deployAccountV3: DeployAccountTransactionV3
+    })
   )
 });
-const PriceUnit = schema.Schema.transform(
-  schema.Schema.Enums(PriceUnit$1),
-  schema.Schema.Literal("wei", "fri", "unknown"),
-  {
-    decode(value) {
-      const enumMap = {
-        [PriceUnit$1.WEI]: "wei",
-        [PriceUnit$1.FRI]: "fri",
-        [PriceUnit$1.UNSPECIFIED]: "unknown",
-        [PriceUnit$1.UNRECOGNIZED]: "unknown"
-      };
-      return enumMap[value] ?? "unknown";
-    },
-    encode(value) {
-      throw new Error("encode: not implemented");
-    }
+const PriceUnit = {
+  encode(x) {
+    switch (x) {
+      case "wei":
+        return PriceUnit$1.WEI;
+      case "fri":
+        return PriceUnit$1.FRI;
+      case "unknown":
+        return PriceUnit$1.UNSPECIFIED;
+      default:
+        return PriceUnit$1.UNRECOGNIZED;
+    }
+  },
+  decode(p) {
+    const enumMap = {
+      [PriceUnit$1.WEI]: "wei",
+      [PriceUnit$1.FRI]: "fri",
+      [PriceUnit$1.UNSPECIFIED]: "unknown",
+      [PriceUnit$1.UNRECOGNIZED]: "unknown"
+    };
+    return enumMap[p] ?? "unknown";
   }
-);
-const FeePayment = schema.Schema.Struct({
-  amount: FieldElement$1,
-  unit: PriceUnit
-});
-const ComputationResources = schema.Schema.Struct({
-  steps: schema.Schema.BigIntFromSelf,
-  memoryHoles: schema.Schema.optional(schema.Schema.BigIntFromSelf),
-  rangeCheckBuiltinApplications: schema.Schema.optional(schema.Schema.BigIntFromSelf),
-  pedersenBuiltinApplications: schema.Schema.optional(schema.Schema.BigIntFromSelf),
-  poseidonBuiltinApplications: schema.Schema.optional(schema.Schema.BigIntFromSelf),
-  ecOpBuiltinApplications: schema.Schema.optional(schema.Schema.BigIntFromSelf),
-  ecdsaBuiltinApplications: schema.Schema.optional(schema.Schema.BigIntFromSelf),
-  bitwiseBuiltinApplications: schema.Schema.optional(schema.Schema.BigIntFromSelf),
-  keccakBuiltinApplications: schema.Schema.optional(schema.Schema.BigIntFromSelf),
-  segmentArenaBuiltin: schema.Schema.optional(schema.Schema.BigIntFromSelf)
-});
-const DataAvailabilityResources = schema.Schema.Struct({
-  l1Gas: schema.Schema.BigIntFromSelf,
-  l1DataGas: schema.Schema.BigIntFromSelf
-});
-const ExecutionResources = schema.Schema.Struct({
-  computation: ComputationResources,
-  dataAvailability: DataAvailabilityResources
+};
+const FeePayment = codec.MessageCodec({
+  amount: codec.RequiredCodec(FieldElement$1),
+  unit: codec.RequiredCodec(PriceUnit)
 });
-const ExecutionSucceeded = schema.Schema.Struct({
-  _tag: tag("succeeded"),
-  succeeded: schema.Schema.Struct({})
+const ComputationResources = codec.MessageCodec({
+  steps: codec.RequiredCodec(codec.BigIntCodec),
+  memoryHoles: codec.OptionalCodec(codec.BigIntCodec),
+  rangeCheckBuiltinApplications: codec.OptionalCodec(codec.BigIntCodec),
+  pedersenBuiltinApplications: codec.OptionalCodec(codec.BigIntCodec),
+  poseidonBuiltinApplications: codec.OptionalCodec(codec.BigIntCodec),
+  ecOpBuiltinApplications: codec.OptionalCodec(codec.BigIntCodec),
+  ecdsaBuiltinApplications: codec.OptionalCodec(codec.BigIntCodec),
+  bitwiseBuiltinApplications: codec.OptionalCodec(codec.BigIntCodec),
+  keccakBuiltinApplications: codec.OptionalCodec(codec.BigIntCodec),
+  segmentArenaBuiltin: codec.OptionalCodec(codec.BigIntCodec)
 });
-const ExecutionReverted = schema.Schema.Struct({
-  _tag: tag("reverted"),
-  reverted: schema.Schema.Struct({
-    reason: schema.Schema.optional(schema.Schema.String)
-  })
+const DataAvailabilityResources = codec.MessageCodec({
+  l1Gas: codec.RequiredCodec(codec.BigIntCodec),
+  l1DataGas: codec.RequiredCodec(codec.BigIntCodec)
 });
-const TransactionReceiptMeta = schema.Schema.Struct({
-  transactionIndex: schema.Schema.Number,
-  transactionHash: FieldElement$1,
-  actualFee: FeePayment,
-  executionResources: ExecutionResources,
-  executionResult: schema.Schema.Union(ExecutionSucceeded, ExecutionReverted)
+const ExecutionResources = codec.MessageCodec({
+  computation: codec.RequiredCodec(ComputationResources),
+  dataAvailability: codec.RequiredCodec(DataAvailabilityResources)
 });
-const InvokeTransactionReceipt = schema.Schema.Struct({
-  _tag: tag("invoke"),
-  invoke: schema.Schema.Struct({})
+const ExecutionSucceeded = codec.MessageCodec({});
+const ExecutionReverted = codec.MessageCodec({
+  reason: codec.OptionalCodec(codec.StringCodec)
 });
-const L1HandlerTransactionReceipt = schema.Schema.Struct({
-  _tag: tag("l1Handler"),
-  l1Handler: schema.Schema.Struct({
-    messageHash: schema.Schema.Uint8ArrayFromSelf
-  })
+const TransactionReceiptMeta = codec.MessageCodec({
+  transactionIndex: codec.RequiredCodec(codec.NumberCodec),
+  transactionHash: codec.RequiredCodec(FieldElement$1),
+  actualFee: codec.RequiredCodec(FeePayment),
+  executionResources: codec.RequiredCodec(ExecutionResources),
+  executionResult: codec.RequiredCodec(
+    codec.OneOfCodec({
+      succeeded: ExecutionSucceeded,
+      reverted: ExecutionReverted
+    })
+  )
 });
-const DeclareTransactionReceipt = schema.Schema.Struct({
-  _tag: tag("declare"),
-  declare: schema.Schema.Struct({})
+const InvokeTransactionReceipt = codec.MessageCodec({});
+const L1HandlerTransactionReceipt = codec.MessageCodec({
+  messageHash: codec.RequiredCodec(codec.Uint8ArrayCodec)
 });
-const DeployTransactionReceipt = schema.Schema.Struct({
-  _tag: tag("deploy"),
-  deploy: schema.Schema.Struct({
-    contractAddress: FieldElement$1
-  })
+const DeclareTransactionReceipt = codec.MessageCodec({});
+const DeployTransactionReceipt = codec.MessageCodec({
+  contractAddress: codec.RequiredCodec(FieldElement$1)
 });
-const DeployAccountTransactionReceipt = schema.Schema.Struct({
-  _tag: tag("deployAccount"),
-  deployAccount: schema.Schema.Struct({
-    contractAddress: FieldElement$1
-  })
+const DeployAccountTransactionReceipt = codec.MessageCodec({
+  contractAddress: codec.RequiredCodec(FieldElement$1)
 });
-const TransactionReceipt = schema.Schema.Struct({
-  filterIds: schema.Schema.Array(schema.Schema.Number),
-  meta: TransactionReceiptMeta,
-  receipt: schema.Schema.Union(
-    InvokeTransactionReceipt,
-    L1HandlerTransactionReceipt,
-    DeclareTransactionReceipt,
-    DeployTransactionReceipt,
-    DeployAccountTransactionReceipt
+const TransactionReceipt = codec.MessageCodec({
+  filterIds: codec.ArrayCodec(codec.NumberCodec),
+  meta: codec.RequiredCodec(TransactionReceiptMeta),
+  receipt: codec.RequiredCodec(
+    codec.OneOfCodec({
+      invoke: InvokeTransactionReceipt,
+      l1Handler: L1HandlerTransactionReceipt,
+      declare: DeclareTransactionReceipt,
+      deploy: DeployTransactionReceipt,
+      deployAccount: DeployAccountTransactionReceipt
+    })
   )
 });
-const Event = schema.Schema.Struct({
-  filterIds: schema.Schema.Array(schema.Schema.Number),
-  address: FieldElement$1,
-  keys: schema.Schema.Array(FieldElement$1),
-  data: schema.Schema.Array(FieldElement$1),
-  eventIndex: schema.Schema.Number,
-  transactionIndex: schema.Schema.Number,
-  transactionHash: FieldElement$1,
-  transactionStatus: TransactionStatus,
-  eventIndexInTransaction: schema.Schema.Number
+const Event = codec.MessageCodec({
+  filterIds: codec.ArrayCodec(codec.NumberCodec),
+  address: codec.RequiredCodec(FieldElement$1),
+  keys: codec.ArrayCodec(FieldElement$1),
+  data: codec.ArrayCodec(FieldElement$1),
+  eventIndex: codec.RequiredCodec(codec.NumberCodec),
+  transactionIndex: codec.RequiredCodec(codec.NumberCodec),
+  transactionHash: codec.RequiredCodec(FieldElement$1),
+  transactionStatus: codec.RequiredCodec(TransactionStatus),
+  eventIndexInTransaction: codec.RequiredCodec(codec.NumberCodec)
 });
-const MessageToL1 = schema.Schema.Struct({
-  filterIds: schema.Schema.Array(schema.Schema.Number),
-  fromAddress: FieldElement$1,
-  toAddress: FieldElement$1,
-  payload: schema.Schema.Array(FieldElement$1),
-  messageIndex: schema.Schema.Number,
-  transactionIndex: schema.Schema.Number,
-  transactionHash: FieldElement$1,
-  transactionStatus: TransactionStatus,
-  messageIndexInTransaction: schema.Schema.Number
+const MessageToL1 = codec.MessageCodec({
+  filterIds: codec.ArrayCodec(codec.NumberCodec),
+  fromAddress: codec.RequiredCodec(FieldElement$1),
+  toAddress: codec.RequiredCodec(FieldElement$1),
+  payload: codec.ArrayCodec(FieldElement$1),
+  messageIndex: codec.RequiredCodec(codec.NumberCodec),
+  transactionIndex: codec.RequiredCodec(codec.NumberCodec),
+  transactionHash: codec.RequiredCodec(FieldElement$1),
+  transactionStatus: codec.RequiredCodec(TransactionStatus),
+  messageIndexInTransaction: codec.RequiredCodec(codec.NumberCodec)
 });
-const StorageEntry = schema.Schema.Struct({
-  key: FieldElement$1,
-  value: FieldElement$1
+const StorageEntry = codec.MessageCodec({
+  key: codec.RequiredCodec(FieldElement$1),
+  value: codec.RequiredCodec(FieldElement$1)
 });
-const StorageDiff = schema.Schema.Struct({
-  filterIds: schema.Schema.Array(schema.Schema.Number),
-  contractAddress: FieldElement$1,
-  storageEntries: schema.Schema.Array(StorageEntry)
+const StorageDiff = codec.MessageCodec({
+  filterIds: codec.ArrayCodec(codec.NumberCodec),
+  contractAddress: codec.RequiredCodec(FieldElement$1),
+  storageEntries: codec.ArrayCodec(StorageEntry)
 });
-const DeclaredClass = schema.Schema.Struct({
-  _tag: tag("declaredClass"),
-  declaredClass: schema.Schema.Struct({
-    classHash: schema.Schema.optional(FieldElement$1),
-    compiledClassHash: schema.Schema.optional(FieldElement$1)
-  })
+const DeclaredClass = codec.MessageCodec({
+  classHash: codec.OptionalCodec(FieldElement$1),
+  compiledClassHash: codec.OptionalCodec(FieldElement$1)
 });
-const ReplacedClass = schema.Schema.Struct({
-  _tag: tag("replacedClass"),
-  replacedClass: schema.Schema.Struct({
-    contractAddress: schema.Schema.optional(FieldElement$1),
-    classHash: schema.Schema.optional(FieldElement$1)
-  })
+const ReplacedClass = codec.MessageCodec({
+  contractAddress: codec.OptionalCodec(FieldElement$1),
+  classHash: codec.OptionalCodec(FieldElement$1)
 });
-const DeployedContract = schema.Schema.Struct({
-  _tag: tag("deployedContract"),
-  deployedContract: schema.Schema.Struct({
-    contractAddress: schema.Schema.optional(FieldElement$1),
-    classHash: schema.Schema.optional(FieldElement$1)
-  })
+const DeployedContract = codec.MessageCodec({
+  contractAddress: codec.OptionalCodec(FieldElement$1),
+  classHash: codec.OptionalCodec(FieldElement$1)
 });
-const ContractChange = schema.Schema.Struct({
-  filterIds: schema.Schema.Array(schema.Schema.Number),
-  change: schema.Schema.Union(DeclaredClass, ReplacedClass, DeployedContract)
-});
-const NonceUpdate = schema.Schema.Struct({
-  filterIds: schema.Schema.Array(schema.Schema.Number),
-  contractAddress: FieldElement$1,
-  nonce: FieldElement$1
+const ContractChange = codec.MessageCodec({
+  filterIds: codec.ArrayCodec(codec.NumberCodec),
+  change: codec.RequiredCodec(
+    codec.OneOfCodec({
+      declaredClass: DeclaredClass,
+      replacedClass: ReplacedClass,
+      deployedContract: DeployedContract
+    })
+  )
 });
-const Block = schema.Schema.Struct({
-  header: BlockHeader,
-  transactions: schema.Schema.Array(Transaction),
-  receipts: schema.Schema.Array(TransactionReceipt),
-  events: schema.Schema.Array(Event),
-  messages: schema.Schema.Array(MessageToL1),
-  storageDiffs: schema.Schema.Array(StorageDiff),
-  contractChanges: schema.Schema.Array(ContractChange),
-  nonceUpdates: schema.Schema.Array(NonceUpdate)
+const NonceUpdate = codec.MessageCodec({
+  filterIds: codec.ArrayCodec(codec.NumberCodec),
+  contractAddress: codec.RequiredCodec(FieldElement$1),
+  nonce: codec.RequiredCodec(FieldElement$1)
 });
-const BlockFromBytes = schema.Schema.transform(
-  schema.Schema.Uint8ArrayFromSelf,
-  schema.Schema.NullOr(Block),
-  {
-    strict: false,
-    decode(value) {
-      if (value.length === 0) {
-        return null;
-      }
-      return Block$1.decode(value);
-    },
-    encode(value) {
-      if (value === null) {
-        return new Uint8Array();
-      }
-      return Block$1.encode(value).finish();
-    }
-  }
-);
-
-const HeaderFilter = schema.Schema.transform(
-  schema.Schema.Enums(HeaderFilter$1),
-  schema.Schema.Literal("always", "on_data", "on_data_or_on_new_block", "unknown"),
-  {
-    decode(value) {
-      const enumMap = {
-        [HeaderFilter$1.ALWAYS]: "always",
-        [HeaderFilter$1.ON_DATA]: "on_data",
-        [HeaderFilter$1.ON_DATA_OR_ON_NEW_BLOCK]: "on_data_or_on_new_block",
-        [HeaderFilter$1.UNSPECIFIED]: "unknown",
-        [HeaderFilter$1.UNRECOGNIZED]: "unknown"
-      };
-      return enumMap[value] ?? "unknown";
-    },
-    encode(value) {
-      switch (value) {
-        case "always":
-          return HeaderFilter$1.ALWAYS;
-        case "on_data":
-          return HeaderFilter$1.ON_DATA;
-        case "on_data_or_on_new_block":
-          return HeaderFilter$1.ON_DATA_OR_ON_NEW_BLOCK;
-        default:
-          return HeaderFilter$1.UNSPECIFIED;
-      }
-    }
-  }
-);
-const Key = schema.Schema.transform(
-  schema.Schema.Struct({ value: schema.Schema.UndefinedOr(FieldElementProto) }),
-  schema.Schema.NullOr(FieldElement$1),
-  {
-    decode({ value }) {
-      if (value === void 0) {
-        return null;
-      }
-      return value;
-    },
-    encode(value) {
-      if (value === null) {
-        return { value: void 0 };
-      }
-      return { value };
-    }
-  }
-);
-const TransactionStatusFilter = schema.Schema.transform(
-  schema.Schema.Enums(TransactionStatusFilter$1),
-  schema.Schema.Literal("succeeded", "reverted", "all", "unknown"),
-  {
-    decode(value) {
-      const enumMap = {
-        [TransactionStatusFilter$1.SUCCEEDED]: "succeeded",
-        [TransactionStatusFilter$1.REVERTED]: "reverted",
-        [TransactionStatusFilter$1.ALL]: "all",
-        [TransactionStatusFilter$1.UNSPECIFIED]: "unknown",
-        [TransactionStatusFilter$1.UNRECOGNIZED]: "unknown"
-      };
-      return enumMap[value] ?? "unknown";
-    },
-    encode(value) {
-      switch (value) {
-        case "succeeded":
-          return TransactionStatusFilter$1.SUCCEEDED;
-        case "reverted":
-          return TransactionStatusFilter$1.REVERTED;
-        case "all":
-          return TransactionStatusFilter$1.ALL;
-        default:
-          return TransactionStatusFilter$1.UNSPECIFIED;
-      }
-    }
+const CallType = {
+  encode(x) {
+    switch (x) {
+      case "libraryCall":
+        return CallType$1.LIBRARY_CALL;
+      case "call":
+        return CallType$1.CALL;
+      case "delegate":
+        return CallType$1.DELEGATE;
+      case "unknown":
+        return CallType$1.UNSPECIFIED;
+      default:
+        return CallType$1.UNRECOGNIZED;
+    }
+  },
+  decode(p) {
+    const enumMap = {
+      [CallType$1.LIBRARY_CALL]: "libraryCall",
+      [CallType$1.CALL]: "call",
+      [CallType$1.DELEGATE]: "delegate",
+      [CallType$1.UNSPECIFIED]: "unknown",
+      [CallType$1.UNRECOGNIZED]: "unknown"
+    };
+    return enumMap[p] ?? "unknown";
   }
-);
-const EventFilter = schema.Schema.Struct({
-  id: schema.Schema.optional(schema.Schema.Number),
-  address: schema.Schema.optional(FieldElement$1),
-  keys: schema.Schema.optional(schema.Schema.Array(Key)),
-  strict: schema.Schema.optional(schema.Schema.Boolean),
-  transactionStatus: schema.Schema.optional(TransactionStatusFilter),
-  includeTransaction: schema.Schema.optional(schema.Schema.Boolean),
-  includeReceipt: schema.Schema.optional(schema.Schema.Boolean),
-  includeMessages: schema.Schema.optional(schema.Schema.Boolean),
-  includeSiblings: schema.Schema.optional(schema.Schema.Boolean)
-});
-const MessageToL1Filter = schema.Schema.Struct({
-  id: schema.Schema.optional(schema.Schema.Number),
-  fromAddress: schema.Schema.optional(FieldElement$1),
-  toAddress: schema.Schema.optional(FieldElement$1),
-  transactionStatus: schema.Schema.optional(TransactionStatusFilter),
-  includeTransaction: schema.Schema.optional(schema.Schema.Boolean),
-  includeReceipt: schema.Schema.optional(schema.Schema.Boolean),
-  includeEvents: schema.Schema.optional(schema.Schema.Boolean)
-});
-const InvokeTransactionV0Filter = schema.Schema.Struct({
-  _tag: tag("invokeV0"),
-  invokeV0: schema.Schema.Struct({})
-});
-const InvokeTransactionV1Filter = schema.Schema.Struct({
-  _tag: tag("invokeV1"),
-  invokeV1: schema.Schema.Struct({})
+};
+const _FunctionInvocationCodec = codec.MessageCodec({
+  contractAddress: codec.RequiredCodec(FieldElement$1),
+  entryPointSelector: codec.RequiredCodec(FieldElement$1),
+  calldata: codec.ArrayCodec(FieldElement$1),
+  callerAddress: codec.RequiredCodec(FieldElement$1),
+  classHash: codec.RequiredCodec(FieldElement$1),
+  callType: codec.RequiredCodec(CallType),
+  result: codec.ArrayCodec(FieldElement$1),
+  events: codec.ArrayCodec(codec.NumberCodec),
+  messages: codec.ArrayCodec(codec.NumberCodec)
 });
-const InvokeTransactionV3Filter = schema.Schema.Struct({
-  _tag: tag("invokeV3"),
-  invokeV3: schema.Schema.Struct({})
+const FunctionInvocationCodec = {
+  encode(x) {
+    const { calls, ...rest } = x;
+    const encodedCalls = calls.map(FunctionInvocationCodec.encode);
+    const encodedRest = _FunctionInvocationCodec.encode(rest);
+    return { calls: encodedCalls, ...encodedRest };
+  },
+  decode(p) {
+    const { calls = [], ...rest } = p;
+    const decodedCalls = calls.map(FunctionInvocationCodec.decode);
+    const decodedRest = _FunctionInvocationCodec.decode(rest);
+    return { ...decodedRest, calls: decodedCalls };
+  }
+};
+const ExecuteInvocationSuccess = FunctionInvocationCodec;
+const ExecuteInvocationReverted = codec.MessageCodec({
+  reason: codec.OptionalCodec(codec.StringCodec)
 });
-const DeployTransactionFilter = schema.Schema.Struct({
-  _tag: tag("deploy"),
-  deploy: schema.Schema.Struct({})
+const InvokeTransactionTrace = codec.MessageCodec({
+  validateInvocation: codec.OptionalCodec(FunctionInvocationCodec),
+  executeInvocation: codec.RequiredCodec(
+    codec.OneOfCodec({
+      success: ExecuteInvocationSuccess,
+      reverted: ExecuteInvocationReverted
+    })
+  ),
+  feeTransferInvocation: codec.OptionalCodec(FunctionInvocationCodec)
 });
-const DeclareV0TransactionFilter = schema.Schema.Struct({
-  _tag: tag("declareV0"),
-  declareV0: schema.Schema.Struct({})
+const DeclareTransactionTrace = codec.MessageCodec({
+  validateInvocation: codec.OptionalCodec(FunctionInvocationCodec),
+  feeTransferInvocation: codec.OptionalCodec(FunctionInvocationCodec)
 });
-const DeclareV1TransactionFilter = schema.Schema.Struct({
-  _tag: tag("declareV1"),
-  declareV1: schema.Schema.Struct({})
+const DeployAccountTransactionTrace = codec.MessageCodec({
+  validateInvocation: codec.OptionalCodec(FunctionInvocationCodec),
+  constructorInvocation: codec.OptionalCodec(FunctionInvocationCodec),
+  feeTransferInvocation: codec.OptionalCodec(FunctionInvocationCodec)
 });
-const DeclareV2TransactionFilter = schema.Schema.Struct({
-  _tag: tag("declareV2"),
-  declareV2: schema.Schema.Struct({})
+const L1HandlerTransactionTrace = codec.MessageCodec({
+  functionInvocation: codec.OptionalCodec(FunctionInvocationCodec)
 });
-const DeclareV3TransactionFilter = schema.Schema.Struct({
-  _tag: tag("declareV3"),
-  declareV3: schema.Schema.Struct({})
+const TransactionTrace = codec.MessageCodec({
+  filterIds: codec.ArrayCodec(codec.NumberCodec),
+  transactionIndex: codec.RequiredCodec(codec.NumberCodec),
+  transactionHash: codec.RequiredCodec(FieldElement$1),
+  traceRoot: codec.RequiredCodec(
+    codec.OneOfCodec({
+      invoke: InvokeTransactionTrace,
+      declare: DeclareTransactionTrace,
+      deployAccount: DeployAccountTransactionTrace,
+      l1Handler: L1HandlerTransactionTrace
+    })
+  )
 });
-const L1HandlerTransactionFilter = schema.Schema.Struct({
-  _tag: tag("l1Handler"),
-  l1Handler: schema.Schema.Struct({})
+const Block = codec.MessageCodec({
+  header: codec.RequiredCodec(BlockHeader),
+  transactions: codec.ArrayCodec(Transaction),
+  receipts: codec.ArrayCodec(TransactionReceipt),
+  events: codec.ArrayCodec(Event),
+  messages: codec.ArrayCodec(MessageToL1),
+  traces: codec.ArrayCodec(TransactionTrace),
+  storageDiffs: codec.ArrayCodec(StorageDiff),
+  contractChanges: codec.ArrayCodec(ContractChange),
+  nonceUpdates: codec.ArrayCodec(NonceUpdate)
 });
-const DeployAccountV1TransactionFilter = schema.Schema.Struct({
-  _tag: tag("deployAccountV1"),
-  deployAccountV1: schema.Schema.Struct({})
+const BlockFromBytes = {
+  encode(x) {
+    const block = Block.encode(x);
+    return Block$1.encode(block).finish();
+  },
+  decode(p) {
+    const block = Block$1.decode(p);
+    return Block.decode(block);
+  }
+};
+
+const HeaderFilter = {
+  encode(x) {
+    switch (x) {
+      case "always":
+        return HeaderFilter$1.ALWAYS;
+      case "on_data":
+        return HeaderFilter$1.ON_DATA;
+      case "on_data_or_on_new_block":
+        return HeaderFilter$1.ON_DATA_OR_ON_NEW_BLOCK;
+      default:
+        return HeaderFilter$1.UNSPECIFIED;
+    }
+  },
+  decode(p) {
+    const enumMap = {
+      [HeaderFilter$1.ALWAYS]: "always",
+      [HeaderFilter$1.ON_DATA]: "on_data",
+      [HeaderFilter$1.ON_DATA_OR_ON_NEW_BLOCK]: "on_data_or_on_new_block",
+      [HeaderFilter$1.UNSPECIFIED]: "unknown",
+      [HeaderFilter$1.UNRECOGNIZED]: "unknown"
+    };
+    return enumMap[p] ?? "unknown";
+  }
+};
+const Key = {
+  encode(x) {
+    if (x === null) {
+      return { value: void 0 };
+    }
+    return { value: FieldElement$1.encode(x) };
+  },
+  decode(p) {
+    if (p.value === void 0) {
+      return null;
+    }
+    return FieldElement$1.decode(p.value);
+  }
+};
+const TransactionStatusFilter = {
+  encode(x) {
+    switch (x) {
+      case "succeeded":
+        return TransactionStatusFilter$1.SUCCEEDED;
+      case "reverted":
+        return TransactionStatusFilter$1.REVERTED;
+      case "all":
+        return TransactionStatusFilter$1.ALL;
+      default:
+        return TransactionStatusFilter$1.UNSPECIFIED;
+    }
+  },
+  decode(p) {
+    const enumMap = {
+      [TransactionStatusFilter$1.SUCCEEDED]: "succeeded",
+      [TransactionStatusFilter$1.REVERTED]: "reverted",
+      [TransactionStatusFilter$1.ALL]: "all",
+      [TransactionStatusFilter$1.UNSPECIFIED]: "unknown",
+      [TransactionStatusFilter$1.UNRECOGNIZED]: "unknown"
+    };
+    return enumMap[p] ?? "unknown";
+  }
+};
+const EventFilter = codec.MessageCodec({
+  id: codec.OptionalCodec(codec.NumberCodec),
+  address: codec.OptionalCodec(FieldElement$1),
+  keys: codec.OptionalCodec(codec.ArrayCodec(Key)),
+  strict: codec.OptionalCodec(codec.BooleanCodec),
+  transactionStatus: codec.OptionalCodec(TransactionStatusFilter),
+  includeTransaction: codec.OptionalCodec(codec.BooleanCodec),
+  includeReceipt: codec.OptionalCodec(codec.BooleanCodec),
+  includeMessages: codec.OptionalCodec(codec.BooleanCodec),
+  includeSiblings: codec.OptionalCodec(codec.BooleanCodec),
+  includeTransactionTrace: codec.OptionalCodec(codec.BooleanCodec)
 });
-const DeployAccountV3TransactionFilter = schema.Schema.Struct({
-  _tag: tag("deployAccountV3"),
-  deployAccountV3: schema.Schema.Struct({})
+const MessageToL1Filter = codec.MessageCodec({
+  id: codec.OptionalCodec(codec.NumberCodec),
+  fromAddress: codec.OptionalCodec(FieldElement$1),
+  toAddress: codec.OptionalCodec(FieldElement$1),
+  transactionStatus: codec.OptionalCodec(TransactionStatusFilter),
+  includeTransaction: codec.OptionalCodec(codec.BooleanCodec),
+  includeReceipt: codec.OptionalCodec(codec.BooleanCodec),
+  includeEvents: codec.OptionalCodec(codec.BooleanCodec),
+  includeTransactionTrace: codec.OptionalCodec(codec.BooleanCodec)
 });
-const TransactionFilter = schema.Schema.Struct({
-  id: schema.Schema.optional(schema.Schema.Number),
-  transactionStatus: schema.Schema.optional(TransactionStatusFilter),
-  includeReceipt: schema.Schema.optional(schema.Schema.Boolean),
-  includeMessages: schema.Schema.optional(schema.Schema.Boolean),
-  includeEvents: schema.Schema.optional(schema.Schema.Boolean),
-  transactionType: schema.Schema.optional(
-    schema.Schema.Union(
-      InvokeTransactionV0Filter,
-      InvokeTransactionV1Filter,
-      InvokeTransactionV3Filter,
-      DeployTransactionFilter,
-      DeclareV0TransactionFilter,
-      DeclareV1TransactionFilter,
-      DeclareV2TransactionFilter,
-      DeclareV3TransactionFilter,
-      DeclareV3TransactionFilter,
-      L1HandlerTransactionFilter,
-      DeployAccountV1TransactionFilter,
-      DeployAccountV3TransactionFilter
-    )
+const InvokeTransactionV0Filter = codec.MessageCodec({});
+const InvokeTransactionV1Filter = codec.MessageCodec({});
+const InvokeTransactionV3Filter = codec.MessageCodec({});
+const DeployTransactionFilter = codec.MessageCodec({});
+const DeclareV0TransactionFilter = codec.MessageCodec({});
+const DeclareV1TransactionFilter = codec.MessageCodec({});
+const DeclareV2TransactionFilter = codec.MessageCodec({});
+const DeclareV3TransactionFilter = codec.MessageCodec({});
+const L1HandlerTransactionFilter = codec.MessageCodec({});
+const DeployAccountV1TransactionFilter = codec.MessageCodec({});
+const DeployAccountV3TransactionFilter = codec.MessageCodec({});
+const TransactionFilter = codec.MessageCodec({
+  id: codec.OptionalCodec(codec.NumberCodec),
+  transactionStatus: codec.OptionalCodec(TransactionStatusFilter),
+  includeReceipt: codec.OptionalCodec(codec.BooleanCodec),
+  includeMessages: codec.OptionalCodec(codec.BooleanCodec),
+  includeEvents: codec.OptionalCodec(codec.BooleanCodec),
+  includeTrace: codec.OptionalCodec(codec.BooleanCodec),
+  transactionType: codec.OptionalCodec(
+    codec.OneOfCodec({
+      invokeV0: InvokeTransactionV0Filter,
+      invokeV1: InvokeTransactionV1Filter,
+      invokeV3: InvokeTransactionV3Filter,
+      deploy: DeployTransactionFilter,
+      declareV0: DeclareV0TransactionFilter,
+      declareV1: DeclareV1TransactionFilter,
+      declareV2: DeclareV2TransactionFilter,
+      declareV3: DeclareV3TransactionFilter,
+      l1Handler: L1HandlerTransactionFilter,
+      deployAccountV1: DeployAccountV1TransactionFilter,
+      deployAccountV3: DeployAccountV3TransactionFilter
+    })
   )
 });
-const StorageDiffFilter = schema.Schema.Struct({
-  id: schema.Schema.optional(schema.Schema.Number),
-  contractAddress: schema.Schema.optional(FieldElement$1)
-});
-const DeclaredClassFilter = schema.Schema.Struct({
-  _tag: tag("declaredClass"),
-  declaredClass: schema.Schema.Struct({})
+const StorageDiffFilter = codec.MessageCodec({
+  id: codec.OptionalCodec(codec.NumberCodec),
+  contractAddress: codec.OptionalCodec(FieldElement$1)
 });
-const ReplacedClassFilter = schema.Schema.Struct({
-  _tag: tag("replacedClass"),
-  replacedClass: schema.Schema.Struct({})
-});
-const DeployedContractFilter = schema.Schema.Struct({
-  _tag: tag("deployedContract"),
-  deployedContract: schema.Schema.Struct({})
-});
-const ContractChangeFilter = schema.Schema.Struct({
-  id: schema.Schema.optional(schema.Schema.Number),
-  change: schema.Schema.optional(
-    schema.Schema.Union(
-      DeclaredClassFilter,
-      ReplacedClassFilter,
-      DeployedContractFilter
-    )
+const DeclaredClassFilter = codec.MessageCodec({});
+const ReplacedClassFilter = codec.MessageCodec({});
+const DeployedContractFilter = codec.MessageCodec({});
+const ContractChangeFilter = codec.MessageCodec({
+  id: codec.OptionalCodec(codec.NumberCodec),
+  change: codec.OptionalCodec(
+    codec.OneOfCodec({
+      declaredClass: DeclaredClassFilter,
+      replacedClass: ReplacedClassFilter,
+      deployedContract: DeployedContractFilter
+    })
   )
 });
-const NonceUpdateFilter = schema.Schema.Struct({
-  id: schema.Schema.optional(schema.Schema.Number),
-  contractAddress: schema.Schema.optional(FieldElement$1)
+const NonceUpdateFilter = codec.MessageCodec({
+  id: codec.OptionalCodec(codec.NumberCodec),
+  contractAddress: codec.OptionalCodec(FieldElement$1)
 });
-const Filter = schema.Schema.Struct({
-  header: schema.Schema.optional(HeaderFilter),
-  transactions: schema.Schema.optional(schema.Schema.Array(TransactionFilter)),
-  events: schema.Schema.optional(schema.Schema.Array(EventFilter)),
-  messages: schema.Schema.optional(schema.Schema.Array(MessageToL1Filter)),
-  storageDiffs: schema.Schema.optional(schema.Schema.Array(StorageDiffFilter)),
-  contractChanges: schema.Schema.optional(schema.Schema.Array(ContractChangeFilter)),
-  nonceUpdates: schema.Schema.optional(schema.Schema.Array(NonceUpdateFilter))
+const Filter = codec.MessageCodec({
+  header: codec.OptionalCodec(HeaderFilter),
+  transactions: codec.OptionalCodec(codec.ArrayCodec(TransactionFilter)),
+  events: codec.OptionalCodec(codec.ArrayCodec(EventFilter)),
+  messages: codec.OptionalCodec(codec.ArrayCodec(MessageToL1Filter)),
+  storageDiffs: codec.OptionalCodec(codec.ArrayCodec(StorageDiffFilter)),
+  contractChanges: codec.OptionalCodec(codec.ArrayCodec(ContractChangeFilter)),
+  nonceUpdates: codec.OptionalCodec(codec.ArrayCodec(NonceUpdateFilter))
 });
-const filterToProto = schema.Schema.encodeSync(Filter);
-const filterFromProto = schema.Schema.decodeSync(Filter);
-const FilterFromBytes = schema.Schema.transform(
-  schema.Schema.Uint8ArrayFromSelf,
-  Filter,
-  {
-    strict: false,
-    decode(value) {
-      return Filter$1.decode(value);
-    },
-    encode(value) {
-      return Filter$1.encode(value).finish();
-    }
+const FilterFromBytes = {
+  encode(x) {
+    const filter = Filter.encode(x);
+    return Filter$1.encode(filter).finish();
+  },
+  decode(p) {
+    const filter = Filter$1.decode(p);
+    return Filter.decode(filter);
   }
-);
-const filterToBytes = schema.Schema.encodeSync(FilterFromBytes);
-const filterFromBytes = schema.Schema.decodeSync(FilterFromBytes);
+};
 function mergeFilter(a, b) {
   const header = mergeHeaderFilter(a.header, b.header);
   return {
@@ -7484,6 +8342,7 @@ const PrimitiveTypeParsers = {
   "core::integer::u64": parser.parseU64,
   "core::integer::u128": parser.parseU128,
   "core::integer::u256": parser.parseU256,
+  "core::bytes_31::bytes31": parser.parseBytes31,
   "core::starknet::contract_address::ContractAddress": parser.parseContractAddress
 };
 function isPrimitiveType(type) {
@@ -7510,6 +8369,19 @@ function getOptionType(type) {
 function isEmptyType(type) {
   return type === "()";
 }
+function isByteArray(type) {
+  return type === "core::byte_array::ByteArray";
+}
+
+function isEventAbi(item) {
+  return item.type === "event";
+}
+function isStructEventAbi(item) {
+  return isEventAbi(item) && item.kind === "struct";
+}
+function isEnumEventAbi(item) {
+  return isEventAbi(item) && item.kind === "enum";
+}
 
 class DecodeEventError extends Error {
   constructor(message) {
@@ -7522,50 +8394,120 @@ function decodeEvent(args) {
   const eventAbi = abi.find(
     (item) => item.name === eventName && item.type === "event"
   );
-  if (!eventAbi || eventAbi.type !== "event") {
+  if (!eventAbi || !isEventAbi(eventAbi)) {
     if (strict) {
       throw new DecodeEventError(`Event ${eventName} not found in ABI`);
     }
     return null;
   }
-  if (eventAbi.kind === "enum") {
-    throw new DecodeEventError("enum: not implemented");
+  try {
+    if (isStructEventAbi(eventAbi)) {
+      return decodeStructEvent(abi, eventAbi, event, eventName);
+    }
+    if (isEnumEventAbi(eventAbi)) {
+      return decodeEnumEvent(abi, eventAbi, event, eventName);
+    }
+    throw new DecodeEventError(
+      `Unsupported event kind: ${eventAbi?.kind}`
+    );
+  } catch (error) {
+    if ((error instanceof DecodeEventError || error instanceof parser.ParseError) && !strict) {
+      return null;
+    }
+    throw error;
   }
+}
+function decodeStructEvent(abi, eventAbi, event, eventName) {
   const selector = BigInt(getEventSelector(eventName));
   if (event.keys && selector !== BigInt(event.keys[0]) || !event.keys) {
-    if (strict) {
-      throw new DecodeEventError(
-        `Selector mismatch. Expected ${selector}, got ${event.keys?.[0]}`
-      );
-    }
-    return null;
+    throw new DecodeEventError(
+      `Selector mismatch. Expected ${selector}, got ${event.keys?.[0]}`
+    );
   }
   const keysAbi = eventAbi.members.filter((m) => m.kind === "key");
   const dataAbi = eventAbi.members.filter((m) => m.kind === "data");
-  try {
-    const keysParser = compileEventMembers(abi, keysAbi);
-    const dataParser = compileEventMembers(abi, dataAbi);
-    const keysWithoutSelector = event.keys?.slice(1) ?? [];
-    const { out: decodedKeys } = keysParser(keysWithoutSelector, 0);
-    const { out: decodedData } = dataParser(event.data ?? [], 0);
-    const decoded = {
-      ...decodedKeys,
-      ...decodedData
-    };
-    return {
-      ...event,
-      eventName,
-      args: decoded
-    };
-  } catch (error) {
-    if (error instanceof DecodeEventError && !strict) {
-      return null;
+  const keysParser = compileEventMembers(abi, keysAbi);
+  const dataParser = compileEventMembers(abi, dataAbi);
+  const keysWithoutSelector = event.keys?.slice(1) ?? [];
+  const { out: decodedKeys } = keysParser(keysWithoutSelector, 0);
+  const { out: decodedData } = dataParser(event.data ?? [], 0);
+  const decoded = {
+    ...decodedKeys,
+    ...decodedData
+  };
+  return {
+    ...event,
+    eventName,
+    args: decoded
+  };
+}
+function decodeEnumEvent(abi, eventAbi, event, eventName) {
+  if (!event.keys || event.keys.length === 0) {
+    throw new DecodeEventError(
+      "Event has no keys; cannot determine variant selector"
+    );
+  }
+  const variants = eventAbi.variants;
+  const variantSelector = event.keys[0];
+  const selectorToVariant = buildVariantSelectorMap(abi, variants);
+  const matchingVariant = selectorToVariant[variantSelector];
+  if (!matchingVariant) {
+    throw new DecodeEventError(
+      `No matching variant found for selector: ${variantSelector}`
+    );
+  }
+  const structEventAbi = abi.find(
+    (item) => item.name === matchingVariant.variant.type && item.type === "event"
+  );
+  if (!structEventAbi || !isStructEventAbi(structEventAbi)) {
+    throw new DecodeEventError(
+      `Nested event type not found or not a struct: ${matchingVariant.variant.type}`
+    );
+  }
+  const decodedStruct = decodeStructEvent(
+    abi,
+    structEventAbi,
+    event,
+    matchingVariant.variant.name
+  );
+  return {
+    ...event,
+    eventName,
+    args: {
+      _tag: matchingVariant.variant.name,
+      [matchingVariant.variant.name]: decodedStruct.args
     }
-    if (error instanceof parser.ParseError && !strict) {
-      return null;
+  };
+}
+function buildVariantSelectorMap(abi, variants) {
+  const selectorMap = {};
+  for (const variant of variants) {
+    if (variant.kind === "nested") {
+      const selector = getEventSelector(variant.name);
+      selectorMap[selector] = { variant, path: [variant.name] };
+    } else if (variant.kind === "flat") {
+      const flatEventName = variant.type;
+      const flatEventAbi = abi.find(
+        (item) => item.name === flatEventName && item.type === "event"
+      );
+      if (!flatEventAbi) {
+        continue;
+      }
+      if (isEnumEventAbi(flatEventAbi)) {
+        const nestedMap = buildVariantSelectorMap(abi, flatEventAbi.variants);
+        for (const [
+          nestedSelector,
+          { variant: nestedVariant, path: nestedPath }
+        ] of Object.entries(nestedMap)) {
+          selectorMap[nestedSelector] = {
+            variant: nestedVariant,
+            path: [variant.name, ...nestedPath]
+          };
+        }
+      }
     }
-    throw error;
   }
+  return selectorMap;
 }
 function compileEventMembers(abi, members) {
   return compileStructParser(abi, members);
@@ -7589,6 +8531,9 @@ function compileTypeParser(abi, type) {
   if (isEmptyType(type)) {
     return parser.parseEmpty;
   }
+  if (isByteArray(type)) {
+    return parser.parseByteArray;
+  }
   const typeAbi = abi.find((item) => item.name === type);
   if (!typeAbi) {
     throw new DecodeEventError(`Type ${type} not found in ABI`);
@@ -7597,8 +8542,9 @@ function compileTypeParser(abi, type) {
     case "struct": {
       return compileStructParser(abi, typeAbi.members);
     }
-    case "enum":
-      throw new DecodeEventError("enum: not implemented");
+    case "enum": {
+      return compileEnumParser(abi, typeAbi);
+    }
     default:
       throw new DecodeEventError(`Invalid type ${typeAbi.type}`);
   }
@@ -7613,22 +8559,35 @@ function compileStructParser(abi, members) {
   }
   return parser.parseStruct(parsers);
 }
+function compileEnumParser(abi, enumAbi) {
+  const parsers = {};
+  for (const [index, variant] of enumAbi.variants.entries()) {
+    parsers[variant.name] = {
+      index,
+      parser: compileTypeParser(abi, variant.type)
+    };
+  }
+  return parser.parseEnum(parsers);
+}
 
 const StarknetStream = new protocol.StreamConfig(
   FilterFromBytes,
   BlockFromBytes,
-  mergeFilter
+  mergeFilter,
+  "starknet"
 );
 
 exports.Block = Block;
 exports.BlockFromBytes = BlockFromBytes;
 exports.BlockHeader = BlockHeader;
+exports.CallType = CallType;
 exports.ComputationResources = ComputationResources;
 exports.ContractChange = ContractChange;
 exports.ContractChangeFilter = ContractChangeFilter;
 exports.DataAvailabilityMode = DataAvailabilityMode;
 exports.DataAvailabilityResources = DataAvailabilityResources;
 exports.DeclareTransactionReceipt = DeclareTransactionReceipt;
+exports.DeclareTransactionTrace = DeclareTransactionTrace;
 exports.DeclareTransactionV0 = DeclareTransactionV0;
 exports.DeclareTransactionV1 = DeclareTransactionV1;
 exports.DeclareTransactionV2 = DeclareTransactionV2;
@@ -7641,6 +8600,7 @@ exports.DeclaredClass = DeclaredClass;
 exports.DeclaredClassFilter = DeclaredClassFilter;
 exports.DecodeEventError = DecodeEventError;
 exports.DeployAccountTransactionReceipt = DeployAccountTransactionReceipt;
+exports.DeployAccountTransactionTrace = DeployAccountTransactionTrace;
 exports.DeployAccountTransactionV1 = DeployAccountTransactionV1;
 exports.DeployAccountTransactionV3 = DeployAccountTransactionV3;
 exports.DeployAccountV1TransactionFilter = DeployAccountV1TransactionFilter;
@@ -7652,16 +8612,18 @@ exports.DeployedContract = DeployedContract;
 exports.DeployedContractFilter = DeployedContractFilter;
 exports.Event = Event;
 exports.EventFilter = EventFilter;
+exports.ExecuteInvocationReverted = ExecuteInvocationReverted;
+exports.ExecuteInvocationSuccess = ExecuteInvocationSuccess;
 exports.ExecutionResources = ExecutionResources;
 exports.ExecutionReverted = ExecutionReverted;
 exports.ExecutionSucceeded = ExecutionSucceeded;
 exports.FeePayment = FeePayment;
 exports.FieldElement = FieldElement$1;
-exports.FieldElementProto = FieldElementProto;
 exports.Filter = Filter;
 exports.FilterFromBytes = FilterFromBytes;
 exports.HeaderFilter = HeaderFilter;
 exports.InvokeTransactionReceipt = InvokeTransactionReceipt;
+exports.InvokeTransactionTrace = InvokeTransactionTrace;
 exports.InvokeTransactionV0 = InvokeTransactionV0;
 exports.InvokeTransactionV0Filter = InvokeTransactionV0Filter;
 exports.InvokeTransactionV1 = InvokeTransactionV1;
@@ -7673,6 +8635,7 @@ exports.L1DataAvailabilityMode = L1DataAvailabilityMode;
 exports.L1HandlerTransaction = L1HandlerTransaction;
 exports.L1HandlerTransactionFilter = L1HandlerTransactionFilter;
 exports.L1HandlerTransactionReceipt = L1HandlerTransactionReceipt;
+exports.L1HandlerTransactionTrace = L1HandlerTransactionTrace;
 exports.MessageToL1 = MessageToL1;
 exports.MessageToL1Filter = MessageToL1Filter;
 exports.NonceUpdate = NonceUpdate;
@@ -7694,14 +8657,9 @@ exports.TransactionReceipt = TransactionReceipt;
 exports.TransactionReceiptMeta = TransactionReceiptMeta;
 exports.TransactionStatus = TransactionStatus;
 exports.TransactionStatusFilter = TransactionStatusFilter;
+exports.TransactionTrace = TransactionTrace;
 exports.U128 = U128;
 exports.decodeEvent = decodeEvent;
-exports.feltFromProto = feltFromProto;
-exports.feltToProto = feltToProto;
-exports.filterFromBytes = filterFromBytes;
-exports.filterFromProto = filterFromProto;
-exports.filterToBytes = filterToBytes;
-exports.filterToProto = filterToProto;
 exports.getBigIntSelector = getBigIntSelector;
 exports.getEventSelector = getEventSelector;
 exports.getReceipt = getReceipt;
@@ -7709,3 +8667,4 @@ exports.getSelector = getSelector;
 exports.getTransaction = getTransaction;
 exports.mergeFilter = mergeFilter;
 exports.proto = index;
+//# sourceMappingURL=index.cjs.map