Add checker to validate manually entered reveal transitions

Shigoto-dev19 · Shigoto-dev19 · commit c428904ca040 · 2024-07-19T11:47:35.000+03:00
diff --git a/src/cli.ts b/src/cli.ts
@@ -1,3 +1,4 @@
+import { assert } from 'o1js';
 import { RegexCompiler } from './compiler.js';
 import { Command } from 'commander';
 
@@ -9,16 +10,17 @@ program
   .description('CLI for ZK Regex Compiler in o1js')
   .argument('<rawRegex>', 'Raw regex pattern to compile')
   .option('-c, --count', 'Enable count for match regex pattern')
-  .option('-t, --revealTransitions <values...>', 'Transitions to reveal')
+  .option(
+    '-t, --revealTransitions <values...>',
+    'Partial state transitions to reveal'
+  )
   .option('-s, --revealSubpatterns <values...>', 'Regex subpatterns to reveal')
   .action((rawRegex, options) => {
     // Extract and set the options
     const countEnabled = options.count || false;
     let revealEnabled = false;
 
-    // Initialize transitionInput to undefined
-    let transitionInput: string[] | [number, number][][] | undefined =
-      undefined;
+    let revealInput: string[] | [number, number][][] | undefined = undefined;
 
     // Ensure only one of --revealTransitions or --revealSubpatterns is provided
     if (options.revealTransitions && options.revealSubpatterns) {
@@ -28,20 +30,25 @@ program
       process.exit(1);
     }
 
+    // Initialize the RegexCompiler
+    const compiler = RegexCompiler.initialize(rawRegex, true);
+
     // Set transitionInput and revealEnabled based on the provided option
     if (options.revealTransitions) {
       revealEnabled = true;
-      transitionInput = parseTransitions(options.revealTransitions);
+      revealInput = parseTransitions(options.revealTransitions);
+
+      assertTransitionsIncluded(
+        revealInput,
+        compiler.extractSubPatternTransitions([rawRegex]).flat()
+      );
     } else if (options.revealSubpatterns) {
       revealEnabled = true;
-      transitionInput = options.revealSubpatterns;
+      revealInput = options.revealSubpatterns;
     }
 
-    // Initialize the RegexCompiler
-    const compiler = RegexCompiler.initialize(rawRegex, true);
-
     // Print the regex circuit based on the options
-    compiler.printRegexCircuit(countEnabled, revealEnabled, transitionInput);
+    compiler.printRegexCircuit(countEnabled, revealEnabled, revealInput);
   });
 
 // Parse the command-line arguments
@@ -60,6 +67,8 @@ function parseTransitions(inputArray: string[]): [number, number][][] {
 
     // Extract pairs of numbers from the cleaned string
     const pairs = cleanedString.match(/\[\d+,\d+\]/g);
+
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     return pairs!.map((pair) => {
       const [a, b] = pair.replace(/[[\]]/g, '').split(',').map(Number);
       if (isNaN(a) || isNaN(b)) {
@@ -69,3 +78,32 @@ function parseTransitions(inputArray: string[]): [number, number][][] {
     });
   });
 }
+
+/**
+ * Assert that all transitions to reveal are included in the full transition array.
+ *
+ * @param transitionsToReveal - The array of transitions to reveal.
+ * @param fullTransitions - The full array of transitions.
+ */
+function assertTransitionsIncluded(
+  transitionsToReveal: [number, number][][],
+  fullTransitions: [number, number][]
+): void {
+  // Convert fullTransitions to a Set of strings for quick lookup
+  const fullTransitionsSet = new Set(
+    fullTransitions.map((transition) => JSON.stringify(transition))
+  );
+
+  // Check each transition in transitionsToReveal
+  for (const group of transitionsToReveal) {
+    for (const transition of group) {
+      const isIncluded = fullTransitionsSet.has(JSON.stringify(transition));
+      assert(
+        isIncluded,
+        `Transition ${JSON.stringify(transition)} not found!\n` +
+          `Please enter transitions that are part of your regex pattern transitions: ` +
+          `[${Array.from(fullTransitionsSet).join(', ')}]`
+      );
+    }
+  }
+}
diff --git a/src/compiler.ts b/src/compiler.ts
@@ -372,7 +372,7 @@ export class RegexCompiler {
     return acceptLines;
   }
 
-  extractSubPatternTransitions(partRegexArray: string[]) {
+  public extractSubPatternTransitions(partRegexArray: string[]) {
     let subPatternDefsArray: [number, number][][] = [];
     for (const partRegex of partRegexArray) {
       assert(
@@ -467,18 +467,18 @@ export class RegexCompiler {
 
   private writeRevealLines(
     revealEnabled: boolean,
-    transitionInput?: string[] | [number, number][][]
+    revealInput?: string[] | [number, number][][]
   ) {
     let revealLines: string;
     if (revealEnabled) {
       let revealedTransitions: [number, number][][];
       // Type guard to check if parsedInput is an array of strings
       try {
         revealedTransitions = this.extractSubPatternTransitions(
-          transitionInput as string[]
+          revealInput as string[]
         );
       } catch (error) {
-        revealedTransitions = transitionInput as [number, number][][];
+        revealedTransitions = revealInput as [number, number][][];
       }
 
       revealLines =
