@apibara/starknet 2.1.0-beta.23 → 2.1.0-beta.25

package/src/filter.ts

@@ -1,7 +1,14 @@
-import { Schema } from "@effect/schema";
-
-import { FieldElement, FieldElementProto } from "./common";
-import { tag } from "./helpers";
+import {
+  ArrayCodec,
+  BooleanCodec,
+  type Codec,
+  type CodecType,
+  MessageCodec,
+  NumberCodec,
+  OneOfCodec,
+  OptionalCodec,
+} from "@apibara/protocol/codec";
+import { FieldElement } from "./common";
 import * as proto from "./proto";
 
 /** Header options.
@@ -10,90 +17,87 @@ import * as proto from "./proto";
  * - `on_data`: receive headers only if any other filter matches.
  * - `on_data_or_on_new_block`: receive headers only if any other filter matches and for "live" blocks.
  */
-export const HeaderFilter = Schema.transform(
-  Schema.Enums(proto.filter.HeaderFilter),
-  Schema.Literal("always", "on_data", "on_data_or_on_new_block", "unknown"),
-  {
-    decode(value) {
-      const enumMap = {
-        [proto.filter.HeaderFilter.ALWAYS]: "always",
-        [proto.filter.HeaderFilter.ON_DATA]: "on_data",
-        [proto.filter.HeaderFilter.ON_DATA_OR_ON_NEW_BLOCK]:
-          "on_data_or_on_new_block",
-        [proto.filter.HeaderFilter.UNSPECIFIED]: "unknown",
-        [proto.filter.HeaderFilter.UNRECOGNIZED]: "unknown",
-      } as const;
-      return enumMap[value] ?? "unknown";
-    },
-    encode(value) {
-      switch (value) {
-        case "always":
-          return proto.filter.HeaderFilter.ALWAYS;
-        case "on_data":
-          return proto.filter.HeaderFilter.ON_DATA;
-        case "on_data_or_on_new_block":
-          return proto.filter.HeaderFilter.ON_DATA_OR_ON_NEW_BLOCK;
-        default:
-          return proto.filter.HeaderFilter.UNSPECIFIED;
-      }
-    },
+export const HeaderFilter: Codec<
+  "always" | "on_data" | "on_data_or_on_new_block" | "unknown",
+  proto.filter.HeaderFilter
+> = {
+  encode(x) {
+    switch (x) {
+      case "always":
+        return proto.filter.HeaderFilter.ALWAYS;
+      case "on_data":
+        return proto.filter.HeaderFilter.ON_DATA;
+      case "on_data_or_on_new_block":
+        return proto.filter.HeaderFilter.ON_DATA_OR_ON_NEW_BLOCK;
+      default:
+        return proto.filter.HeaderFilter.UNSPECIFIED;
+    }
+  },
+  decode(p) {
+    const enumMap = {
+      [proto.filter.HeaderFilter.ALWAYS]: "always",
+      [proto.filter.HeaderFilter.ON_DATA]: "on_data",
+      [proto.filter.HeaderFilter.ON_DATA_OR_ON_NEW_BLOCK]:
+        "on_data_or_on_new_block",
+      [proto.filter.HeaderFilter.UNSPECIFIED]: "unknown",
+      [proto.filter.HeaderFilter.UNRECOGNIZED]: "unknown",
+    } as const;
+    return enumMap[p] ?? "unknown";
   },
-);
+};
 
-export type HeaderFilter = typeof HeaderFilter.Type;
+export type HeaderFilter = CodecType<typeof HeaderFilter>;
 
 /** An event key filter. Use `null` to match any event key. */
-export const Key = Schema.transform(
-  Schema.Struct({ value: Schema.UndefinedOr(FieldElementProto) }),
-  Schema.NullOr(FieldElement),
-  {
-    decode({ value }) {
-      if (value === undefined) {
-        return null;
-      }
-      return value;
-    },
-    encode(value) {
-      if (value === null) {
-        return { value: undefined };
-      }
-      return { value };
-    },
+export const Key: Codec<
+  FieldElement | null,
+  { value?: proto.common.FieldElement | undefined }
+> = {
+  encode(x) {
+    if (x === null) {
+      return { value: undefined };
+    }
+    return { value: FieldElement.encode(x) };
+  },
+  decode(p) {
+    if (p.value === undefined) {
+      return null;
+    }
+    return FieldElement.decode(p.value);
   },
-);
-
-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 Key = CodecType<typeof Key>;
+
+export const TransactionStatusFilter: Codec<
+  "succeeded" | "reverted" | "all" | "unknown",
+  proto.filter.TransactionStatusFilter
+> = {
+  encode(x) {
+    switch (x) {
+      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;
+    }
   },
-);
+  decode(p) {
+    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[p] ?? "unknown";
+  },
+};
 
-export type TransactionStatusFilter = typeof TransactionStatusFilter.Type;
+export type TransactionStatusFilter = CodecType<typeof TransactionStatusFilter>;
 
 /** Filter events.
  *
@@ -108,20 +112,20 @@ export type TransactionStatusFilter = typeof TransactionStatusFilter.Type;
  * @prop includeSiblings Include the sibling events of the matched events.
  * @prop includeTransactionTrace Include the trace of the transaction that emitted the event.
  */
-export const EventFilter = Schema.Struct({
-  id: Schema.optional(Schema.Number),
-  address: Schema.optional(FieldElement),
-  keys: Schema.optional(Schema.Array(Key)),
-  strict: Schema.optional(Schema.Boolean),
-  transactionStatus: Schema.optional(TransactionStatusFilter),
-  includeTransaction: Schema.optional(Schema.Boolean),
-  includeReceipt: Schema.optional(Schema.Boolean),
-  includeMessages: Schema.optional(Schema.Boolean),
-  includeSiblings: Schema.optional(Schema.Boolean),
-  includeTransactionTrace: Schema.optional(Schema.Boolean),
+export const EventFilter = MessageCodec({
+  id: OptionalCodec(NumberCodec),
+  address: OptionalCodec(FieldElement),
+  keys: OptionalCodec(ArrayCodec(Key)),
+  strict: OptionalCodec(BooleanCodec),
+  transactionStatus: OptionalCodec(TransactionStatusFilter),
+  includeTransaction: OptionalCodec(BooleanCodec),
+  includeReceipt: OptionalCodec(BooleanCodec),
+  includeMessages: OptionalCodec(BooleanCodec),
+  includeSiblings: OptionalCodec(BooleanCodec),
+  includeTransactionTrace: OptionalCodec(BooleanCodec),
 });
 
-export type EventFilter = typeof EventFilter.Type;
+export type EventFilter = Readonly<CodecType<typeof EventFilter>>;
 
 /** Filter messages to L1.
  *
@@ -133,97 +137,74 @@ export type EventFilter = typeof EventFilter.Type;
  * @prop includeEvents Include events from the same transaction.
  * @prop includeTransactionTrace Include the trace of the transaction that sent the message.
  */
-export const MessageToL1Filter = Schema.Struct({
-  id: Schema.optional(Schema.Number),
-  fromAddress: Schema.optional(FieldElement),
-  toAddress: Schema.optional(FieldElement),
-  transactionStatus: Schema.optional(TransactionStatusFilter),
-  includeTransaction: Schema.optional(Schema.Boolean),
-  includeReceipt: Schema.optional(Schema.Boolean),
-  includeEvents: Schema.optional(Schema.Boolean),
-  includeTransactionTrace: Schema.optional(Schema.Boolean),
-});
-
-export type MessageToL1Filter = typeof MessageToL1Filter.Type;
-
-export const InvokeTransactionV0Filter = Schema.Struct({
-  _tag: tag("invokeV0"),
-  invokeV0: Schema.Struct({}),
-});
-
-export type InvokeTransactionV0Filter = typeof InvokeTransactionV0Filter.Type;
-
-export const InvokeTransactionV1Filter = Schema.Struct({
-  _tag: tag("invokeV1"),
-  invokeV1: Schema.Struct({}),
-});
-
-export type InvokeTransactionV1Filter = typeof InvokeTransactionV1Filter.Type;
-
-export const InvokeTransactionV3Filter = Schema.Struct({
-  _tag: tag("invokeV3"),
-  invokeV3: Schema.Struct({}),
-});
-
-export type InvokeTransactionV3Filter = typeof InvokeTransactionV3Filter.Type;
-
-export const DeployTransactionFilter = Schema.Struct({
-  _tag: tag("deploy"),
-  deploy: Schema.Struct({}),
-});
-
-export type DeployTransactionFilter = typeof DeployTransactionFilter.Type;
-
-export const DeclareV0TransactionFilter = Schema.Struct({
-  _tag: tag("declareV0"),
-  declareV0: Schema.Struct({}),
-});
-
-export type DeclareV0TransactionFilter = typeof DeclareV0TransactionFilter.Type;
-
-export const DeclareV1TransactionFilter = Schema.Struct({
-  _tag: tag("declareV1"),
-  declareV1: Schema.Struct({}),
-});
-
-export type DeclareV1TransactionFilter = typeof DeclareV1TransactionFilter.Type;
-
-export const DeclareV2TransactionFilter = Schema.Struct({
-  _tag: tag("declareV2"),
-  declareV2: Schema.Struct({}),
-});
-
-export type DeclareV2TransactionFilter = typeof DeclareV2TransactionFilter.Type;
-
-export const DeclareV3TransactionFilter = Schema.Struct({
-  _tag: tag("declareV3"),
-  declareV3: Schema.Struct({}),
-});
-
-export type DeclareV3TransactionFilter = typeof DeclareV3TransactionFilter.Type;
-
-export const L1HandlerTransactionFilter = Schema.Struct({
-  _tag: tag("l1Handler"),
-  l1Handler: Schema.Struct({}),
-});
-
-export type L1HandlerTransactionFilter = typeof L1HandlerTransactionFilter.Type;
-
-export const DeployAccountV1TransactionFilter = Schema.Struct({
-  _tag: tag("deployAccountV1"),
-  deployAccountV1: Schema.Struct({}),
+export const MessageToL1Filter = MessageCodec({
+  id: OptionalCodec(NumberCodec),
+  fromAddress: OptionalCodec(FieldElement),
+  toAddress: OptionalCodec(FieldElement),
+  transactionStatus: OptionalCodec(TransactionStatusFilter),
+  includeTransaction: OptionalCodec(BooleanCodec),
+  includeReceipt: OptionalCodec(BooleanCodec),
+  includeEvents: OptionalCodec(BooleanCodec),
+  includeTransactionTrace: OptionalCodec(BooleanCodec),
 });
 
-export type DeployAccountV1TransactionFilter =
-  typeof DeployAccountV1TransactionFilter.Type;
-
-export const DeployAccountV3TransactionFilter = Schema.Struct({
-  _tag: tag("deployAccountV3"),
-  deployAccountV3: Schema.Struct({}),
-});
-
-export type DeployAccountV3TransactionFilter =
-  typeof DeployAccountV3TransactionFilter.Type;
+export type MessageToL1Filter = Readonly<CodecType<typeof MessageToL1Filter>>;
+
+// Transaction type filters
+export const InvokeTransactionV0Filter = MessageCodec({});
+export type InvokeTransactionV0Filter = Readonly<
+  CodecType<typeof InvokeTransactionV0Filter>
+>;
+
+export const InvokeTransactionV1Filter = MessageCodec({});
+export type InvokeTransactionV1Filter = Readonly<
+  CodecType<typeof InvokeTransactionV1Filter>
+>;
+
+export const InvokeTransactionV3Filter = MessageCodec({});
+export type InvokeTransactionV3Filter = Readonly<
+  CodecType<typeof InvokeTransactionV3Filter>
+>;
+
+export const DeployTransactionFilter = MessageCodec({});
+export type DeployTransactionFilter = Readonly<
+  CodecType<typeof DeployTransactionFilter>
+>;
+
+export const DeclareV0TransactionFilter = MessageCodec({});
+export type DeclareV0TransactionFilter = Readonly<
+  CodecType<typeof DeclareV0TransactionFilter>
+>;
+
+export const DeclareV1TransactionFilter = MessageCodec({});
+export type DeclareV1TransactionFilter = Readonly<
+  CodecType<typeof DeclareV1TransactionFilter>
+>;
+
+export const DeclareV2TransactionFilter = MessageCodec({});
+export type DeclareV2TransactionFilter = Readonly<
+  CodecType<typeof DeclareV2TransactionFilter>
+>;
+
+export const DeclareV3TransactionFilter = MessageCodec({});
+export type DeclareV3TransactionFilter = Readonly<
+  CodecType<typeof DeclareV3TransactionFilter>
+>;
+
+export const L1HandlerTransactionFilter = MessageCodec({});
+export type L1HandlerTransactionFilter = Readonly<
+  CodecType<typeof L1HandlerTransactionFilter>
+>;
+
+export const DeployAccountV1TransactionFilter = MessageCodec({});
+export type DeployAccountV1TransactionFilter = Readonly<
+  CodecType<typeof DeployAccountV1TransactionFilter>
+>;
+
+export const DeployAccountV3TransactionFilter = MessageCodec({});
+export type DeployAccountV3TransactionFilter = Readonly<
+  CodecType<typeof DeployAccountV3TransactionFilter>
+>;
 
 /** Filter transactions.
  *
@@ -233,122 +214,108 @@ export type DeployAccountV3TransactionFilter =
  * @prop includeMessages Include messages sent in the transaction.
  * @prop includeTrace Include the transaction's trace.
  */
-export const TransactionFilter = Schema.Struct({
-  id: Schema.optional(Schema.Number),
-  transactionStatus: Schema.optional(TransactionStatusFilter),
-  includeReceipt: Schema.optional(Schema.Boolean),
-  includeMessages: Schema.optional(Schema.Boolean),
-  includeEvents: Schema.optional(Schema.Boolean),
-  includeTrace: Schema.optional(Schema.Boolean),
-  transactionType: Schema.optional(
-    Schema.Union(
-      InvokeTransactionV0Filter,
-      InvokeTransactionV1Filter,
-      InvokeTransactionV3Filter,
-      DeployTransactionFilter,
-      DeclareV0TransactionFilter,
-      DeclareV1TransactionFilter,
-      DeclareV2TransactionFilter,
-      DeclareV3TransactionFilter,
-      DeclareV3TransactionFilter,
-      L1HandlerTransactionFilter,
-      DeployAccountV1TransactionFilter,
-      DeployAccountV3TransactionFilter,
-    ),
+export const TransactionFilter = MessageCodec({
+  id: OptionalCodec(NumberCodec),
+  transactionStatus: OptionalCodec(TransactionStatusFilter),
+  includeReceipt: OptionalCodec(BooleanCodec),
+  includeMessages: OptionalCodec(BooleanCodec),
+  includeEvents: OptionalCodec(BooleanCodec),
+  includeTrace: OptionalCodec(BooleanCodec),
+  transactionType: OptionalCodec(
+    OneOfCodec({
+      invokeV0: InvokeTransactionV0Filter,
+      invokeV1: InvokeTransactionV1Filter,
+      invokeV3: InvokeTransactionV3Filter,
+      deploy: DeployTransactionFilter,
+      declareV0: DeclareV0TransactionFilter,
+      declareV1: DeclareV1TransactionFilter,
+      declareV2: DeclareV2TransactionFilter,
+      declareV3: DeclareV3TransactionFilter,
+      l1Handler: L1HandlerTransactionFilter,
+      deployAccountV1: DeployAccountV1TransactionFilter,
+      deployAccountV3: DeployAccountV3TransactionFilter,
+    }),
   ),
 });
 
-export type TransactionFilter = typeof TransactionFilter.Type;
+export type TransactionFilter = Readonly<CodecType<typeof TransactionFilter>>;
 
 /** Filter storage diffs.
  *
  *  @prop contractAddress Filter by contract address.
  */
-export const StorageDiffFilter = Schema.Struct({
-  id: Schema.optional(Schema.Number),
-  contractAddress: Schema.optional(FieldElement),
+export const StorageDiffFilter = MessageCodec({
+  id: OptionalCodec(NumberCodec),
+  contractAddress: OptionalCodec(FieldElement),
 });
 
-export type StorageDiffFilter = typeof StorageDiffFilter.Type;
+export type StorageDiffFilter = Readonly<CodecType<typeof StorageDiffFilter>>;
 
 /** Filter declared classes. */
-export const DeclaredClassFilter = Schema.Struct({
-  _tag: tag("declaredClass"),
-  declaredClass: Schema.Struct({}),
-});
+export const DeclaredClassFilter = MessageCodec({});
+export type DeclaredClassFilter = Readonly<
+  CodecType<typeof DeclaredClassFilter>
+>;
 
-export type DeclaredClassFilter = typeof DeclaredClassFilter.Type;
+export const ReplacedClassFilter = MessageCodec({});
+export type ReplacedClassFilter = Readonly<
+  CodecType<typeof ReplacedClassFilter>
+>;
 
-export const ReplacedClassFilter = Schema.Struct({
-  _tag: tag("replacedClass"),
-  replacedClass: Schema.Struct({}),
-});
-
-export type ReplacedClassFilter = typeof ReplacedClassFilter.Type;
-
-export const DeployedContractFilter = Schema.Struct({
-  _tag: tag("deployedContract"),
-  deployedContract: Schema.Struct({}),
-});
-
-export type DeployedContractFilter = typeof DeployedContractFilter.Type;
+export const DeployedContractFilter = MessageCodec({});
+export type DeployedContractFilter = Readonly<
+  CodecType<typeof DeployedContractFilter>
+>;
 
 /** Filter contract changes. */
-export const ContractChangeFilter = Schema.Struct({
-  id: Schema.optional(Schema.Number),
-  change: Schema.optional(
-    Schema.Union(
-      DeclaredClassFilter,
-      ReplacedClassFilter,
-      DeployedContractFilter,
-    ),
+export const ContractChangeFilter = MessageCodec({
+  id: OptionalCodec(NumberCodec),
+  change: OptionalCodec(
+    OneOfCodec({
+      declaredClass: DeclaredClassFilter,
+      replacedClass: ReplacedClassFilter,
+      deployedContract: DeployedContractFilter,
+    }),
   ),
 });
 
-export type ContractChangeFilter = typeof ContractChangeFilter.Type;
+export type ContractChangeFilter = Readonly<
+  CodecType<typeof ContractChangeFilter>
+>;
 
 /** Filter updates to nonces.
  *
  * @prop contractAddress Filter by contract address.
  */
-export const NonceUpdateFilter = Schema.Struct({
-  id: Schema.optional(Schema.Number),
-  contractAddress: Schema.optional(FieldElement),
+export const NonceUpdateFilter = MessageCodec({
+  id: OptionalCodec(NumberCodec),
+  contractAddress: OptionalCodec(FieldElement),
 });
 
-export type NonceUpdateFilter = typeof NonceUpdateFilter.Type;
+export type NonceUpdateFilter = Readonly<CodecType<typeof NonceUpdateFilter>>;
 
-export const Filter = Schema.Struct({
-  header: Schema.optional(HeaderFilter),
-  transactions: Schema.optional(Schema.Array(TransactionFilter)),
-  events: Schema.optional(Schema.Array(EventFilter)),
-  messages: Schema.optional(Schema.Array(MessageToL1Filter)),
-  storageDiffs: Schema.optional(Schema.Array(StorageDiffFilter)),
-  contractChanges: Schema.optional(Schema.Array(ContractChangeFilter)),
-  nonceUpdates: Schema.optional(Schema.Array(NonceUpdateFilter)),
+export const Filter = MessageCodec({
+  header: OptionalCodec(HeaderFilter),
+  transactions: OptionalCodec(ArrayCodec(TransactionFilter)),
+  events: OptionalCodec(ArrayCodec(EventFilter)),
+  messages: OptionalCodec(ArrayCodec(MessageToL1Filter)),
+  storageDiffs: OptionalCodec(ArrayCodec(StorageDiffFilter)),
+  contractChanges: OptionalCodec(ArrayCodec(ContractChangeFilter)),
+  nonceUpdates: OptionalCodec(ArrayCodec(NonceUpdateFilter)),
 });
 
-export type Filter = typeof Filter.Type;
-
-export const filterToProto = Schema.encodeSync(Filter);
-export const filterFromProto = Schema.decodeSync(Filter);
-
-export const FilterFromBytes = Schema.transform(
-  Schema.Uint8ArrayFromSelf,
-  Filter,
-  {
-    strict: false,
-    decode(value) {
-      return proto.filter.Filter.decode(value);
-    },
-    encode(value) {
-      return proto.filter.Filter.encode(value).finish();
-    },
-  },
-);
+export type Filter = Readonly<CodecType<typeof Filter>>;
 
-export const filterToBytes = Schema.encodeSync(FilterFromBytes);
-export const filterFromBytes = Schema.decodeSync(FilterFromBytes);
+export const FilterFromBytes: Codec<Filter, Uint8Array> = {
+  encode(x) {
+    const filter = Filter.encode(x);
+    return proto.filter.Filter.encode(filter).finish();
+  },
+  decode(p) {
+    const filter = proto.filter.Filter.decode(p);
+    return Filter.decode(filter);
+  },
+};
 
 export function mergeFilter(a: Filter, b: Filter): Filter {
   const header = mergeHeaderFilter(a.header, b.header);

package/src/index.ts

@@ -15,6 +15,8 @@ export { getBigIntSelector, getEventSelector, getSelector } from "./abi";
 
 declare module "abi-wan-kanabi" {
   interface Config {
+    AddressType: `0x${string}`;
+    ClassHashType: `0x${string}`;
     FeltType: bigint;
     BigIntType: bigint;
     U256Type: bigint;

package/src/parser.ts

@@ -77,7 +77,7 @@ export function parseU256(data: readonly FieldElement[], offset: number) {
 export function parseAsHex(data: readonly FieldElement[], offset: number) {
   assertInBounds(data, offset);
   return {
-    out: String(data[offset]),
+    out: data[offset],
     offset: offset + 1,
   };
 }
@@ -96,7 +96,7 @@ export function parseFelt252(data: readonly FieldElement[], offset: number) {
   };
 }
 
-export function parseEmpty(data: readonly FieldElement[], offset: number) {
+export function parseEmpty(_data: readonly FieldElement[], offset: number) {
   return { out: null, offset };
 }
 
@@ -132,13 +132,13 @@ export function parseOption<T>(type: Parser<T>) {
   };
 }
 
-export function parseStruct<T extends { [key: string]: unknown }>(
+export function parseStruct<T extends Record<string, unknown>>(
   parsers: { [K in keyof T]: { index: number; parser: Parser<T[K]> } },
-) {
+): Parser<{ [K in keyof T]: T[K] }> {
   const sortedParsers = Object.entries(parsers).sort(
     (a, b) => a[1].index - b[1].index,
   );
-  return (data: readonly FieldElement[], startingOffset: number) => {
+  const parser = (data: readonly FieldElement[], startingOffset: number) => {
     let offset = startingOffset;
     const out: Record<string, unknown> = {};
     for (const [key, { parser }] of sortedParsers) {
@@ -148,6 +148,7 @@ export function parseStruct<T extends { [key: string]: unknown }>(
     }
     return { out, offset };
   };
+  return parser as Parser<{ [K in keyof T]: T[K] }>;
 }
 
 export function parseTuple<T extends Parser<unknown>[]>(

package/dist/shared/starknet.2b19268a.d.cts

@@ -1,32 +0,0 @@
-import * as _effect_schema_AST from '@effect/schema/AST';
-import { Schema } from '@effect/schema';
-
-/** Wire representation of `FieldElement`. */
-declare const FieldElementProto: Schema.Struct<{
-    x0: typeof Schema.BigIntFromSelf;
-    x1: typeof Schema.BigIntFromSelf;
-    x2: typeof Schema.BigIntFromSelf;
-    x3: typeof Schema.BigIntFromSelf;
-}>;
-/** Field element. */
-declare const FieldElement: Schema.transform<Schema.Struct<{
-    x0: typeof Schema.BigIntFromSelf;
-    x1: typeof Schema.BigIntFromSelf;
-    x2: typeof Schema.BigIntFromSelf;
-    x3: typeof Schema.BigIntFromSelf;
-}>, Schema.SchemaClass<`0x${string}`, `0x${string}`, never>>;
-type FieldElement = Schema.Schema.Type<typeof FieldElement>;
-declare const feltToProto: (a: `0x${string}`, overrideOptions?: _effect_schema_AST.ParseOptions) => {
-    readonly x0: bigint;
-    readonly x1: bigint;
-    readonly x2: bigint;
-    readonly x3: bigint;
-};
-declare const feltFromProto: (i: {
-    readonly x0: bigint;
-    readonly x1: bigint;
-    readonly x2: bigint;
-    readonly x3: bigint;
-}, overrideOptions?: _effect_schema_AST.ParseOptions) => `0x${string}`;
-
-export { FieldElement as F, FieldElementProto as a, feltFromProto as b, feltToProto as f };