midnight-mcp 0.1.20 → 0.1.21

package/dist/tools/repository/validation.js

@@ -1294,6 +1294,91 @@ export async function extractContractStructure(input) {
             }
         }
     }
+    // 6. Detect division operator usage (not supported in Compact)
+    const divisionPattern = /[^/]\/[^/*]/g;
+    let divMatch;
+    while ((divMatch = divisionPattern.exec(code)) !== null) {
+        // Skip if inside a comment
+        const beforeDiv = code.substring(0, divMatch.index);
+        const lastLineStart = beforeDiv.lastIndexOf("\n") + 1;
+        const lineContent = beforeDiv.substring(lastLineStart);
+        if (lineContent.includes("//"))
+            continue;
+        const lineNum = lineByIndex[divMatch.index] || 1;
+        potentialIssues.push({
+            type: "unsupported_division",
+            line: lineNum,
+            message: `Division operator '/' is not supported in Compact`,
+            suggestion: `Use a witness-based division pattern: 'witness divideWithRemainder(a, b): [quotient, remainder]' with on-chain verification`,
+            severity: "error",
+        });
+        break; // Only warn once
+    }
+    // 7. Detect Counter.value access (Counter only has .increment())
+    const counterValuePattern = /(\w+)\.value\b/g;
+    let counterMatch;
+    while ((counterMatch = counterValuePattern.exec(code)) !== null) {
+        const varName = counterMatch[1];
+        // Check if this variable is a Counter type
+        const counterLedger = ledgerItems.find((l) => l.name === varName && l.type === "Counter");
+        if (counterLedger) {
+            const lineNum = lineByIndex[counterMatch.index] || 1;
+            potentialIssues.push({
+                type: "invalid_counter_access",
+                line: lineNum,
+                message: `Counter type '${varName}' does not have a '.value' property`,
+                suggestion: `Counter only has '.increment(n)'. Use 'Uint<32>' or 'Uint<64>' instead if you need to read the value`,
+                severity: "error",
+            });
+        }
+    }
+    // 8. Detect potential Uint overflow in multiplication (suggest Field casting)
+    const multiplyPattern = /(\w+)\s*\*\s*(\w+)(?:\s*\+\s*\w+)?\s*(?:as\s+Uint|==)/g;
+    let multMatch;
+    while ((multMatch = multiplyPattern.exec(code)) !== null) {
+        // Check if operands are likely Uint types and not already cast to Field
+        const beforeMult = code.substring(Math.max(0, multMatch.index - 200), multMatch.index);
+        const afterMult = code.substring(multMatch.index, multMatch.index + multMatch[0].length + 50);
+        // Skip if already casting to Field
+        if (afterMult.includes("as Field") || beforeMult.includes("as Field"))
+            continue;
+        // Check if this looks like a verification pattern (common in witness verification)
+        if (/assert|==/.test(afterMult)) {
+            const lineNum = lineByIndex[multMatch.index] || 1;
+            potentialIssues.push({
+                type: "potential_overflow",
+                line: lineNum,
+                message: `Multiplication '${multMatch[1]} * ${multMatch[2]}' may overflow Uint bounds`,
+                suggestion: `Cast operands to Field for safe arithmetic: '(${multMatch[1]} as Field) * (${multMatch[2]} as Field)'`,
+                severity: "warning",
+            });
+            break; // Only warn once
+        }
+    }
+    // 9. Detect witness/private values used in conditionals without disclose()
+    // Look for patterns like: if (witnessVar ...) or if (param == privateValue)
+    const witnessNames = witnesses.map((w) => w.name);
+    const ifPattern = /if\s*\(([^)]+)\)/g;
+    let ifMatch;
+    while ((ifMatch = ifPattern.exec(code)) !== null) {
+        const condition = ifMatch[1];
+        // Check if condition uses a witness value without disclose
+        for (const witnessName of witnessNames) {
+            if (condition.includes(witnessName) &&
+                !condition.includes(`disclose(${witnessName}`) &&
+                !condition.includes("disclose(")) {
+                const lineNum = lineByIndex[ifMatch.index] || 1;
+                potentialIssues.push({
+                    type: "undisclosed_witness_conditional",
+                    line: lineNum,
+                    message: `Witness value '${witnessName}' used in conditional without disclose()`,
+                    suggestion: `Wrap witness comparisons in disclose(): 'if (disclose(${witnessName} == expected))'`,
+                    severity: "warning",
+                });
+                break;
+            }
+        }
+    }
     const summary = [];
     if (circuits.length > 0) {
         summary.push(`${circuits.length} circuit(s)`);

package/package.json

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