runtime-tables:include negative tests

Author: querolita

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

@@ -38,10 +38,14 @@ export {
  *   should consider an optimized custom solution.
  * - **mutable data**: runtime tables are write-once only, so once inserted entries in table are
  *   remain fixed. To represent changing data, consider using DynamicArrays.
- *
+ * - **unknown bounded size**: runtime lookup tables require all possible `indices` to be preallocated
+ *   at construction time. If the set of possible indices is not known in advance, consider using
+ *   DynamicArrays instead.
+ * 
  * ## Invariants & constraints
  * - `id !== 0 && id !== 1`. (Reserved for XOR and range-check tables.)
  * - `indices` are **unique**. Duplicates are rejected.
+ * - `indices` must be **known** at construction time.
  * - `lookup()` **batches** each 3 calls (for the same table) into **one** gate automatically.
  * - `check()` call is required for soundness to flush 1–2 pending pairs before the end of the circuit.
  *
@@ -180,4 +184,4 @@ class RuntimeTable {
             this.pairs = [];
         }
     }
-}
+}

src/lib/provable/test/runtime-table.unit-test.ts

@@ -7,13 +7,15 @@ import { RuntimeTable } from '../gadgets/runtime-table.js';
 import { constraintSystem, contains } from '../../testing/constraint-system.js';
 import { FeatureFlags } from '../../proof-system/feature-flags.js';
 import { Cache } from '../../proof-system/cache.js';
+import { Provable } from '../provable.js';
 
-let uint = (n: number | bigint): Spec<bigint, Field> => {
-  return fieldWithRng(Random.bignat((1n << BigInt(n)) - 1n));
-};
 
-// Runtime table tests
+// in-circuit unit tests
 {
+  let uint = (n: number | bigint): Spec<bigint, Field> => {
+    return fieldWithRng(Random.bignat((1n << BigInt(n)) - 1n));
+  };
+
   let RuntimeTableZkProgram = ZkProgram({
     name: 'runtime-table',
     methods: {
@@ -68,3 +70,39 @@ let uint = (n: number | bigint): Spec<bigint, Field> => {
     }
   );
 }
+
+// off-circuit checks
+{
+    function expectThrows(fn: () => void | Promise<void>, msg: string) {
+    let threw = false;
+    try {
+      fn();
+    } catch {
+      threw = true;
+    }
+    assert(threw, msg);
+  }
+
+  // Cannot create a table with reserved id
+  expectThrows(() => {
+    new RuntimeTable(0, [0n, 1n]);
+  }, 'Table id 0 is reserved');
+
+  expectThrows(() => {
+    new RuntimeTable(1, [0n, 1n]);
+  }, 'Table id 1 is reserved');
+
+  // Cannot create a table with duplicate indices
+  expectThrows(() => {
+    new RuntimeTable(3, [0n, 1n, 2n, 2n]);
+  }, 'Indices must be unique');
+
+  // Cannot insert pairs with indices not in the table
+  await Provable.runAndCheck(async () => {
+      let table = new RuntimeTable(42, [0n, 1n, 2n, 3n, 4n, 5n]);
+
+      expectThrows(() => {
+        table.insert([[0n, new Field(1)], [6n, new Field(2)]]);
+      }, 'Indices must be preallocated at creation of the runtime table'); 
+  });
+}