@bananapus/core-v6 0.0.18 → 0.0.20

package/src/interfaces/IJBTerminal.sol

@@ -6,6 +6,8 @@ import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 import {IJBPayHook} from "./IJBPayHook.sol";
 import {JBAccountingContext} from "../structs/JBAccountingContext.sol";
 import {JBAfterPayRecordedContext} from "../structs/JBAfterPayRecordedContext.sol";
+import {JBPayHookSpecification} from "../structs/JBPayHookSpecification.sol";
+import {JBRuleset} from "../structs/JBRuleset.sol";
 
 /// @notice A terminal that accepts payments and can be migrated.
 interface IJBTerminal is IERC165 {
@@ -102,6 +104,32 @@ interface IJBTerminal is IERC165 {
         view
         returns (uint256);
 
+    /// @notice Simulates paying a project through this terminal without modifying state.
+    /// @param projectId The ID of the project being paid.
+    /// @param token The token being paid in.
+    /// @param amount The amount of tokens being paid.
+    /// @param beneficiary The address to mint project tokens to.
+    /// @param metadata Extra data to pass along to the data hook and pay hooks.
+    /// @return ruleset The project's current ruleset.
+    /// @return beneficiaryTokenCount The number of project tokens that would be minted for the beneficiary.
+    /// @return reservedTokenCount The number of project tokens that would be reserved.
+    /// @return hookSpecifications Any pay hook specifications from the data hook.
+    function previewPayFor(
+        uint256 projectId,
+        address token,
+        uint256 amount,
+        address beneficiary,
+        bytes calldata metadata
+    )
+        external
+        view
+        returns (
+            JBRuleset memory ruleset,
+            uint256 beneficiaryTokenCount,
+            uint256 reservedTokenCount,
+            JBPayHookSpecification[] memory hookSpecifications
+        );
+
     /// @notice Adds accounting contexts for a project's tokens.
     /// @param projectId The ID of the project to add accounting contexts for.
     /// @param accountingContexts The accounting contexts to add.

package/src/interfaces/IJBTerminalStore.sol

@@ -65,6 +65,22 @@ interface IJBTerminalStore {
         view
         returns (uint256);
 
+    /// @notice Returns the reclaimable surplus for a project across all terminals using all accounting contexts.
+    /// @param projectId The ID of the project.
+    /// @param cashOutCount The number of tokens being cashed out.
+    /// @param decimals The number of decimals to express the result with.
+    /// @param currency The currency to express the result in.
+    /// @return The reclaimable surplus amount.
+    function currentTotalReclaimableSurplusOf(
+        uint256 projectId,
+        uint256 cashOutCount,
+        uint256 decimals,
+        uint256 currency
+    )
+        external
+        view
+        returns (uint256);
+
     /// @notice Returns the current surplus for a terminal and project.
     /// @param terminal The terminal to get the surplus of.
     /// @param projectId The ID of the project.
@@ -97,6 +113,56 @@ interface IJBTerminalStore {
         view
         returns (uint256);
 
+    /// @notice Simulates a cash out without modifying state.
+    /// @param holder The address cashing out.
+    /// @param projectId The ID of the project being cashed out from.
+    /// @param cashOutCount The number of project tokens being cashed out.
+    /// @param accountingContext The accounting context of the token being reclaimed.
+    /// @param balanceAccountingContexts The accounting contexts to include in the balance calculation.
+    /// @param beneficiaryIsFeeless Whether the cash out's beneficiary is a feeless address.
+    /// @param metadata Extra data to pass along to the data hook.
+    /// @return ruleset The project's current ruleset.
+    /// @return reclaimAmount The amount that would be reclaimed.
+    /// @return cashOutTaxRate The cash out tax rate that would be applied.
+    /// @return hookSpecifications Any cash out hook specifications from the data hook.
+    function previewCashOutFrom(
+        address holder,
+        uint256 projectId,
+        uint256 cashOutCount,
+        JBAccountingContext calldata accountingContext,
+        JBAccountingContext[] calldata balanceAccountingContexts,
+        bool beneficiaryIsFeeless,
+        bytes calldata metadata
+    )
+        external
+        view
+        returns (
+            JBRuleset memory ruleset,
+            uint256 reclaimAmount,
+            uint256 cashOutTaxRate,
+            JBCashOutHookSpecification[] memory hookSpecifications
+        );
+
+    /// @notice Simulates a payment without modifying state.
+    /// @param payer The address of the payer.
+    /// @param amount The amount being paid.
+    /// @param projectId The ID of the project being paid.
+    /// @param beneficiary The address to mint project tokens to.
+    /// @param metadata Extra data to pass along to the data hook.
+    /// @return ruleset The project's current ruleset.
+    /// @return tokenCount The number of project tokens that would be minted, including reserved tokens.
+    /// @return hookSpecifications Any pay hook specifications from the data hook.
+    function previewPayFrom(
+        address payer,
+        JBTokenAmount memory amount,
+        uint256 projectId,
+        address beneficiary,
+        bytes calldata metadata
+    )
+        external
+        view
+        returns (JBRuleset memory ruleset, uint256 tokenCount, JBPayHookSpecification[] memory hookSpecifications);
+
     /// @notice Returns the amount of payout limit used by a terminal for a project in a given cycle.
     /// @param terminal The terminal to get the used payout limit of.
     /// @param projectId The ID of the project.

package/src/libraries/JBPayoutSplitGroupLib.sol

@@ -0,0 +1,157 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+import {mulDiv} from "@prb/math/src/Common.sol";
+
+import {IJBPayoutTerminal} from "../interfaces/IJBPayoutTerminal.sol";
+import {IJBSplits} from "../interfaces/IJBSplits.sol";
+import {IJBTerminalStore} from "../interfaces/IJBTerminalStore.sol";
+import {JBSplit} from "../structs/JBSplit.sol";
+import {JBConstants} from "./JBConstants.sol";
+
+/// @notice Minimal callback surface used only by this library to call back into the terminal's `executePayout(...)`.
+/// @dev Kept local to this file because `executePayout(...)` is an implementation detail, not a shared public
+/// interface.
+interface IJBPayoutSplitGroupExecutor {
+    function executePayout(
+        JBSplit calldata split,
+        uint256 projectId,
+        address token,
+        uint256 amount,
+        address originalMessageSender
+    )
+        external
+        returns (uint256 netPayoutAmount);
+}
+
+/// @notice External library for payout split-group distribution extracted to reduce terminal bytecode.
+/// @dev Called via DELEGATECALL from the terminal, so events are emitted from the terminal's address.
+library JBPayoutSplitGroupLib {
+    event PayoutReverted(uint256 indexed projectId, JBSplit split, uint256 amount, bytes reason, address caller);
+    event SendPayoutToSplit(
+        uint256 indexed projectId,
+        uint256 indexed rulesetId,
+        uint256 indexed group,
+        JBSplit split,
+        uint256 amount,
+        uint256 netAmount,
+        address caller
+    );
+
+    /// @notice Sends payouts to the payout splits group specified in a project's ruleset.
+    /// @param splits The splits contract to read splits from.
+    /// @param store The terminal store used to restore balance when a payout fails.
+    /// @param projectId The ID of the project to send the payouts of.
+    /// @param token The address of the token being paid out.
+    /// @param rulesetId The ID of the ruleset of the split group being paid.
+    /// @param amount The total amount being paid out.
+    /// @param caller The original caller of the terminal payout flow.
+    /// @return leftoverAmount The leftover amount after split payouts.
+    /// @return amountEligibleForFees The amount of payouts that are eligible for fees.
+    function sendPayoutsToSplitGroupOf(
+        IJBSplits splits,
+        IJBTerminalStore store,
+        uint256 projectId,
+        address token,
+        uint256 rulesetId,
+        uint256 amount,
+        address caller
+    )
+        external
+        returns (uint256 leftoverAmount, uint256 amountEligibleForFees)
+    {
+        // The total percentage available to split.
+        uint256 leftoverPercentage = JBConstants.SPLITS_TOTAL_PERCENT;
+        uint256 group = uint256(uint160(token));
+
+        // Get a reference to the project's payout splits.
+        JBSplit[] memory payoutSplits = splits.splitsOf({projectId: projectId, rulesetId: rulesetId, groupId: group});
+
+        leftoverAmount = amount;
+
+        // Transfer between all splits.
+        for (uint256 i; i < payoutSplits.length; i++) {
+            // Get a reference to the split being iterated on.
+            JBSplit memory split = payoutSplits[i];
+
+            // The amount to send to the split.
+            uint256 payoutAmount = mulDiv(leftoverAmount, split.percent, leftoverPercentage);
+
+            // The final payout amount after taking out any fees.
+            uint256 netPayoutAmount = _sendPayoutToSplit({
+                store: store, split: split, projectId: projectId, token: token, amount: payoutAmount, caller: caller
+            });
+
+            // If the split hook is a feeless address, this payout doesn't incur a fee.
+            if (netPayoutAmount != 0 && netPayoutAmount != payoutAmount) {
+                amountEligibleForFees += payoutAmount;
+            }
+
+            if (payoutAmount != 0) {
+                // Subtract from the amount to be sent to the beneficiary.
+                unchecked {
+                    leftoverAmount -= payoutAmount;
+                }
+            }
+
+            unchecked {
+                // Decrement the leftover percentage.
+                leftoverPercentage -= split.percent;
+            }
+
+            emit SendPayoutToSplit({
+                projectId: projectId,
+                rulesetId: rulesetId,
+                group: group,
+                split: split,
+                amount: payoutAmount,
+                netAmount: netPayoutAmount,
+                caller: caller
+            });
+        }
+    }
+
+    /// @notice Sends a payout to a split.
+    /// @param store The terminal store used to restore balance when a payout fails.
+    /// @param split The split to pay.
+    /// @param projectId The ID of the project the split was specified by.
+    /// @param token The address of the token being paid out.
+    /// @param amount The total amount that the split is being paid.
+    /// @param caller The original caller of the terminal payout flow.
+    /// @return netPayoutAmount The amount sent to the split after subtracting fees.
+    function _sendPayoutToSplit(
+        IJBTerminalStore store,
+        JBSplit memory split,
+        uint256 projectId,
+        address token,
+        uint256 amount,
+        address caller
+    )
+        private
+        returns (uint256 netPayoutAmount)
+    {
+        // Failed split payouts consume the payout limit by design. The try-catch prevents a single
+        // split from DoS-ing the entire payout. Failed splits' amounts are returned to the project balance via
+        // `recordAddedBalanceFor`. Payout limit consumption is correct because the project authorized the
+        // distribution.
+        // slither-disable-next-line reentrancy-events
+        try IJBPayoutSplitGroupExecutor(address(this))
+            .executePayout({
+                split: split, projectId: projectId, token: token, amount: amount, originalMessageSender: caller
+            }) returns (
+            uint256 payoutAmount
+        ) {
+            return payoutAmount;
+        } catch (bytes memory failureReason) {
+            emit PayoutReverted({
+                projectId: projectId, split: split, amount: amount, reason: failureReason, caller: caller
+            });
+
+            // Add balance back to the project.
+            store.recordAddedBalanceFor({projectId: projectId, token: token, amount: amount});
+
+            // Since the payout failed the netPayoutAmount is zero.
+            return 0;
+        }
+    }
+}

package/src/structs/JBCashOutHookSpecification.sol

@@ -6,11 +6,13 @@ import {IJBCashOutHook} from "../interfaces/IJBCashOutHook.sol";
 /// @notice A cash out hook specification sent from the ruleset's data hook back to the terminal. This specification is
 /// fulfilled by the terminal.
 /// @custom:member hook The cash out hook to use when fulfilling this specification.
+/// @custom:member noop A flag indicating if the hook callback should be skipped.
 /// @custom:member amount The amount to send to the hook.
 /// @custom:member metadata Metadata to pass to the hook.
 // forge-lint: disable-next-line(pascal-case-struct)
 struct JBCashOutHookSpecification {
     IJBCashOutHook hook;
+    bool noop;
     uint256 amount;
     bytes metadata;
 }

package/src/structs/JBPayHookSpecification.sol

@@ -6,11 +6,13 @@ import {IJBPayHook} from "../interfaces/IJBPayHook.sol";
 /// @notice A pay hook specification sent from the ruleset's data hook back to the terminal. This specification is
 /// fulfilled by the terminal.
 /// @custom:member hook The pay hook to use when fulfilling this specification.
+/// @custom:member noop A flag indicating if the hook callback should be skipped.
 /// @custom:member amount The amount to send to the hook.
 /// @custom:member metadata Metadata to pass the hook.
 // forge-lint: disable-next-line(pascal-case-struct)
 struct JBPayHookSpecification {
     IJBPayHook hook;
+    bool noop;
     uint256 amount;
     bytes metadata;
 }

package/test/CoreExploitTests.t.sol

@@ -358,7 +358,7 @@ contract EdgeCases_Local is TestBaseWorkflow {
     ///         requires a call boundary to catch the panic.
     function externalWriteToIndex1(JBPayHookSpecification[] memory specs) external pure {
         // This will revert with Panic(0x32) -- array index out of bounds.
-        specs[1] = JBPayHookSpecification({hook: IJBPayHook(address(0)), amount: 0, metadata: ""});
+        specs[1] = JBPayHookSpecification({hook: IJBPayHook(address(0)), noop: false, amount: 0, metadata: ""});
     }
 
     /// @notice Verify that when BOTH hooks are present, the array size is 2 and no OOB occurs.
@@ -372,8 +372,10 @@ contract EdgeCases_Local is TestBaseWorkflow {
         JBPayHookSpecification[] memory hookSpecifications = new JBPayHookSpecification[](arraySize);
 
         // Both writes are valid.
-        hookSpecifications[0] = JBPayHookSpecification({hook: IJBPayHook(address(0)), amount: 0, metadata: ""});
-        hookSpecifications[1] = JBPayHookSpecification({hook: IJBPayHook(address(0)), amount: 0, metadata: ""});
+        hookSpecifications[0] =
+            JBPayHookSpecification({hook: IJBPayHook(address(0)), noop: false, amount: 0, metadata: ""});
+        hookSpecifications[1] =
+            JBPayHookSpecification({hook: IJBPayHook(address(0)), noop: false, amount: 0, metadata: ""});
     }
 
     /// @notice Verify that when neither hook is present, no write occurs.
@@ -1171,7 +1173,9 @@ contract EdgeCases_Local is TestBaseWorkflow {
             // Replicate REVDeployer logic exactly:
             // if (usesTiered721Hook) hookSpecifications[0] = ...
             if (usesT) {
-                specs[0] = JBPayHookSpecification({hook: IJBPayHook(address(0xdead)), amount: 1 ether, metadata: ""});
+                specs[0] = JBPayHookSpecification({
+                    hook: IJBPayHook(address(0xdead)), noop: false, amount: 1 ether, metadata: ""
+                });
             }
 
             // if (usesBuybackHook) hookSpecifications[1] = ... // ALWAYS index 1!
@@ -1182,8 +1186,9 @@ contract EdgeCases_Local is TestBaseWorkflow {
                     this.externalWriteToIndex1(specs);
                 } else {
                     // usesT=true, usesB=true → size=2, writing to [1] → OK
-                    specs[1] =
-                        JBPayHookSpecification({hook: IJBPayHook(address(0xbeef)), amount: 2 ether, metadata: ""});
+                    specs[1] = JBPayHookSpecification({
+                        hook: IJBPayHook(address(0xbeef)), noop: false, amount: 2 ether, metadata: ""
+                    });
                 }
             }
         }
@@ -1496,6 +1501,10 @@ contract EdgeCases_Local is TestBaseWorkflow {
 
     /// @notice Verify processHeldFeesOf correctly handles partial unlock (some locked, some unlocked).
     function test_partialLockedFees() public {
+        // Use an explicit warp to a realistic timestamp to avoid via_ir reordering of block.timestamp reads.
+        vm.warp(1_000_000);
+        uint256 _startTime = 1_000_000;
+
         // Launch fee project.
         JBTerminalConfig[] memory terminalConfigurations = new JBTerminalConfig[](1);
         JBAccountingContext[] memory tokensToAccept = new JBAccountingContext[](1);
@@ -1615,7 +1624,9 @@ contract EdgeCases_Local is TestBaseWorkflow {
         });
 
         // Warp 14 days (halfway through holding period).
-        vm.warp(block.timestamp + 14 days);
+        uint256 _fee1Time = _startTime;
+        uint256 _midPoint = _fee1Time + 14 days;
+        vm.warp(_midPoint);
 
         // Create second held fee (this one will be locked when we process at day 28).
         vm.prank(_projectOwner);
@@ -1635,7 +1646,7 @@ contract EdgeCases_Local is TestBaseWorkflow {
         assertEq(heldFees.length, 2, "should have 2 held fees");
 
         // Warp to 28 days + 1 from the start (first fee unlocked, second still locked 14 more days).
-        vm.warp(block.timestamp + 14 days + 1);
+        vm.warp(_midPoint + 14 days + 1);
 
         // Process all — should only process the first (unlocked) fee and stop at the second (locked).
         _terminal.processHeldFeesOf(projectId, JBConstants.NATIVE_TOKEN, 100);
@@ -1644,8 +1655,8 @@ contract EdgeCases_Local is TestBaseWorkflow {
         JBFee[] memory remainingFees = _terminal.heldFeesOf(projectId, JBConstants.NATIVE_TOKEN, 100);
         assertEq(remainingFees.length, 1, "one fee should still be locked");
 
-        // Warp past second fee's unlock.
-        vm.warp(block.timestamp + 14 days + 1);
+        // Warp past second fee's unlock (second fee was created at _midPoint, unlocks at _midPoint + 28 days).
+        vm.warp(_midPoint + 28 days + 1);
 
         // Process the remaining fee.
         _terminal.processHeldFeesOf(projectId, JBConstants.NATIVE_TOKEN, 100);

package/test/TestCashOutHooks.sol

@@ -156,8 +156,9 @@ contract TestCashOutHooks_Local is TestBaseWorkflow {
         // Reference cash out hook specifications.
         JBCashOutHookSpecification[] memory _specifications = new JBCashOutHookSpecification[](1);
 
-        _specifications[0] =
-            JBCashOutHookSpecification({hook: IJBCashOutHook(_cashOutHook), amount: _halfPaid, metadata: ""});
+        _specifications[0] = JBCashOutHookSpecification({
+            hook: IJBCashOutHook(_cashOutHook), noop: false, amount: _halfPaid, metadata: ""
+        });
 
         vm.startPrank(multisig());
         // Set the hook as feeless.
@@ -260,8 +261,9 @@ contract TestCashOutHooks_Local is TestBaseWorkflow {
         // Reference cash out hook specifications.
         JBCashOutHookSpecification[] memory _specifications = new JBCashOutHookSpecification[](1);
 
-        _specifications[0] =
-            JBCashOutHookSpecification({hook: IJBCashOutHook(_cashOutHook), amount: _halfPaid, metadata: ""});
+        _specifications[0] = JBCashOutHookSpecification({
+            hook: IJBCashOutHook(_cashOutHook), noop: false, amount: _halfPaid, metadata: ""
+        });
 
         uint256 _customCashOutTaxRate = JBConstants.MAX_CASH_OUT_TAX_RATE / 2;
         uint256 _customCashOutCount = 1 * 10 ** 18;

package/test/TestDataHookFuzzing.sol

@@ -206,6 +206,7 @@ contract TestDataHookFuzzing_Local is TestBaseWorkflow {
         JBPayHookSpecification[] memory _specs = new JBPayHookSpecification[](1);
         _specs[0] = JBPayHookSpecification({
             hook: IJBPayHook(_payHook),
+            noop: false,
             amount: _payAmount + 1, // exceeds the paid amount
             metadata: ""
         });
@@ -327,7 +328,9 @@ contract TestDataHookFuzzing_Local is TestBaseWorkflow {
         jbFeelessAddresses().setFeelessAddress(_cashOutHook, true);
 
         JBCashOutHookSpecification[] memory _specs = new JBCashOutHookSpecification[](1);
-        _specs[0] = JBCashOutHookSpecification({hook: IJBCashOutHook(_cashOutHook), amount: _hookAmount, metadata: ""});
+        _specs[0] = JBCashOutHookSpecification({
+            hook: IJBCashOutHook(_cashOutHook), noop: false, amount: _hookAmount, metadata: ""
+        });
 
         // Override: cashOutTaxRate=0, half the tokens cashed out, original totalSupply.
         vm.mockCall(
@@ -491,7 +494,8 @@ contract TestDataHookFuzzing_Local is TestBaseWorkflow {
         // Cash out all tokens. With cashOutTaxRate=0, reclaim = full surplus = _payAmount.
         // Set hook spec amount to 1 wei -- total = _payAmount + 1 which exceeds balance.
         JBCashOutHookSpecification[] memory _specs = new JBCashOutHookSpecification[](1);
-        _specs[0] = JBCashOutHookSpecification({hook: IJBCashOutHook(makeAddr("hook")), amount: 1, metadata: ""});
+        _specs[0] =
+            JBCashOutHookSpecification({hook: IJBCashOutHook(makeAddr("hook")), noop: false, amount: 1, metadata: ""});
 
         vm.mockCall(
             _DATA_HOOK,

package/test/TestPayHooks.sol

@@ -136,7 +136,7 @@ contract TestPayHooks_Local is TestBaseWorkflow {
 
             // Package up the specification struct.
             _specifications[i] = JBPayHookSpecification({
-                hook: IJBPayHook(_hookAddress), amount: _payHookAmounts[i], metadata: _hookMetadata
+                hook: IJBPayHook(_hookAddress), noop: false, amount: _payHookAmounts[i], metadata: _hookMetadata
             });
 
             // Keep a reference to the data that'll be received by the hook.

package/test/TestRulesetQueueing.sol

@@ -39,7 +39,7 @@ contract TestRulesetQueuing_Local is TestBaseWorkflow {
         super.setUp();
 
         // Foundry defaults block.timestamp to 1, which causes underflow in tests using past timestamps.
-        vm.warp(7 days);
+        vm.warp(1_000_001);
 
         _terminal = jbMultiTerminal();
         _controller = jbController();
@@ -637,9 +637,6 @@ contract TestRulesetQueuing_Local is TestBaseWorkflow {
         uint112 _weightFirstQueued = uint112(1234 * 10 ** 18);
         uint112 _weightSecondQueued = uint112(6969 * 10 ** 18);
 
-        // Keep a reference to the expected ruleset IDs (timestamps).
-        uint256 _initialRulesetId = block.timestamp;
-
         // Package up a config.
         JBRulesetConfig[] memory _rulesetConfig = new JBRulesetConfig[](1);
         _rulesetConfig[0].mustStartAtOrAfter = 0;
@@ -657,10 +654,12 @@ contract TestRulesetQueuing_Local is TestBaseWorkflow {
         // Get the ruleset.
         JBRuleset memory _ruleset = jbRulesets().currentOf(projectId);
 
+        // Keep a reference to the expected ruleset IDs (use returned id to avoid via_ir reordering of block.timestamp).
+        uint256 _initialRulesetId = _ruleset.id;
+
         // Make sure the first ruleset has begun.
         assertEq(_ruleset.cycleNumber, 1);
         assertEq(_ruleset.weight, _weightInitial);
-        assertEq(_ruleset.id, block.timestamp);
 
         // Package up a new config.
         JBRulesetConfig[] memory _firstQueued = new JBRulesetConfig[](1);

package/test/TestRulesetQueuingStress.sol

@@ -236,10 +236,11 @@ contract MockApprovalHookConfigurable is IJBRulesetApprovalHook {
         /// @notice Mid-cycle queuing: new ruleset starts at next duration boundary.
         function test_midCycleQueuing_snapsToNextBoundary() external {
             uint256 pid = _launchProject(SEVEN_DAYS, INITIAL_WEIGHT, 0, IJBRulesetApprovalHook(address(0)));
-            uint256 originalStart = block.timestamp;
+            // Capture originalStart from the actual ruleset (avoid via_ir reordering of block.timestamp).
+            uint256 originalStart = _rulesets.currentOf(pid).start;
 
             // Warp to mid-cycle (day 3 of 7).
-            vm.warp(block.timestamp + 3 days);
+            vm.warp(originalStart + 3 days);
 
             _queueRuleset(pid, 0, SEVEN_DAYS, INITIAL_WEIGHT * 2, 0, IJBRulesetApprovalHook(address(0)));
 
@@ -573,7 +574,8 @@ contract MockApprovalHookConfigurable is IJBRulesetApprovalHook {
         /// @notice deriveStartFrom one second after boundary: snaps to next boundary.
         function test_deriveStartFrom_oneSecondAfterBoundary_snapsToNext() external {
             uint256 pid = _launchProject(SEVEN_DAYS, INITIAL_WEIGHT, 0, IJBRulesetApprovalHook(address(0)));
-            uint256 originalStart = block.timestamp;
+            // Capture originalStart from the actual ruleset (avoid via_ir reordering of block.timestamp).
+            uint256 originalStart = _rulesets.currentOf(pid).start;
 
             // 1 second after first boundary -> should snap to second boundary.
             _queueRuleset(