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

package/package.json

@@ -1,47 +1,18 @@
 {
   "name": "@apibara/starknet",
-  "version": "2.0.0-beta.2",
-  "description": "Apibara DNA - Starknet types",
-  "repository": "apibara/typescript-sdk",
-  "license": "Apache-2.0",
-  "sideEffects": false,
+  "version": "2.0.0-beta.4",
+  "type": "module",
   "source": "./src/index.ts",
   "main": "./dist/index.mjs",
   "exports": {
     ".": {
-      "import": {
-        "types": "./dist/index.d.mts",
-        "default": "./dist/index.mjs"
-      },
-      "require": {
-        "types": "./dist/index.d.cts",
-        "default": "./dist/index.cjs"
-      }
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.mjs"
     }
   },
-  "publishConfig": {
-    "files": [
-      "dist",
-      "src",
-      "README.md"
-    ]
-  },
-  "dependencies": {
-    "@effect/schema": "^0.67.15",
-    "effect": "^3.2.6",
-    "long": "^5.2.1",
-    "nice-grpc-common": "^2.0.2",
-    "protobufjs": "^7.1.2",
-    "@apibara/protocol": "2.0.0-beta.2"
-  },
-  "devDependencies": {
-    "@bufbuild/buf": "^1.32.1",
-    "@types/long": "^5.0.0",
-    "@types/node": "^20.12.12",
-    "unbuild": "^2.0.0",
-    "viem": "^2.13.8",
-    "vitest": "^1.6.0"
-  },
+  "publishConfig": {},
   "scripts": {
     "build": "pnpm build:proto && unbuild",
     "build:proto": "buf generate proto",
@@ -52,5 +23,26 @@
     "lint:fix": "pnpm lint --write",
     "format": "biome format . --write"
   },
+  "devDependencies": {
+    "@bufbuild/buf": "^1.32.1",
+    "@types/long": "^5.0.0",
+    "@types/node": "^20.12.12",
+    "unbuild": "^2.0.0",
+    "viem": "^2.13.8",
+    "vitest": "^1.6.0"
+  },
+  "dependencies": {
+    "@apibara/protocol": "2.0.0-beta.4",
+    "@effect/schema": "^0.67.15",
+    "effect": "^3.2.6",
+    "long": "^5.2.1",
+    "nice-grpc-common": "^2.0.2",
+    "protobufjs": "^7.1.2"
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md"
+  ],
   "types": "./dist/index.d.ts"
-}
+}

package/src/block.ts

@@ -35,16 +35,38 @@ export const L1DataAvailabilityMode = Schema.transform(
   },
 );
 
+export const TransactionStatus = Schema.transform(
+  Schema.Enums(proto.data.TransactionStatus),
+  Schema.Literal("unknown", "succeeded", "reverted"),
+  {
+    decode(value) {
+      const enumMap = {
+        [proto.data.TransactionStatus.SUCCEEDED]: "succeeded",
+        [proto.data.TransactionStatus.REVERTED]: "reverted",
+        [proto.data.TransactionStatus.UNSPECIFIED]: "unknown",
+        [proto.data.TransactionStatus.UNRECOGNIZED]: "unknown",
+      } as const;
+
+      return enumMap[value] ?? "unknown";
+    },
+    encode(value) {
+      throw new Error("encode: not implemented");
+    },
+  },
+);
+
+export type TransactionStatus = typeof TransactionStatus.Type;
+
 export const U128 = Schema.transform(
   Schema.Struct({
-    low: Schema.BigIntFromSelf,
-    high: Schema.BigIntFromSelf,
+    x0: Schema.BigIntFromSelf,
+    x1: Schema.BigIntFromSelf,
   }),
   Schema.BigIntFromSelf,
   {
     decode(value) {
-      const low = value.low.toString(16).padStart(16, "0");
-      const high = value.high.toString(16).padStart(16, "0");
+      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) {
@@ -117,12 +139,12 @@ export type BlockHeader = typeof BlockHeader.Type;
  *
  * @prop transactionIndex The transaction index in the block.
  * @prop transactionHash The transaction hash.
- * @prop transactionReverted Whether the transaction was reverted.
+ * @prop transactionStatus The transaction status.
  */
 export const TransactionMeta = Schema.Struct({
   transactionIndex: Schema.optional(Schema.Number),
   transactionHash: Schema.optional(FieldElement),
-  transactionReverted: Schema.optional(Schema.Boolean),
+  transactionStatus: Schema.optional(TransactionStatus),
 });
 
 export type TransactionMeta = typeof TransactionMeta.Type;
@@ -267,6 +289,7 @@ export const DeployAccountTransactionV3 = Schema.Struct({
  * @prop meta Transaction metadata.
  */
 export const Transaction = Schema.Struct({
+  filterIds: Schema.optional(Schema.Array(Schema.Number)),
   meta: Schema.optional(TransactionMeta),
   transaction: Schema.optional(
     Schema.Union(
@@ -395,6 +418,7 @@ export const DeployAccountTransactionReceipt = Schema.Struct({
  * @prop receipt Transaction-specific receipt.
  */
 export const TransactionReceipt = Schema.Struct({
+  filterIds: Schema.optional(Schema.Array(Schema.Number)),
   meta: Schema.optional(TransactionReceiptMeta),
   receipt: Schema.optional(
     Schema.Union(
@@ -417,16 +441,17 @@ export type TransactionReceipt = typeof TransactionReceipt.Type;
  * @prop eventIndex The event index in the block.
  * @prop transactionIndex The transaction index in the block.
  * @prop transactionHash The transaction hash.
- * @prop transactionReverted Whether the transaction was reverted.
+ * @prop transactionStatus The transaction status.
  */
 export const Event = Schema.Struct({
-  fromAddress: Schema.optional(FieldElement),
+  filterIds: Schema.optional(Schema.Array(Schema.Number)),
+  address: Schema.optional(FieldElement),
   keys: Schema.optional(Schema.Array(FieldElement)),
   data: Schema.optional(Schema.Array(FieldElement)),
   eventIndex: Schema.optional(Schema.Number),
   transactionIndex: Schema.optional(Schema.Number),
   transactionHash: Schema.optional(FieldElement),
-  transactionReverted: Schema.optional(Schema.Boolean),
+  transactionStatus: Schema.optional(TransactionStatus),
 });
 
 export type Event = typeof Event.Type;
@@ -439,16 +464,17 @@ export type Event = typeof Event.Type;
  * @prop messageIndex The message index in the block.
  * @prop transactionIndex The transaction index in the block.
  * @prop transactionHash The transaction hash.
- * @prop transactionReverted Whether the transaction was reverted.
+ * @prop transactionStatus The transaction status.
  */
 export const MessageToL1 = Schema.Struct({
+  filterIds: Schema.optional(Schema.Array(Schema.Number)),
   fromAddress: Schema.optional(FieldElement),
   toAddress: Schema.optional(FieldElement),
   payload: Schema.optional(Schema.Array(FieldElement)),
   messageIndex: Schema.optional(Schema.Number),
   transactionIndex: Schema.optional(Schema.Number),
   transactionHash: Schema.optional(FieldElement),
-  transactionReverted: Schema.optional(Schema.Boolean),
+  transactionStatus: Schema.optional(TransactionStatus),
 });
 
 export type MessageToL1 = typeof MessageToL1.Type;

package/src/common.test.ts

@@ -10,10 +10,10 @@ describe("FieldElement", () => {
 
     const message = feltToProto(felt);
 
-    expect(message.loLo).toBeDefined();
-    expect(message.loHi).toBeDefined();
-    expect(message.hiLo).toBeDefined();
-    expect(message.hiHi).toBeDefined();
+    expect(message.x0).toBeDefined();
+    expect(message.x1).toBeDefined();
+    expect(message.x2).toBeDefined();
+    expect(message.x3).toBeDefined();
 
     const back = feltFromProto(message);
     expect(back).toEqual(pad(felt, { size: 32 }));

package/src/common.ts

@@ -7,30 +7,30 @@ const _FieldElement = Schema.TemplateLiteral(
 
 /** Wire representation of `FieldElement`. */
 export const FieldElementProto = Schema.Struct({
-  loLo: Schema.BigIntFromSelf,
-  loHi: Schema.BigIntFromSelf,
-  hiLo: Schema.BigIntFromSelf,
-  hiHi: Schema.BigIntFromSelf,
+  x0: Schema.BigIntFromSelf,
+  x1: Schema.BigIntFromSelf,
+  x2: Schema.BigIntFromSelf,
+  x3: Schema.BigIntFromSelf,
 });
 
 /** Field element. */
 export const FieldElement = Schema.transform(FieldElementProto, _FieldElement, {
   decode(value) {
-    const loLo = value.loLo.toString(16).padStart(16, "0");
-    const loHi = value.loHi.toString(16).padStart(16, "0");
-    const hiLo = value.hiLo.toString(16).padStart(16, "0");
-    const hiHi = value.hiHi.toString(16).padStart(16, "0");
-    return `0x${loLo}${loHi}${hiLo}${hiHi}` as `0x${string}`;
+    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}` as `0x${string}`;
   },
   encode(value) {
     const bn = BigInt(value);
     const hex = bn.toString(16).padStart(64, "0");
     const s = hex.length;
-    const hiHi = BigInt(`0x${hex.slice(s - 16, s)}`);
-    const hiLo = BigInt(`0x${hex.slice(s - 32, s - 16)}`);
-    const loHi = BigInt(`0x${hex.slice(s - 48, s - 32)}`);
-    const loLo = BigInt(`0x${hex.slice(s - 64, s - 48)}`);
-    return { loLo, loHi, hiLo, hiHi };
+    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)}`);
+    return { x0, x1, x2, x3 };
   },
 });
 

package/src/filter.test.ts

@@ -42,10 +42,10 @@ describe("Key", () => {
     expect(proto).toMatchInlineSnapshot(`
       {
         "value": {
-          "hiHi": 4660n,
-          "hiLo": 0n,
-          "loHi": 0n,
-          "loLo": 0n,
+          "x0": 0n,
+          "x1": 0n,
+          "x2": 0n,
+          "x3": 4660n,
         },
       }
     `);
@@ -69,7 +69,7 @@ describe("EventFilter", () => {
 
   it("should encode and decode all values", () => {
     const proto = encode({
-      fromAddress: "0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
+      address: "0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
       keys: [
         "0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
         null,
@@ -77,7 +77,7 @@ describe("EventFilter", () => {
         "0xCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC",
       ],
       strict: true,
-      includeReverted: true,
+      transactionStatus: "all",
       includeTransaction: true,
       includeReceipt: true,
       includeMessages: true,
@@ -85,24 +85,23 @@ describe("EventFilter", () => {
     });
     expect(proto).toMatchInlineSnapshot(`
       {
-        "fromAddress": {
-          "hiHi": 12297829382473034410n,
-          "hiLo": 12297829382473034410n,
-          "loHi": 170n,
-          "loLo": 0n,
+        "address": {
+          "x0": 0n,
+          "x1": 170n,
+          "x2": 12297829382473034410n,
+          "x3": 12297829382473034410n,
         },
         "includeMessages": true,
         "includeReceipt": true,
-        "includeReverted": true,
         "includeSiblings": true,
         "includeTransaction": true,
         "keys": [
           {
             "value": {
-              "hiHi": 13527612320720337851n,
-              "hiLo": 13527612320720337851n,
-              "loHi": 187n,
-              "loLo": 0n,
+              "x0": 0n,
+              "x1": 187n,
+              "x2": 13527612320720337851n,
+              "x3": 13527612320720337851n,
             },
           },
           {
@@ -113,23 +112,23 @@ describe("EventFilter", () => {
           },
           {
             "value": {
-              "hiHi": 14757395258967641292n,
-              "hiLo": 14757395258967641292n,
-              "loHi": 0n,
-              "loLo": 0n,
+              "x0": 0n,
+              "x1": 0n,
+              "x2": 14757395258967641292n,
+              "x3": 14757395258967641292n,
             },
           },
         ],
         "strict": true,
+        "transactionStatus": 3,
       }
     `);
     const decoded = decode(proto);
     expect(decoded).toMatchInlineSnapshot(`
       {
-        "fromAddress": "0x000000000000000000000000000000aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+        "address": "0x000000000000000000000000000000aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
         "includeMessages": true,
         "includeReceipt": true,
-        "includeReverted": true,
         "includeSiblings": true,
         "includeTransaction": true,
         "keys": [
@@ -139,6 +138,7 @@ describe("EventFilter", () => {
           "0x00000000000000000000000000000000cccccccccccccccccccccccccccccccc",
         ],
         "strict": true,
+        "transactionStatus": "all",
       }
     `);
   });
@@ -160,14 +160,14 @@ describe("TransactionFilter", () => {
       includeEvents: true,
       includeMessages: true,
       includeReceipt: true,
-      includeReverted: true,
+      transactionStatus: "reverted",
     });
     expect(proto).toMatchInlineSnapshot(`
       {
         "includeEvents": true,
         "includeMessages": true,
         "includeReceipt": true,
-        "includeReverted": true,
+        "transactionStatus": 2,
       }
     `);
     const decoded = decode(proto);
@@ -176,7 +176,7 @@ describe("TransactionFilter", () => {
         "includeEvents": true,
         "includeMessages": true,
         "includeReceipt": true,
-        "includeReverted": true,
+        "transactionStatus": "reverted",
       }
     `);
   });
@@ -540,17 +540,17 @@ describe("mergeFilter", () => {
 
   it("concatenates events", () => {
     const f = mergeFilter(
-      { events: [{ fromAddress: "0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" }] },
-      { events: [{ fromAddress: "0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB" }] },
+      { events: [{ address: "0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" }] },
+      { events: [{ address: "0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB" }] },
     );
     expect(f).toMatchInlineSnapshot(`
       {
         "events": [
           {
-            "fromAddress": "0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
+            "address": "0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
           },
           {
-            "fromAddress": "0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
+            "address": "0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
           },
         ],
         "header": undefined,

package/src/filter.ts

@@ -36,24 +36,55 @@ export const Key = Schema.transform(
 
 export type Key = typeof Key.Type;
 
+export const TransactionStatusFilter = Schema.transform(
+  Schema.Enums(proto.filter.TransactionStatusFilter),
+  Schema.Literal("succeeded", "reverted", "all", "unknown"),
+  {
+    decode(value) {
+      const enumMap = {
+        [proto.filter.TransactionStatusFilter.SUCCEEDED]: "succeeded",
+        [proto.filter.TransactionStatusFilter.REVERTED]: "reverted",
+        [proto.filter.TransactionStatusFilter.ALL]: "all",
+        [proto.filter.TransactionStatusFilter.UNSPECIFIED]: "unknown",
+        [proto.filter.TransactionStatusFilter.UNRECOGNIZED]: "unknown",
+      } as const;
+      return enumMap[value] ?? "unknown";
+    },
+    encode(value) {
+      switch (value) {
+        case "succeeded":
+          return proto.filter.TransactionStatusFilter.SUCCEEDED;
+        case "reverted":
+          return proto.filter.TransactionStatusFilter.REVERTED;
+        case "all":
+          return proto.filter.TransactionStatusFilter.ALL;
+        default:
+          return proto.filter.TransactionStatusFilter.UNSPECIFIED;
+      }
+    },
+  },
+);
+
+export type TransactionStatusFilter = typeof TransactionStatusFilter.Type;
+
 /** Filter events.
  *
- * @prop fromAddress Filter events by the sender address.
+ * @prop address Filter events by the sender address.
  * @prop keys Filter events by the event keys. Use `null` to match any key.
  * @prop strict If `true`, then the filter will only match events that have exactly the
  * same number of keys as specified in `keys`.
- * @prop includeReverted Include events from reverted transactions. In most
- * cases, this will be the fee payment Transfer event.
+ * @prop transactionStatus Filter based on the transaction status.
  * @prop includeTransaction Include the transaction that emitted the event.
  * @prop includeReceipt Include the transaction receipt.
  * @prop includeMessages Include the messages that were sent to L1 in the same transaction.
  * @prop includeSiblings Include the sibling events of the matched events.
  */
 export const EventFilter = Schema.Struct({
-  fromAddress: Schema.optional(FieldElement),
+  id: Schema.optional(Schema.Number),
+  address: Schema.optional(FieldElement),
   keys: Schema.optional(Schema.Array(Key)),
   strict: Schema.optional(Schema.Boolean),
-  includeReverted: Schema.optional(Schema.Boolean),
+  transactionStatus: Schema.optional(TransactionStatusFilter),
   includeTransaction: Schema.optional(Schema.Boolean),
   includeReceipt: Schema.optional(Schema.Boolean),
   includeMessages: Schema.optional(Schema.Boolean),
@@ -66,15 +97,16 @@ export type EventFilter = typeof EventFilter.Type;
  *
  * @prop fromAddress Filter messages by the sender address (on L2).
  * @prop toAddress Filter messages by the recipient address (on L1).
- * @prop includeReverted Include messages from reverted transactions.
+ * @prop transactionStatus Filter based on the transaction status.
  * @prop includeTransaction Include the transaction that sent the message.
  * @prop includeReceipt Include the transaction receipt.
  * @prop includeEvents Include events from the same transaction.
  */
 export const MessageToL1Filter = Schema.Struct({
+  id: Schema.optional(Schema.Number),
   fromAddress: Schema.optional(FieldElement),
   toAddress: Schema.optional(FieldElement),
-  includeReverted: Schema.optional(Schema.Boolean),
+  transactionStatus: Schema.optional(TransactionStatusFilter),
   includeTransaction: Schema.optional(Schema.Boolean),
   includeReceipt: Schema.optional(Schema.Boolean),
   includeEvents: Schema.optional(Schema.Boolean),
@@ -139,13 +171,14 @@ export const DeployAccountV3TransactionFilter = Schema.Struct({
 
 /** Filter transactions.
  *
- * @prop includeReverted Include messages from reverted transactions.
+ * @prop transactionStatus Filter based on the transaction status.
  * @prop includeReceipt Include the transaction receipt.
  * @prop includeEvents Include events from the same transaction.
  * @prop includeMessages Include messages sent in the transaction.
  */
 export const TransactionFilter = Schema.Struct({
-  includeReverted: Schema.optional(Schema.Boolean),
+  id: Schema.optional(Schema.Number),
+  transactionStatus: Schema.optional(TransactionStatusFilter),
   includeReceipt: Schema.optional(Schema.Boolean),
   includeMessages: Schema.optional(Schema.Boolean),
   includeEvents: Schema.optional(Schema.Boolean),

package/src/proto/common.ts

@@ -12,41 +12,41 @@ export const protobufPackage = "starknet.v2";
 
 /** A field element. */
 export interface FieldElement {
-  readonly loLo?: bigint | undefined;
-  readonly loHi?: bigint | undefined;
-  readonly hiLo?: bigint | undefined;
-  readonly hiHi?: bigint | undefined;
+  readonly x0?: bigint | undefined;
+  readonly x1?: bigint | undefined;
+  readonly x2?: bigint | undefined;
+  readonly x3?: bigint | undefined;
 }
 
 function createBaseFieldElement(): FieldElement {
-  return { loLo: BigInt("0"), loHi: BigInt("0"), hiLo: BigInt("0"), hiHi: BigInt("0") };
+  return { x0: BigInt("0"), x1: BigInt("0"), x2: BigInt("0"), x3: BigInt("0") };
 }
 
 export const FieldElement = {
   encode(message: FieldElement, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.loLo !== undefined && message.loLo !== BigInt("0")) {
-      if (BigInt.asUintN(64, message.loLo) !== message.loLo) {
-        throw new globalThis.Error("value provided for field message.loLo of type fixed64 too large");
+    if (message.x0 !== undefined && message.x0 !== BigInt("0")) {
+      if (BigInt.asUintN(64, message.x0) !== message.x0) {
+        throw new globalThis.Error("value provided for field message.x0 of type fixed64 too large");
       }
-      writer.uint32(9).fixed64(message.loLo.toString());
+      writer.uint32(9).fixed64(message.x0.toString());
     }
-    if (message.loHi !== undefined && message.loHi !== BigInt("0")) {
-      if (BigInt.asUintN(64, message.loHi) !== message.loHi) {
-        throw new globalThis.Error("value provided for field message.loHi of type fixed64 too large");
+    if (message.x1 !== undefined && message.x1 !== BigInt("0")) {
+      if (BigInt.asUintN(64, message.x1) !== message.x1) {
+        throw new globalThis.Error("value provided for field message.x1 of type fixed64 too large");
       }
-      writer.uint32(17).fixed64(message.loHi.toString());
+      writer.uint32(17).fixed64(message.x1.toString());
     }
-    if (message.hiLo !== undefined && message.hiLo !== BigInt("0")) {
-      if (BigInt.asUintN(64, message.hiLo) !== message.hiLo) {
-        throw new globalThis.Error("value provided for field message.hiLo of type fixed64 too large");
+    if (message.x2 !== undefined && message.x2 !== BigInt("0")) {
+      if (BigInt.asUintN(64, message.x2) !== message.x2) {
+        throw new globalThis.Error("value provided for field message.x2 of type fixed64 too large");
       }
-      writer.uint32(25).fixed64(message.hiLo.toString());
+      writer.uint32(25).fixed64(message.x2.toString());
     }
-    if (message.hiHi !== undefined && message.hiHi !== BigInt("0")) {
-      if (BigInt.asUintN(64, message.hiHi) !== message.hiHi) {
-        throw new globalThis.Error("value provided for field message.hiHi of type fixed64 too large");
+    if (message.x3 !== undefined && message.x3 !== BigInt("0")) {
+      if (BigInt.asUintN(64, message.x3) !== message.x3) {
+        throw new globalThis.Error("value provided for field message.x3 of type fixed64 too large");
       }
-      writer.uint32(33).fixed64(message.hiHi.toString());
+      writer.uint32(33).fixed64(message.x3.toString());
     }
     return writer;
   },
@@ -63,28 +63,28 @@ export const FieldElement = {
             break;
           }
 
-          message.loLo = longToBigint(reader.fixed64() as Long);
+          message.x0 = longToBigint(reader.fixed64() as Long);
           continue;
         case 2:
           if (tag !== 17) {
             break;
           }
 
-          message.loHi = longToBigint(reader.fixed64() as Long);
+          message.x1 = longToBigint(reader.fixed64() as Long);
           continue;
         case 3:
           if (tag !== 25) {
             break;
           }
 
-          message.hiLo = longToBigint(reader.fixed64() as Long);
+          message.x2 = longToBigint(reader.fixed64() as Long);
           continue;
         case 4:
           if (tag !== 33) {
             break;
           }
 
-          message.hiHi = longToBigint(reader.fixed64() as Long);
+          message.x3 = longToBigint(reader.fixed64() as Long);
           continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
@@ -97,26 +97,26 @@ export const FieldElement = {
 
   fromJSON(object: any): FieldElement {
     return {
-      loLo: isSet(object.loLo) ? BigInt(object.loLo) : BigInt("0"),
-      loHi: isSet(object.loHi) ? BigInt(object.loHi) : BigInt("0"),
-      hiLo: isSet(object.hiLo) ? BigInt(object.hiLo) : BigInt("0"),
-      hiHi: isSet(object.hiHi) ? BigInt(object.hiHi) : BigInt("0"),
+      x0: isSet(object.x0) ? BigInt(object.x0) : BigInt("0"),
+      x1: isSet(object.x1) ? BigInt(object.x1) : BigInt("0"),
+      x2: isSet(object.x2) ? BigInt(object.x2) : BigInt("0"),
+      x3: isSet(object.x3) ? BigInt(object.x3) : BigInt("0"),
     };
   },
 
   toJSON(message: FieldElement): unknown {
     const obj: any = {};
-    if (message.loLo !== undefined && message.loLo !== BigInt("0")) {
-      obj.loLo = message.loLo.toString();
+    if (message.x0 !== undefined && message.x0 !== BigInt("0")) {
+      obj.x0 = message.x0.toString();
     }
-    if (message.loHi !== undefined && message.loHi !== BigInt("0")) {
-      obj.loHi = message.loHi.toString();
+    if (message.x1 !== undefined && message.x1 !== BigInt("0")) {
+      obj.x1 = message.x1.toString();
     }
-    if (message.hiLo !== undefined && message.hiLo !== BigInt("0")) {
-      obj.hiLo = message.hiLo.toString();
+    if (message.x2 !== undefined && message.x2 !== BigInt("0")) {
+      obj.x2 = message.x2.toString();
     }
-    if (message.hiHi !== undefined && message.hiHi !== BigInt("0")) {
-      obj.hiHi = message.hiHi.toString();
+    if (message.x3 !== undefined && message.x3 !== BigInt("0")) {
+      obj.x3 = message.x3.toString();
     }
     return obj;
   },
@@ -126,10 +126,10 @@ export const FieldElement = {
   },
   fromPartial(object: DeepPartial<FieldElement>): FieldElement {
     const message = createBaseFieldElement() as any;
-    message.loLo = object.loLo ?? BigInt("0");
-    message.loHi = object.loHi ?? BigInt("0");
-    message.hiLo = object.hiLo ?? BigInt("0");
-    message.hiHi = object.hiHi ?? BigInt("0");
+    message.x0 = object.x0 ?? BigInt("0");
+    message.x1 = object.x1 ?? BigInt("0");
+    message.x2 = object.x2 ?? BigInt("0");
+    message.x3 = object.x3 ?? BigInt("0");
     return message;
   },
 };