RuntimeTable: add assertions to early-fail if the API is used incorrectly

Author: querolita

src/lib/provable/gadgets/runtime-table.ts

@@ -2,6 +2,7 @@
  * This module defines the `RuntimeTable` class, which represents a runtime table used in zk-SNARKs.
  */
 
+import { assert } from "console";
 import { Field } from "../field.js";
 import { Gates } from "../gates.js";
 
@@ -24,23 +25,34 @@ class RuntimeTable {
      * Indices that define the structure of the runtime table.
      * They can be consecutive or not, but they must be unique.
      */
-    readonly indices: bigint[];
+    readonly indices: Set<bigint>;
     /**
      * Pending pairs to be checked on the runtime table.
      */
     pairs: Array<[bigint, Field]> = [];
 
     constructor(id: number, indices: bigint[]) {
-      this.id = id;
-      this.indices = indices;
-      Gates.addRuntimeTableConfig(id, indices);
+        // check that id is not 0 or 1, as those are reserved values
+        assert(id !== 0 && id !== 1, "Runtime table id must be different than 0 and 1");
+ 
+        // check that all the indices are unique
+        let uniqueIndices = new Set(indices);
+        assert(uniqueIndices.size === indices.length, "Runtime table indices must be unique");
+
+        // initialize the runtime table
+        this.id = id;
+        this.indices = uniqueIndices;
+        Gates.addRuntimeTableConfig(id, indices);
     }
 
     /**
      * Inserts key-value pairs into the runtime table.
      * Under the hood, this method uses the `Gates.lookup` function to perform
      * lookups to the table with identifier `this.id`. One single lookup gate
-     * can store up to 3 different pairs of index and value. 
+     * can store up to 3 different pairs of index and value.
+     * 
+     * It throws when trying to insert a pair with an index that is not part of
+     * the runtime table.
      *
      * @param pairs Array of pairs [index, value] to insert into the runtime table.
      */
@@ -50,13 +62,18 @@ class RuntimeTable {
             const [idx0, value0] = chunk[0];
             const [idx1, value1] = chunk[1] || [idx0, value0];
             const [idx2, value2] = chunk[2] || [idx0, value0];
+
+            assert(this.indices.has(idx0) && this.indices.has(idx1) && this.indices.has(idx2),
+                `Indices must be part of the runtime table with id ${this.id}`);
+
             Gates.lookup(Field.from(this.id), Field.from(idx0), value0, Field.from(idx1), value1, Field.from(idx2), value2);
         }
     }
 
     /**
-     * Checks if a key-value pair exists in the runtime table. Note that the same
-     * index can be queried several times as long as the value remains the same.
+     * In-circuit checks if a key-value pair exists in the runtime table. Note
+     * that the same index can be queried several times as long as the value 
+     * remains the same.
      * 
      * Every three calls to this method for the same identifier will be grouped 
      * into a single lookup gate for efficiency.