Include positions without active delegations

0xh3rman · 0xh3rman · commit 0f59bd18e4c0 · 2026-02-11T15:51:12.000+09:00
StakingLens: When a delegator has no explicit delegations and the result set is not full, iterate all validators (_allValidatorIds) and process them so positions that only have withdrawals or rewards are included. Adjust snapshot checks to treat snapshots with rewards as non-empty and include reward-only delegations when building positions.

Tests: Add test_getDelegationsIncludesPositionsWithoutActiveDelegations and supporting mock helpers (_mockConsensusSet overload, _mockEpoch, _mockDelegations, _mockDelegator, _mockWithdrawalRequest) to verify positions are returned for validators with only withdrawals or rewards.
diff --git a/justfile b/justfile
@@ -28,26 +28,22 @@ read-staking-lens-address BROADCAST_FILE="broadcast/StakingLens.s.sol/143/run-la
     #!/usr/bin/env bash
     jq -r '.receipts[]?.contractAddress // empty' "{{BROADCAST_FILE}}"
 
-verify-monad-staking ADDRESS="": build-monad
-    ADDRESS_TO_VERIFY=${STAKING_LENS_ADDRESS:-${ADDRESS-}}
-    [ -n "${ADDRESS_TO_VERIFY-}" ] || { echo "Set STAKING_LENS_ADDRESS (hint: STAKING_LENS_ADDRESS=$(just read-staking-lens-address))" >&2; exit 1; }
+verify-monad-staking ADDRESS: build-monad
     forge verify-contract \
         --rpc-url https://rpc.monad.xyz \
         --verifier sourcify \
         --verifier-url 'https://sourcify-api-monad.blockvision.org/' \
         --chain-id 143 \
-        "$ADDRESS_TO_VERIFY" \
+        "{{ADDRESS}}" \
         src/monad/StakingLens.sol:StakingLens
 
-verify-monad-staking-etherscan ADDRESS="": build-monad
-    ADDRESS_TO_VERIFY=${STAKING_LENS_ADDRESS:-${ADDRESS-}}
-    [ -n "${ADDRESS_TO_VERIFY-}" ] || { echo "Set STAKING_LENS_ADDRESS (hint: STAKING_LENS_ADDRESS=$(just read-staking-lens-address))" >&2; exit 1; }
+verify-monad-staking-etherscan ADDRESS: build-monad
     [ -n "${ETHERSCAN_API_KEY-}" ] || { echo "ETHERSCAN_API_KEY is required" >&2; exit 1; }
     forge verify-contract \
-        --verifier etherscan \
+        --verifier custom \
         --verifier-url 'https://api.etherscan.io/v2/api?chainid=143' \
+        --verifier-api-key "$ETHERSCAN_API_KEY" \
         --chain 143 \
         --rpc-url https://rpc.monad.xyz \
-        --etherscan-api-key "$ETHERSCAN_API_KEY" \
-        "$ADDRESS_TO_VERIFY" \
+        "{{ADDRESS}}" \
         src/monad/StakingLens.sol:StakingLens
diff --git a/src/monad/StakingLens.sol b/src/monad/StakingLens.sol
@@ -90,6 +90,8 @@ contract StakingLens {
         positions = new Delegation[](MAX_POSITIONS);
         uint256 positionCount = 0;
         uint16 validatorCount = 0;
+        uint64[] memory processedValidatorIds = new uint64[](uint256(MAX_DELEGATIONS));
+        uint256 processedValidatorCount = 0;
 
         (uint64 currentEpoch,) = STAKING.getEpoch();
 
@@ -104,7 +106,13 @@ contract StakingLens {
 
             for (uint256 i = 0; i < len && validatorCount < MAX_DELEGATIONS; ++i) {
                 uint64 validatorId = valIds[i];
+                if (_containsValidator(processedValidatorIds, processedValidatorCount, validatorId)) {
+                    continue;
+                }
+
                 positionCount = _processValidator(delegator, validatorId, currentEpoch, positions, positionCount);
+                processedValidatorIds[processedValidatorCount] = validatorId;
+                ++processedValidatorCount;
                 ++validatorCount;
             }
 
@@ -115,11 +123,41 @@ contract StakingLens {
             (isDone, nextValId, valIds) = STAKING.getDelegations(delegator, nextValId);
         }
 
+        if (validatorCount < MAX_DELEGATIONS && positionCount < MAX_POSITIONS) {
+            uint64[] memory allValidatorIds = _allValidatorIds();
+            uint256 len = allValidatorIds.length;
+            for (uint256 i = 0; i < len && validatorCount < MAX_DELEGATIONS && positionCount < MAX_POSITIONS; ++i) {
+                uint64 validatorId = allValidatorIds[i];
+                if (_containsValidator(processedValidatorIds, processedValidatorCount, validatorId)) {
+                    continue;
+                }
+
+                positionCount = _processValidator(delegator, validatorId, currentEpoch, positions, positionCount);
+                processedValidatorIds[processedValidatorCount] = validatorId;
+                ++processedValidatorCount;
+                ++validatorCount;
+            }
+        }
+
         assembly {
             mstore(positions, positionCount)
         }
     }
 
+    function _containsValidator(uint64[] memory validatorIds, uint256 count, uint64 validatorId)
+        internal
+        pure
+        returns (bool)
+    {
+        for (uint256 i = 0; i < count; ++i) {
+            if (validatorIds[i] == validatorId) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
     function _processValidator(
         address delegator,
         uint64 validatorId,
@@ -133,11 +171,11 @@ contract StakingLens {
         (positionCount, lastWithdrawId, hasWithdrawals) =
             _appendWithdrawals(delegator, validatorId, currentEpoch, positions, positionCount);
 
-        if (snap.stake == 0 && snap.pendingStake == 0 && !hasWithdrawals) {
+        if (snap.stake == 0 && snap.pendingStake == 0 && snap.rewards == 0 && !hasWithdrawals) {
             return positionCount;
         }
 
-        if (snap.stake > 0 && positionCount < MAX_POSITIONS) {
+        if ((snap.stake > 0 || snap.rewards > 0) && positionCount < MAX_POSITIONS) {
             positions[positionCount] = Delegation({
                 validatorId: validatorId,
                 withdrawId: lastWithdrawId,
diff --git a/test/monad/StakingLens.t.sol b/test/monad/StakingLens.t.sol
@@ -46,12 +46,127 @@ contract StakingLensTest is Test {
         assertEq(validators[1].apyBps, expected);
     }
 
+    function test_getDelegationsIncludesPositionsWithoutActiveDelegations() public {
+        address delegator = address(0xc08A759F868Ab179F1259b2A7b1B81b0B968710E);
+        uint64 withdrawValidatorId = 7;
+        uint64 rewardsValidatorId = 9;
+        uint64 currentEpoch = 3;
+        uint64 withdrawEpoch = 4;
+        uint256 withdrawAmount = 2 ether;
+        uint256 rewardAmount = 1 ether;
+
+        uint64[] memory validators = new uint64[](2);
+        validators[0] = withdrawValidatorId;
+        validators[1] = rewardsValidatorId;
+        _mockConsensusSet(validators);
+
+        _mockEpoch(currentEpoch);
+        _mockDelegations(delegator, new uint64[](0));
+        _mockDelegator(delegator, withdrawValidatorId, 0, 0, 0, 0);
+        _mockDelegator(delegator, rewardsValidatorId, 0, rewardAmount, 0, 0);
+
+        _mockWithdrawalRequest(withdrawValidatorId, delegator, 0, withdrawAmount, withdrawEpoch);
+        for (uint8 withdrawId = 1; withdrawId < lens.MAX_WITHDRAW_IDS(); ++withdrawId) {
+            _mockWithdrawalRequest(withdrawValidatorId, delegator, withdrawId, 0, 0);
+        }
+        for (uint8 withdrawId = 0; withdrawId < lens.MAX_WITHDRAW_IDS(); ++withdrawId) {
+            _mockWithdrawalRequest(rewardsValidatorId, delegator, withdrawId, 0, 0);
+        }
+
+        StakingLens.Delegation[] memory positions = lens.getDelegations(delegator);
+
+        assertEq(positions.length, 2);
+
+        assertEq(positions[0].validatorId, withdrawValidatorId);
+        assertEq(positions[0].withdrawId, 0);
+        assertEq(uint8(positions[0].state), uint8(StakingLens.DelegationState.Deactivating));
+        assertEq(positions[0].amount, withdrawAmount);
+        assertEq(positions[0].rewards, 0);
+        assertEq(positions[0].withdrawEpoch, withdrawEpoch);
+        assertGt(positions[0].completionTimestamp, 0);
+
+        assertEq(positions[1].validatorId, rewardsValidatorId);
+        assertEq(uint8(positions[1].state), uint8(StakingLens.DelegationState.Active));
+        assertEq(positions[1].amount, 0);
+        assertEq(positions[1].rewards, rewardAmount);
+        assertEq(positions[1].withdrawEpoch, 0);
+        assertEq(positions[1].completionTimestamp, 0);
+    }
+
+    function test_getDelegationsIncludesWithdrawalsWhenActiveDelegationsExist() public {
+        address delegator = address(0xc08A759F868Ab179F1259b2A7b1B81b0B968710E);
+        uint64 withdrawValidatorId = 7;
+        uint64 activeValidatorId = 9;
+        uint64 currentEpoch = 3;
+        uint64 withdrawEpoch = 4;
+        uint256 withdrawAmount = 2 ether;
+        uint256 activeStake = 5 ether;
+
+        uint64[] memory validators = new uint64[](2);
+        validators[0] = withdrawValidatorId;
+        validators[1] = activeValidatorId;
+        _mockConsensusSet(validators);
+
+        uint64[] memory activeDelegations = new uint64[](1);
+        activeDelegations[0] = activeValidatorId;
+
+        _mockEpoch(currentEpoch);
+        _mockDelegations(delegator, activeDelegations);
+        _mockDelegator(delegator, activeValidatorId, activeStake, 0, 0, 0);
+        _mockDelegator(delegator, withdrawValidatorId, 0, 0, 0, 0);
+
+        for (uint8 withdrawId = 0; withdrawId < lens.MAX_WITHDRAW_IDS(); ++withdrawId) {
+            _mockWithdrawalRequest(activeValidatorId, delegator, withdrawId, 0, 0);
+        }
+        _mockWithdrawalRequest(withdrawValidatorId, delegator, 1, withdrawAmount, withdrawEpoch);
+        for (uint8 withdrawId = 0; withdrawId < lens.MAX_WITHDRAW_IDS(); ++withdrawId) {
+            if (withdrawId != 1) {
+                _mockWithdrawalRequest(withdrawValidatorId, delegator, withdrawId, 0, 0);
+            }
+        }
+
+        StakingLens.Delegation[] memory positions = lens.getDelegations(delegator);
+
+        assertEq(positions.length, 2);
+
+        bool foundActive;
+        bool foundWithdraw;
+        for (uint256 i = 0; i < positions.length; ++i) {
+            StakingLens.Delegation memory position = positions[i];
+
+            if (position.validatorId == activeValidatorId && position.state == StakingLens.DelegationState.Active) {
+                foundActive = true;
+                assertEq(position.amount, activeStake);
+                assertEq(position.rewards, 0);
+            }
+
+            if (
+                position.validatorId == withdrawValidatorId
+                    && position.state == StakingLens.DelegationState.Deactivating && position.withdrawId == 1
+            ) {
+                foundWithdraw = true;
+                assertEq(position.amount, withdrawAmount);
+                assertEq(position.rewards, 0);
+                assertEq(position.withdrawEpoch, withdrawEpoch);
+            }
+        }
+
+        assertTrue(foundActive);
+        assertTrue(foundWithdraw);
+    }
+
     function _mockConsensusSet() internal {
         bytes memory data = abi.encodeCall(IStaking.getConsensusValidatorSet, (0));
         bytes memory result = abi.encode(true, uint32(0), validatorIds);
         vm.mockCall(STAKING_PRECOMPILE, data, result);
     }
 
+    function _mockConsensusSet(uint64[] memory ids) internal {
+        bytes memory data = abi.encodeCall(IStaking.getConsensusValidatorSet, (0));
+        bytes memory result = abi.encode(true, uint32(0), ids);
+        vm.mockCall(STAKING_PRECOMPILE, data, result);
+    }
+
     function _mockValidator(uint64 validatorId, uint256 stake, uint256 commission) internal {
         bytes memory data = abi.encodeCall(IStaking.getValidator, (validatorId));
         bytes memory result = abi.encode(
@@ -71,6 +186,43 @@ contract StakingLensTest is Test {
         vm.mockCall(STAKING_PRECOMPILE, data, result);
     }
 
+    function _mockEpoch(uint64 epoch) internal {
+        bytes memory data = abi.encodeCall(IStaking.getEpoch, ());
+        bytes memory result = abi.encode(epoch, false);
+        vm.mockCall(STAKING_PRECOMPILE, data, result);
+    }
+
+    function _mockDelegations(address delegator, uint64[] memory valIds) internal {
+        bytes memory data = abi.encodeCall(IStaking.getDelegations, (delegator, uint64(0)));
+        bytes memory result = abi.encode(true, uint64(0), valIds);
+        vm.mockCall(STAKING_PRECOMPILE, data, result);
+    }
+
+    function _mockDelegator(
+        address delegator,
+        uint64 validatorId,
+        uint256 stake,
+        uint256 rewards,
+        uint256 deltaStake,
+        uint256 nextDeltaStake
+    ) internal {
+        bytes memory data = abi.encodeCall(IStaking.getDelegator, (validatorId, delegator));
+        bytes memory result = abi.encode(stake, uint256(0), rewards, deltaStake, nextDeltaStake, uint64(0), uint64(0));
+        vm.mockCall(STAKING_PRECOMPILE, data, result);
+    }
+
+    function _mockWithdrawalRequest(
+        uint64 validatorId,
+        address delegator,
+        uint8 withdrawId,
+        uint256 amount,
+        uint64 withdrawEpoch
+    ) internal {
+        bytes memory data = abi.encodeCall(IStaking.getWithdrawalRequest, (validatorId, delegator, withdrawId));
+        bytes memory result = abi.encode(amount, uint256(0), withdrawEpoch);
+        vm.mockCall(STAKING_PRECOMPILE, data, result);
+    }
+
     function _expectedNetworkApy() internal view returns (uint64) {
         uint256 annualRewards = lens.MONAD_BLOCK_REWARD() * lens.MONAD_BLOCKS_PER_YEAR();
         uint256 apy = (annualRewards * lens.APY_BPS_PRECISION()) / TOTAL_STAKE;
