fix: Retargetter rebalance path and flash-loan callback hardening (#209)

* fix: harden Retargetter rebalance path and flash-loan callback

- rebalance: totalAssets must not grow while the operation's Request is
  unrepaid and short of its deadline (value-conservation gate, all callers)
- rebalance: a module above target only reverts when it worsened, so an
  untouched module no longer blocks the other legs
- onFlashLoan: bound to the payload committed at the window open (transient
  digest) and to full delivery of the principal (pre-loan balance snapshot)

* fix: measure bridge value on the whole book and scope window authority to the payload

The value-conservation gate read the position manager's totalAssets, which
drops any module whose debt exceeds its collateral, so it read flat while
bridge capital was poured into an underwater module. It now measures quoted
collateral minus debt summed over every module (PositionValueIncreased).

Window step authority moved from the whole flash-loan call into the callback
around the committed payload, so a module holds no authority in its own frame
and cannot source the delivery check's balance growth from the position
manager itself.

* refactor: read the Request through syncRepaidStatus and store the payload digest as a uint

The value gate derived the effective repaid state from the mirrored deadline
plus the stale repaid flag; syncRepaidStatus returns exactly that disjunction
and folds a past-deadline Request into the flag, the same idiom resolve uses.

The payload digest now goes through the existing tStoreUint/tLoadUint, so
LibTransientSlot is untouched by this PR.

* perf: read the position aggregates once per rebalance snapshot

_positionSnapshot returns the aggregate LTV and the net value from a single
read of collateralAmountQuoted/debtAmount, replacing the two helpers that each
re-read the pair. The post-call check hands the LTV back to the direction
checks so they do not read it again, which also keeps valueAfter off the
rebalance stack (it would otherwise re-trigger stack-too-deep).

Halves the module iterations on the rebalancer path (8 to 4) and drops the
runtime size by 169 bytes.

* docs: point the rebalance NatSpec at the renamed value-gate helpers

Author: maxencerb

src/interfaces/manager/rebalancer/IRetargetter.sol

@@ -251,7 +251,11 @@ interface IRetargetter {
   ///      one balance snapshot taken before any leg executes and do not compose: every leg
   ///      resolves against the same pre-call balances, never the state left by earlier legs,
   ///      so REPAY sentinels across several modules can together commit more than the shared
-  ///      balance and revert.
+  ///      balance and revert. While the operation's Request is unrepaid, the position's net
+  ///      value (quoted collateral minus debt over every module, underwater ones included)
+  ///      must not grow across the call, for every caller including the owner: Request
+  ///      capital may enter the position only against equivalent value flowing back out in
+  ///      the same call.
   /// @param data The rebalancing data forwarded to the position manager
   function rebalance(RebalancingData calldata data) external;
 
@@ -276,8 +280,10 @@ interface IRetargetter {
 
   /// @notice Runs a whole retargetting operation atomically inside a flash loan.
   /// @dev The steps are supplied as a multicall payload executed inside the flash-loan
-  ///      callback. At window close no order may be stored and the Retargetter's balances
-  ///      of both bound assets must be within the configured residual tolerance.
+  ///      callback. The callback is bound to this exact payload (digest match) and requires
+  ///      the loan delivered in full before any step runs. At window close no order may be
+  ///      stored and the Retargetter's balances of both bound assets must be within the
+  ///      configured residual tolerance.
   /// @param positionManager The position manager to retarget (must match the bound pair)
   /// @param flashLoanModule The whitelisted flash-loan module to borrow through
   /// @param flashLoanAmount The flash-loan size, checked against the principal cap

src/libs/manager/rebalancer/LibRetargetterConstants.sol

@@ -116,11 +116,13 @@ bytes32 constant OPERATION_STORAGE_SLOT = 0x79211724a6a2d25fad538c732b7f9fee62ff
 /*                     TRANSIENT STORAGE                      */
 /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
 
-/// @dev Transient slot for the flash-loan window: holds the module driving the open window,
-///      the only address besides the owner and rebalancer role holders that passes the step
-///      authorization (zero when no window is open). Distinct from MODULE_TSLOT, which
-///      authenticates the callback and is zeroed on callback entry to make it single-shot,
-///      while this slot keeps the window's authority until the window closes.
+/// @dev Transient slot for the executing payload: holds the module whose committed step
+///      calls are running, the only address besides the owner and rebalancer role holders
+///      that passes the step authorization (zero otherwise). Set and cleared around the
+///      payload inside the callback, so the module holds no authority in its own frame and
+///      cannot act on the Retargetter before the delivery check or after the steps end.
+///      Distinct from MODULE_TSLOT, which authenticates the callback and is zeroed on
+///      callback entry to make it single-shot.
 ///      Computed as: bytes32(uint256(keccak256("retargetter.transient.window")) - 1)
 bytes32 constant WINDOW_TSLOT = 0xd6afb5b9c2dc000141f8a98b95795a2e10b482782ed7428b0e955204ff9c2c83;
 
@@ -132,6 +134,20 @@ bytes32 constant MODULE_TSLOT = 0x3766ddc68b0c7bb3c206ee7037a0b3dd14384ba84828df
 ///      Computed as: bytes32(uint256(keccak256("retargetter.transient.amount")) - 1)
 bytes32 constant AMOUNT_TSLOT = 0xc37562d71acab34fa73520c0ed6a5ead38685eb8f5e228c3c887ece9e742319b;
 
+/// @dev Transient slot for the keccak256 digest of the flash-loan payload built by
+///      startSyncRetargetting (zeroed on callback entry alongside the module slot). The
+///      callback requires its incoming data to hash to this digest, so a module can only
+///      forward the payload verbatim, never substitute its own step calls.
+///      Computed as: bytes32(uint256(keccak256("retargetter.transient.payload")) - 1)
+bytes32 constant PAYLOAD_TSLOT = 0x82d191e7de0d5f5912d24aa67206a4049e4b39e437d0e09fea37efbbc2449b0f;
+
+/// @dev Transient slot for the Retargetter's debt-asset balance snapshot taken just before
+///      the flash loan is requested. The callback requires the live balance to have grown by
+///      the nominal amount, so a module cannot collect the repayment approval for funds it
+///      never delivered.
+///      Computed as: bytes32(uint256(keccak256("retargetter.transient.balance")) - 1)
+bytes32 constant BALANCE_TSLOT = 0x0420a475633bdc4ca97e276f4192fd3de522d15a099866aba16352c41acd46eb;
+
 /// @dev Transient slot for the reentrancy guard flag (nonzero while a guarded call runs).
 ///      Computed as: bytes32(uint256(keccak256("retargetter.transient.reentrancy")) - 1)
 bytes32 constant REENTRANCY_TSLOT = 0x9085860804617f26160a86c0245a6d09a1576cd7c916d029770b32608c92fe70;

src/libs/manager/rebalancer/LibRetargetterErrors.sol

@@ -68,10 +68,19 @@ library LibRetargetterErrors {
   /// @param target The position manager's target LTV (WAD)
   error AboveTargetLtv(uint256 ltvAfter, uint256 ltvBefore, uint256 target);
 
-  /// @notice Thrown when a rebalance leaves a single position above target without improving it.
+  /// @notice Thrown when a rebalance leaves a single position above target while worsening it.
   /// @param position The offending borrow module
   error PositionAboveTarget(address position);
 
+  /// @notice Thrown when a rebalance grows the position manager's net value while the
+  ///         operation's Request is unrepaid and short of its deadline (the growth would be
+  ///         bridge capital left in the position manager with no shares backing it, exposed
+  ///         to capture by any LP exit before the Request is repaid).
+  /// @param valueBefore The net value snapshot before the rebalance (quoted collateral minus
+  ///        debt, summed over every module including underwater ones, so it may be negative)
+  /// @param valueAfter The net value after the rebalance, under the same convention
+  error PositionValueIncreased(int256 valueBefore, int256 valueAfter);
+
   /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
   /*                           ORDERS                           */
   /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
@@ -99,9 +108,14 @@ library LibRetargetterErrors {
   /*                        FLASH LOANS                         */
   /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
 
-  /// @notice Thrown when onFlashLoan is not called by the expected module with the expected amount.
+  /// @notice Thrown when onFlashLoan is not called by the expected module with the expected
+  ///         amount and the exact payload committed at the window open.
   error UnauthorizedFlashLoanCallback();
 
+  /// @notice Thrown when the flash-loan module has not delivered the full nominal amount
+  ///         before the callback payload runs.
+  error PrincipalNotDelivered();
+
   /// @notice Thrown when the adapter's provider callback is not called by the provider,
   ///         or no flash loan is in flight.
   error UnauthorizedCaller();