midnight-mcp 0.1.39 → 0.1.40

package/dist/config/compact-version.d.ts

@@ -110,6 +110,19 @@ export declare const TYPE_COMPATIBILITY: {
         fix: string;
         note?: undefined;
     })[];
+    typeCasting: ({
+        from: string;
+        to: string;
+        direct: boolean;
+        fix: string;
+        note?: undefined;
+    } | {
+        from: string;
+        to: string;
+        direct: boolean;
+        note: string;
+        fix?: undefined;
+    })[];
     assignments: {
         types: string;
         works: boolean;
@@ -137,8 +150,7 @@ export declare const LEDGER_TYPE_LIMITS: {
             note: string;
         }[];
         typescriptAccess: string;
-        reason: string;
-        pattern: string;
+        note: string;
     };
     Set: {
         circuitOperations: {
@@ -147,7 +159,7 @@ export declare const LEDGER_TYPE_LIMITS: {
             note: string;
         }[];
         typescriptAccess: string;
-        reason: string;
+        note: string;
     };
     MerkleTree: {
         circuitOperations: {

package/dist/config/compact-version.js

@@ -190,7 +190,37 @@ export const TYPE_COMPATIBILITY = {
         {
             types: "Uint<N> + Uint<N>",
             works: true,
-            note: "Must fit in result width",
+            note: "Result is bounded type, cast back: (a + b) as Uint<64>",
+        },
+        {
+            types: "Uint<64> + Uint<64>",
+            works: true,
+            note: "Result is Uint<0..36893488147419103230>, must cast: (a + b) as Uint<64>",
+        },
+        {
+            types: "Uint<64> * Uint<64>",
+            works: true,
+            note: "Result is wide bounded type, cast back to target type",
+        },
+    ],
+    typeCasting: [
+        {
+            from: "Uint<64>",
+            to: "Bytes<32>",
+            direct: false,
+            fix: "Go through Field: (amount as Field) as Bytes<32>",
+        },
+        {
+            from: "Uint<N>",
+            to: "Field",
+            direct: true,
+            note: "Safe cast: value as Field",
+        },
+        {
+            from: "arithmetic result",
+            to: "Uint<64>",
+            direct: true,
+            note: "Required cast: (a + b) as Uint<64>",
         },
     ],
     assignments: [
@@ -240,25 +270,17 @@ export const LEDGER_TYPE_LIMITS = {
             { method: ".remove(key)", works: true, note: "Removes entry" },
             {
                 method: ".lookup(key)",
-                works: false,
-                note: "NOT available in circuits",
+                works: true,
+                note: "Returns Option<ValueType> - use in circuits",
             },
             {
                 method: ".member(key)",
-                works: false,
-                note: "NOT available in circuits",
+                works: true,
+                note: "Returns Boolean - checks if key exists",
             },
         ],
         typescriptAccess: "Query map via `contractState.data.get(key)` in TypeScript SDK",
-        reason: "ZK circuits prove transitions, not current state. Use witnesses for reads.",
-        pattern: `// To read a map value in a circuit, use a witness:
-witness get_stored_value(key: Bytes<32>): Field;
-
-export circuit update_if_exists(key: Bytes<32>, new_value: Field): [] {
-  const current = get_stored_value(key);  // Prover fetches from ledger
-  // ... use current value
-  data.insert(key, new_value);  // Update is allowed
-}`,
+        note: "Map.lookup() and Map.member() ARE available in circuits (verified with OpenZeppelin contracts)",
     },
     Set: {
         circuitOperations: [
@@ -266,12 +288,12 @@ export circuit update_if_exists(key: Bytes<32>, new_value: Field): [] {
             { method: ".remove(value)", works: true, note: "Removes from set" },
             {
                 method: ".member(value)",
-                works: false,
-                note: "NOT available in circuits",
+                works: true,
+                note: "Returns Boolean - checks if value exists in set",
             },
         ],
         typescriptAccess: "Check membership via `contractState.set.has(value)` in TypeScript SDK",
-        reason: "Same as Map - use witnesses for membership checks",
+        note: "Set.member() IS available in circuits",
     },
     MerkleTree: {
         circuitOperations: [
@@ -338,10 +360,34 @@ export ledger myField: Field;  // Not Cell<Field>`,
     },
     {
         error: "member access requires struct type",
-        cause: "Trying to use .member() or .lookup() on Map/Set in circuit",
-        fix: `Map/Set queries are not available in circuits.
-Use a witness to fetch the value from the prover:
-witness lookup_value(key: Bytes<32>): Field;`,
+        cause: "Trying to access a field on a non-struct type",
+        fix: `Make sure you're accessing a struct field, not a primitive.
+Map.lookup() and Map.member() ARE available in circuits.
+Check that the base type is actually a struct.`,
+    },
+    {
+        error: "potential witness-value disclosure must be declared",
+        cause: "Circuit parameter flows to ledger operation without disclose()",
+        fix: `Disclose parameters at the start of the circuit:
+export circuit my_circuit(param: Bytes<32>): [] {
+  const d_param = disclose(param);  // Acknowledge on-chain visibility
+  ledger.insert(d_param, value);    // Now use disclosed value
+}`,
+    },
+    {
+        error: "expected second argument of insert to have type Uint<64> but received Uint<0..N>",
+        cause: "Arithmetic result has bounded type, needs cast back to target",
+        fix: `Cast arithmetic results back to the target type:
+const new_balance = (current + amount) as Uint<64>;
+ledger_map.insert(key, new_balance);`,
+    },
+    {
+        error: "cannot cast from type Uint<64> to type Bytes<32>",
+        cause: "Direct Uint to Bytes cast not allowed",
+        fix: `Go through Field first:
+const amount_field = amount as Field;
+const amount_bytes = amount_field as Bytes<32>;
+// Or chained: (amount as Field) as Bytes<32>`,
     },
     {
         error: "cannot prove assertion",

package/dist/prompts/templates.js

@@ -142,6 +142,15 @@ Based on syntax reference, generate the contract using:
 - Empty tuple return: \`circuit fn(): []\` (NOT \`Void\`)
 - Export enums: \`export enum State { ... }\`
 - Wrap witness conditionals: \`if (disclose(witness == value))\`
+- Disclose circuit params that touch ledger: \`const d = disclose(param); ledger.insert(d, v);\`
+- Cast arithmetic results: \`(a + b) as Uint<64>\`
+- Uint to Bytes needs two casts: \`(amount as Field) as Bytes<32>\`
+
+### IMPORTANT: Compact is NOT TypeScript!
+- Map.lookup() and Set.member() ARE available in circuits
+- No 'function' keyword - use 'circuit' or 'pure circuit'
+- No 'void' - use '[]'
+- Enum access: \`Choice.rock\` NOT \`Choice::rock\`
 
 ### Step 3: Validate Before Returning
 Call \`midnight-extract-contract-structure\` with your generated code to check for:
@@ -386,6 +395,13 @@ If syntax errors found, call \`midnight-get-latest-syntax\` to get:
 - The \`commonMistakes\` array with correct patterns
 - Current \`quickStartTemplate\` for reference
 
+### Step 3: Check for Common Compiler Errors
+Match error message against known fixes:
+- "cannot cast from type Uint<64> to type Bytes<32>" → Use \`(amount as Field) as Bytes<32>\`
+- "expected type Uint<64> but received Uint<0..N>" → Cast arithmetic: \`(a + b) as Uint<64>\`
+- "potential witness-value disclosure must be declared" → Disclose params: \`const d = disclose(param);\`
+- Map.lookup() and Set.member() ARE available in circuits (ignore old advice saying they aren't)
+
 ---
 
 Please help me debug by:

package/dist/tools/repository/handlers.d.ts

@@ -195,6 +195,19 @@ export declare function getLatestSyntax(input: GetLatestSyntaxInput): Promise<{
             fix: string;
             note?: undefined;
         })[];
+        typeCasting: ({
+            from: string;
+            to: string;
+            direct: boolean;
+            fix: string;
+            note?: undefined;
+        } | {
+            from: string;
+            to: string;
+            direct: boolean;
+            note: string;
+            fix?: undefined;
+        })[];
         assignments: {
             types: string;
             works: boolean;
@@ -219,8 +232,7 @@ export declare function getLatestSyntax(input: GetLatestSyntaxInput): Promise<{
                 note: string;
             }[];
             typescriptAccess: string;
-            reason: string;
-            pattern: string;
+            note: string;
         };
         Set: {
             circuitOperations: {
@@ -229,7 +241,7 @@ export declare function getLatestSyntax(input: GetLatestSyntaxInput): Promise<{
                 note: string;
             }[];
             typescriptAccess: string;
-            reason: string;
+            note: string;
         };
         MerkleTree: {
             circuitOperations: {

package/dist/tools/repository/handlers.js

@@ -406,11 +406,6 @@ export circuit increment(): [] {
                         correct: "// Read via witness or TypeScript SDK",
                         error: 'operation "value" undefined for Counter',
                     },
-                    {
-                        wrong: "data.lookup(key)",
-                        correct: "// Use witness: witness get_value(key): Type;",
-                        error: "member access requires struct type",
-                    },
                     {
                         wrong: "Choice::rock (Rust-style)",
                         correct: "Choice.rock (dot notation)",
@@ -426,6 +421,21 @@ export circuit increment(): [] {
                         correct: "pure circuit helper(): T",
                         error: 'unbound identifier "function"',
                     },
+                    {
+                        wrong: "amount as Bytes<32>  // direct Uint to Bytes",
+                        correct: "(amount as Field) as Bytes<32>  // go through Field",
+                        error: "cannot cast from type Uint<64> to type Bytes<32>",
+                    },
+                    {
+                        wrong: "ledger.insert(key, a + b)  // arithmetic result",
+                        correct: "ledger.insert(key, (a + b) as Uint<64>)  // cast result",
+                        error: "expected type Uint<64> but received Uint<0..N>",
+                    },
+                    {
+                        wrong: "export circuit fn(param: T): [] { ledger.insert(param, v); }",
+                        correct: "export circuit fn(param: T): [] { const d = disclose(param); ledger.insert(d, v); }",
+                        error: "potential witness-value disclosure must be declared",
+                    },
                 ],
                 syntaxReference: compactReference,
                 sections: [
@@ -453,13 +463,19 @@ export circuit increment(): [] {
                     repo: rc.repo,
                     description: rc.description,
                 })),
-                note: `CRITICAL: Use quickStartTemplate as your base. Check commonMistakes and commonErrors before submitting code. 
-KEY GOTCHAS:
+                note: `⚠️ CALL THIS TOOL BEFORE generating ANY Compact code!
+Use quickStartTemplate as your base. Check commonMistakes BEFORE submitting code.
+
+KEY RULES:
 1. public_key() is NOT a builtin - use persistentHash pattern
 2. Counter.value() NOT available in circuits - use witnesses
-3. Map.lookup()/Set.member() NOT available in circuits - use witnesses
-4. Field vs Uint comparison requires casting
-This reference is for Compact ${COMPACT_VERSION.min}-${COMPACT_VERSION.max} (last updated: ${COMPACT_VERSION.lastUpdated}).`,
+3. Map.lookup()/Set.member() ARE available in circuits (verified)
+4. Arithmetic results need casting: (a + b) as Uint<64>
+5. Uint→Bytes needs two casts: (amount as Field) as Bytes<32>
+6. Circuit params touching ledger need disclose(): const d = disclose(param);
+
+Compact is NOT TypeScript - don't guess syntax, use this reference!
+Version: ${COMPACT_VERSION.min}-${COMPACT_VERSION.max} (updated: ${COMPACT_VERSION.lastUpdated}).`,
             };
         }
     }

package/dist/tools/repository/tools.js

@@ -223,7 +223,15 @@ export const repositoryTools = [
     },
     {
         name: "midnight-get-latest-syntax",
-        description: "Get the authoritative syntax reference for Compact language at the latest version. Use this as the source of truth when writing or reviewing contracts to ensure they compile.",
+        description: `🚨 CALL THIS BEFORE GENERATING ANY COMPACT CODE!
+Get the authoritative Compact syntax reference. Prevents hallucination by providing:
+- Correct syntax patterns (Compact is NOT TypeScript!)
+- commonMistakes array with wrong→correct mappings
+- Type casting rules (Uint→Bytes needs two casts)
+- disclose() requirements for circuit params
+- Map.lookup()/Set.member() ARE available in circuits
+
+ALWAYS check this reference before writing Compact contracts.`,
         inputSchema: {
             type: "object",
             properties: {
@@ -237,7 +245,7 @@ export const repositoryTools = [
         annotations: {
             readOnlyHint: true,
             openWorldHint: true,
-            title: "Get Latest Syntax Reference",
+            title: "🚨 Get Syntax Reference (Call First!)",
             category: "versioning",
         },
         handler: getLatestSyntax,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "midnight-mcp",
-  "version": "0.1.39",
+  "version": "0.1.40",
   "description": "Model Context Protocol Server for Midnight Blockchain Development",
   "type": "module",
   "main": "dist/index.js",