Skip to content

test: add more comprehensive dsf checks #1192

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
ypatil12 merged 4 commits into from
Mar 3, 2025
Merged

test: add more comprehensive dsf checks #1192

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
6838334
test: add dsf increase invariants
ypatil12 Feb 28, 2025
eca4cff
chore: handle complete as 0 shares eddge case
ypatil12 Feb 28, 2025
2020f10
chore: cleanup logic & comments
ypatil12 Feb 28, 2025
ecdfb11
chore: make assertions more explicit
ypatil12 Mar 2, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
93 changes: 92 additions & 1 deletion src/test/integration/IntegrationBase.t.sol
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -554,7 +554,7 @@ abstract contract IntegrationBase is IntegrationDeployer, TypeImporter {
}
}

function assert_DSF_Reset(
function assert_DSF_WAD(
User staker,
IStrategy[] memory strategies,
string memory err
Expand Down Expand Up @@ -1876,6 +1876,97 @@ abstract contract IntegrationBase is IntegrationDeployer, TypeImporter {
}
}

function assert_Snap_Increased_DSF(
User staker,
IStrategy[] memory strategies,
string memory err
) internal {
uint[] memory curDSFs = _getDepositScalingFactors(staker, strategies);
uint[] memory prevDSFs = _getPrevDepositScalingFactors(staker, strategies);

for (uint i = 0; i < strategies.length; i++) {
assertGt(curDSFs[i], prevDSFs[i], err);
}
}

/// @dev Used to assert that the DSF is either increased or unchanged, depending on the slashing factor, on a deposit
Copy link
Copy Markdown
Collaborator

@eigenmikem eigenmikem Mar 3, 2025

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I've been trying to consolidate "withdrawal as shares" and "deposit" assertions since they should be the same thing, might make sense to do that here if you have time

Copy link
Copy Markdown
Contributor Author

@ypatil12 ypatil12 Mar 3, 2025

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Think we can do it in a separate PR? Trying to get this in

function assert_Snap_DSF_State_Deposit(
User staker,
IStrategy[] memory strategies,
string memory err
) internal {
for (uint i = 0; i < strategies.length; i++) {
IStrategy[] memory stratArray = strategies[i].toArray();
/// @dev We don't need the previous slashing factors as they shouldn't change before/after a deposit
uint curSlashingFactor = _getSlashingFactor(staker, strategies[i]);

// If there was never a slashing, no need to normalize
if (curSlashingFactor == WAD) {
assert_Snap_Unchanged_DSF(staker, stratArray, err); // No slashing, so DSF is unchanged
assert_DSF_WAD(staker, stratArray, err); // DSF should have always been WAD
}
// If there was a slashing, and we deposit, normalize
else {
assert_Snap_Increased_DSF(staker, stratArray, err); // Slashing, so DSF is increased
}
}
}

/// @dev When completing withdrawals as shares, we must also handle the case where a staker completes a withdrawal for 0 shares
function assert_Snap_DSF_State_WithdrawalAsShares(
User staker,
IStrategy[] memory strategies,
string memory err
) internal {
uint[] memory curDepositShares = _getStakerDepositShares(staker, strategies);
for (uint i = 0; i < strategies.length; i++) {
IStrategy[] memory stratArray = strategies[i].toArray();
/// We don't need the previous slashing factors as they shouldn't change before/after a deposit
uint curSlashingFactor = _getSlashingFactor(staker, strategies[i]);

// If there was never a slashing, no need to normalize
// If there was a slashing, but we complete a withdrawal for 0 shares, no need to normalize
if (curSlashingFactor == WAD || curDepositShares[i] == 0) {
assert_Snap_Unchanged_DSF(staker, stratArray, err);
assert_DSF_WAD(staker, stratArray, err);
}
// If there was a slashing, and we complete a withdrawal for non-zero shares, normalize
else {
assert_Snap_Increased_DSF(staker, stratArray, err);
}
}
}

/// @dev On a delegation, the DSF should be increased if the operator magnitude is non-WAD
function assert_Snap_DSF_State_Delegation(
User staker,
IStrategy[] memory strategies,
uint[] memory delegatableShares,
string memory err
) internal {
uint64[] memory maxMags = _getMaxMagnitudes(staker, strategies);

for (uint i = 0; i < strategies.length; i++) {
IStrategy[] memory stratArray = strategies[i].toArray();

// If you are delegating with 0 shares, no need to normalize
// If there was never an operator slashing, no need to normalize
if (delegatableShares[i] == 0 || maxMags[i] == WAD) {
assert_Snap_Unchanged_DSF(staker, stratArray, err);

// If we are not a beaconChainStrategy, we should also have a DSF of WAD
// We exclude BEACONCHAIN_ETH_STRAT because it could have had a non-WAD DSF from BC slashings
if (strategies[i] != BEACONCHAIN_ETH_STRAT) {
assert_DSF_WAD(staker, stratArray, err);
}
}
// If there was an operator slashing, and delegating with non-zero shares, normalize
else {
assert_Snap_Increased_DSF(staker, stratArray, err); // Slashing, so DSF is increased
}
}
}

/*******************************************************************************
SNAPSHOT ASSERTIONS: STRATEGY SHARES
*******************************************************************************/
Expand Down
12 changes: 10 additions & 2 deletions src/test/integration/IntegrationChecks.t.sol
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -208,6 +208,7 @@ contract IntegrationCheckUtils is IntegrationBase {
} else {
assert_Snap_Added_Staker_WithdrawableShares(staker, strategies, shares, "deposit should increase withdrawable shares");
}
assert_Snap_DSF_State_Deposit(staker, strategies, "staker's DSF not updated correctly");
}

function check_Deposit_State_PartialDeposit(User staker, IStrategy[] memory strategies, uint[] memory shares, uint[] memory tokenBalances) internal {
Expand All @@ -226,6 +227,7 @@ contract IntegrationCheckUtils is IntegrationBase {
} else {
assert_Snap_Added_Staker_WithdrawableShares(staker, strategies, shares, "deposit should increase withdrawable shares");
}
assert_Snap_DSF_State_Deposit(staker, strategies, "staker's DSF not updated correctly");
}

function check_Delegation_State(
Expand All @@ -246,6 +248,7 @@ contract IntegrationCheckUtils is IntegrationBase {
uint256[] memory delegatableShares = _getPrevStakerWithdrawableShares(staker, strategies);
assert_Snap_Added_OperatorShares(operator, strategies, delegatableShares, "operator should have received shares");
check_Added_SlashableStake(operator, strategies, delegatableShares);
assert_Snap_DSF_State_Delegation(staker, strategies, delegatableShares, "staker's DSF not updated correctly");
}

function check_Added_SlashableStake(
Expand Down Expand Up @@ -297,7 +300,7 @@ contract IntegrationCheckUtils is IntegrationBase {
for (uint i = 0; i < strategies.length; i++) {
// For a full withdrawal, the dsf should be reset to wad
if (_getStakerDepositShares(staker, strategies[i].toArray())[0] == 0) {
assert_DSF_Reset(staker, strategies[i].toArray(),
assert_DSF_WAD(staker, strategies[i].toArray(),
"check_QueuedWithdrawal_State: dsf should be reset to wad");
}
// For a partial withdrawal, the dsf should not be changed
Expand Down Expand Up @@ -345,7 +348,7 @@ contract IntegrationCheckUtils is IntegrationBase {
"check_Undelegate_State: calculated withdrawal should match returned root");
assert_AllWithdrawalsPending(withdrawalRoots,
"check_Undelegate_State: stakers withdrawal should now be pending");
assert_DSF_Reset(staker, strategies,
assert_DSF_WAD(staker, strategies,
"check_Undelegate_State: staker dsfs should be reset to wad");
assert_Snap_Added_QueuedWithdrawals(staker, withdrawals,
"check_Undelegate_State: staker should have increased nonce by withdrawals.length");
Expand Down Expand Up @@ -388,6 +391,8 @@ contract IntegrationCheckUtils is IntegrationBase {
"check_QueuedWithdrawal_State: failed to remove staker withdrawable shares");
assert_Snap_Unchanged_OperatorShares(newOperator,
"check_Redelegate_State: new operator shares should not have changed");
assert_DSF_WAD(staker, strategies,
"check_Redelegate_State: staker dsfs should be reset to wad");
}

/**
Expand Down Expand Up @@ -447,6 +452,7 @@ contract IntegrationCheckUtils is IntegrationBase {
}
assert_Snap_Added_OperatorShares(operator, strategies, withdrawableShares, "operator should have received shares");
}
assert_Snap_DSF_State_WithdrawalAsShares(staker, strategies, "staker's DSF not updated correctly");
}

/// @notice Difference from above is that operator shares do not increase since staker is not delegated
Expand All @@ -471,6 +477,7 @@ contract IntegrationCheckUtils is IntegrationBase {
assert_Snap_Added_Staker_WithdrawableShares(staker, strategies, expectedWithdrawableShares, "staker should have received expected withdrawable shares");
assert_Snap_Unchanged_OperatorShares(operator, "operator should have shares unchanged");
assert_Snap_Unchanged_StrategyShares(strategies, "strategies should have total shares unchanged");
assert_Snap_DSF_State_WithdrawalAsShares(staker, strategies, "staker's DSF not updated correctly");
}

function check_Withdrawal_AsShares_Redelegated_State(
Expand All @@ -494,6 +501,7 @@ contract IntegrationCheckUtils is IntegrationBase {
assert_Snap_Unchanged_OperatorShares(operator, "operator should have shares unchanged");
assert_Snap_Unchanged_StrategyShares(strategies, "strategies should have total shares unchanged");
assert_Snap_Expected_Staker_WithdrawableShares_Deposit(staker, newOperator, strategies, withdrawableShares, "staker should have received expected withdrawable shares");
assert_Snap_DSF_State_WithdrawalAsShares(staker, strategies, "staker's DSF not updated correctly");
}

/*******************************************************************************
Expand Down
Loading