diff --git a/.github/workflows/link-check.yml b/.github/workflows/link-check.yml
index be8daf08c..cbef067d3 100644
--- a/.github/workflows/link-check.yml
+++ b/.github/workflows/link-check.yml
@@ -30,6 +30,7 @@ jobs:
             --format markdown
             --exclude '^https://doi\.org/'
             --exclude '^https://russellranch\.ucdavis\.edu'
+            --exclude '^https://join\.slack\.com'
             .
           fail: true
         env:
diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md
index 1b9bf9783..98ee0d11c 100644
--- a/docs/CHANGELOG.md
+++ b/docs/CHANGELOG.md
@@ -27,6 +27,7 @@ sections to include in release notes:
 ### Added
 
 - `sipnet-view` tool for visualizing SIPNET output files (#317)
+- `leafon` and `leafoff` events for tracking phenological transitions (#326)
 
 ### Fixed
 
diff --git a/docs/README.md b/docs/README.md
index fa338e4eb..1e0ae9b10 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -24,7 +24,7 @@ SIPNET (Simplified Photosynthesis and Evapotranspiration Model) is a lightweight
 - **Understanding the code:** The [developer docs](model-structure.md) describe architecture, while sections on [testing](developer-guide/testing.md) and [CLI extensions](developer-guide/cli-options.md) cover contributions.
 - **Project practices:** Review the [Contributing guide](CONTRIBUTING.md), [Code of Conduct](CODE_OF_CONDUCT.md), and [Changelog](CHANGELOG.md) before opening PRs or issues.
 
-Need help? Open an issue on [GitHub](https://github.com/PecanProject/sipnet/issues) or join the [PEcAn community Slack](https://join.slack.com/t/pecanproject/shared_invite/zt-3ile31ylu-r1sMh~esl~7A_AolYNNYLQ).
+Need help? Open an issue on [GitHub](https://github.com/PecanProject/sipnet/issues) or join the [PEcAn community Slack](https://join.slack.com/t/pecanproject/shared_invite/zt-3wlzwms7n-mmoLuYsIfaDqp_FRZD1eQQ).
 
 ## License
 
diff --git a/docs/model-structure.md b/docs/model-structure.md
index 200b8c0de..45a4d3fe3 100644
--- a/docs/model-structure.md
+++ b/docs/model-structure.md
@@ -1162,6 +1162,32 @@ f_{\text{intercept}} \, F^W_{\text{irrig}}, & I_{\text{irrigation}} = 0 \\
 \label{eq:irrig_evap}
 \end{equation}
 
+### Leaf On/Leaf Off
+
+Leaf on and leaf off events define the timing of leaf emergence and senescence, respectively. These events directly
+specify the amount of carbon added to the leaf carbon pool on the leaf on date, and the fraction of carbon removed from
+the leaf carbon pool on the leaf off date. 
+
+When a leaf on event occurs, an amount of carbon (specified by the `leafGrowth` parameter) is transferred from the wood
+carbon pool to the leaf carbon pool. As leaf C:N is usually lower than wood C:N, the excess nitrogen
+implied by the static C:N ratios is included as part of the plant nitrogen demand. If there is insufficient nitrogen
+available for this lump-sum move, nitrogen limitation will occur. 
+
+When a leaf off event occurs, a fraction of the leaf carbon (specified by the `fracLeafFall` parameter) is transferred
+from the leaf carbon pool to the litter pool (or soil pool, if the litter pool is not being used). The corresponding
+nitrogen (calculated from the leaf C:N ratio) is also transferred to the litter or soil nitrogen pool.
+
+**Event parameters:**
+
+| Parameter | Value                | Description       |
+|-----------|----------------------|-------------------|
+| Year      | integer              | Year              |
+| Day       | integer              | Day of year       |
+| Type      | `leafon` / `leafoff` | The type of event |
+
+There are no other parameters needed for these events, as the amount of transfer is determined by the parameters
+mentioned above.
+
 <!-- 
 **Flooding** increases soil water to water holding capacity and then adds water equivalent to the depth of flooding. Subsequent irrigation events maintain flooding by topping off water content.
 
diff --git a/docs/parameters.md b/docs/parameters.md
index 06fe49724..f4c763fdd 100644
--- a/docs/parameters.md
+++ b/docs/parameters.md
@@ -154,21 +154,21 @@ Run-time parameters can change from one run to the next, or when the model is st
 
 ### Phenology-Related Parameters
 
-| Symbol                   | Parameter Name   | Definition                                                            | Units                            | Notes                                |
-| ------------------------ | ---------------- | --------------------------------------------------------------------- | -------------------------------- | ------------------------------------ |
-| $D_{\text{on}}$          | leafOnDay        | Day of year when leaves appear                                        | unitless                         | day of year (1–365)                  |
-| $GDD_{\text{on}}$        | gddLeafOn        | GDD threshold for leaf appearance (GDD-based phenology)               | $°\text{C} \cdot \text{day}$     |                                      |
-| $T_{\text{on}}$          | soilTempLeafOn   | Soil temperature threshold for leaf appearance (temp-based phenology) | $°\text{C}$                      |                                      |
-| $D_{\text{off}}$         | leafOffDay       | Day of year for leaf drop                                             | unitless                         | day of year (1–365)                  |
-| $\Delta C_{\text{leaf}}$ | leafGrowth       | Additional leaf growth at start of growing season                     | $\text{g C} \cdot \text{m}^{-2}$ |                                      |
-| $f_{\text{fall}}$        | fracLeafFall     | Additional fraction of leaves that fall at end of growing season      | unitless                         |                                      |
-| $\alpha_{\text{leaf}}$   | leafAllocation   | Fraction of $NPP$ allocated to leaf growth                            | unitless                         |                                      |
-| $K_{\text{leaf}}$        | leafTurnoverRate | Average turnover rate of leaves                                       | $\text{year}^{-1}$               | Converted to per-day rate internally |
+| Symbol                    | Parameter Name   | Definition                                                            | Units                            | Notes                                |
+|---------------------------|------------------|-----------------------------------------------------------------------|----------------------------------|--------------------------------------|
+| $D_{\text{on}}$           | leafOnDay        | Day of year when leaves appear                                        | unitless                         | day of year (1–365); 0 to turn off   |
+| $GDD_{\text{on}}$         | gddLeafOn        | GDD threshold for leaf appearance (GDD-based phenology)               | $°\text{C} \cdot \text{day}$     |                                      |
+| $T_{\text{on}}$           | soilTempLeafOn   | Soil temperature threshold for leaf appearance (temp-based phenology) | $°\text{C}$                      |                                      |
+| $D_{\text{off}}$          | leafOffDay       | Day of year for leaf drop                                             | unitless                         | day of year (1–365); 0 to turn off   |
+| $\Delta C_{\text{leaf}}$  | leafGrowth       | Additional leaf growth at start of growing season                     | $\text{g C} \cdot \text{m}^{-2}$ |                                      |
+| $f_{\text{fall}}$         | fracLeafFall     | Additional fraction of leaves that fall at end of growing season      | unitless                         |                                      |
+| $\alpha_{\text{leaf}}$    | leafAllocation   | Fraction of $NPP$ allocated to leaf growth                            | unitless                         |                                      |
+| $K_{\text{leaf}}$         | leafTurnoverRate | Average turnover rate of leaves                                       | $\text{year}^{-1}$               | Converted to per-day rate internally |
 
 ### Allocation Parameters
 
 | Symbol                        | Parameter Name       | Definition                                  | Units    | Notes                                                                                                                                             |
-| ----------------------------- | -------------------- | ------------------------------------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
+|-------------------------------|----------------------|---------------------------------------------|----------|---------------------------------------------------------------------------------------------------------------------------------------------------|
 | $\alpha_{\text{fine root}}$   | fineRootAllocation   | Fraction of $NPP$ allocated to fine roots   | unitless |                                                                                                                                                   |
 | $\alpha_{\text{coarse root}}$ | coarseRootAllocation | Fraction of $NPP$ allocated to coarse roots | unitless | Calculated internally from remainder: $\alpha_{\text{coarse root}} = 1 - \alpha_{\text{leaf}} - \alpha_{\text{wood}} - \alpha_{\text{fine root}}$ |
 | $\alpha_{\text{wood}}$        | woodAllocation       | Fraction of $NPP$ allocated to wood         | unitless |                                                                                                                                                   |
diff --git a/src/sipnet/events.c b/src/sipnet/events.c
index d9a36e49b..1bfa72da5 100644
--- a/src/sipnet/events.c
+++ b/src/sipnet/events.c
@@ -136,6 +136,32 @@ EventNode *createEventNode(int year, int day, int eventType,
       tParams->tillageEffect = tillEffect;
       newEvent->eventParams = tParams;
     } break;
+    case LEAFON: {
+      double dummy;
+      LeafOnParams *lParams = (LeafOnParams *)malloc(sizeof(LeafOnParams));
+      // Check for extraneous data: leafon takes no parameters, so error if any
+      // numbers are found. sscanf returns 0 or EOF (-1) for empty/whitespace.
+      int numRead = sscanf(eventParamsStr,  // NOLINT
+                           "%lf", &dummy);
+      if (numRead > NUM_LEAFON_PARAMS) {
+        logError("parsing LeafOn params for year %d day %d\n", year, day);
+        exit(EXIT_CODE_INPUT_FILE_ERROR);
+      }
+      newEvent->eventParams = lParams;
+    } break;
+    case LEAFOFF: {
+      double dummy;
+      LeafOffParams *lParams = (LeafOffParams *)malloc(sizeof(LeafOffParams));
+      // Check for extraneous data: leafoff takes no parameters, so error if
+      // any numbers are found. sscanf returns 0 or EOF (-1) for empty input.
+      int numRead = sscanf(eventParamsStr,  // NOLINT
+                           "%lf", &dummy);
+      if (numRead > NUM_LEAFOFF_PARAMS) {
+        logError("parsing LeafOff params for year %d day %d\n", year, day);
+        exit(EXIT_CODE_INPUT_FILE_ERROR);
+      }
+      newEvent->eventParams = lParams;
+    } break;
     default:
       // Unknown type, error and exit
       logError("found unknown event type %d while reading event file\n",
@@ -159,6 +185,10 @@ const char *eventTypeToString(event_type_t type) {
       return "fert";
     case TILLAGE:
       return "till";
+    case LEAFON:
+      return "leafon";
+    case LEAFOFF:
+      return "leafoff";
     default:
       logError("unknown event type in eventTypeToString (%d)", type);
       exit(EXIT_CODE_UNKNOWN_EVENT_TYPE_OR_PARAM);
@@ -168,15 +198,26 @@ const char *eventTypeToString(event_type_t type) {
 event_type_t eventStringToType(const char *eventTypeStr) {
   if (strcmp(eventTypeStr, "irrig") == 0) {
     return IRRIGATION;
-  } else if (strcmp(eventTypeStr, "fert") == 0) {
+  }
+  if (strcmp(eventTypeStr, "fert") == 0) {
     return FERTILIZATION;
-  } else if (strcmp(eventTypeStr, "plant") == 0) {
+  }
+  if (strcmp(eventTypeStr, "plant") == 0) {
     return PLANTING;
-  } else if (strcmp(eventTypeStr, "till") == 0) {
+  }
+  if (strcmp(eventTypeStr, "till") == 0) {
     return TILLAGE;
-  } else if (strcmp(eventTypeStr, "harv") == 0) {
+  }
+  if (strcmp(eventTypeStr, "harv") == 0) {
     return HARVEST;
   }
+  if (strcmp(eventTypeStr, "leafon") == 0) {
+    return LEAFON;
+  }
+  if (strcmp(eventTypeStr, "leafoff") == 0) {
+    return LEAFOFF;
+  }
+
   return UNKNOWN_EVENT;
 }
 
@@ -193,6 +234,18 @@ static void checkEventLineTruncation(const char *line, size_t len) {
   }
 }
 
+void checkForCalculatedLeafEvents(void) {
+  // We have a leaf event in events.in, so make sure we are not also
+  // calculating leaf events
+  if (ctx.gdd || ctx.soilPhenol || params.leafOnDay > 0 ||
+      params.leafOffDay > 0) {
+    logError("calculated leaf events (via leafOnDay/leafOffDay params or "
+             "gdd/soil-phenol command-line options) are not compatible "
+             "with user-specified leaf events in event file\n");
+    exit(EXIT_CODE_BAD_PARAMETER_VALUE);
+  }
+}
+
 EventNode *readEventData(const char *eventFile) {
   int year, day, eventType;
   int currYear, currDay;
@@ -202,6 +255,7 @@ EventNode *readEventData(const char *eventFile) {
   char line[EVENT_LINE_SIZE];
   EventNode *curr, *next;
   EventNode *newEvents = NULL;
+  int hasCheckedLeafEvents = 0;
 
   // Check for a non-empty file
   if (access(eventFile, F_OK) != 0) {
@@ -238,6 +292,13 @@ EventNode *readEventData(const char *eventFile) {
     exit(EXIT_CODE_UNKNOWN_EVENT_TYPE_OR_PARAM);
   }
 
+  if (eventType == LEAFOFF || eventType == LEAFON) {
+    // If we have a leaf event, make sure we aren't also looking for
+    // calculated leaf events.
+    checkForCalculatedLeafEvents();
+    hasCheckedLeafEvents = 1;
+  }
+
   newEvents = createEventNode(year, day, eventType, eventParamsStr);
   next = newEvents;
   currYear = year;
@@ -264,12 +325,20 @@ EventNode *readEventData(const char *eventFile) {
       exit(EXIT_CODE_UNKNOWN_EVENT_TYPE_OR_PARAM);
     }
 
+    if (eventType == LEAFOFF || eventType == LEAFON) {
+      // If we have a leaf event, make sure we aren't also looking for
+      // calculated leaf events.
+      if (!hasCheckedLeafEvents) {
+        checkForCalculatedLeafEvents();
+        hasCheckedLeafEvents = 1;
+      }
+    }
+
     if ((year < currYear) || ((year == currYear) && (day < currDay))) {
-      // clang-format off
       logError("reading event file: last event was at (%d, %d), next event is "
-               "at (%d, %d)\n", currYear, currDay, year, day);
+               "at (%d, %d)\n",
+               currYear, currDay, year, day);
       logError("event records must be in time-ascending order\n");
-      // clang-format on
       exit(EXIT_CODE_INPUT_FILE_ERROR);
     }
 
@@ -363,30 +432,9 @@ int isFirstEventBefore(int year, int day) {
   return firstEvent->day < day;
 }
 
-void resetEventFluxes(void) {
-  fluxes.eventLeafC = 0.0;
-  fluxes.eventWoodC = 0.0;
-  fluxes.eventFineRootC = 0.0;
-  fluxes.eventCoarseRootC = 0.0;
-  fluxes.eventEvap = 0.0;
-  fluxes.eventSoilWater = 0.0;
-  fluxes.eventSoilC = 0.0;
-  fluxes.eventLitterC = 0.0;
-  fluxes.eventMinN = 0.0;
-  fluxes.eventSoilOrgN = 0.0;
-  fluxes.eventLitterN = 0.0;
-
-  // mass balance
-  fluxes.eventInputC = 0.0;
-  fluxes.eventOutputC = 0.0;
-  fluxes.eventInputN = 0.0;
-  fluxes.eventOutputN = 0.0;
-}
-
 void processEvents(void) {
-  // Set all event fluxes to zero, as these have no memory from one step to
-  // the next
-  resetEventFluxes();
+  // Event fluxes have all been reset to zero at the start of the time step,
+  // so we can just add to them as needed
 
   // If event starts off NULL, this function will just fall through, as it
   // should.
@@ -537,15 +585,20 @@ void processEvents(void) {
                          fracRB);
           fluxes.eventOutputN += outputN / climLen;
         }
+        // clang-format off
         writeEventOut(
-            gEvent, 10, "fluxes.eventSoilC", soilAdd / climLen,
-            "fluxes.eventLitterC", litterAdd / climLen, "fluxes.eventLeafC",
-            leafDelta / climLen, "fluxes.eventWoodC", woodDelta / climLen,
+            gEvent, 10,
+            "fluxes.eventSoilC", soilAdd / climLen,
+            "fluxes.eventLitterC", litterAdd / climLen,
+            "fluxes.eventLeafC", leafDelta / climLen,
+            "fluxes.eventWoodC", woodDelta / climLen,
             "fluxes.eventFineRootC", fineDelta / climLen,
             "fluxes.eventCoarseRootC", coarseDelta / climLen,
-            "fluxes.eventSoilOrgN", soilNAdd / climLen, "fluxes.eventLitterN",
-            litterNAdd / climLen, "fluxes.eventOutputC", outputC / climLen,
+            "fluxes.eventSoilOrgN", soilNAdd / climLen,
+            "fluxes.eventLitterN", litterNAdd / climLen,
+            "fluxes.eventOutputC", outputC / climLen,
             "fluxes.eventOutputN", outputN / climLen);
+        // clang-format on
       } break;
       case TILLAGE: {
         // BIG NOTE: this is the one event type that is NOT modeled as a flux;
@@ -561,8 +614,12 @@ void processEvents(void) {
       case FERTILIZATION: {
         const FertilizationParams *fertParams = gEvent->eventParams;
         const double orgC = fertParams->orgC;
-        double orgN = fertParams->orgN;
-        double minN = fertParams->minN;
+        double orgN = 0.0;
+        double minN = 0.0;
+        if (ctx.nitrogenCycle) {
+          orgN = fertParams->orgN;
+          minN = fertParams->minN;
+        }
         if (ctx.litterPool) {
           fluxes.eventLitterC += orgC / climLen;
         } else {
@@ -583,10 +640,47 @@ void processEvents(void) {
           fluxes.eventInputN += (orgN + minN) / climLen;
         }
 
-        writeEventOut(gEvent, 5, "fluxes.eventOrgN", orgN / climLen,
-                      "fluxes.eventLitterC", orgC / climLen, "fluxes.eventMinN",
-                      minN / climLen, "fluxes.eventInputC", orgC / climLen,
-                      "fluxes.eventInputN", (orgN + minN) / climLen);
+        // clang-format off
+        writeEventOut(gEvent, 6,
+          "fluxes.eventLitterC", ctx.litterPool ? orgC / climLen : 0.0,
+          "fluxes.eventSoilC", ctx.litterPool ? 0.0 : orgC / climLen,
+          "fluxes.eventMinN", minN / climLen,
+          "fluxes.eventLitterN", orgN / climLen,
+          "fluxes.eventInputC", orgC / climLen,
+          "fluxes.eventInputN", (orgN + minN) / climLen);
+        // clang-format on
+      } break;
+      case LEAFON: {
+        double leafOn = params.leafGrowth;
+        fluxes.eventLeafOnCreation += leafOn / climLen;
+
+        // Nitrogen is handled implicitly by relative CN ratios. Missing N
+        // from low-N wood to higher-N leaves is accounted for in
+        // calcNFixationAndUptakeFluxes() via calcPlantNDemand()
+
+        // Unlike planting, this is NOT a system input, so no adjustments to
+        // eventInputC or eventInputN
+
+        // ALSO, unlike all other events, we don't write the event here, as N
+        // limitation may change the amount
+      } break;
+      case LEAFOFF: {
+        double leafOff = envi.plantLeafC * params.fracLeafFall;
+        fluxes.eventLeafOffLitter += leafOff / climLen;
+
+        double litterNAdd = 0.0;
+        if (ctx.nitrogenCycle) {
+          // Nitrogen - need to account for leaf N moving to litter, as with
+          // harvests
+          litterNAdd = leafOff / params.leafCN;
+          fluxes.eventLitterN += litterNAdd / climLen;
+        }
+
+        // clang-format off
+        writeEventOut(gEvent, 2,
+          "fluxes.eventLeafOffLitter", leafOff / climLen,
+          "fluxes.eventLitterN", litterNAdd / climLen);
+        // clang-format on
       } break;
       default:
         logError("Unknown event type (%d) in processEvents()\n", gEvent->type);
@@ -609,6 +703,16 @@ void updatePoolsForEvents(void) {
     envi.litterC += fluxes.eventLitterC * climate->length;
   }
 
+  // Leaf on and off events
+  envi.plantWoodC -= fluxes.eventLeafOnCreation * climate->length;
+  envi.plantLeafC += (fluxes.eventLeafOnCreation - fluxes.eventLeafOffLitter) *
+                     climate->length;
+  if (ctx.litterPool) {
+    envi.litterC += fluxes.eventLeafOffLitter * climate->length;
+  } else {
+    envi.soilC += fluxes.eventLeafOffLitter * climate->length;
+  }
+
   // Harvest and planting events
   envi.coarseRootC += fluxes.eventCoarseRootC * climate->length;
   envi.fineRootC += fluxes.eventFineRootC * climate->length;
diff --git a/src/sipnet/events.h b/src/sipnet/events.h
index 3ab004423..c204f327e 100644
--- a/src/sipnet/events.h
+++ b/src/sipnet/events.h
@@ -11,6 +11,8 @@ typedef enum EventType {
   IRRIGATION,
   PLANTING,
   TILLAGE,
+  LEAFON,
+  LEAFOFF,
   UNKNOWN_EVENT
 } event_type_t;
 
@@ -58,6 +60,18 @@ typedef struct TillageParams {
 // Tillage effect decay factor
 #define TILLAGE_DECAY_FACTOR (1 / 30.0)
 
+#define NUM_LEAFON_PARAMS 0
+typedef struct LeafOnParams {
+  // Currently none, but we need one for compilation
+  double dummy;
+} LeafOnParams;
+
+#define NUM_LEAFOFF_PARAMS 0
+typedef struct LeafOffParams {
+  // Currently none, but we need one for compilation
+  double dummy;
+} LeafOffParams;
+
 #define NUM_EVENT_CORE_PARAMS 3
 typedef struct EventNode EventNode;
 struct EventNode {
@@ -170,15 +184,6 @@ void setupEvents(void);
  */
 int isFirstEventBefore(int year, int day);
 
-// TODO: remove this function and its call sites, sipnet:resetFluxes now
-//  handles this
-/*!
- * Set all event fluxes to zero
- *
- * Reset all event fluxes to zero in preparation for the next climate step.
- */
-void resetEventFluxes(void);
-
 /*!
  * \brief Process events for current location/year/day
  *
diff --git a/src/sipnet/sipnet.c b/src/sipnet/sipnet.c
index 81801769d..8edfdbec8 100644
--- a/src/sipnet/sipnet.c
+++ b/src/sipnet/sipnet.c
@@ -705,24 +705,32 @@ int pastLeafGrowth(void) {
       cumulativeGdd += trackers.gdd;
     }
     return (cumulativeGdd >= params.gddLeafOn);
-  } else if (ctx.soilPhenol) {
+  }
+  if (ctx.soilPhenol) {
     // [TAG:UNKNOWN_PROVENANCE] soil phenol functionality
     return (climate->tsoil >= params.soilTempLeafOn);  // soil temperature
                                                        // threshold
-  } else {
+  }
+  if (params.leafOnDay > 0) {
     // :: from [1]
     double currTime = (double)climate->day + climate->time / 24.0;
     return (currTime >= params.leafOnDay);  // turn-on day
   }
+
+  return 0;
 }
 
 // have we passed the growing season-end leaf fall trigger this year?
 // 0 = no, 1 = yes
 int pastLeafFall(void) {
   // :: from [1]
-  return ((climate->day + climate->time / 24.0) >=
-          params.leafOffDay);  // turn-off
-                               // day
+  if (params.leafOffDay > 0) {
+    return ((climate->day + climate->time / 24.0) >=
+            params.leafOffDay);  // turn-off
+    // day
+  }
+
+  return 0;
 }
 
 /*!
@@ -1381,8 +1389,10 @@ double calcPlantNDemand() {
   // demand should only count the difference in the N
   // between those two pools, hence subtracting
   // params.woodCN from params.leafCN for leafOnCreation
-  double leafOnDemand = fluxes.leafOnCreation / params.leafCN -
-                        fluxes.leafOnCreation / params.woodCN;
+  // Note we can have leafOn creation terms from two places
+  double leafOnCreation = fluxes.leafOnCreation + fluxes.eventLeafOnCreation;
+  double leafOnDemand =
+      leafOnCreation / params.leafCN - leafOnCreation / params.woodCN;
   // calculate demand from all other creation terms
   double creationDemand = fluxes.woodCreation / params.woodCN +
                           fluxes.leafCreation / params.leafCN +
@@ -1450,6 +1460,7 @@ void calcNFixationAndUptakeFluxes(void) {
             climate->day, climate->time);
 
     // Reduce all drains on soil N
+    fluxes.eventLeafOnCreation *= reduction;
     fluxes.leafOnCreation *= reduction;
     fluxes.woodCreation *= reduction;
     fluxes.leafCreation *= reduction;
@@ -1475,6 +1486,13 @@ void writeLeafOnEventIfNeeded(void) {
     writeComputedEventOut(climate->year, climate->day, "leafon", 1,
                           "fluxes.leafOnCreation", fluxes.leafOnCreation);
   }
+  if (fluxes.eventLeafOnCreation > TINY && ctx.events) {
+    // Not really a computed event, but we don't have the event object here, so
+    // we use this mechanism
+    writeComputedEventOut(climate->year, climate->day, "leafon", 1,
+                          "fluxes.eventLeafOnCreation",
+                          fluxes.eventLeafOnCreation);
+  }
 }
 
 /**
@@ -1493,8 +1511,7 @@ void calcNPoolFluxes(void) {
   // litter
   // The litter org N flux is determined by the carbon fluxes from wood and leaf
   // litter, and N loss due to mineralization. N added via fertilization
-  // is handled elsewhere.Added subtraction of (fluxes.litterToSoil / litterCN)
-  // to prevent N duplication.
+  // is handled elsewhere.
   fluxes.nOrgLitter = fluxes.leafLitter / params.leafCN +
                       fluxes.woodLitter / params.woodCN - litterMin -
                       fluxes.litterToSoil / litterCN;
@@ -1530,19 +1547,19 @@ void calcMethaneFlux(void) {
 }
 
 /**
- * Reset all (non-event) fluxes.
+ * Reset all fluxes, including event fluxes.
  *
- * Make sure to add new fluxes to this list!
+ * This is called at the start of each time step (in updateState()), before
+ * event and non-event fluxes are calculated.
  */
-void resetFluxes(void) {
-  // This reset all fluxes, including the event fluxes (which we want)
-  fluxes = (struct FluxVars){0};
-}
+void resetFluxes(void) { fluxes = (struct FluxVars){0}; }
 
 /*!
  * Calculate flux terms for sipnet as part of main model flow
  *
  * All fluxes should be calculated before state variables are updated.
+ * Note: fluxes are reset in updateState() before this is called, so we can
+ * assume fluxes start at zero here.
  */
 void calculateFluxes(void) {
   // base foliar respiration, calc'd as part of potential photosynthesis
@@ -1561,9 +1578,6 @@ void calculateFluxes(void) {
   // net rain, equal to (rain - immedEvap) (cm/day)
   double netRain;
 
-  // Let's make sure to get all fluxes to zero before starting this
-  resetFluxes();
-
   // Psn, moisture and water fluxes
   lai = envi.plantLeafC / params.leafCSpWt;  // current lai
 
@@ -1608,9 +1622,9 @@ void calculateFluxes(void) {
 
   // Nitrogen cycle
   //
-  // Many of the nitrogen fluxes depend on carbon flux calculations, so make
-  // sure this stays at the bottom of this function (or after the carbon calcs,
-  // at least).
+  // Many of the nitrogen fluxes depend on carbon and water flux calculations,
+  // so make sure this stays at the bottom of this function (or after the
+  // carbon and water calcs, at least).
   if (ctx.nitrogenCycle) {
     calcNVolatilizationFlux();
     calcNLeachingFlux();
@@ -1787,7 +1801,9 @@ void updateTrackers(double oldSoilWater) {
   trackers.soilWetnessFrac =
       (oldSoilWater + envi.soilWater) / (2.0 * params.soilWHC);
 
-  trackers.yearlyLitter += fluxes.leafLitter;
+  // If we get another event flux in this function, we should create an
+  // updateTrackersForEvents() function in events.c|h
+  trackers.yearlyLitter += fluxes.leafLitter + fluxes.eventLeafOffLitter;
 
   if (ctx.gdd) {
     trackers.gdd += climate->gdd;
@@ -2012,12 +2028,17 @@ void updateState(void) {
   ///////////////////////
   // 1. Calculate Fluxes
 
-  // All non-event fluxes
-  calculateFluxes();
+  // Reset all fluxes to zero before calculating anything this time step.
+  resetFluxes();
 
-  // All event handling, which is modeled as fluxes
+  // All event handling, which is modeled as fluxes. Note that we have this
+  // before the other fluxes so that everything is in place when we consider
+  // N limitation at the end of calculateFluxes().
   processEvents();
 
+  // All non-event fluxes
+  calculateFluxes();
+
   ///////////////////////
   // 2. Update Pools
 
diff --git a/src/sipnet/state.h b/src/sipnet/state.h
index 93e70fd41..58225aa5f 100644
--- a/src/sipnet/state.h
+++ b/src/sipnet/state.h
@@ -590,6 +590,10 @@ typedef struct FluxVars {
   double eventInputN;
   // Total system nitrogen output, for mass balance checks
   double eventOutputN;
+  // Transfer from woodC to leafC from a leaf-on event
+  double eventLeafOnCreation;
+  // Transfer from leafC to soil/litter from a leaf-off event
+  double eventLeafOffLitter;
 
   // ****************************************
   // Methane production
diff --git a/tests/sipnet/test_events_infrastructure/testEventOutputFile.c b/tests/sipnet/test_events_infrastructure/testEventOutputFile.c
index ac7bb55a5..b48f29637 100644
--- a/tests/sipnet/test_events_infrastructure/testEventOutputFile.c
+++ b/tests/sipnet/test_events_infrastructure/testEventOutputFile.c
@@ -4,8 +4,8 @@
 
 #include "utils/tUtils.h"
 #include "common/logging.h"
-#include "sipnet/sipnet.c"
-#include "sipnet/events.c"
+// #include "sipnet/sipnet.c"
+#include "utils/helpers.c"
 
 void init(void) {
   // Values here don't matter, just want to make sure they are initialized to
@@ -53,11 +53,6 @@ void init(void) {
   climate = climate1;
 }
 
-void procEvents() {
-  processEvents();
-  updatePoolsForEvents();
-}
-
 void runLoc(void) {
   ClimateNode *climStart = climate;
   setupEvents();
diff --git a/tests/sipnet/test_events_types/Makefile b/tests/sipnet/test_events_types/Makefile
index 605c52472..d7996907d 100644
--- a/tests/sipnet/test_events_types/Makefile
+++ b/tests/sipnet/test_events_types/Makefile
@@ -8,7 +8,7 @@ LDFLAGS=-L$(ROOT_DIR)/libs
 LDLIBS=-lsipnet -lsipnet_common -lm
 
 # List test files in this directory here
-TEST_CFILES=testEventIrrigation.c testEventPlanting.c testEventHarvest.c testEventFertilization.c  testEventTillage.c
+TEST_CFILES=testEventIrrigation.c testEventPlanting.c testEventHarvest.c testEventFertilization.c  testEventTillage.c testEventLeafOnOff.c
 
 # The rest is boilerplate, likely copyable as is to a new test directory
 TEST_OBJ_FILES=$(TEST_CFILES:%.c=%.o)
diff --git a/tests/sipnet/test_events_types/events_one_leafoff.in b/tests/sipnet/test_events_types/events_one_leafoff.in
new file mode 100644
index 000000000..1a794b3b6
--- /dev/null
+++ b/tests/sipnet/test_events_types/events_one_leafoff.in
@@ -0,0 +1 @@
+2024 70 leafoff
diff --git a/tests/sipnet/test_events_types/events_one_leafon.in b/tests/sipnet/test_events_types/events_one_leafon.in
new file mode 100644
index 000000000..87296ab1f
--- /dev/null
+++ b/tests/sipnet/test_events_types/events_one_leafon.in
@@ -0,0 +1 @@
+2024 70 leafon
diff --git a/tests/sipnet/test_events_types/events_two_leafoff.in b/tests/sipnet/test_events_types/events_two_leafoff.in
new file mode 100644
index 000000000..87076a846
--- /dev/null
+++ b/tests/sipnet/test_events_types/events_two_leafoff.in
@@ -0,0 +1,2 @@
+2024 70 leafoff
+2024 70 leafoff
diff --git a/tests/sipnet/test_events_types/events_two_leafon.in b/tests/sipnet/test_events_types/events_two_leafon.in
new file mode 100644
index 000000000..125a1c877
--- /dev/null
+++ b/tests/sipnet/test_events_types/events_two_leafon.in
@@ -0,0 +1,2 @@
+2024 70 leafon
+2024 70 leafon
diff --git a/tests/sipnet/test_events_types/testEventFertilization.c b/tests/sipnet/test_events_types/testEventFertilization.c
index 69220eb12..1c975eb30 100644
--- a/tests/sipnet/test_events_types/testEventFertilization.c
+++ b/tests/sipnet/test_events_types/testEventFertilization.c
@@ -2,8 +2,7 @@
 #include <stdlib.h>
 
 #include "utils/tUtils.h"
-
-#include "typesUtils.h"
+#include "utils/helpers.c"
 
 int checkOutput(double orgN, double litterC, double minN) {
   int status = 0;
diff --git a/tests/sipnet/test_events_types/testEventHarvest.c b/tests/sipnet/test_events_types/testEventHarvest.c
index 2b7be7d41..98e0b7c38 100644
--- a/tests/sipnet/test_events_types/testEventHarvest.c
+++ b/tests/sipnet/test_events_types/testEventHarvest.c
@@ -2,8 +2,7 @@
 #include <stdlib.h>
 
 #include "utils/tUtils.h"
-
-#include "typesUtils.h"
+#include "utils/helpers.c"
 
 int checkBioOutput(double leafC, double woodC, double fineC, double coarseC) {
   int status = 0;
diff --git a/tests/sipnet/test_events_types/testEventIrrigation.c b/tests/sipnet/test_events_types/testEventIrrigation.c
index cf7fc1d1e..cb53b1e71 100644
--- a/tests/sipnet/test_events_types/testEventIrrigation.c
+++ b/tests/sipnet/test_events_types/testEventIrrigation.c
@@ -3,8 +3,7 @@
 #include <stdlib.h>
 
 #include "utils/tUtils.h"
-
-#include "typesUtils.h"
+#include "utils/helpers.c"
 
 int checkOutput(double soilWater, double eventEvap) {
   int status = 0;
diff --git a/tests/sipnet/test_events_types/testEventLeafOnOff.c b/tests/sipnet/test_events_types/testEventLeafOnOff.c
new file mode 100644
index 000000000..8929232a9
--- /dev/null
+++ b/tests/sipnet/test_events_types/testEventLeafOnOff.c
@@ -0,0 +1,248 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "utils/tUtils.h"
+#include "utils/exitHandler.c"
+#include "utils/helpers.c"
+
+int checkLeafOn(const char *stage, double expWoodC, double expLeafC) {
+  int status = 0;
+  if (!compareDoubles(expWoodC, envi.plantWoodC)) {
+    logTest("%s: plantWoodC is %f, expected %f\n", stage, envi.plantWoodC,
+            expWoodC);
+    status = 1;
+  }
+  if (!compareDoubles(expLeafC, envi.plantLeafC)) {
+    logTest("%s: plantLeafC is %f, expected %f\n", stage, envi.plantLeafC,
+            expLeafC);
+    status = 1;
+  }
+  return status;
+}
+
+int checkLeafOff(const char *stage, double expLeafC, double expPoolC,
+                 double expLitterN) {
+  int status = 0;
+  double curPoolC = ctx.litterPool ? envi.litterC : envi.soilC;
+  if (!compareDoubles(expLeafC, envi.plantLeafC)) {
+    logTest("%s: plantLeafC is %f, expected %f\n", stage, envi.plantLeafC,
+            expLeafC);
+    status = 1;
+  }
+  if (!compareDoubles(expPoolC, curPoolC)) {
+    logTest("%s: %s is %f, expected %f\n", stage,
+            ctx.litterPool ? "litterC" : "soilC", curPoolC, expPoolC);
+    status = 1;
+  }
+  if (!compareDoubles(expLitterN, envi.litterN)) {
+    logTest("%s: litterN is %f, expected %f\n", stage, envi.litterN,
+            expLitterN);
+    status = 1;
+  }
+  return status;
+}
+
+void initEnv(double woodC, double leafC) {
+  envi.plantWoodC = woodC;
+  envi.plantLeafC = leafC;
+  envi.litterC = 0.0;
+  envi.soilC = 0.0;
+  envi.litterN = 0.0;
+}
+
+int run(void) {
+  int status = 0;
+
+  prepTypesTest();
+  updateIntContext("litterPool", 1, CTX_TEST);
+  updateIntContext("gdd", 0, CTX_TEST);
+
+  // Set params needed for leaf on/off events
+  params.leafGrowth = 3.0;
+  params.fracLeafFall = 0.5;
+  params.leafCN = 30.0;
+  params.leafOnDay = 0;
+  params.leafOffDay = 0;
+
+  //// ONE LEAFON EVENT
+  logTest("Testing one leafon event\n");
+  initEnv(10.0, 0.0);
+  resetFluxes();
+  initEvents("events_one_leafon.in", "events.out", 0);
+  setupEvents();
+  procEvents();
+  closeEventOutFile();
+
+  // leafOn = params.leafGrowth = 3.0
+  // wood decreases by 3.0, leaf increases by 3.0
+  status |= checkLeafOn("one leafon", 10.0 - 3.0, 0.0 + 3.0);
+
+  //// TWO LEAFON EVENTS
+  logTest("Testing two leafon events\n");
+  initEnv(10.0, 0.0);
+  resetFluxes();
+  initEvents("events_two_leafon.in", "events.out", 0);
+  setupEvents();
+  procEvents();
+  closeEventOutFile();
+
+  // Two leafOn events: total 2 * 3.0 = 6.0 from wood to leaf
+  status |= checkLeafOn("two leafon", 10.0 - 6.0, 0.0 + 6.0);
+
+  //// ONE LEAFOFF EVENT (without nitrogen cycle)
+  logTest("Testing one leafoff event (no nitrogen cycle)\n");
+  initEnv(5.0, 10.0);
+  resetFluxes();
+  initEvents("events_one_leafoff.in", "events.out", 0);
+  setupEvents();
+  procEvents();
+  closeEventOutFile();
+
+  // leafOff = plantLeafC * fracLeafFall = 10.0 * 0.5 = 5.0
+  // leaf decreases by 5.0, litter increases by 5.0; no N (nitrogenCycle off)
+  status |= checkLeafOff("one leafoff (no N)", 10.0 - 5.0, 0.0 + 5.0, 0.0);
+
+  //// ONE LEAFOFF EVENT (with nitrogen cycle)
+  logTest("Testing one leafoff event (with nitrogen cycle)\n");
+  updateIntContext("anaerobic", 1, CTX_TEST);
+  updateIntContext("waterHResp", 1, CTX_TEST);
+  updateIntContext("nitrogenCycle", 1, CTX_TEST);
+  initEnv(5.0, 10.0);
+  resetFluxes();
+  initEvents("events_one_leafoff.in", "events.out", 0);
+  setupEvents();
+  procEvents();
+  closeEventOutFile();
+
+  // leafOff = 10.0 * 0.5 = 5.0; N = leafOff / leafCN = 5.0 / 30.0
+  status |=
+      checkLeafOff("one leafoff (with N)", 10.0 - 5.0, 0.0 + 5.0, 5.0 / 30.0);
+
+  //// ONE LEAFOFF EVENT (without litter pool)
+  logTest("Testing one leafoff event (no litter pool)\n");
+  updateIntContext("litterPool", 0, CTX_TEST);
+  updateIntContext("nitrogenCycle", 0, CTX_TEST);
+  updateIntContext("anaerobic", 0, CTX_TEST);
+  updateIntContext("waterHResp", 0, CTX_TEST);
+  initEnv(5.0, 10.0);
+  resetFluxes();
+  initEvents("events_one_leafoff.in", "events.out", 0);
+  setupEvents();
+  procEvents();
+  closeEventOutFile();
+
+  // Without litter pool, leaf C goes to soil C instead
+  status |=
+      checkLeafOff("one leafoff (no litter pool)", 10.0 - 5.0, 0.0 + 5.0, 0.0);
+
+  //// CHECK FOR CALCULATED LEAF EVENTS
+
+  // Restore context for the following tests: no flags set, leafOnDay and
+  // leafOffDay set to 0 (disabled), so readEventData should NOT error
+  updateIntContext("litterPool", 1, CTX_TEST);
+  updateIntContext("gdd", 0, CTX_TEST);
+  updateIntContext("soilPhenol", 0, CTX_TEST);
+  params.leafOnDay = 0;
+  params.leafOffDay = 0;
+
+  int jmp_rval;
+
+  // Baseline: no calculated leaf events configured; readEventData should
+  // succeed without calling exit()
+  logTest("Testing checkForCalculateLeafEvents: baseline (no conflict)\n");
+  should_exit = 0;
+  exit_result = 1;
+  jmp_rval = setjmp(jump_env);
+  if (!jmp_rval) {
+    readEventData("events_one_leafon.in");
+  }
+  test_assert(jmp_rval == 0);
+  status |= !exit_result;
+  if (!exit_result) {
+    logTest("FAIL checkForCalculateLeafEvents baseline\n");
+  }
+
+  // ctx.gdd=1 should error
+  logTest("Testing checkForCalculateLeafEvents: gdd=1 conflicts\n");
+  updateIntContext("gdd", 1, CTX_TEST);
+  should_exit = 1;
+  exit_result = 1;
+  expected_code = EXIT_CODE_BAD_PARAMETER_VALUE;
+  jmp_rval = setjmp(jump_env);
+  if (!jmp_rval) {
+    readEventData("events_one_leafon.in");
+  }
+  test_assert(jmp_rval == 1);
+  status |= !exit_result;
+  if (!exit_result) {
+    logTest("FAIL checkForCalculateLeafEvents with gdd=1\n");
+  }
+  updateIntContext("gdd", 0, CTX_TEST);
+
+  // ctx.soilPhenol=1 should error
+  logTest("Testing checkForCalculateLeafEvents: soilPhenol=1 conflicts\n");
+  updateIntContext("soilPhenol", 1, CTX_TEST);
+  should_exit = 1;
+  exit_result = 1;
+  expected_code = EXIT_CODE_BAD_PARAMETER_VALUE;
+  jmp_rval = setjmp(jump_env);
+  if (!jmp_rval) {
+    readEventData("events_one_leafon.in");
+  }
+  test_assert(jmp_rval == 1);
+  status |= !exit_result;
+  if (!exit_result) {
+    logTest("FAIL checkForCalculateLeafEvents with soilPhenol=1\n");
+  }
+  updateIntContext("soilPhenol", 0, CTX_TEST);
+
+  // params.leafOnDay > 0 should error
+  logTest("Testing checkForCalculateLeafEvents: leafOnDay>0 conflicts\n");
+  params.leafOnDay = 47.0;
+  should_exit = 1;
+  exit_result = 1;
+  expected_code = EXIT_CODE_BAD_PARAMETER_VALUE;
+  jmp_rval = setjmp(jump_env);
+  if (!jmp_rval) {
+    readEventData("events_one_leafon.in");
+  }
+  test_assert(jmp_rval == 1);
+  status |= !exit_result;
+  if (!exit_result) {
+    logTest("FAIL checkForCalculateLeafEvents with leafOnDay>0\n");
+  }
+  params.leafOnDay = 0;
+
+  // params.leafOffDay > 0 should error
+  logTest("Testing checkForCalculateLeafEvents: leafOffDay>0 conflicts\n");
+  params.leafOffDay = 285.0;
+  should_exit = 1;
+  exit_result = 1;
+  expected_code = EXIT_CODE_BAD_PARAMETER_VALUE;
+  jmp_rval = setjmp(jump_env);
+  if (!jmp_rval) {
+    readEventData("events_one_leafoff.in");
+  }
+  test_assert(jmp_rval == 1);
+  status |= !exit_result;
+  if (!exit_result) {
+    logTest("FAIL checkForCalculateLeafEvents with leafOffDay>0\n");
+  }
+  params.leafOffDay = 0;
+
+  // Allow real exit for the remainder of the test
+  really_exit = 1;
+
+  return status;
+}
+
+int main(void) {
+  logTest("Starting run()\n");
+  int status = run();
+  if (status) {
+    logTest("FAILED testEventLeafOnOff with status %d\n", status);
+    exit(status);
+  }
+
+  logTest("PASSED testEventLeafOnOff\n");
+}
diff --git a/tests/sipnet/test_events_types/testEventPlanting.c b/tests/sipnet/test_events_types/testEventPlanting.c
index 9088aa628..266b7ad38 100644
--- a/tests/sipnet/test_events_types/testEventPlanting.c
+++ b/tests/sipnet/test_events_types/testEventPlanting.c
@@ -2,8 +2,7 @@
 #include <stdlib.h>
 
 #include "utils/tUtils.h"
-
-#include "typesUtils.h"
+#include "utils/helpers.c"
 
 int checkOutput(double leafC, double woodC, double fineC, double coarseC) {
   int status = 0;
diff --git a/tests/sipnet/test_events_types/testEventTillage.c b/tests/sipnet/test_events_types/testEventTillage.c
index dd945a6ce..5831880ec 100644
--- a/tests/sipnet/test_events_types/testEventTillage.c
+++ b/tests/sipnet/test_events_types/testEventTillage.c
@@ -1,9 +1,7 @@
-#include <stdio.h>
 #include <stdlib.h>
 
 #include "utils/tUtils.h"
-
-#include "typesUtils.h"
+#include "utils/helpers.c"
 
 int checkOutput(const char *stage, double expTillMod) {
   int status = 0;
diff --git a/tests/sipnet/test_modeling/events_leaf.in b/tests/sipnet/test_modeling/events_leaf.in
new file mode 100644
index 000000000..b0e6435cd
--- /dev/null
+++ b/tests/sipnet/test_modeling/events_leaf.in
@@ -0,0 +1,2 @@
+2016 46 leafon
+2016 50 leafoff
diff --git a/tests/sipnet/test_modeling/testBalance.c b/tests/sipnet/test_modeling/testBalance.c
index 3ff9f8675..1b2966b7b 100644
--- a/tests/sipnet/test_modeling/testBalance.c
+++ b/tests/sipnet/test_modeling/testBalance.c
@@ -91,6 +91,9 @@ int testBalanceLeaf(void) {
   logTest("Starting testBalanceLeaf()\n");
   int status = 0;
 
+  params.leafOnDay = 0;
+  params.leafOffDay = 0;
+
   // Run the whole climate file (5 days), which includes a leaf-on event and a
   // leaf-off event
   while (climate != NULL) {
@@ -105,6 +108,26 @@ int testBalanceLeaf(void) {
   return status;
 }
 
+int testBalanceLeafEvents(void) {
+  logTest("Starting testBalanceLeafEvents()\n");
+  int status = 0;
+
+  // Run the whole climate file (5 days), which includes model-based leaf-on
+  // and leaf-off events (days 47 and 49), PLUS event-file-based
+  // leaf-on/leaf-off events on different days to test that event-based leaf
+  // fluxes maintain carbon and nitrogen balance
+  while (climate != NULL) {
+    step();
+
+    status |= checkCarbon();
+    status |= checkNitrogen();
+
+    climate = climate->nextClim;
+  }
+
+  return status;
+}
+
 int testBalanceNoLitterPool(void) {
   logTest("Starting testBalanceNoLitterPool()\n");
   int status = 0;
@@ -138,6 +161,13 @@ int run(void) {
   status |= testBalanceLeaf();
   reset();
 
+  // Re-initialize events with leaf on/off events for the next test
+  closeEventOutFile();
+  initEvents("events_leaf.in", "events.out", 0);
+  setupEvents();
+  status |= testBalanceLeafEvents();
+  reset();
+
   status |= testBalanceNoLitterPool();
 
   return status;
diff --git a/tests/smoke/russell_2/events.out b/tests/smoke/russell_2/events.out
index 20ac433d4..1ffc9b95b 100644
--- a/tests/smoke/russell_2/events.out
+++ b/tests/smoke/russell_2/events.out
@@ -1,11 +1,11 @@
 year  day  type     param_name=delta[,param_name=delta,...]
 2016   47  leafon   fluxes.leafOnCreation=85.26
-2016   90  fert     fluxes.eventOrgN=120.00,fluxes.eventLitterC=40.00,fluxes.eventMinN=80.00,fluxes.eventInputC=40.00,fluxes.eventInputN=200.00
+2016   90  fert     fluxes.eventLitterC=40.00,fluxes.eventSoilC=0.00,fluxes.eventMinN=80.00,fluxes.eventLitterN=120.00,fluxes.eventInputC=40.00,fluxes.eventInputN=200.00
 2016   92  irrig    fluxes.eventSoilWater=22.40,fluxes.eventEvap=0.00
 2016   96  irrig    fluxes.eventSoilWater=22.40,fluxes.eventEvap=0.00
 2016  100  irrig    fluxes.eventSoilWater=22.40,fluxes.eventEvap=0.00
 2016  104  irrig    fluxes.eventSoilWater=22.40,fluxes.eventEvap=0.00
-2016  104  fert     fluxes.eventOrgN=120.00,fluxes.eventLitterC=40.00,fluxes.eventMinN=80.00,fluxes.eventInputC=40.00,fluxes.eventInputN=200.00
+2016  104  fert     fluxes.eventLitterC=40.00,fluxes.eventSoilC=0.00,fluxes.eventMinN=80.00,fluxes.eventLitterN=120.00,fluxes.eventInputC=40.00,fluxes.eventInputN=200.00
 2016  108  irrig    fluxes.eventSoilWater=22.40,fluxes.eventEvap=0.00
 2016  112  irrig    fluxes.eventSoilWater=22.40,fluxes.eventEvap=0.00
 2016  116  irrig    fluxes.eventSoilWater=22.40,fluxes.eventEvap=0.00
diff --git a/tests/sipnet/test_events_types/typesUtils.h b/tests/utils/helpers.c
similarity index 58%
rename from tests/sipnet/test_events_types/typesUtils.h
rename to tests/utils/helpers.c
index ee2795680..ff2e5b912 100644
--- a/tests/sipnet/test_events_types/typesUtils.h
+++ b/tests/utils/helpers.c
@@ -1,10 +1,11 @@
-#ifndef SIPNET_TYPESUTILS_H
-#define SIPNET_TYPESUTILS_H
+// Helper functions for setting up and processing events
+
+// NOTE: don't include sipnet.c as well as this file, it won't compile
 
 #include "common/context.h"
 #include "sipnet/sipnet.c"
 
-void prepTypesTest() {
+void prepTypesTest(void) {
   // Setup context
   initContext();
   updateIntContext("events", 1, CTX_TEST);
@@ -14,11 +15,12 @@ void prepTypesTest() {
   climate->year = 2024;
   climate->day = 70;
   climate->length = 0.125;
+  climate->time = 0.0;
+  climate->nextClim = NULL;
 }
 
-void procEvents() {
+void procEvents(void) {
+  resetFluxes();
   processEvents();
   updatePoolsForEvents();
 }
-
-#endif  // SIPNET_TYPESUTILS_H