feat(types): support CairoOption

Author: MartianGreed

examples/example-vite-react-sdk/src/useSystemCalls.ts

@@ -52,7 +52,6 @@ export const useSystemCalls = () => {
         try {
             // Execute the spawn action from the client
             // await client.actions.spawn(account!);
-            console.log(dojoProvider.spawn);
             await dojoProvider.spawn(account!);
 
             // Wait for the entity to be updated with the new state

packages/core/src/provider/DojoProvider.ts

@@ -356,15 +356,13 @@ class DojoProviderBase extends Provider {
                     continue;
                 }
 
-                // check here in interfaces and then in function having name matching
                 const interfaceAbi = abiItems.find(
                     (item: any) =>
                         item?.type === "interface" &&
                         item?.items.find(
                             (i: any) =>
                                 i?.type === "function" && i?.name === systemName
                         )
-                    // item?.type === "function" && item?.name === systemName
                 );
 
                 if (!interfaceAbi) {

packages/core/src/types/README.md

@@ -48,7 +48,7 @@ type ModelPath = ModelPathFromAbi<typeof compiledAbi>; // e.g. "dojo_starter-Pos
 ## Extracted type groups
 
 - **`structs`** – Cairo structs mapped to TypeScript objects with nested references resolved.
-- **`enums`** – Cairo enums with a `CairoCustomEnum` instance type, a `variantNames` union, and a strongly typed `variants` map.
+- **`enums`** – Cairo enums with a `CairoCustomEnum` instance type (or `CairoOption` for `core::option::Option`), a `variantNames` union, and a strongly typed `variants` map.
 - **`interfaces`** – Contract interfaces keyed by fully qualified name with typed function signatures.
 - **`models`** – Dojo models grouped by namespace; the shape aligns with `SchemaType` used throughout the SDK.
 - **`actions`** – System action interfaces grouped by namespace, preserving typed inputs and outputs.
@@ -58,6 +58,10 @@ type Direction = Abi["enums"]["dojo_starter::models::Direction"];
 type DirectionValue = Direction["type"]; // CairoCustomEnum
 type DirectionVariants = Direction["variantNames"]; // "Up" | "Down" | ...
 
+type OptionalDirection =
+    Abi["enums"]["core::option::Option::<dojo_starter::models::Direction>"];
+type OptionalDirectionValue = OptionalDirection["type"]; // CairoOption<DirectionValue>
+
 type Actions = Abi["actions"]["dojo_starter"]["IActions"];
 type SpawnInputs = Actions["spawn"]["inputs"]; // { entity: Position; ... }
 ```

packages/core/src/types/example-usage.ts

@@ -11,6 +11,8 @@ import { compiledAbi } from "../../../../worlds/dojo-starter/compiled-abi";
 import {
     Account,
     CairoCustomEnum,
+    CairoOption,
+    CairoOptionVariant,
     ETransactionVersion,
     ProviderInterface,
 } from "starknet";
@@ -39,6 +41,8 @@ type MyAbiStructs = MyAbi["structs"];
 type MyAbiEnums = MyAbi["enums"];
 type MyAbiFunctions = MyAbi["functions"];
 type MyAbiInterfaces = MyAbi["interfaces"];
+type OptionnalNumber = MyAbiEnums["core::option::Option::<core::integer::u32>"];
+const e = new CairoOption(CairoOptionVariant.Some, 12);
 
 type DojoStarterActions =
     MyAbiInterfaces["dojo_starter::systems::actions::IActions"];
@@ -66,8 +70,8 @@ provider.register_contract(account, {
 });
 provider.delete_entities(account, {
     model_selector: "test",
-    indexes: ["Keys"],
-    layout: "Fixed",
+    indexes: new CairoCustomEnum({ Id: "()" }),
+    layout: new CairoCustomEnum({ Fixed: "()" }),
 });
 
 // Now you can use the extracted types
@@ -89,6 +93,16 @@ type DirectionValue = Direction["type"]; // CairoCustomEnum
 type DirectionVariantNames = Direction["variantNames"]; // "None" | "Up" | "Down" | "Left" | "Right"
 type DirectionVariantMap = Direction["variants"]; // Object with variant names as keys
 
+type OptionalDirection =
+    MyAbi["enums"]["core::option::Option::<dojo_starter::models::Direction>"];
+type OptionalDirectionValue = OptionalDirection["type"]; // CairoOption<DirectionValue>
+const od: OptionalDirectionValue = new CairoOption(CairoOptionVariant.None);
+
+const maybeDirection: OptionalDirectionValue = new CairoOption(
+    CairoOptionVariant.Some,
+    new CairoCustomEnum({ Up: "()" })
+);
+
 // Interface types - access interface functions
 type IWorld = MyAbi["interfaces"]["dojo::world::iworld::IWorld"];
 type WorldResourceFunction = IWorld["resource"]; // { inputs: { selector: string }, outputs: Resource }

packages/core/src/types/index.test.ts

@@ -38,6 +38,22 @@ const sampleAbi = {
                 { name: "Right", type: "()" },
             ],
         },
+        {
+            type: "enum",
+            name: "core::option::Option::<demo::models::Direction>",
+            variants: [
+                { name: "Some", type: "demo::models::Direction" },
+                { name: "None", type: "()" },
+            ],
+        },
+        {
+            type: "enum",
+            name: "core::option::Option::<core::integer::u32>",
+            variants: [
+                { name: "Some", type: "core::integer::u32" },
+                { name: "None", type: "()" },
+            ],
+        },
         {
             type: "function",
             name: "move",
@@ -109,6 +125,30 @@ describe("ExtractAbiTypes", () => {
             "Up" | "Down" | "Left" | "Right"
         >();
 
+        type OptionalDirection = Extracted["enums"][
+            "core::option::Option::<demo::models::Direction>"
+        ];
+
+        expectTypeOf<OptionalDirection["type"]>().toEqualTypeOf<
+            CairoOption<DirectionEnum["type"]>
+        >();
+        expectTypeOf<OptionalDirection["variantNames"]>().toEqualTypeOf<
+            "Some" | "None"
+        >();
+        expectTypeOf<OptionalDirection["variants"].Some>().toEqualTypeOf<
+            DirectionEnum["type"]
+        >();
+        expectTypeOf<OptionalDirection["variants"].None>().toEqualTypeOf<
+            void
+        >();
+
+        type OptionalScore = Extracted["enums"][
+            "core::option::Option::<core::integer::u32>"
+        ];
+
+        expectTypeOf<OptionalScore["type"]>().toEqualTypeOf<CairoOption<number>>();
+        expectTypeOf<OptionalScore["variants"].Some>().toEqualTypeOf<number>();
+
         type Actions = ActionsFromAbi<typeof sampleAbi>;
         expectTypeOf<keyof Actions>().toEqualTypeOf<"demo">();
         expectTypeOf<keyof Actions["demo"]>().toEqualTypeOf<"IActions">();

packages/core/src/types/index.ts

@@ -1,4 +1,4 @@
-import { Calldata, CairoCustomEnum, RawArgs } from "starknet";
+import { Calldata, CairoCustomEnum, CairoOption, RawArgs } from "starknet";
 
 /**
  * Enumeration representing various entry points or functions available in the World.
@@ -355,10 +355,12 @@ type ExtractEnumType<
 > = ExtractEnumVariants<Name, ABI> extends infer VariantMap
     ? [VariantMap] extends [never]
         ? never
-        : CairoCustomEnum & {
-              readonly __variantMap?: VariantMap;
-              readonly __variantNames?: keyof VariantMap & string;
-          }
+        : Name extends `core::option::Option::<${infer Inner}>`
+            ? CairoOption<MapCairoType<Inner, ABI>>
+            : CairoCustomEnum & {
+                  readonly __variantMap?: VariantMap;
+                  readonly __variantNames?: keyof VariantMap & string;
+              }
     : never;
 
 /**

packages/sdk/.gitignore

@@ -1,3 +1,4 @@
 node_modules
 dist
 tsup.node.bundled_*
+tsup.web.bundled_*