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

package/src/common.ts

@@ -1,40 +1,25 @@
-import { Schema } from "@effect/schema";
+import type { Codec, CodecType } from "@apibara/protocol/codec";
+import type * as proto from "./proto";
 
-const _FieldElement = Schema.TemplateLiteral(
-  Schema.Literal("0x"),
-  Schema.String,
-);
+const MAX_U64 = 0xffffffffffffffffn;
 
-/** Wire representation of `FieldElement`. */
-export const FieldElementProto = Schema.Struct({
-  x0: Schema.BigIntFromSelf,
-  x1: Schema.BigIntFromSelf,
-  x2: Schema.BigIntFromSelf,
-  x3: Schema.BigIntFromSelf,
-});
-
-/** Field element. */
-export const FieldElement = Schema.transform(FieldElementProto, _FieldElement, {
-  decode(value) {
-    const x0 = value.x0.toString(16).padStart(16, "0");
-    const x1 = value.x1.toString(16).padStart(16, "0");
-    const x2 = value.x2.toString(16).padStart(16, "0");
-    const x3 = value.x3.toString(16).padStart(16, "0");
-    return `0x${x0}${x1}${x2}${x3}` as `0x${string}`;
-  },
-  encode(value) {
-    const bn = BigInt(value);
-    const hex = bn.toString(16).padStart(64, "0");
-    const s = hex.length;
-    const x3 = BigInt(`0x${hex.slice(s - 16, s)}`);
-    const x2 = BigInt(`0x${hex.slice(s - 32, s - 16)}`);
-    const x1 = BigInt(`0x${hex.slice(s - 48, s - 32)}`);
-    const x0 = BigInt(`0x${hex.slice(s - 64, s - 48)}`);
+export const FieldElement: Codec<`0x${string}`, proto.common.FieldElement> = {
+  encode(x) {
+    const bn = BigInt(x);
+    const x3 = bn & MAX_U64;
+    const x2 = (bn >> 64n) & MAX_U64;
+    const x1 = (bn >> 128n) & MAX_U64;
+    const x0 = (bn >> 192n) & MAX_U64;
     return { x0, x1, x2, x3 };
   },
-});
-
-export type FieldElement = Schema.Schema.Type<typeof FieldElement>;
+  decode(p) {
+    const x0 = p.x0 ?? 0n;
+    const x1 = p.x1 ?? 0n;
+    const x2 = p.x2 ?? 0n;
+    const x3 = p.x3 ?? 0n;
+    const bn = x3 + (x2 << 64n) + (x1 << 128n) + (x0 << 192n);
+    return `0x${bn.toString(16).padStart(64, "0")}` as `0x${string}`;
+  },
+};
 
-export const feltToProto = Schema.encodeSync(FieldElement);
-export const feltFromProto = Schema.decodeSync(FieldElement);
+export type FieldElement = CodecType<typeof FieldElement>;

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 {
@@ -11,17 +10,31 @@ import {
   getOptionType,
   getSpanType,
   isArrayType,
+  isByteArray,
   isEmptyType,
   isOptionType,
   isPrimitiveType,
   isSpanType,
 } from "./abi";
+import {
+  type AbiEnum,
+  type AbiEvent,
+  type AbiEventEnum,
+  type AbiEventStruct,
+  type AbiMember,
+  type EventToPrimitiveType,
+  isEnumEventAbi,
+  isEventAbi,
+  isStructEventAbi,
+} from "./abi-wan-helpers";
 import type { Event } from "./block";
 import {
   ParseError,
   type Parser,
   parseArray,
+  parseByteArray,
   parseEmpty,
+  parseEnum,
   parseOption,
   parseSpan,
   parseStruct,
@@ -78,61 +91,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>>(
@@ -166,6 +302,10 @@ function compileTypeParser(abi: Abi, type: string): Parser<unknown> {
     return parseEmpty;
   }
 
+  if (isByteArray(type)) {
+    return parseByteArray;
+  }
+
   // Not a well-known type. Look it up in the ABI.
   const typeAbi = abi.find((item) => item.name === type);
   if (!typeAbi) {
@@ -176,18 +316,14 @@ 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": {
+      return compileEnumParser(abi, typeAbi);
+    }
     default:
       throw new DecodeEventError(`Invalid type ${typeAbi.type}`);
   }
 }
 
-type AbiMember = {
-  name: string;
-  type: string;
-};
-
 function compileStructParser(
   abi: Abi,
   members: readonly AbiMember[],
@@ -202,3 +338,15 @@ function compileStructParser(
   }
   return parseStruct(parsers);
 }
+
+function compileEnumParser(abi: Abi, enumAbi: AbiEnum): Parser<unknown> {
+  const parsers: Record<string, { index: number; parser: Parser<unknown> }> =
+    {};
+  for (const [index, variant] of enumAbi.variants.entries()) {
+    parsers[variant.name] = {
+      index,
+      parser: compileTypeParser(abi, variant.type),
+    };
+  }
+  return parseEnum(parsers);
+}