Merge branch 'main' into release/v2.6.1

Trivo25 · Trivo25 · commit 767a3342c0dc · 2025-07-03T20:17:27.000+07:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -21,6 +21,8 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 
 ### Added
 
+- Lazy mode for prover index computation. https://github.com/o1-labs/o1js/pull/2143
+- Added reverse functionality to `DynamicArray` and indexed `forEach` and `forEachReverse` variants.
 - Added `ZkProgram.analyzeSingleMethod(methodName: string)` to analyze a single method of a ZkProgram. https://github.com/o1-labs/o1js/pull/2217
   - This is an addition to `ZkProgram.analyzeMethods()` which analyzes all methods of a ZkProgram by executing them.
   - Now only a single method is analyzed at a time.
@@ -30,8 +32,7 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 ### Added
 
 - API support for circuit chunking. https://github.com/o1-labs/o1js/pull/1905
-  - still requires memory optimizations to be fully functional, and
-  - proof-systems version still needs to be updated to include [this commit](https://github.com/o1-labs/proof-systems/pull/3222/commits/8c37c293f8159eed3676964ba47fc5dc0ae6ea1e)
+  - work in progress, still requires memory optimizations to be fully functional
 - Dynamic array provable type. https://github.com/o1-labs/o1js/pull/1848
 
 ## [2.5.0](https://github.com/o1-labs/o1js/compare/6ff7f8470a...4e23a60)
diff --git a/flake.nix b/flake.nix
@@ -16,12 +16,12 @@
   nixConfig = {
     auto-optimize-store = true;
     max-jobs = "auto";
-    #coppied from flake.nix in mina
+    # taken from flake.nix in mina
     allow-import-from-derivation = "true";
-    substituters =
+    extra-substituters =
       [ "https://storage.googleapis.com/mina-nix-cache"
       ];
-    trusted-public-keys =
+    extra-trusted-public-keys =
       [ "mina-nix-cache-1:djtioLfv2oxuK2lqPUgmZbf8bY8sK/BnYZCU2iU5Q10="
         "nix-cache.minaprotocol.org:fdcuDzmnM0Kbf7yU4yywBuUEJWClySc1WIF6t6Mm8h4="
         "nix-cache.minaprotocol.org:D3B1W+V7ND1Fmfii8EhbAbF1JXoe2Ct4N34OKChwk2c="
diff --git a/src/bindings.d.ts b/src/bindings.d.ts
@@ -385,7 +385,7 @@ declare const Snarky: {
     /**
      * Generates a proving key and a verification key for the provable function `main`
      */
-    compile(main: Snarky.Main, publicInputSize: number): Snarky.Keypair;
+    compile(main: Snarky.Main, publicInputSize: number, lazyMode: boolean): Snarky.Keypair;
 
     /**
      * Proves a statement using the private input, public input and the keypair of the circuit.
@@ -703,6 +703,7 @@ declare const Pickles: {
       storable?: Pickles.Cache;
       overrideWrapDomain?: 0 | 1 | 2;
       numChunks?: number;
+      lazyMode?: boolean;
     }
   ) => {
     provers: MlArray<Pickles.Prover>;
diff --git a/src/bindings/js/web/worker-spec.js b/src/bindings/js/web/worker-spec.js
@@ -22,6 +22,8 @@ function workerSpec(wasm) {
         undefined /* number */,
         // srs
         wasm.WasmFpSrs,
+        // lazy_mode
+        undefined /* boolean */,
       ],
       res: wasm.WasmPastaFpPlonkIndex,
     },
@@ -39,6 +41,8 @@ function workerSpec(wasm) {
         undefined /* number */,
         // srs
         wasm.WasmFqSrs,
+        // lazy_mode
+        undefined /* boolean */,
       ],
       res: wasm.WasmPastaFqPlonkIndex,
     },
diff --git a/src/bindings/ocaml/lib/pickles_bindings.ml b/src/bindings/ocaml/lib/pickles_bindings.ml
@@ -618,7 +618,8 @@ let pickles_compile (choices : pickles_rule_js array)
       ; publicOutputSize : int Js.prop
       ; storable : Cache.js_storable Js.optdef_prop
       ; overrideWrapDomain : int Js.optdef_prop 
-      ; numChunks : int Js.optdef_prop >
+      ; numChunks : int Js.optdef_prop
+      ; lazyMode : bool Js.optdef_prop >
       Js.t ) =
   (* translate number of branches and recursively verified proofs from JS *)
   let branches = Array.length choices in
@@ -640,6 +641,7 @@ let pickles_compile (choices : pickles_rule_js array)
   let num_chunks =
     Js.Optdef.get config##.numChunks (fun () -> 1)
   in
+  let lazy_mode = Js.Optdef.get config##.lazyMode (fun () -> false) in
   let (Choices choices) =
     Choices.of_js ~public_input_size ~public_output_size choices
   in
@@ -662,7 +664,7 @@ let pickles_compile (choices : pickles_rule_js array)
            , public_input_typ public_output_size ) )
       ~auxiliary_typ:Typ.unit
       ~max_proofs_verified:(module Max_proofs_verified)
-      ~name ~num_chunks ~choices ()
+      ~name ~num_chunks ~lazy_mode ~choices ()
   in
 
   (* translate returned prover and verify functions to JS *)
diff --git a/src/bindings/ocaml/lib/pickles_bindings.mli b/src/bindings/ocaml/lib/pickles_bindings.mli
@@ -66,7 +66,8 @@ val pickles :
           ; publicOutputSize : int Js.prop
           ; storable : Cache.js_storable Js.optdef_prop
           ; overrideWrapDomain : int Js.optdef_prop 
-          ; numChunks : int Js.optdef_prop >
+          ; numChunks : int Js.optdef_prop
+          ; lazyMode : bool Js.optdef_prop >
           Js.t
        -> < getVerificationKey :
               (   unit
diff --git a/src/bindings/ocaml/lib/snarky_bindings.ml b/src/bindings/ocaml/lib/snarky_bindings.ml
@@ -384,11 +384,11 @@ module Circuit = struct
       main'
   end
 
-  let compile main public_input_size =
+  let compile main public_input_size lazy_mode =
     let input_typ = typ public_input_size in
     let return_typ = Impl.Typ.unit in
     let cs = Impl.constraint_system ~input_typ ~return_typ (Main.of_js main) in
-    Impl.Keypair.generate ~prev_challenges:0 cs
+    Impl.Keypair.generate ~lazy_mode ~prev_challenges:0 cs
 
   let prove main public_input_size public_input keypair =
     let pk = Impl.Keypair.pk keypair in
diff --git a/src/bindings/ocaml/lib/snarky_bindings.mli b/src/bindings/ocaml/lib/snarky_bindings.mli
@@ -249,7 +249,8 @@ val snarky :
       Js.t
       Js.readonly_prop
   ; circuit :
-      < compile : ((Field.t array -> unit) -> int -> Impl.Keypair.t) Js.meth
+      < compile :
+          ((Field.t array -> unit) -> int -> bool -> Impl.Keypair.t) Js.meth
       ; keypair :
           < getConstraintSystemJSON : (Impl.Keypair.t -> 'a) Js.meth
           ; getVerificationKey :
diff --git a/src/bindings/scripts/download-bindings.sh b/src/bindings/scripts/download-bindings.sh
@@ -7,7 +7,8 @@ set -e
 REV=${REV:=$(git rev-parse HEAD)}
 RUN_ID=$( \
     gh run list --commit "${REV}" --json name,databaseId | \
-    jq -r '.[] | select(.name == "Checks" or .name == "Build and upload bindings") | .databaseId' \
+    jq -r '.[] | select(.name == "Checks" or .name == "Build and upload bindings") | .databaseId' | \
+    head -1 \
   )
 
 if [ -z "$RUN_ID" ]
diff --git a/src/lib/proof-system/circuit.ts b/src/lib/proof-system/circuit.ts
@@ -22,13 +22,13 @@ class Circuit {
    * const keypair = await MyCircuit.generateKeypair();
    * ```
    */
-  static async generateKeypair() {
+  static async generateKeypair(lazyMode: boolean = false) {
     let main = mainFromCircuitData(this._main);
     let publicInputSize = this._main.publicInputType.sizeInFields();
     await initializeBindings();
     return prettifyStacktracePromise(
       withThreadPool(async () => {
-        let keypair = Snarky.circuit.compile(main, publicInputSize);
+        let keypair = Snarky.circuit.compile(main, publicInputSize, lazyMode);
         return new Keypair(keypair);
       })
     );
diff --git a/src/lib/proof-system/lazy-mode.unit-test.ts b/src/lib/proof-system/lazy-mode.unit-test.ts
@@ -0,0 +1,90 @@
+import { Field } from '../provable/field.js';
+import { Cache } from '../proof-system/cache.js';
+import { ZkProgram } from '../proof-system/zkprogram.js';
+import { Spec, fieldWithRng } from '../testing/equivalent.js';
+import { Random } from '../testing/property.js';
+import { assert } from '../provable/gadgets/common.js';
+import { Gadgets } from '../provable/gadgets/gadgets.js';
+import { wasm } from '../../bindings.js';
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname, join, basename } from 'path';
+
+// Path resolution for subprocess execution
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const scriptPath = join(__dirname, basename(__filename));
+
+function getMemory() {
+  return {
+    wasm: (wasm as any).__wasm.memory.buffer.byteLength / (1024 * 1024),
+    js: process.memoryUsage().heapTotal / (1024 * 1024),
+  };
+}
+
+let uint = (n: number | bigint): Spec<bigint, Field> => {
+  return fieldWithRng(Random.bignat((1n << BigInt(n)) - 1n));
+};
+
+// Dummy circuit
+let LazyMode = ZkProgram({
+  name: 'lazy-mode',
+  methods: {
+    baseCase: {
+      privateInputs: [Field],
+      async method(v: Field) {
+        for (let i = 0; i < 1 << 15; i++) {
+          let w = v.add(new Field(i));
+          Gadgets.rangeCheck64(w);
+        }
+      },
+    },
+  },
+});
+
+export async function testLazyMode(lazyMode: boolean) {
+  console.log(`(${lazyMode ? 'Lazy' : 'Eager'}) Memory before compilation`, getMemory());
+
+  await LazyMode.compile({
+    lazyMode,
+    cache: Cache.None,
+    forceRecompile: true,
+  });
+
+  console.log(`(${lazyMode ? 'Lazy' : 'Eager'}) Memory after compilation`, getMemory());
+  console.log(' ');
+  console.log(`(${lazyMode ? 'Lazy' : 'Eager'}) Memory before proof`, getMemory());
+
+  let { proof } = await LazyMode.baseCase(new Field(1n));
+
+  console.log(`(${lazyMode ? 'Lazy' : 'Eager'}) Memory after proof`, getMemory());
+  console.log(' ');
+
+  let isValid = await LazyMode.verify(proof);
+
+  console.log(`(${lazyMode ? 'Lazy' : 'Eager'}) Memory after verify`, getMemory());
+
+  assert(isValid);
+}
+
+// If launched as subprocess: run the actual test
+if (process.argv[2] === 'true' || process.argv[2] === 'false') {
+  const lazyMode = process.argv[2] === 'true';
+  await testLazyMode(lazyMode);
+  process.exit(0);
+}
+
+// Parent process logic: spawn two subprocesses
+function runSubprocess(lazyMode: boolean): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const child = spawn('node', [scriptPath, String(lazyMode)], {
+      stdio: 'inherit',
+    });
+    child.on('exit', (code) => {
+      console.log(`(Parent) Process lazyMode=${lazyMode} exited with code ${code}`);
+      code === 0 ? resolve() : reject(new Error(`Test failed for lazyMode=${lazyMode}`));
+    });
+  });
+}
+
+await Promise.all([runSubprocess(true), runSubprocess(false)]);
diff --git a/src/lib/proof-system/zkprogram.ts b/src/lib/proof-system/zkprogram.ts
@@ -245,6 +245,7 @@ function ZkProgram<
     proofsEnabled?: boolean;
     withRuntimeTables?: boolean;
     numChunks?: number;
+    lazyMode?: boolean;
   }) => Promise<{
     verificationKey: { data: string; hash: Field };
   }>;
@@ -382,6 +383,7 @@ function ZkProgram<
     forceRecompile = false,
     proofsEnabled = undefined as boolean | undefined,
     withRuntimeTables = false,
+    lazyMode = false,
   } = {}) {
     doProving = proofsEnabled ?? doProving;
 
@@ -405,6 +407,7 @@ function ZkProgram<
         numChunks: config.numChunks,
         state: programState,
         withRuntimeTables,
+        lazyMode,
       });
 
       compileOutput = { provers, verify, maxProofsVerified };
@@ -712,6 +715,7 @@ async function compileProgram({
   numChunks,
   state,
   withRuntimeTables,
+  lazyMode,
 }: {
   publicInputType: Provable<any>;
   publicOutputType: Provable<any>;
@@ -726,6 +730,7 @@ async function compileProgram({
   numChunks?: number;
   state?: ReturnType<typeof createProgramState>;
   withRuntimeTables?: boolean;
+  lazyMode?: boolean;
 }) {
   await initializeBindings();
   if (methodIntfs.length === 0)
@@ -782,6 +787,7 @@ If you are using a SmartContract, make sure you are using the @method decorator.
           storable: picklesCache,
           overrideWrapDomain,
           numChunks: numChunks ?? 1,
+          lazyMode: lazyMode ?? false,
         });
         let { getVerificationKey, provers, verify, tag } = result;
         CompiledTag.store(proofSystemTag, tag);
diff --git a/src/lib/provable/dynamic-array.ts b/src/lib/provable/dynamic-array.ts
@@ -274,12 +274,26 @@ class DynamicArrayBase<ProvableValue = any, Value = any> {
    * Iterate over all elements of the array.
    *
    * The callback will be passed an element and a boolean `isDummy` indicating
-   * whether the value is part of the actual array.
+   * whether the value is part of the actual array. Optionally, an index can be
+   * passed as a third argument (used in `forEachReversed`)
    */
-  forEach(f: (t: ProvableValue, isDummy: Bool) => void) {
-    zip(this.array, this.#dummyMask()).forEach(([t, isDummy]) => {
-      f(t, isDummy);
-    });
+  forEach(f: (t: ProvableValue, isDummy: Bool, i?: number) => void): void {
+    zip(this.array, this.#dummyMask()).forEach(([t, isDummy], i) => f(t, isDummy, i));
+  }
+
+  /**
+   * Iterate over all elements of the array, in reverse order.
+   *
+   * The callback will be passed an element and a boolean `isDummy` indicating whether the value is part of the actual array.
+   *
+   * Note: the indices are also passed in reverse order, i.e. we always have `t = this.array[i]`.
+   */
+  forEachReverse(f: (t: ProvableValue, isDummy: Bool, i: number) => void) {
+    zip(this.array, this.#dummyMask())
+      .reverse()
+      .forEach(([t, isDummy], i) => {
+        f(t, isDummy, this.capacity - 1 - i);
+      });
   }
 
   /**
@@ -519,6 +533,21 @@ class DynamicArrayBase<ProvableValue = any, Value = any> {
     return sliced;
   }
 
+  /**
+   * Returns a new array with the elements reversed.
+   */
+  reverse(): DynamicArray<ProvableValue, Value> {
+    let Array = DynamicArray(this.innerType, { capacity: this.capacity });
+    // first, copy the inner array of length capacity and reverse it
+    let array = this.array.slice().reverse();
+
+    // now, slice off the padding that is now at the beginning of the array
+    let capacity = new Field(this.capacity);
+    return new Array(array, capacity).slice(
+      capacity.sub(this.length).seal()
+    );
+  }
+
   /**
    * Concatenates the current array with another dynamic array, returning a new
    * dynamic array with the values of both arrays. The capacity of the new array
diff --git a/src/lib/provable/test/dynamic-array.unit-test.ts b/src/lib/provable/test/dynamic-array.unit-test.ts
@@ -581,6 +581,14 @@ import { Provable } from '../provable.js';
           // Checking inclusion of elements
           assert(bytes.includes(new UInt8(1)));
           assert(bytes.includes(new UInt8(20)).not());
+
+          // Reverse the array
+          let reversed = bytes.reverse();
+          for (let i = 0; i < 8; i++) {
+            assert(reversed.get(new Field(i)).value.equals(new Field(8 - i)));
+            // the original array is not modified
+            assert(bytes.get(new Field(i)).value.equals(new Field(i + 1)));
+          }
         },
       },
     },

Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,8 @@ set -e`
`7`	`7`	`REV=${REV:=$(git rev-parse HEAD)}`
`8`	`8`	`RUN_ID=$( \`
`9`	`9`	`gh run list --commit "${REV}" --json name,databaseId \| \`
`10`		`- jq -r '.[] \| select(.name == "Checks" or .name == "Build and upload bindings") \| .databaseId' \`
	`10`	`+ jq -r '.[] \| select(.name == "Checks" or .name == "Build and upload bindings") \| .databaseId' \| \`
	`11`	`+ head -1 \`
`11`	`12`	`)`
`12`	`13`
`13`	`14`	`if [ -z "$RUN_ID" ]`