Why does compiling a .circom file with a WitnessTester update that file's LastModifiedAt timestamp?

[dsernst]

Setup

If I have MyCircuit.circom, and then a unit test that includes:

const circuit = await circomkit.WitnessTester('MyCircuit', {
  file: './MyCircuit.circom',
  template: 'MyCircuit',
})

every time this unit test runs, the referenced MyCircuit.circom file's mtime aka Last Modified At timestamp is also updating.

Even though running the unit test does not change any of the contents of the .circom file itself.

(The compiled build outputs might have changed, sure, but that's not what I'm talking about).

Command to Verify:

One way to verify this, from a MacOS shell:

mdls -name kMDItemContentModificationDate ./MyCircuit.circom

Impact:

This makes it significantly more difficult to watch .circom files for changes, and then trigger unit tests. Because currently this creates infinite loops.

I've spent quite a lot of time digging into the circomkit internals, and circom_tester, but didn't yet track down the source of this. It seems pretty clearly unintended, buggy behavior. Would love to see it fixed, or at least if anyone can help point to where exactly this is being caused.

[dsernst]

I have a working, but less than ideal workaround, by adding another background process to watch the .circom files for changes:

In package.json:

"scripts": {
  "watch-circuits": "bunx nodemon --quiet --ext circom --delay 0.5 --exec 'bun ts/watch-circuits.ts'"
}

ts/watch-circuits.ts: hashes the .circom files, and writes their hashes to a .json file:

// To run: `npm run watch-circuits`
//
// This script watches our .circom files, and checks when their contents change.
// By importing the resulting circuit-hashes.json file into our tests, watch mode will trigger auto re-runs from updated circuits.
// (Unfortunately, we can't just watch the .circom files directly, because the test files actually touch them too (during compile), which triggers an infinite loop. See https://github.com/erhant/circomkit/issues/120)

import { createHash } from 'node:crypto'
import { readFileSync, writeFileSync, readdirSync } from 'node:fs'
import prevHashes from './circuit-hashes.json'
const prev = prevHashes as Record<string, string>

// ANSI color codes
const RESET = '\x1b[0m'
const YELLOW = '\x1b[33m'
const GRAY = '\x1b[90m'

// Hash a single file into a short digest
function hashFile(path: string): string {
  const data = readFileSync(path)
  const hash = createHash('sha256')
  hash.update(data)
  return hash.digest('hex').slice(0, 10)
}

// Build map of hashes
let whichChanged = []
const hashes: Record<string, string> = {}
const files = readdirSync('./circuits').filter((f) => f.endsWith('.circom'))
for (const file of files) {
  const hash = hashFile('./circuits/' + file)
  if (hash !== prev[file]) whichChanged.push(file)
  hashes[file] = hash
}

// Only write to the file if the hashes have changed
if (whichChanged.length > 0) {
  console.log(
    `${
      GRAY +
      new Date().toLocaleTimeString().replace(' AM', 'a').replace(' PM', 'p') +
      YELLOW
    } ${whichChanged.join(', ') + RESET}`
  )
  writeFileSync('./ts/circuit-hashes.json', JSON.stringify(hashes, null, 2))
}

This creates a .gitignore'd circuit-hashes.json file, like:

{
  "MyCircuit.circom": "d8d6fd7632"
}

And then that file gets imported into my unit test file:

+ import '../circuit-hashes.json'

So that the unit test's watcher (bun test --watch) treats it as a dependency, and auto re-runs the tests whenever any of the hashes change.

---

This works

Now saving changes to one of the watched .circom files triggers the unit tests to auto re-run.

But all of this would be unnecessary, and feel a lot cleaner, if the mtimes weren't being unexpected updated.

[dsernst]

This is also related to #26, because I also want the recompile boolean to be set automatically, based on if the circom file has changed since the last compile.

That would be easy if the mtimes were honest, just checking if dot_circom_mtime > compiled_r1cs_mtime.

I have a workaround here too— added another field updated_at to the circuit-hashes.json map, in place of dot_circom_mtime. But again, would be cleaner with OS-native mtimes.

---

My workaround:

watch-circuits.ts Inner loop modified to add the timestamp too:

 for (const file of files) {
   const hash = hashFile('./circuits/' + file)
+  const didChange = hash !== prev[file]?.[0]
-  if (hash !== prev[file]) whichChanged.push(file)
+  if (didChange) whichChanged.push(file)
-  hashes[file] = hash
+  hashes[file] = [hash, !didChange ? prev[file]?.[1] : new Date().toISOString()]
 }

And a new function:

export function shouldRecompile(file: string): boolean {
  const dot_circom_mtime = new Date(prev[file]?.[1])
  const compiled_r1cs_mtime = statSync(
    `./build/${file.replace('.circom', '.r1cs')}`
  ).mtime
  const changedSinceCompile = dot_circom_mtime > compiled_r1cs_mtime

  if (changedSinceCompile) console.log('\nRecompiling', YELLOW, file, RESET)

  return changedSinceCompile
}

which can be called like:

const circuit = await circomkit.WitnessTester('MyCircuit', {
  file: './MyCircuit.circom',
  template: 'MyCircuit',
  recompile: shouldRecompile('MyCircuit.circom')
})

[erhant]

Sorry @dsernst I was on a national holiday leave on a foreign country with minimal internet, excuse my belated response 🙏🏻
This is a greatly detailed issue, thank you!

I didnt know about the mtime issue, indeed would be much more lovely for this to be solved at OS-level without resorting to otherwise bookkeeping methods. The compilation here done by the tester is just an exec call by child_process so maybe we can have more control there to overcome this issue, instead of wrapping circom_tester.

I am rewriting the Circomkit as a whole, going to a monorepo with more well-defined sub-parts and better tests for them, tester parts will be such a thing as well and I will see if I can find a fix for this 🙏🏻

[dsernst]

Cool, no worries.

My workaround is working great locally for now, but wanted to document everything I had found and wrote, in case it could be helpful for others too.

Cheers for the great library.