consistency in variable naming

src/SablierFlow.sol

@@ -483,8 +483,8 @@ contract SablierFlow is
     }
 
     /// @notice Calculates the total debt.
-    /// @dev The total debt is the sum of the snapshot debt and the ongoing debt. This value is independent of the
-    /// stream's balance.
+    /// @dev The total debt is the sum of the snapshot debt and the ongoing debt descaled to token's decimal. This
+    /// value is independent of the stream's balance.
     function _totalDebtOf(uint256 streamId) internal view returns (uint256) {
         uint256 scaledTotalDebt = _ongoingDebtScaledOf(streamId) + _streams[streamId].snapshotDebtScaled;
         return Helpers.descaleAmount({ amount: scaledTotalDebt, decimals: _streams[streamId].tokenDecimals });

src/interfaces/ISablierFlow.sol

@@ -121,7 +121,8 @@ interface ISablierFlow is
     /// @param streamId The stream ID for the query.
     function depletionTimeOf(uint256 streamId) external view returns (uint256 depletionTime);
 
-    /// @notice Returns the amount of debt accrued since the snapshot time until now, denoted in token's decimals.
+    /// @notice Returns the amount of debt accrued since the snapshot time until now, denoted as a fixed-point number
+    /// where 1e18 is 1 token.
     /// @dev Reverts if `streamId` references a null stream.
     /// @param streamId The stream ID for the query.
     function ongoingDebtScaledOf(uint256 streamId) external view returns (uint256 ongoingDebtScaled);

tests/fork/Flow.t.sol

@@ -250,9 +250,9 @@ contract Flow_Fork_Test is Fork_Test {
         flow.adjustRatePerSecond({ streamId: streamId, newRatePerSecond: newRatePerSecond });
 
         // It should update snapshot debt.
-        vars.actualSnapshotDebt = flow.getSnapshotDebtScaled(streamId);
-        vars.expectedSnapshotDebt = ongoingDebtScaled + beforeSnapshotAmount;
-        assertEq(vars.actualSnapshotDebt, vars.expectedSnapshotDebt, "AdjustRatePerSecond: snapshot debt");
+        vars.actualScaledSnapshotDebt = flow.getSnapshotDebtScaled(streamId);
+        vars.expectedScaledSnapshotDebt = ongoingDebtScaled + beforeSnapshotAmount;
+        assertEq(vars.actualScaledSnapshotDebt, vars.expectedScaledSnapshotDebt, "AdjustRatePerSecond: snapshot debt");
 
         // It should set the new rate per second
         vars.actualRatePerSecond = flow.getRatePerSecond(streamId);

tests/integration/concrete/adjust-rate-per-second/adjustRatePerSecond.t.sol

@@ -95,9 +95,9 @@ contract AdjustRatePerSecond_Integration_Concrete_Test is Integration_Test {
         uint40 expectedSnapshotTime = getBlockTimestamp() - ONE_MONTH;
         assertEq(actualSnapshotTime, expectedSnapshotTime, "snapshot time");
 
-        uint256 actualSnapshotDebt = flow.getSnapshotDebtScaled(defaultStreamId);
-        uint128 expectedSnapshotDebt = 0;
-        assertEq(actualSnapshotDebt, expectedSnapshotDebt, "snapshot debt");
+        uint256 actualScaledSnapshotDebt = flow.getSnapshotDebtScaled(defaultStreamId);
+        uint128 expectedScaledSnapshotDebt = 0;
+        assertEq(actualScaledSnapshotDebt, expectedScaledSnapshotDebt, "snapshot debt");
 
         UD21x18 newRatePerSecond = ud21x18(RATE_PER_SECOND.unwrap() / 2);
 
@@ -118,9 +118,9 @@ contract AdjustRatePerSecond_Integration_Concrete_Test is Integration_Test {
         assertEq(uint8(flow.statusOf(defaultStreamId)), uint8(Flow.Status.STREAMING_SOLVENT), "status not streaming");
 
         // It should update snapshot debt.
-        actualSnapshotDebt = flow.getSnapshotDebtScaled(defaultStreamId);
-        expectedSnapshotDebt = ONE_MONTH_DEBT_18D;
-        assertEq(actualSnapshotDebt, expectedSnapshotDebt, "snapshot debt");
+        actualScaledSnapshotDebt = flow.getSnapshotDebtScaled(defaultStreamId);
+        expectedScaledSnapshotDebt = ONE_MONTH_DEBT_18D;
+        assertEq(actualScaledSnapshotDebt, expectedScaledSnapshotDebt, "snapshot debt");
 
         // It should set the new rate per second
         actualRatePerSecond = flow.getRatePerSecond(defaultStreamId);

tests/integration/concrete/deposit-and-pause/depositAndPause.t.sol

@@ -56,7 +56,7 @@ contract DepositAndPause_Integration_Concrete_Test is Integration_Test {
 
     function test_WhenCallerSender() external whenNoDelegateCall givenNotNull givenNotPaused {
         uint128 previousStreamBalance = flow.getBalance(defaultStreamId);
-        uint256 expectedSnapshotDebt = flow.ongoingDebtScaledOf(defaultStreamId);
+        uint256 expectedScaledSnapshotDebt = flow.ongoingDebtScaledOf(defaultStreamId);
 
         // It should emit 1 {Transfer}, 1 {DepositFlowStream}, 1 {PauseFlowStream}, 1 {MetadataUpdate} events
         vm.expectEmit({ emitter: address(usdc) });
@@ -98,7 +98,7 @@ contract DepositAndPause_Integration_Concrete_Test is Integration_Test {
         assertEq(actualRatePerSecond, 0, "rate per second");
 
         // It should update the snapshot debt
-        uint256 actualSnapshotDebt = flow.getSnapshotDebtScaled(defaultStreamId);
-        assertEq(actualSnapshotDebt, expectedSnapshotDebt, "snapshot debt");
+        uint256 actualScaledSnapshotDebt = flow.getSnapshotDebtScaled(defaultStreamId);
+        assertEq(actualScaledSnapshotDebt, expectedScaledSnapshotDebt, "snapshot debt");
     }
 }

tests/integration/concrete/pause/pause.t.sol

@@ -66,7 +66,7 @@ contract Pause_Integration_Concrete_Test is Integration_Test {
     }
 
     function _test_Pause() private {
-        uint256 expectedSnapshotDebt = flow.ongoingDebtScaledOf(defaultStreamId);
+        uint256 expectedScaledSnapshotDebt = flow.ongoingDebtScaledOf(defaultStreamId);
 
         // It should emit 1 {PauseFlowStream}, 1 {MetadataUpdate} events.
         vm.expectEmit({ emitter: address(flow) });
@@ -90,7 +90,7 @@ contract Pause_Integration_Concrete_Test is Integration_Test {
         assertEq(actualRatePerSecond, 0, "rate per second");
 
         // It should update the snapshot debt.
-        uint256 actualSnapshotDebt = flow.getSnapshotDebtScaled(defaultStreamId);
-        assertEq(actualSnapshotDebt, expectedSnapshotDebt, "snapshot debt");
+        uint256 actualScaledSnapshotDebt = flow.getSnapshotDebtScaled(defaultStreamId);
+        assertEq(actualScaledSnapshotDebt, expectedScaledSnapshotDebt, "snapshot debt");
     }
 }

tests/integration/concrete/refund-and-pause/refundAndPause.t.sol

@@ -54,7 +54,7 @@ contract RefundAndPause_Integration_Concrete_Test is Integration_Test {
     }
 
     function test_WhenCallerSender() external whenNoDelegateCall givenNotNull givenNotPaused {
-        uint256 expectedSnapshotDebt = flow.ongoingDebtScaledOf(defaultStreamId);
+        uint256 expectedScaledSnapshotDebt = flow.ongoingDebtScaledOf(defaultStreamId);
 
         // It should emit 1 {Transfer}, 1 {RefundFromFlowStream}, 1 {PauseFlowStream}, 1 {MetadataUpdate} events
         vm.expectEmit({ emitter: address(usdc) });
@@ -96,7 +96,7 @@ contract RefundAndPause_Integration_Concrete_Test is Integration_Test {
         assertEq(actualRatePerSecond, 0, "rate per second");
 
         // It should update the snapshot debt
-        uint256 actualSnapshotDebt = flow.getSnapshotDebtScaled(defaultStreamId);
-        assertEq(actualSnapshotDebt, expectedSnapshotDebt, "snapshot debt");
+        uint256 actualScaledSnapshotDebt = flow.getSnapshotDebtScaled(defaultStreamId);
+        assertEq(actualScaledSnapshotDebt, expectedScaledSnapshotDebt, "snapshot debt");
     }
 }

tests/integration/concrete/withdraw-max/withdrawMax.t.sol

@@ -71,8 +71,8 @@ contract WithdrawMax_Integration_Concrete_Test is Integration_Test {
         assertEq(vars.actualStreamBalance, vars.expectedStreamBalance, "stream balance");
 
         // It should set the snapshot debt to zero.
-        vars.actualSnapshotDebt = flow.getSnapshotDebtScaled(defaultStreamId);
-        assertEq(vars.actualSnapshotDebt, 0, "snapshot debt");
+        vars.actualScaledSnapshotDebt = flow.getSnapshotDebtScaled(defaultStreamId);
+        assertEq(vars.actualScaledSnapshotDebt, 0, "snapshot debt");
 
         if (flow.getRatePerSecond(defaultStreamId).unwrap() > 0) {
             // It should update snapshot time.

tests/integration/fuzz/ongoingDebtOf.t.sol → tests/integration/fuzz/ongoingDebtScaledOf.t.sol

@@ -21,14 +21,14 @@ contract OngoingDebtScaledOf_Integration_Fuzz_Test is Shared_Integration_Fuzz_Te
         // Pause the stream.
         flow.pause(streamId);
 
-        uint256 expectedOngoingDebtScaled = flow.ongoingDebtScaledOf(streamId);
+        uint256 expectedScaledOngoingDebt = flow.ongoingDebtScaledOf(streamId);
 
         // Simulate the passage of time after pause.
         vm.warp({ newTimestamp: getBlockTimestamp() + timeJump });
 
         // Assert that the ongoing debt did not change.
-        uint256 actualOngoingDebtScaled = flow.ongoingDebtScaledOf(streamId);
-        assertEq(actualOngoingDebtScaled, expectedOngoingDebtScaled, "ongoing debt");
+        uint256 actualScaledOngoingDebt = flow.ongoingDebtScaledOf(streamId);
+        assertEq(actualScaledOngoingDebt, expectedScaledOngoingDebt, "ongoing debt");
     }
 
     /// @dev It should return 0.
@@ -56,8 +56,8 @@ contract OngoingDebtScaledOf_Integration_Fuzz_Test is Shared_Integration_Fuzz_Te
         updateSnapshotTimeAndWarp(streamId);
 
         // Assert that ongoing debt is zero.
-        uint256 actualOngoingDebtScaled = flow.ongoingDebtScaledOf(streamId);
-        assertEq(actualOngoingDebtScaled, 0, "ongoing debt");
+        uint256 actualScaledOngoingDebt = flow.ongoingDebtScaledOf(streamId);
+        assertEq(actualScaledOngoingDebt, 0, "ongoing debt");
     }
 
     /// @dev It should return the ongoing debt.
@@ -88,8 +88,8 @@ contract OngoingDebtScaledOf_Integration_Fuzz_Test is Shared_Integration_Fuzz_Te
         uint128 ratePerSecond = flow.getRatePerSecond(streamId).unwrap();
 
         // Assert that the ongoing debt equals the expected value.
-        uint256 actualOngoingDebtScaled = flow.ongoingDebtScaledOf(streamId);
-        uint256 expectedOngoingDebtScaled = ratePerSecond * timeJump;
-        assertEq(actualOngoingDebtScaled, expectedOngoingDebtScaled, "ongoing debt");
+        uint256 actualScaledOngoingDebt = flow.ongoingDebtScaledOf(streamId);
+        uint256 expectedScaledOngoingDebt = ratePerSecond * timeJump;
+        assertEq(actualScaledOngoingDebt, expectedScaledOngoingDebt, "ongoing debt");
     }
 }

tests/integration/fuzz/withdraw.t.sol

@@ -147,10 +147,10 @@ contract Withdraw_Integration_Fuzz_Test is Shared_Integration_Fuzz_Test {
 
         vars.previousAggregateAmount = flow.aggregateBalance(token);
         vars.previousTokenBalance = token.balanceOf(address(flow));
-        vars.previousOngoingDebtScaled = flow.totalDebtOf(streamId);
+        vars.previousScaledOngoingDebt = flow.totalDebtOf(streamId);
         vars.previousTotalDebt = getDescaledAmount(
             flow.getSnapshotDebtScaled(streamId), flow.getTokenDecimals(streamId)
-        ) + vars.previousOngoingDebtScaled;
+        ) + vars.previousScaledOngoingDebt;
         vars.previousStreamBalance = flow.getBalance(streamId);
 
         vars.expectedProtocolRevenue = flow.protocolRevenue(token);

tests/utils/Vars.sol

@@ -10,7 +10,7 @@ struct Vars {
     IERC20 token;
     // previous values.
     uint256 previousAggregateAmount;
-    uint256 previousOngoingDebtScaled;
+    uint256 previousScaledOngoingDebt;
     uint40 previousSnapshotTime;
     uint128 previousStreamBalance;
     uint256 previousTokenBalance;
@@ -20,7 +20,7 @@ struct Vars {
     uint128 actualProtocolFeeAmount;
     uint128 actualProtocolRevenue;
     UD21x18 actualRatePerSecond;
-    uint256 actualSnapshotDebt;
+    uint256 actualScaledSnapshotDebt;
     uint40 actualSnapshotTime;
     uint128 actualStreamBalance;
     uint256 actualStreamId;
@@ -32,7 +32,7 @@ struct Vars {
     uint128 expectedProtocolFeeAmount;
     uint128 expectedProtocolRevenue;
     UD21x18 expectedRatePerSecond;
-    uint256 expectedSnapshotDebt;
+    uint256 expectedScaledSnapshotDebt;
     uint40 expectedSnapshotTime;
     uint128 expectedStreamBalance;
     uint256 expectedStreamId;