@ic-reactor/candid 3.0.14-beta.0 → 3.0.14-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ic-reactor/candid",
-  "version": "3.0.14-beta.0",
+  "version": "3.0.14-beta.1",
   "description": "IC Reactor Candid Adapter - Fetch and parse Candid definitions from Internet Computer canisters",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -44,7 +44,7 @@
   "dependencies": {
     "@noble/hashes": "^2.0.1",
     "zod": "^4.3.5",
-    "@ic-reactor/core": "^3.0.14-beta.0"
+    "@ic-reactor/core": "^3.0.14-beta.1"
   },
   "peerDependencies": {
     "zod": "^4.3.5",

package/src/visitor/arguments/helpers.ts

@@ -1,5 +1,5 @@
 import {
-  ArgumentFieldType,
+  VisitorDataType,
   CompoundField,
   FieldNode,
   FieldByType,
@@ -27,7 +27,7 @@ import {
  * }
  * ```
  */
-export function isFieldType<T extends ArgumentFieldType>(
+export function isFieldType<T extends VisitorDataType>(
   field: FieldNode,
   type: T
 ): field is FieldByType<T> {

package/src/visitor/arguments/index.test.ts

@@ -148,8 +148,8 @@ describe("ArgumentFieldVisitor", () => {
       expect(field.type).toBe("record")
       expect(field.label).toBe("person")
       expect(field.fields).toHaveLength(2)
-      expect(field.fieldMap.has("name")).toBe(true)
-      expect(field.fieldMap.has("age")).toBe(true)
+      expect(field.fields.some((f) => f.label === "name")).toBe(true)
+      expect(field.fields.some((f) => f.label === "age")).toBe(true)
 
       const nameField = field.fields.find((f) => f.label === "name")
       if (!nameField || nameField.type !== "text") {
@@ -289,14 +289,14 @@ describe("ArgumentFieldVisitor", () => {
 
       expect(field.type).toBe("variant")
       expect(field.label).toBe("status")
-      expect(field.options).toEqual(["Inactive", "Active", "Pending"])
+      expect(field.fields.map((f) => f.label)).toEqual([
+        "Inactive",
+        "Active",
+        "Pending",
+      ])
       expect(field.defaultOption).toBe("Inactive")
       expect(field.fields).toHaveLength(3)
-      expect(field.optionMap.has("Active")).toBe(true)
-
-      field.fields.forEach((f) => {
-        expect(f.type).toBe("null")
-      })
+      expect(field.fields.some((f) => f.label === "Active")).toBe(true)
 
       // Test getOptionDefault helper
       expect(field.getOptionDefault("Active")).toEqual({ _type: "Active" })
@@ -338,7 +338,11 @@ describe("ArgumentFieldVisitor", () => {
       )
 
       expect(field.type).toBe("variant")
-      expect(field.options).toEqual(["Approve", "Burn", "Transfer"]) // Sorted order
+      expect(field.fields.map((f) => f.label)).toEqual([
+        "Approve",
+        "Burn",
+        "Transfer",
+      ]) // Sorted order
 
       const transferField = field.fields.find(
         (f) => f.label === "Transfer"
@@ -371,8 +375,8 @@ describe("ArgumentFieldVisitor", () => {
       )
 
       expect(field.type).toBe("variant")
-      expect(field.options).toContain("Ok")
-      expect(field.options).toContain("Err")
+      expect(field.fields.some((f) => f.label === "Ok")).toBe(true)
+      expect(field.fields.some((f) => f.label === "Err")).toBe(true)
 
       const okField = field.fields.find((f) => f.label === "Ok")
       if (!okField || okField.type !== "text") {
@@ -567,8 +571,8 @@ describe("ArgumentFieldVisitor", () => {
         throw new Error("Extracted field is not variant")
       }
       expect(extracted.type).toBe("variant")
-      expect(extracted.options).toContain("Leaf")
-      expect(extracted.options).toContain("Node")
+      expect(extracted.fields.some((f) => f.label === "Leaf")).toBe(true)
+      expect(extracted.fields.some((f) => f.label === "Node")).toBe(true)
     })
 
     it("should handle recursive linked list", () => {
@@ -602,7 +606,7 @@ describe("ArgumentFieldVisitor", () => {
         throw new Error("Extracted field is not variant")
       }
       expect(extracted.type).toBe("variant")
-      expect(extracted.options).toEqual(["Nil", "Cons"])
+      expect(extracted.fields.map((f) => f.label)).toEqual(["Nil", "Cons"])
 
       const consField = extracted.fields.find(
         (f) => f.label === "Cons"
@@ -919,9 +923,13 @@ describe("ArgumentFieldVisitor", () => {
       )
 
       expect(field.type).toBe("variant")
-      expect(field.options).toContain("Motion")
-      expect(field.options).toContain("TransferSnsTreasuryFunds")
-      expect(field.options).toContain("UpgradeSnsControlledCanister")
+      expect(field.fields.some((f) => f.label === "Motion")).toBe(true)
+      expect(
+        field.fields.some((f) => f.label === "TransferSnsTreasuryFunds")
+      ).toBe(true)
+      expect(
+        field.fields.some((f) => f.label === "UpgradeSnsControlledCanister")
+      ).toBe(true)
 
       // Check Motion variant
       const motionField = field.fields.find(
@@ -1392,4 +1400,40 @@ describe("ArgumentFieldVisitor", () => {
       }
     })
   })
+
+  // ════════════════════════════════════════════════════════════════════════
+  // Format Detection
+  // ════════════════════════════════════════════════════════════════════════
+
+  describe("Format Detection", () => {
+    it("should NOT detect eth format for method_name", () => {
+      const field = visitor.visitText(IDL.Text, "method_name")
+      expect(field.format).toBe("plain")
+    })
+
+    it("should detect eth format for my_eth_address", () => {
+      const field = visitor.visitText(IDL.Text, "my_eth_address")
+      expect(field.format).toBe("eth")
+    })
+
+    it("should detect eth format for myEthAddress", () => {
+      const field = visitor.visitText(IDL.Text, "myEthAddress")
+      expect(field.format).toBe("eth")
+    })
+
+    it("should detect eth format for ethereum", () => {
+      const field = visitor.visitText(IDL.Text, "ethereum")
+      expect(field.format).toBe("eth")
+    })
+
+    it("should detect btc format for bitcoin_address", () => {
+      const field = visitor.visitText(IDL.Text, "bitcoin_address")
+      expect(field.format).toBe("btc")
+    })
+
+    it("should NOT detect btc format for debt", () => {
+      const field = visitor.visitText(IDL.Text, "debt")
+      expect(field.format).toBe("plain")
+    })
+  })
 })

package/src/visitor/arguments/index.ts

@@ -278,7 +278,6 @@ export class FieldVisitor<A = BaseActor> extends IDL.Visitor<
   ): RecordField {
     const name = this.currentName()
     const fields: FieldNode[] = []
-    const fieldMap = new Map<string, FieldNode>()
     const defaultValue: Record<string, unknown> = {}
     const schemaShape: Record<string, z.ZodTypeAny> = {}
 
@@ -288,7 +287,6 @@ export class FieldVisitor<A = BaseActor> extends IDL.Visitor<
       ) as FieldNode
 
       fields.push(field)
-      fieldMap.set(key, field)
       defaultValue[key] = field.defaultValue
       schemaShape[key] = field.schema
     }
@@ -303,7 +301,6 @@ export class FieldVisitor<A = BaseActor> extends IDL.Visitor<
       component: "record-container",
       renderHint: COMPOUND_RENDER_HINT,
       fields,
-      fieldMap,
       defaultValue,
       schema,
       candidType: "record",
@@ -317,8 +314,6 @@ export class FieldVisitor<A = BaseActor> extends IDL.Visitor<
   ): VariantField {
     const name = this.currentName()
     const fields: FieldNode[] = []
-    const options: string[] = []
-    const optionMap = new Map<string, FieldNode>()
     const variantSchemas: z.ZodTypeAny[] = []
 
     for (const [key, type] of fields_) {
@@ -327,8 +322,6 @@ export class FieldVisitor<A = BaseActor> extends IDL.Visitor<
       ) as FieldNode
 
       fields.push(field)
-      options.push(key)
-      optionMap.set(key, field)
 
       if (field.type === "null") {
         variantSchemas.push(z.object({ _type: z.literal(key) }))
@@ -342,8 +335,8 @@ export class FieldVisitor<A = BaseActor> extends IDL.Visitor<
       }
     }
 
-    const defaultOption = options[0]
     const firstField = fields[0]
+    const defaultOption = firstField.label
 
     const defaultValue =
       firstField.type === "null"
@@ -353,11 +346,11 @@ export class FieldVisitor<A = BaseActor> extends IDL.Visitor<
             [defaultOption]: firstField.defaultValue,
           }
 
-    const schema = z.union(variantSchemas)
+    const schema = z.union(variantSchemas as [z.ZodTypeAny, ...z.ZodTypeAny[]])
 
     // Helper to get default value for any option
     const getOptionDefault = (option: string): Record<string, unknown> => {
-      const optField = optionMap.get(option)
+      const optField = fields.find((f) => f.label === option)
       if (!optField) {
         throw new Error(`Unknown variant option: ${option}`)
       }
@@ -368,7 +361,7 @@ export class FieldVisitor<A = BaseActor> extends IDL.Visitor<
 
     // Helper to get field for a specific option
     const getField = (option: string): FieldNode => {
-      const optField = optionMap.get(option)
+      const optField = fields.find((f) => f.label === option)
       if (!optField) {
         throw new Error(`Unknown variant option: ${option}`)
       }
@@ -380,7 +373,9 @@ export class FieldVisitor<A = BaseActor> extends IDL.Visitor<
       if (value._type && typeof value._type === "string") {
         return value._type
       }
-      const validKeys = Object.keys(value).filter((k) => options.includes(k))
+      const validKeys = Object.keys(value).filter((k) =>
+        fields.some((f) => f.label === k)
+      )
       return validKeys[0] ?? defaultOption
     }
 
@@ -398,9 +393,7 @@ export class FieldVisitor<A = BaseActor> extends IDL.Visitor<
       component: "variant-select",
       renderHint: COMPOUND_RENDER_HINT,
       fields,
-      options,
       defaultOption,
-      optionMap,
       defaultValue,
       schema,
       getOptionDefault,