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

package/src/proto/filter.ts

@@ -5,13 +5,58 @@
 // source: filter.proto
 
 /* eslint-disable */
-import _m0 from "protobufjs/minimal";
-import { FieldElement } from "./common";
+import _m0 from "protobufjs/minimal.js";
+import { FieldElement } from "./common.js";
 
 export const protobufPackage = "starknet.v2";
 
 /** Starknet DNA definitions (filter). */
 
+export enum HeaderFilter {
+  UNSPECIFIED = 0,
+  ALWAYS = 1,
+  ON_DATA = 2,
+  ON_DATA_OR_ON_NEW_BLOCK = 3,
+  UNRECOGNIZED = -1,
+}
+
+export function headerFilterFromJSON(object: any): HeaderFilter {
+  switch (object) {
+    case 0:
+    case "HEADER_FILTER_UNSPECIFIED":
+      return HeaderFilter.UNSPECIFIED;
+    case 1:
+    case "HEADER_FILTER_ALWAYS":
+      return HeaderFilter.ALWAYS;
+    case 2:
+    case "HEADER_FILTER_ON_DATA":
+      return HeaderFilter.ON_DATA;
+    case 3:
+    case "HEADER_FILTER_ON_DATA_OR_ON_NEW_BLOCK":
+      return HeaderFilter.ON_DATA_OR_ON_NEW_BLOCK;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return HeaderFilter.UNRECOGNIZED;
+  }
+}
+
+export function headerFilterToJSON(object: HeaderFilter): string {
+  switch (object) {
+    case HeaderFilter.UNSPECIFIED:
+      return "HEADER_FILTER_UNSPECIFIED";
+    case HeaderFilter.ALWAYS:
+      return "HEADER_FILTER_ALWAYS";
+    case HeaderFilter.ON_DATA:
+      return "HEADER_FILTER_ON_DATA";
+    case HeaderFilter.ON_DATA_OR_ON_NEW_BLOCK:
+      return "HEADER_FILTER_ON_DATA_OR_ON_NEW_BLOCK";
+    case HeaderFilter.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
 export enum TransactionStatusFilter {
   UNSPECIFIED = 0,
   SUCCEEDED = 1,
@@ -71,12 +116,19 @@ export interface Filter {
     | readonly EventFilter[]
     | undefined;
   /** Filter messages to L1. */
-  readonly messages?: readonly MessageToL1Filter[] | undefined;
-}
-
-export interface HeaderFilter {
-  /** Always include header data. Defaults to `false`. */
-  readonly always?: boolean | undefined;
+  readonly messages?:
+    | readonly MessageToL1Filter[]
+    | undefined;
+  /** Filter storage diffs. */
+  readonly storageDiffs?:
+    | readonly StorageDiffFilter[]
+    | undefined;
+  /** Filter contract changes. */
+  readonly contractChanges?:
+    | readonly ContractChangeFilter[]
+    | undefined;
+  /** Filter nonce updates. */
+  readonly nonceUpdates?: readonly NonceUpdateFilter[] | undefined;
 }
 
 /** Filter events. */
@@ -281,14 +333,56 @@ export interface DeployAccountV1TransactionFilter {
 export interface DeployAccountV3TransactionFilter {
 }
 
+export interface StorageDiffFilter {
+  readonly id?:
+    | number
+    | undefined;
+  /** Filter by contract address. */
+  readonly contractAddress?: FieldElement | undefined;
+}
+
+export interface ContractChangeFilter {
+  readonly id?: number | undefined;
+  readonly change?:
+    | { readonly $case: "declaredClass"; readonly declaredClass: DeclaredClassFilter }
+    | { readonly $case: "replacedClass"; readonly replacedClass: ReplacedClassFilter }
+    | { readonly $case: "deployedContract"; readonly deployedContract: DeployedContractFilter }
+    | undefined;
+}
+
+export interface DeclaredClassFilter {
+}
+
+export interface ReplacedClassFilter {
+}
+
+export interface DeployedContractFilter {
+}
+
+export interface NonceUpdateFilter {
+  readonly id?:
+    | number
+    | undefined;
+  /** Filter by contract address. */
+  readonly contractAddress?: FieldElement | undefined;
+}
+
 function createBaseFilter(): Filter {
-  return { header: undefined, transactions: [], events: [], messages: [] };
+  return {
+    header: 0,
+    transactions: [],
+    events: [],
+    messages: [],
+    storageDiffs: [],
+    contractChanges: [],
+    nonceUpdates: [],
+  };
 }
 
 export const Filter = {
   encode(message: Filter, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.header !== undefined) {
-      HeaderFilter.encode(message.header, writer.uint32(10).fork()).ldelim();
+    if (message.header !== undefined && message.header !== 0) {
+      writer.uint32(8).int32(message.header);
     }
     if (message.transactions !== undefined && message.transactions.length !== 0) {
       for (const v of message.transactions) {
@@ -305,6 +399,21 @@ export const Filter = {
         MessageToL1Filter.encode(v!, writer.uint32(34).fork()).ldelim();
       }
     }
+    if (message.storageDiffs !== undefined && message.storageDiffs.length !== 0) {
+      for (const v of message.storageDiffs) {
+        StorageDiffFilter.encode(v!, writer.uint32(42).fork()).ldelim();
+      }
+    }
+    if (message.contractChanges !== undefined && message.contractChanges.length !== 0) {
+      for (const v of message.contractChanges) {
+        ContractChangeFilter.encode(v!, writer.uint32(50).fork()).ldelim();
+      }
+    }
+    if (message.nonceUpdates !== undefined && message.nonceUpdates.length !== 0) {
+      for (const v of message.nonceUpdates) {
+        NonceUpdateFilter.encode(v!, writer.uint32(58).fork()).ldelim();
+      }
+    }
     return writer;
   },
 
@@ -316,11 +425,11 @@ export const Filter = {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          if (tag !== 10) {
+          if (tag !== 8) {
             break;
           }
 
-          message.header = HeaderFilter.decode(reader, reader.uint32());
+          message.header = reader.int32() as any;
           continue;
         case 2:
           if (tag !== 18) {
@@ -343,6 +452,27 @@ export const Filter = {
 
           message.messages!.push(MessageToL1Filter.decode(reader, reader.uint32()));
           continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
+
+          message.storageDiffs!.push(StorageDiffFilter.decode(reader, reader.uint32()));
+          continue;
+        case 6:
+          if (tag !== 50) {
+            break;
+          }
+
+          message.contractChanges!.push(ContractChangeFilter.decode(reader, reader.uint32()));
+          continue;
+        case 7:
+          if (tag !== 58) {
+            break;
+          }
+
+          message.nonceUpdates!.push(NonceUpdateFilter.decode(reader, reader.uint32()));
+          continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -354,7 +484,7 @@ export const Filter = {
 
   fromJSON(object: any): Filter {
     return {
-      header: isSet(object.header) ? HeaderFilter.fromJSON(object.header) : undefined,
+      header: isSet(object.header) ? headerFilterFromJSON(object.header) : 0,
       transactions: globalThis.Array.isArray(object?.transactions)
         ? object.transactions.map((e: any) => TransactionFilter.fromJSON(e))
         : [],
@@ -362,13 +492,22 @@ export const Filter = {
       messages: globalThis.Array.isArray(object?.messages)
         ? object.messages.map((e: any) => MessageToL1Filter.fromJSON(e))
         : [],
+      storageDiffs: globalThis.Array.isArray(object?.storageDiffs)
+        ? object.storageDiffs.map((e: any) => StorageDiffFilter.fromJSON(e))
+        : [],
+      contractChanges: globalThis.Array.isArray(object?.contractChanges)
+        ? object.contractChanges.map((e: any) => ContractChangeFilter.fromJSON(e))
+        : [],
+      nonceUpdates: globalThis.Array.isArray(object?.nonceUpdates)
+        ? object.nonceUpdates.map((e: any) => NonceUpdateFilter.fromJSON(e))
+        : [],
     };
   },
 
   toJSON(message: Filter): unknown {
     const obj: any = {};
-    if (message.header !== undefined) {
-      obj.header = HeaderFilter.toJSON(message.header);
+    if (message.header !== undefined && message.header !== 0) {
+      obj.header = headerFilterToJSON(message.header);
     }
     if (message.transactions?.length) {
       obj.transactions = message.transactions.map((e) => TransactionFilter.toJSON(e));
@@ -379,6 +518,15 @@ export const Filter = {
     if (message.messages?.length) {
       obj.messages = message.messages.map((e) => MessageToL1Filter.toJSON(e));
     }
+    if (message.storageDiffs?.length) {
+      obj.storageDiffs = message.storageDiffs.map((e) => StorageDiffFilter.toJSON(e));
+    }
+    if (message.contractChanges?.length) {
+      obj.contractChanges = message.contractChanges.map((e) => ContractChangeFilter.toJSON(e));
+    }
+    if (message.nonceUpdates?.length) {
+      obj.nonceUpdates = message.nonceUpdates.map((e) => NonceUpdateFilter.toJSON(e));
+    }
     return obj;
   },
 
@@ -387,69 +535,13 @@ export const Filter = {
   },
   fromPartial(object: DeepPartial<Filter>): Filter {
     const message = createBaseFilter() as any;
-    message.header = (object.header !== undefined && object.header !== null)
-      ? HeaderFilter.fromPartial(object.header)
-      : undefined;
+    message.header = object.header ?? 0;
     message.transactions = object.transactions?.map((e) => TransactionFilter.fromPartial(e)) || [];
     message.events = object.events?.map((e) => EventFilter.fromPartial(e)) || [];
     message.messages = object.messages?.map((e) => MessageToL1Filter.fromPartial(e)) || [];
-    return message;
-  },
-};
-
-function createBaseHeaderFilter(): HeaderFilter {
-  return { always: undefined };
-}
-
-export const HeaderFilter = {
-  encode(message: HeaderFilter, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.always !== undefined) {
-      writer.uint32(8).bool(message.always);
-    }
-    return writer;
-  },
-
-  decode(input: _m0.Reader | Uint8Array, length?: number): HeaderFilter {
-    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseHeaderFilter() as any;
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 1:
-          if (tag !== 8) {
-            break;
-          }
-
-          message.always = reader.bool();
-          continue;
-      }
-      if ((tag & 7) === 4 || tag === 0) {
-        break;
-      }
-      reader.skipType(tag & 7);
-    }
-    return message;
-  },
-
-  fromJSON(object: any): HeaderFilter {
-    return { always: isSet(object.always) ? globalThis.Boolean(object.always) : undefined };
-  },
-
-  toJSON(message: HeaderFilter): unknown {
-    const obj: any = {};
-    if (message.always !== undefined) {
-      obj.always = message.always;
-    }
-    return obj;
-  },
-
-  create(base?: DeepPartial<HeaderFilter>): HeaderFilter {
-    return HeaderFilter.fromPartial(base ?? {});
-  },
-  fromPartial(object: DeepPartial<HeaderFilter>): HeaderFilter {
-    const message = createBaseHeaderFilter() as any;
-    message.always = object.always ?? undefined;
+    message.storageDiffs = object.storageDiffs?.map((e) => StorageDiffFilter.fromPartial(e)) || [];
+    message.contractChanges = object.contractChanges?.map((e) => ContractChangeFilter.fromPartial(e)) || [];
+    message.nonceUpdates = object.nonceUpdates?.map((e) => NonceUpdateFilter.fromPartial(e)) || [];
     return message;
   },
 };
@@ -1725,6 +1817,433 @@ export const DeployAccountV3TransactionFilter = {
   },
 };
 
+function createBaseStorageDiffFilter(): StorageDiffFilter {
+  return { id: 0, contractAddress: undefined };
+}
+
+export const StorageDiffFilter = {
+  encode(message: StorageDiffFilter, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.id !== undefined && message.id !== 0) {
+      writer.uint32(8).uint32(message.id);
+    }
+    if (message.contractAddress !== undefined) {
+      FieldElement.encode(message.contractAddress, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): StorageDiffFilter {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseStorageDiffFilter() as any;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.id = reader.uint32();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.contractAddress = FieldElement.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): StorageDiffFilter {
+    return {
+      id: isSet(object.id) ? globalThis.Number(object.id) : 0,
+      contractAddress: isSet(object.contractAddress) ? FieldElement.fromJSON(object.contractAddress) : undefined,
+    };
+  },
+
+  toJSON(message: StorageDiffFilter): unknown {
+    const obj: any = {};
+    if (message.id !== undefined && message.id !== 0) {
+      obj.id = Math.round(message.id);
+    }
+    if (message.contractAddress !== undefined) {
+      obj.contractAddress = FieldElement.toJSON(message.contractAddress);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<StorageDiffFilter>): StorageDiffFilter {
+    return StorageDiffFilter.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<StorageDiffFilter>): StorageDiffFilter {
+    const message = createBaseStorageDiffFilter() as any;
+    message.id = object.id ?? 0;
+    message.contractAddress = (object.contractAddress !== undefined && object.contractAddress !== null)
+      ? FieldElement.fromPartial(object.contractAddress)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseContractChangeFilter(): ContractChangeFilter {
+  return { id: 0, change: undefined };
+}
+
+export const ContractChangeFilter = {
+  encode(message: ContractChangeFilter, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.id !== undefined && message.id !== 0) {
+      writer.uint32(8).uint32(message.id);
+    }
+    switch (message.change?.$case) {
+      case "declaredClass":
+        DeclaredClassFilter.encode(message.change.declaredClass, writer.uint32(18).fork()).ldelim();
+        break;
+      case "replacedClass":
+        ReplacedClassFilter.encode(message.change.replacedClass, writer.uint32(26).fork()).ldelim();
+        break;
+      case "deployedContract":
+        DeployedContractFilter.encode(message.change.deployedContract, writer.uint32(34).fork()).ldelim();
+        break;
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ContractChangeFilter {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseContractChangeFilter() as any;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.id = reader.uint32();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.change = {
+            $case: "declaredClass",
+            declaredClass: DeclaredClassFilter.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.change = {
+            $case: "replacedClass",
+            replacedClass: ReplacedClassFilter.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.change = {
+            $case: "deployedContract",
+            deployedContract: DeployedContractFilter.decode(reader, reader.uint32()),
+          };
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): ContractChangeFilter {
+    return {
+      id: isSet(object.id) ? globalThis.Number(object.id) : 0,
+      change: isSet(object.declaredClass)
+        ? { $case: "declaredClass", declaredClass: DeclaredClassFilter.fromJSON(object.declaredClass) }
+        : isSet(object.replacedClass)
+        ? { $case: "replacedClass", replacedClass: ReplacedClassFilter.fromJSON(object.replacedClass) }
+        : isSet(object.deployedContract)
+        ? { $case: "deployedContract", deployedContract: DeployedContractFilter.fromJSON(object.deployedContract) }
+        : undefined,
+    };
+  },
+
+  toJSON(message: ContractChangeFilter): unknown {
+    const obj: any = {};
+    if (message.id !== undefined && message.id !== 0) {
+      obj.id = Math.round(message.id);
+    }
+    if (message.change?.$case === "declaredClass") {
+      obj.declaredClass = DeclaredClassFilter.toJSON(message.change.declaredClass);
+    }
+    if (message.change?.$case === "replacedClass") {
+      obj.replacedClass = ReplacedClassFilter.toJSON(message.change.replacedClass);
+    }
+    if (message.change?.$case === "deployedContract") {
+      obj.deployedContract = DeployedContractFilter.toJSON(message.change.deployedContract);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<ContractChangeFilter>): ContractChangeFilter {
+    return ContractChangeFilter.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<ContractChangeFilter>): ContractChangeFilter {
+    const message = createBaseContractChangeFilter() as any;
+    message.id = object.id ?? 0;
+    if (
+      object.change?.$case === "declaredClass" &&
+      object.change?.declaredClass !== undefined &&
+      object.change?.declaredClass !== null
+    ) {
+      message.change = {
+        $case: "declaredClass",
+        declaredClass: DeclaredClassFilter.fromPartial(object.change.declaredClass),
+      };
+    }
+    if (
+      object.change?.$case === "replacedClass" &&
+      object.change?.replacedClass !== undefined &&
+      object.change?.replacedClass !== null
+    ) {
+      message.change = {
+        $case: "replacedClass",
+        replacedClass: ReplacedClassFilter.fromPartial(object.change.replacedClass),
+      };
+    }
+    if (
+      object.change?.$case === "deployedContract" &&
+      object.change?.deployedContract !== undefined &&
+      object.change?.deployedContract !== null
+    ) {
+      message.change = {
+        $case: "deployedContract",
+        deployedContract: DeployedContractFilter.fromPartial(object.change.deployedContract),
+      };
+    }
+    return message;
+  },
+};
+
+function createBaseDeclaredClassFilter(): DeclaredClassFilter {
+  return {};
+}
+
+export const DeclaredClassFilter = {
+  encode(_: DeclaredClassFilter, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): DeclaredClassFilter {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDeclaredClassFilter() as any;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): DeclaredClassFilter {
+    return {};
+  },
+
+  toJSON(_: DeclaredClassFilter): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create(base?: DeepPartial<DeclaredClassFilter>): DeclaredClassFilter {
+    return DeclaredClassFilter.fromPartial(base ?? {});
+  },
+  fromPartial(_: DeepPartial<DeclaredClassFilter>): DeclaredClassFilter {
+    const message = createBaseDeclaredClassFilter() as any;
+    return message;
+  },
+};
+
+function createBaseReplacedClassFilter(): ReplacedClassFilter {
+  return {};
+}
+
+export const ReplacedClassFilter = {
+  encode(_: ReplacedClassFilter, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ReplacedClassFilter {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseReplacedClassFilter() as any;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): ReplacedClassFilter {
+    return {};
+  },
+
+  toJSON(_: ReplacedClassFilter): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create(base?: DeepPartial<ReplacedClassFilter>): ReplacedClassFilter {
+    return ReplacedClassFilter.fromPartial(base ?? {});
+  },
+  fromPartial(_: DeepPartial<ReplacedClassFilter>): ReplacedClassFilter {
+    const message = createBaseReplacedClassFilter() as any;
+    return message;
+  },
+};
+
+function createBaseDeployedContractFilter(): DeployedContractFilter {
+  return {};
+}
+
+export const DeployedContractFilter = {
+  encode(_: DeployedContractFilter, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): DeployedContractFilter {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDeployedContractFilter() as any;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): DeployedContractFilter {
+    return {};
+  },
+
+  toJSON(_: DeployedContractFilter): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create(base?: DeepPartial<DeployedContractFilter>): DeployedContractFilter {
+    return DeployedContractFilter.fromPartial(base ?? {});
+  },
+  fromPartial(_: DeepPartial<DeployedContractFilter>): DeployedContractFilter {
+    const message = createBaseDeployedContractFilter() as any;
+    return message;
+  },
+};
+
+function createBaseNonceUpdateFilter(): NonceUpdateFilter {
+  return { id: 0, contractAddress: undefined };
+}
+
+export const NonceUpdateFilter = {
+  encode(message: NonceUpdateFilter, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.id !== undefined && message.id !== 0) {
+      writer.uint32(8).uint32(message.id);
+    }
+    if (message.contractAddress !== undefined) {
+      FieldElement.encode(message.contractAddress, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): NonceUpdateFilter {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseNonceUpdateFilter() as any;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.id = reader.uint32();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.contractAddress = FieldElement.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): NonceUpdateFilter {
+    return {
+      id: isSet(object.id) ? globalThis.Number(object.id) : 0,
+      contractAddress: isSet(object.contractAddress) ? FieldElement.fromJSON(object.contractAddress) : undefined,
+    };
+  },
+
+  toJSON(message: NonceUpdateFilter): unknown {
+    const obj: any = {};
+    if (message.id !== undefined && message.id !== 0) {
+      obj.id = Math.round(message.id);
+    }
+    if (message.contractAddress !== undefined) {
+      obj.contractAddress = FieldElement.toJSON(message.contractAddress);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<NonceUpdateFilter>): NonceUpdateFilter {
+    return NonceUpdateFilter.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<NonceUpdateFilter>): NonceUpdateFilter {
+    const message = createBaseNonceUpdateFilter() as any;
+    message.id = object.id ?? 0;
+    message.contractAddress = (object.contractAddress !== undefined && object.contractAddress !== null)
+      ? FieldElement.fromPartial(object.contractAddress)
+      : undefined;
+    return message;
+  },
+};
+
 type Builtin = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;
 
 export type DeepPartial<T> = T extends Builtin ? T