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

package/dist/index.cjs

@@ -8369,6 +8369,16 @@ function isEmptyType(type) {
   return type === "()";
 }
 
+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) {
     super(message);
@@ -8380,50 +8390,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);
@@ -8455,8 +8535,9 @@ function compileTypeParser(abi, type) {
     case "struct": {
       return compileStructParser(abi, typeAbi.members);
     }
-    case "enum":
-      throw new DecodeEventError("enum: not implemented");
+    case "enum": {
+      throw new DecodeEventError(`Enum types are not supported: ${type}`);
+    }
     default:
       throw new DecodeEventError(`Invalid type ${typeAbi.type}`);
   }

package/dist/index.d.cts

@@ -4,7 +4,7 @@ import _m0 from 'protobufjs/minimal.js';
 import { StreamConfig } from '@apibara/protocol';
 import { Abi } from 'abi-wan-kanabi';
 export { Abi } from 'abi-wan-kanabi';
-import { ExtractAbiEventNames, EventToPrimitiveType } from 'abi-wan-kanabi/kanabi';
+import { ExtractAbiEventNames, ExtractAbiEvent, AbiEventMember, StringToPrimitiveType } from 'abi-wan-kanabi/kanabi';
 
 declare const protobufPackage$1 = "starknet.v2";
 /** Starknet DNA definitions (data). */
@@ -5983,6 +5983,35 @@ declare function getTransaction(transactionIndex: number, params: {
     transactions: readonly Transaction[];
 } | readonly Transaction[]): Transaction | undefined;
 
+type ResolveNestedVariantType<TAbi extends Abi, TTypeName extends string> = EventToPrimitiveType<TAbi, TTypeName>;
+type VariantToTaggedUnion<TAbi extends Abi, TVariant extends AbiEventMember> = TVariant extends {
+    kind: "nested";
+} ? // Nested: Use the helper to resolve the payload type.
+{
+    _tag: TVariant["name"];
+} & {
+    [K in TVariant["name"]]: ResolveNestedVariantType<TAbi, TVariant["type"]>;
+} : TVariant extends {
+    kind: "flat";
+} ? EventToPrimitiveType<TAbi, TVariant["type"]> : never;
+type EventToPrimitiveType<TAbi extends Abi, TEventName extends ExtractAbiEventNames<TAbi>> = ExtractAbiEvent<TAbi, TEventName> extends infer TEventDef ? TEventDef extends {
+    type: "event";
+    kind: "struct";
+    members: infer TMembers extends readonly AbiEventMember[];
+} ? {
+    [Member in TMembers[number] as Member["name"]]: StringToPrimitiveType<TAbi, Member["type"]>;
+} : TEventDef extends {
+    type: "event";
+    kind: "enum";
+    variants: infer TVariants extends readonly AbiEventMember[];
+} ? {
+    [Idx in keyof TVariants]: VariantToTaggedUnion<TAbi, TVariants[Idx]>;
+}[number] : TEventDef extends {
+    type: "event";
+    kind: "enum";
+    variants: [];
+} ? never : never : never;
+
 declare class DecodeEventError extends Error {
     constructor(message: string);
 }
@@ -6015,6 +6044,8 @@ declare function getEventSelector(name: string): FieldElement$1;
 
 declare module "abi-wan-kanabi" {
     interface Config {
+        AddressType: `0x${string}`;
+        ClassHashType: `0x${string}`;
         FeltType: bigint;
         BigIntType: bigint;
         U256Type: bigint;

package/dist/index.d.mts

@@ -4,7 +4,7 @@ import _m0 from 'protobufjs/minimal.js';
 import { StreamConfig } from '@apibara/protocol';
 import { Abi } from 'abi-wan-kanabi';
 export { Abi } from 'abi-wan-kanabi';
-import { ExtractAbiEventNames, EventToPrimitiveType } from 'abi-wan-kanabi/kanabi';
+import { ExtractAbiEventNames, ExtractAbiEvent, AbiEventMember, StringToPrimitiveType } from 'abi-wan-kanabi/kanabi';
 
 declare const protobufPackage$1 = "starknet.v2";
 /** Starknet DNA definitions (data). */
@@ -5983,6 +5983,35 @@ declare function getTransaction(transactionIndex: number, params: {
     transactions: readonly Transaction[];
 } | readonly Transaction[]): Transaction | undefined;
 
+type ResolveNestedVariantType<TAbi extends Abi, TTypeName extends string> = EventToPrimitiveType<TAbi, TTypeName>;
+type VariantToTaggedUnion<TAbi extends Abi, TVariant extends AbiEventMember> = TVariant extends {
+    kind: "nested";
+} ? // Nested: Use the helper to resolve the payload type.
+{
+    _tag: TVariant["name"];
+} & {
+    [K in TVariant["name"]]: ResolveNestedVariantType<TAbi, TVariant["type"]>;
+} : TVariant extends {
+    kind: "flat";
+} ? EventToPrimitiveType<TAbi, TVariant["type"]> : never;
+type EventToPrimitiveType<TAbi extends Abi, TEventName extends ExtractAbiEventNames<TAbi>> = ExtractAbiEvent<TAbi, TEventName> extends infer TEventDef ? TEventDef extends {
+    type: "event";
+    kind: "struct";
+    members: infer TMembers extends readonly AbiEventMember[];
+} ? {
+    [Member in TMembers[number] as Member["name"]]: StringToPrimitiveType<TAbi, Member["type"]>;
+} : TEventDef extends {
+    type: "event";
+    kind: "enum";
+    variants: infer TVariants extends readonly AbiEventMember[];
+} ? {
+    [Idx in keyof TVariants]: VariantToTaggedUnion<TAbi, TVariants[Idx]>;
+}[number] : TEventDef extends {
+    type: "event";
+    kind: "enum";
+    variants: [];
+} ? never : never : never;
+
 declare class DecodeEventError extends Error {
     constructor(message: string);
 }
@@ -6015,6 +6044,8 @@ declare function getEventSelector(name: string): FieldElement$1;
 
 declare module "abi-wan-kanabi" {
     interface Config {
+        AddressType: `0x${string}`;
+        ClassHashType: `0x${string}`;
         FeltType: bigint;
         BigIntType: bigint;
         U256Type: bigint;

package/dist/index.d.ts

@@ -4,7 +4,7 @@ import _m0 from 'protobufjs/minimal.js';
 import { StreamConfig } from '@apibara/protocol';
 import { Abi } from 'abi-wan-kanabi';
 export { Abi } from 'abi-wan-kanabi';
-import { ExtractAbiEventNames, EventToPrimitiveType } from 'abi-wan-kanabi/kanabi';
+import { ExtractAbiEventNames, ExtractAbiEvent, AbiEventMember, StringToPrimitiveType } from 'abi-wan-kanabi/kanabi';
 
 declare const protobufPackage$1 = "starknet.v2";
 /** Starknet DNA definitions (data). */
@@ -5983,6 +5983,35 @@ declare function getTransaction(transactionIndex: number, params: {
     transactions: readonly Transaction[];
 } | readonly Transaction[]): Transaction | undefined;
 
+type ResolveNestedVariantType<TAbi extends Abi, TTypeName extends string> = EventToPrimitiveType<TAbi, TTypeName>;
+type VariantToTaggedUnion<TAbi extends Abi, TVariant extends AbiEventMember> = TVariant extends {
+    kind: "nested";
+} ? // Nested: Use the helper to resolve the payload type.
+{
+    _tag: TVariant["name"];
+} & {
+    [K in TVariant["name"]]: ResolveNestedVariantType<TAbi, TVariant["type"]>;
+} : TVariant extends {
+    kind: "flat";
+} ? EventToPrimitiveType<TAbi, TVariant["type"]> : never;
+type EventToPrimitiveType<TAbi extends Abi, TEventName extends ExtractAbiEventNames<TAbi>> = ExtractAbiEvent<TAbi, TEventName> extends infer TEventDef ? TEventDef extends {
+    type: "event";
+    kind: "struct";
+    members: infer TMembers extends readonly AbiEventMember[];
+} ? {
+    [Member in TMembers[number] as Member["name"]]: StringToPrimitiveType<TAbi, Member["type"]>;
+} : TEventDef extends {
+    type: "event";
+    kind: "enum";
+    variants: infer TVariants extends readonly AbiEventMember[];
+} ? {
+    [Idx in keyof TVariants]: VariantToTaggedUnion<TAbi, TVariants[Idx]>;
+}[number] : TEventDef extends {
+    type: "event";
+    kind: "enum";
+    variants: [];
+} ? never : never : never;
+
 declare class DecodeEventError extends Error {
     constructor(message: string);
 }
@@ -6015,6 +6044,8 @@ declare function getEventSelector(name: string): FieldElement$1;
 
 declare module "abi-wan-kanabi" {
     interface Config {
+        AddressType: `0x${string}`;
+        ClassHashType: `0x${string}`;
         FeltType: bigint;
         BigIntType: bigint;
         U256Type: bigint;

package/dist/index.mjs

@@ -8362,6 +8362,16 @@ function isEmptyType(type) {
   return type === "()";
 }
 
+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) {
     super(message);
@@ -8373,50 +8383,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 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 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);
@@ -8448,8 +8528,9 @@ function compileTypeParser(abi, type) {
     case "struct": {
       return compileStructParser(abi, typeAbi.members);
     }
-    case "enum":
-      throw new DecodeEventError("enum: not implemented");
+    case "enum": {
+      throw new DecodeEventError(`Enum types are not supported: ${type}`);
+    }
     default:
       throw new DecodeEventError(`Invalid type ${typeAbi.type}`);
   }

package/dist/parser.cjs

@@ -37,7 +37,7 @@ function parseU256(data, offset) {
 function parseAsHex(data, offset) {
   assertInBounds(data, offset);
   return {
-    out: String(data[offset]),
+    out: data[offset],
     offset: offset + 1
   };
 }
@@ -53,7 +53,7 @@ function parseFelt252(data, offset) {
     offset: offset + 1
   };
 }
-function parseEmpty(data, offset) {
+function parseEmpty(_data, offset) {
   return { out: null, offset };
 }
 function parseArray(type) {
@@ -84,16 +84,17 @@ function parseStruct(parsers) {
   const sortedParsers = Object.entries(parsers).sort(
     (a, b) => a[1].index - b[1].index
   );
-  return (data, startingOffset) => {
+  const parser = (data, startingOffset) => {
     let offset = startingOffset;
     const out = {};
-    for (const [key, { parser }] of sortedParsers) {
-      const { out: value, offset: newOffset } = parser(data, offset);
+    for (const [key, { parser: parser2 }] of sortedParsers) {
+      const { out: value, offset: newOffset } = parser2(data, offset);
       out[key] = value;
       offset = newOffset;
     }
     return { out, offset };
   };
+  return parser;
 }
 function parseTuple(...parsers) {
   return (data, startingOffset) => {

package/dist/parser.d.cts

@@ -28,7 +28,7 @@ declare function parseU256(data: readonly FieldElement[], offset: number): {
     offset: number;
 };
 declare function parseAsHex(data: readonly FieldElement[], offset: number): {
-    out: string;
+    out: `0x${string}`;
     offset: number;
 };
 declare const parseContractAddress: typeof parseAsHex;
@@ -40,7 +40,7 @@ declare function parseFelt252(data: readonly FieldElement[], offset: number): {
     out: bigint;
     offset: number;
 };
-declare function parseEmpty(data: readonly FieldElement[], offset: number): {
+declare function parseEmpty(_data: readonly FieldElement[], offset: number): {
     out: null;
     offset: number;
 };
@@ -53,17 +53,14 @@ declare function parseOption<T>(type: Parser<T>): (data: readonly FieldElement[]
     out: null;
     offset: number;
 };
-declare function parseStruct<T extends {
-    [key: string]: unknown;
-}>(parsers: {
+declare function parseStruct<T extends Record<string, unknown>>(parsers: {
     [K in keyof T]: {
         index: number;
         parser: Parser<T[K]>;
     };
-}): (data: readonly FieldElement[], startingOffset: number) => {
-    out: Record<string, unknown>;
-    offset: number;
-};
+}): Parser<{
+    [K in keyof T]: T[K];
+}>;
 declare function parseTuple<T extends Parser<unknown>[]>(...parsers: T): Parser<UnwrapParsers<T>>;
 type UnwrapParsers<TP> = {
     [Index in keyof TP]: TP[Index] extends Parser<infer U> ? U : never;

package/dist/parser.d.mts

@@ -28,7 +28,7 @@ declare function parseU256(data: readonly FieldElement[], offset: number): {
     offset: number;
 };
 declare function parseAsHex(data: readonly FieldElement[], offset: number): {
-    out: string;
+    out: `0x${string}`;
     offset: number;
 };
 declare const parseContractAddress: typeof parseAsHex;
@@ -40,7 +40,7 @@ declare function parseFelt252(data: readonly FieldElement[], offset: number): {
     out: bigint;
     offset: number;
 };
-declare function parseEmpty(data: readonly FieldElement[], offset: number): {
+declare function parseEmpty(_data: readonly FieldElement[], offset: number): {
     out: null;
     offset: number;
 };
@@ -53,17 +53,14 @@ declare function parseOption<T>(type: Parser<T>): (data: readonly FieldElement[]
     out: null;
     offset: number;
 };
-declare function parseStruct<T extends {
-    [key: string]: unknown;
-}>(parsers: {
+declare function parseStruct<T extends Record<string, unknown>>(parsers: {
     [K in keyof T]: {
         index: number;
         parser: Parser<T[K]>;
     };
-}): (data: readonly FieldElement[], startingOffset: number) => {
-    out: Record<string, unknown>;
-    offset: number;
-};
+}): Parser<{
+    [K in keyof T]: T[K];
+}>;
 declare function parseTuple<T extends Parser<unknown>[]>(...parsers: T): Parser<UnwrapParsers<T>>;
 type UnwrapParsers<TP> = {
     [Index in keyof TP]: TP[Index] extends Parser<infer U> ? U : never;

package/dist/parser.d.ts

@@ -28,7 +28,7 @@ declare function parseU256(data: readonly FieldElement[], offset: number): {
     offset: number;
 };
 declare function parseAsHex(data: readonly FieldElement[], offset: number): {
-    out: string;
+    out: `0x${string}`;
     offset: number;
 };
 declare const parseContractAddress: typeof parseAsHex;
@@ -40,7 +40,7 @@ declare function parseFelt252(data: readonly FieldElement[], offset: number): {
     out: bigint;
     offset: number;
 };
-declare function parseEmpty(data: readonly FieldElement[], offset: number): {
+declare function parseEmpty(_data: readonly FieldElement[], offset: number): {
     out: null;
     offset: number;
 };
@@ -53,17 +53,14 @@ declare function parseOption<T>(type: Parser<T>): (data: readonly FieldElement[]
     out: null;
     offset: number;
 };
-declare function parseStruct<T extends {
-    [key: string]: unknown;
-}>(parsers: {
+declare function parseStruct<T extends Record<string, unknown>>(parsers: {
     [K in keyof T]: {
         index: number;
         parser: Parser<T[K]>;
     };
-}): (data: readonly FieldElement[], startingOffset: number) => {
-    out: Record<string, unknown>;
-    offset: number;
-};
+}): Parser<{
+    [K in keyof T]: T[K];
+}>;
 declare function parseTuple<T extends Parser<unknown>[]>(...parsers: T): Parser<UnwrapParsers<T>>;
 type UnwrapParsers<TP> = {
     [Index in keyof TP]: TP[Index] extends Parser<infer U> ? U : never;

package/dist/parser.mjs

@@ -35,7 +35,7 @@ function parseU256(data, offset) {
 function parseAsHex(data, offset) {
   assertInBounds(data, offset);
   return {
-    out: String(data[offset]),
+    out: data[offset],
     offset: offset + 1
   };
 }
@@ -51,7 +51,7 @@ function parseFelt252(data, offset) {
     offset: offset + 1
   };
 }
-function parseEmpty(data, offset) {
+function parseEmpty(_data, offset) {
   return { out: null, offset };
 }
 function parseArray(type) {
@@ -82,16 +82,17 @@ function parseStruct(parsers) {
   const sortedParsers = Object.entries(parsers).sort(
     (a, b) => a[1].index - b[1].index
   );
-  return (data, startingOffset) => {
+  const parser = (data, startingOffset) => {
     let offset = startingOffset;
     const out = {};
-    for (const [key, { parser }] of sortedParsers) {
-      const { out: value, offset: newOffset } = parser(data, offset);
+    for (const [key, { parser: parser2 }] of sortedParsers) {
+      const { out: value, offset: newOffset } = parser2(data, offset);
       out[key] = value;
       offset = newOffset;
     }
     return { out, offset };
   };
+  return parser;
 }
 function parseTuple(...parsers) {
   return (data, startingOffset) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apibara/starknet",
-  "version": "2.1.0-beta.24",
+  "version": "2.1.0-beta.25",
   "type": "module",
   "files": [
     "dist",
@@ -27,8 +27,8 @@
     "build": "pnpm build:proto && unbuild",
     "build:proto": "buf generate proto",
     "typecheck": "tsc --noEmit",
-    "test": "vitest",
-    "test:ci": "vitest run",
+    "test": "vitest --typecheck",
+    "test:ci": "vitest run --typecheck",
     "lint": "biome check .",
     "lint:fix": "pnpm lint --write",
     "format": "biome format . --write"
@@ -42,7 +42,7 @@
     "vitest": "^1.6.0"
   },
   "dependencies": {
-    "@apibara/protocol": "2.1.0-beta.24",
+    "@apibara/protocol": "2.1.0-beta.25",
     "@scure/starknet": "^1.1.0",
     "abi-wan-kanabi": "^2.2.4",
     "effect": "^3.2.6",

package/src/abi-wan-helpers.ts

@@ -0,0 +1,140 @@
+/*
+
+This file extends "abi-wan-kanabi" to provide a more type-safe way to decode events.
+
+https://github.com/keep-starknet-strange/abi-wan-kanabi
+
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this software, either in source code form or as a compiled binary, for any purpose, commercial or non-commercial, and by any means.
+In jurisdictions that recognize copyright laws, the author or authors of this software dedicate any and all copyright interest in the software to the public domain. We make this dedication for the benefit of the public at large and to the detriment of our heirs and successors. We intend this dedication to be an overt act of relinquishment in perpetuity of all present and future rights to this software under copyright law.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+For more information, please refer to https://unlicense.org
+
+*/
+
+import type { Abi } from "abi-wan-kanabi";
+import type {
+  AbiEventMember,
+  ExtractAbiEvent,
+  ExtractAbiEventNames,
+  StringToPrimitiveType,
+} from "abi-wan-kanabi/kanabi";
+
+export type AbiEventStruct = {
+  type: "event";
+  name: string;
+  kind: "struct";
+  members: AbiEventMember[];
+};
+
+export type AbiMember = {
+  name: string;
+  type: string;
+};
+
+export type AbiEventEnum = {
+  type: "event";
+  name: string;
+  kind: "enum";
+  variants: AbiEventMember[];
+};
+
+export type AbiEvent = AbiEventStruct | AbiEventEnum;
+
+export type AbiItem = Abi[number];
+
+export type DecodeEventArgs<
+  TAbi extends Abi = Abi,
+  TEventName extends ExtractAbiEventNames<TAbi> = ExtractAbiEventNames<TAbi>,
+  TStrict extends boolean = true,
+> = {
+  abi: TAbi;
+  eventName: TEventName;
+  event: Event;
+  strict?: TStrict;
+};
+
+export type DecodedEvent<
+  TAbi extends Abi = Abi,
+  TEventName extends ExtractAbiEventNames<TAbi> = ExtractAbiEventNames<TAbi>,
+> = Event & {
+  eventName: TEventName;
+  args: EventToPrimitiveType<TAbi, TEventName>;
+};
+
+export type DecodeEventReturn<
+  TAbi extends Abi = Abi,
+  TEventName extends ExtractAbiEventNames<TAbi> = ExtractAbiEventNames<TAbi>,
+  TStrict extends boolean = true,
+> = TStrict extends true
+  ? DecodedEvent<TAbi, TEventName>
+  : DecodedEvent<TAbi, TEventName> | null;
+
+// Helper type to resolve the payload type of a nested variant.
+// when the type name corresponds to an event; resolves it using EventToPrimitiveType,
+export type ResolveNestedVariantType<
+  TAbi extends Abi,
+  TTypeName extends string,
+> = EventToPrimitiveType<TAbi, TTypeName>; // resolve its structure recursively
+
+// Helper type to convert a variant member (nested or flat) into its corresponding tagged union part(s).
+export type VariantToTaggedUnion<
+  TAbi extends Abi,
+  TVariant extends AbiEventMember,
+> = TVariant extends { kind: "nested" }
+  ? // Nested: Use the helper to resolve the payload type.
+    { _tag: TVariant["name"] } & {
+      [K in TVariant["name"]]: ResolveNestedVariantType<TAbi, TVariant["type"]>;
+    }
+  : TVariant extends { kind: "flat" }
+    ? // Flat: Recursively call EventToPrimitiveType on the referenced event type.
+      // This will return the union of tagged types for the nested event.
+      EventToPrimitiveType<TAbi, TVariant["type"]>
+    : never; // Should not happen for valid ABIs
+
+// Main type to convert an event definition (struct or enum) to its TS representation.
+export type EventToPrimitiveType<
+  TAbi extends Abi,
+  TEventName extends ExtractAbiEventNames<TAbi>,
+> = ExtractAbiEvent<TAbi, TEventName> extends infer TEventDef
+  ? TEventDef extends {
+      type: "event";
+      kind: "struct";
+      members: infer TMembers extends readonly AbiEventMember[];
+    }
+    ? // Struct Event: A simple object with member names as keys and their primitive types as values.
+      {
+        [Member in TMembers[number] as Member["name"]]: StringToPrimitiveType<
+          TAbi,
+          Member["type"]
+        >;
+      }
+    : TEventDef extends {
+          type: "event";
+          kind: "enum";
+          variants: infer TVariants extends readonly AbiEventMember[];
+        }
+      ? // Enum Event: Create a union of all possible tagged types derived from its variants.
+        {
+          // Map each variant to its corresponding tagged union structure(s).
+          [Idx in keyof TVariants]: VariantToTaggedUnion<TAbi, TVariants[Idx]>;
+        }[number] // Indexing with [number] converts the tuple of union parts into a single union type.
+      : // Explicitly handle empty enum events to ensure the `extends never` check works reliably.
+        TEventDef extends { type: "event"; kind: "enum"; variants: [] }
+        ? never
+        : // Not an event definition found for TEventName -> never
+          never
+  : // If the event name is not found in the ABI, return never.
+    never;
+
+export function isEventAbi(item: AbiItem): item is AbiEvent {
+  return item.type === "event";
+}
+
+export function isStructEventAbi(item: AbiItem): item is AbiEventStruct {
+  return isEventAbi(item) && item.kind === "struct";
+}
+
+export function isEnumEventAbi(item: AbiItem): item is AbiEventEnum {
+  return isEventAbi(item) && item.kind === "enum";
+}

package/src/event.ts

@@ -1,7 +1,6 @@
 import type { Abi } from "abi-wan-kanabi";
 import type {
   AbiEventMember,
-  EventToPrimitiveType,
   ExtractAbiEventNames,
 } from "abi-wan-kanabi/kanabi";
 import {
@@ -16,6 +15,16 @@ import {
   isPrimitiveType,
   isSpanType,
 } from "./abi";
+import {
+  type AbiEvent,
+  type AbiEventEnum,
+  type AbiEventStruct,
+  type AbiMember,
+  type EventToPrimitiveType,
+  isEnumEventAbi,
+  isEventAbi,
+  isStructEventAbi,
+} from "./abi-wan-helpers";
 import type { Event } from "./block";
 import {
   ParseError,
@@ -78,61 +87,184 @@ export function decodeEvent<
     (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 as DecodeEventReturn<TAbi, TEventName, TStrict>;
   }
 
-  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 as AbiEvent)?.kind}`,
+    );
+  } catch (error) {
+    if (
+      (error instanceof DecodeEventError || error instanceof ParseError) &&
+      !strict
+    ) {
+      return null as DecodeEventReturn<TAbi, TEventName, TStrict>;
+    }
+
+    throw error;
   }
+}
 
+function decodeStructEvent<
+  TAbi extends Abi = Abi,
+  TEventName extends ExtractAbiEventNames<TAbi> = ExtractAbiEventNames<TAbi>,
+>(
+  abi: TAbi,
+  eventAbi: AbiEventStruct,
+  event: Event,
+  eventName: TEventName,
+): DecodedEvent<TAbi, TEventName> {
   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 as DecodeEventReturn<TAbi, TEventName, TStrict>;
+    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,
-    } as EventToPrimitiveType<TAbi, TEventName>;
-
-    return {
-      ...event,
-      eventName,
-      args: decoded,
-    } as DecodedEvent<TAbi, TEventName>;
-  } catch (error) {
-    if (error instanceof DecodeEventError && !strict) {
-      return null as DecodeEventReturn<TAbi, TEventName, TStrict>;
-    }
+  const keysParser = compileEventMembers(abi, keysAbi);
+  const dataParser = compileEventMembers(abi, dataAbi);
 
-    if (error instanceof ParseError && !strict) {
-      return null as DecodeEventReturn<TAbi, TEventName, TStrict>;
+  const keysWithoutSelector = event.keys?.slice(1) ?? [];
+
+  const { out: decodedKeys } = keysParser(keysWithoutSelector, 0);
+  const { out: decodedData } = dataParser(event.data ?? [], 0);
+
+  const decoded = {
+    ...decodedKeys,
+    ...decodedData,
+  } as EventToPrimitiveType<TAbi, TEventName>;
+
+  return {
+    ...event,
+    eventName,
+    args: decoded,
+  } as DecodedEvent<TAbi, TEventName>;
+}
+
+function decodeEnumEvent<
+  TAbi extends Abi = Abi,
+  TEventName extends ExtractAbiEventNames<TAbi> = ExtractAbiEventNames<TAbi>,
+>(
+  abi: TAbi,
+  eventAbi: AbiEventEnum,
+  event: Event,
+  eventName: TEventName,
+): DecodedEvent<TAbi, TEventName> {
+  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];
+
+  // Create a map of all possible selectors to their variant paths
+  const selectorToVariant = buildVariantSelectorMap(abi, variants);
+
+  // Find the matching variant and path
+  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,
+    },
+  } as DecodedEvent<TAbi, TEventName>;
+}
+
+type EnumFlatVariantMap = Record<
+  string,
+  { variant: AbiEventMember; path: string[] }
+>;
+
+// Helper to build a map of all possible selectors to their variant paths
+function buildVariantSelectorMap(
+  abi: Abi,
+  variants: AbiEventMember[],
+): EnumFlatVariantMap {
+  const selectorMap: EnumFlatVariantMap = {};
+
+  for (const variant of variants) {
+    // For nested events, just map the variant's own selector
+    if (variant.kind === "nested") {
+      const selector = getEventSelector(variant.name);
+      selectorMap[selector] = { variant, path: [variant.name] };
     }
+    // For flat events, recursively map all possible selectors from the event hierarchy
+    else if (variant.kind === "flat") {
+      const flatEventName = variant.type;
+      const flatEventAbi = abi.find(
+        (item) => item.name === flatEventName && item.type === "event",
+      );
 
-    throw error;
+      // Skip if the flat event type is not found
+      if (!flatEventAbi) {
+        continue;
+      }
+
+      if (isEnumEventAbi(flatEventAbi)) {
+        // For enum events, recursively map all their variants
+        const nestedMap = buildVariantSelectorMap(abi, flatEventAbi.variants);
+
+        // Add this variant to the path for all nested selectors
+        for (const [
+          nestedSelector,
+          { variant: nestedVariant, path: nestedPath },
+        ] of Object.entries(nestedMap)) {
+          selectorMap[nestedSelector] = {
+            variant: nestedVariant,
+            path: [variant.name, ...nestedPath],
+          };
+        }
+      }
+    }
   }
+
+  return selectorMap;
 }
 
 function compileEventMembers<T extends Record<string, unknown>>(
@@ -176,18 +308,16 @@ function compileTypeParser(abi: Abi, type: string): Parser<unknown> {
     case "struct": {
       return compileStructParser(abi, typeAbi.members);
     }
-    case "enum":
-      throw new DecodeEventError("enum: not implemented");
+    case "enum": {
+      // This should never happen anyways as compileTypeParser is only called
+      // primitive types or to compile structs parsers.
+      throw new DecodeEventError(`Enum types are not supported: ${type}`);
+    }
     default:
       throw new DecodeEventError(`Invalid type ${typeAbi.type}`);
   }
 }
 
-type AbiMember = {
-  name: string;
-  type: string;
-};
-
 function compileStructParser(
   abi: Abi,
   members: readonly AbiMember[],

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>[]>(