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

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

@@ -1,6 +1,6 @@
-import { F as FieldElement } from './shared/starknet.2b19268a.cjs';
-import '@effect/schema/AST';
-import '@effect/schema';
+import { a as FieldElement } from './shared/starknet.e649ecb1.cjs';
+import '@apibara/protocol/codec';
+import 'protobufjs/minimal.js';
 
 type Parser<TOut> = (data: readonly FieldElement[], offset: number) => {
     out: TOut;
@@ -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

@@ -1,6 +1,6 @@
-import { F as FieldElement } from './shared/starknet.2b19268a.mjs';
-import '@effect/schema/AST';
-import '@effect/schema';
+import { a as FieldElement } from './shared/starknet.e649ecb1.mjs';
+import '@apibara/protocol/codec';
+import 'protobufjs/minimal.js';
 
 type Parser<TOut> = (data: readonly FieldElement[], offset: number) => {
     out: TOut;
@@ -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

@@ -1,6 +1,6 @@
-import { F as FieldElement } from './shared/starknet.2b19268a.js';
-import '@effect/schema/AST';
-import '@effect/schema';
+import { a as FieldElement } from './shared/starknet.e649ecb1.js';
+import '@apibara/protocol/codec';
+import 'protobufjs/minimal.js';
 
 type Parser<TOut> = (data: readonly FieldElement[], offset: number) => {
     out: TOut;
@@ -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/dist/shared/starknet.e649ecb1.d.cts

@@ -0,0 +1,40 @@
+import { Codec, CodecType } from '@apibara/protocol/codec';
+import _m0 from 'protobufjs/minimal.js';
+
+declare const protobufPackage = "starknet.v2";
+/** A field element. */
+interface FieldElement$1 {
+    readonly x0?: bigint | undefined;
+    readonly x1?: bigint | undefined;
+    readonly x2?: bigint | undefined;
+    readonly x3?: bigint | undefined;
+}
+declare const FieldElement$1: {
+    encode(message: FieldElement$1, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): FieldElement$1;
+    fromJSON(object: any): FieldElement$1;
+    toJSON(message: FieldElement$1): unknown;
+    create(base?: DeepPartial<FieldElement$1>): FieldElement$1;
+    fromPartial(object: DeepPartial<FieldElement$1>): FieldElement$1;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;
+type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {
+    readonly $case: string;
+} ? {
+    [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]>;
+} & {
+    readonly $case: T["$case"];
+} : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+
+type common_DeepPartial<T> = DeepPartial<T>;
+declare const common_protobufPackage: typeof protobufPackage;
+declare namespace common {
+  export { type common_DeepPartial as DeepPartial, FieldElement$1 as FieldElement, common_protobufPackage as protobufPackage };
+}
+
+declare const FieldElement: Codec<`0x${string}`, FieldElement$1>;
+type FieldElement = CodecType<typeof FieldElement>;
+
+export { FieldElement$1 as F, FieldElement as a, common as c };

package/dist/shared/starknet.e649ecb1.d.mts

@@ -0,0 +1,40 @@
+import { Codec, CodecType } from '@apibara/protocol/codec';
+import _m0 from 'protobufjs/minimal.js';
+
+declare const protobufPackage = "starknet.v2";
+/** A field element. */
+interface FieldElement$1 {
+    readonly x0?: bigint | undefined;
+    readonly x1?: bigint | undefined;
+    readonly x2?: bigint | undefined;
+    readonly x3?: bigint | undefined;
+}
+declare const FieldElement$1: {
+    encode(message: FieldElement$1, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): FieldElement$1;
+    fromJSON(object: any): FieldElement$1;
+    toJSON(message: FieldElement$1): unknown;
+    create(base?: DeepPartial<FieldElement$1>): FieldElement$1;
+    fromPartial(object: DeepPartial<FieldElement$1>): FieldElement$1;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;
+type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {
+    readonly $case: string;
+} ? {
+    [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]>;
+} & {
+    readonly $case: T["$case"];
+} : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+
+type common_DeepPartial<T> = DeepPartial<T>;
+declare const common_protobufPackage: typeof protobufPackage;
+declare namespace common {
+  export { type common_DeepPartial as DeepPartial, FieldElement$1 as FieldElement, common_protobufPackage as protobufPackage };
+}
+
+declare const FieldElement: Codec<`0x${string}`, FieldElement$1>;
+type FieldElement = CodecType<typeof FieldElement>;
+
+export { FieldElement$1 as F, FieldElement as a, common as c };

package/dist/shared/starknet.e649ecb1.d.ts

@@ -0,0 +1,40 @@
+import { Codec, CodecType } from '@apibara/protocol/codec';
+import _m0 from 'protobufjs/minimal.js';
+
+declare const protobufPackage = "starknet.v2";
+/** A field element. */
+interface FieldElement$1 {
+    readonly x0?: bigint | undefined;
+    readonly x1?: bigint | undefined;
+    readonly x2?: bigint | undefined;
+    readonly x3?: bigint | undefined;
+}
+declare const FieldElement$1: {
+    encode(message: FieldElement$1, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): FieldElement$1;
+    fromJSON(object: any): FieldElement$1;
+    toJSON(message: FieldElement$1): unknown;
+    create(base?: DeepPartial<FieldElement$1>): FieldElement$1;
+    fromPartial(object: DeepPartial<FieldElement$1>): FieldElement$1;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;
+type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {
+    readonly $case: string;
+} ? {
+    [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]>;
+} & {
+    readonly $case: T["$case"];
+} : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+
+type common_DeepPartial<T> = DeepPartial<T>;
+declare const common_protobufPackage: typeof protobufPackage;
+declare namespace common {
+  export { type common_DeepPartial as DeepPartial, FieldElement$1 as FieldElement, common_protobufPackage as protobufPackage };
+}
+
+declare const FieldElement: Codec<`0x${string}`, FieldElement$1>;
+type FieldElement = CodecType<typeof FieldElement>;
+
+export { FieldElement$1 as F, FieldElement as a, common as c };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apibara/starknet",
-  "version": "2.1.0-beta.23",
+  "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,8 +42,7 @@
     "vitest": "^1.6.0"
   },
   "dependencies": {
-    "@apibara/protocol": "2.1.0-beta.23",
-    "@effect/schema": "^0.67.15",
+    "@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";
+}