# EPF6 - Week 19

## Overview
- Attended Lodestar Weekly Standup and [shared updates](https://github.com/ChainSafe/lodestar/wiki/Lodestar-Weekly-Standups-2025#epf-contributors-progress)
- Discussed the **syncing.ts** logic with mentor
- Investigated the **simulation timing stability** between the previous framework and Kurtosis environment:
- Investigated the **stop()** sequence and controller behavior to ensure proper error reporting.
- Tested the simulation with new delay and logging improvements.

## Main points

### 1. Syncing Logic Discussion

After discussing with my mentor, we agreed to comment out this syncing logic in `multiFork.test.ts`:

await assertRangeSync(env);
await assertCheckpointSync(env);
await assertUnknownBlockSync(env);

for now and treat it as a **follow-up subtask** to be implemented later.

**Mentor’s Proposal**
The future syncing tests could be achieved by:
<ol>
<li>Creating a Kurtosis network config with additional participants dedicated to sync testing.</li>
<li>Starting the enclave with all participants.</li>
<li>Stopping a few participants manually using <code>docker stop service-name</code>.</li>
<li>Allowing the rest of the network to continue growing.</li>
<li>Restarting the stopped participants at a later fork to test their ability to catch up.</li>
</ol>
</div>

For now, the syncing logic remains commented out while the main simulation is tested and stabilized.

### 2. Timing Differences Between Job/JobOption and Kurtosis

Kurtosis handles service cleanup differently from the previous version, as it doesn’t use manual `job.stop()` calls that act as natural timing buffers.

**Issue Observed:**
- The simulation summary wasn’t printing correctly when error count was greater than zero.
- Missing implicit delay caused logging overlap and truncated outputs.

**Initial Fix:**
Added a small delay in `stop()`:

await new Promise((resolve) => setTimeout(resolve, 100));

This improved log timing and output ordering, but minor timing inconsistencies remained.

### 3. Controller Abort and Summary Printing

**Problem:**
`controller.abort()` was being called before `summary()`, interrupting the tracker’s error handler and interfering with output.

**Tested solution:**
Moved `abort()` after the summary call.

**Final sequence:**

if (this.runTimeout) {
  clearTimeout(this.runTimeout);
}

if (this.tracker.getErrorCount() > 0) {
  this.tracker.reporter.summary();
  // Allow logger to flush before exit
  await new Promise((resolve) => setTimeout(resolve, 100));
}

// Abort after summary to avoid interference
this.options.controller.abort();
process.exit(this.tracker.getErrorCount() > 0 ? 1 : code);

### 4. utils/syncing.ts Refactor Planning

The current syncing utilities rely on direct **job.start()** and **job.stop()** calls, which belong to the Docker architecture.

**Options under consideration:**

- Add logic to dynamically add/remove services within an active Kurtosis enclave.
- Or, redesign syncing tests to no longer depend on manual node lifecycle management.

**For now**, these changes are deferred until the main migration stabilizes.

## Key Learnings

| Area | Insight |
|------|----------|
| **Syncing Logic** | Dynamic node restart logic must be rethought for Kurtosis-based simulations. |
| **Timing Stability** | Kurtosis doesn’t include Docker’s implicit delays, requiring manual flush and wait controls. |
| **Controller Flow** | Moving `abort()` after `summary()` ensures clean termination and accurate output. |
| **Future Work** | Sync tests will likely require custom service control logic in Kurtosis. |

## Week 20 TODOs

- Continue testing and fine-tuning simulation stability and timing consistency.
- Keep the syncing logic commented out and document it as a future subtask for post-migration testing.
- Review simulation stop behavior and ensure summary reporting works across edge cases.
- Polish and clean up the code, focusing on readability and maintainability.
- Proceed with next steps entirely based on team and mentor feedback once the simulation behavior is confirmed stable.
- Devconnect presentation and final report