When rolling over, user will lose his winnings from previous epoch
When `mintRollovers` is called, when the function mints shares for the new epoch for the user, the amount of shares minted will be the same as the original assets he requested to rollover - not including the amount he won. After this, all these asset shares from the previous epoch are burnt. So the user won't be able to claim his winnings.\\nWhen user requests to `enlistInRollover`, he supplies the amount of assets to rollover, and this is saved in the queue.\\n```\\nrolloverQueue[index].assets = _assets;\\n```\\n\\nWhen `mintRollovers` is called, the function checks if the user won the previous epoch, and proceeds to burn all the shares the user requested to roll:\\n```\\n            if (epochResolved[queue[index].epochId]) {\\n                uint256 entitledShares = previewWithdraw(\\n                    queue[index].epochId,\\n                    queue[index].assets\\n                );\\n                // mint only if user won epoch he is rolling over\\n                if (entitledShares > queue[index].assets) {\\n                    // rest of code\\n                    // @note we know shares were locked up to this point\\n                    _burn(\\n                        queue[index].receiver,\\n                        queue[index].epochId,\\n                        queue[index].assets\\n                    );\\n```\\n\\nThen, and this is the problem, the function mints to the user his original assets - `assetsToMint` - and not `entitledShares`.\\n```\\nuint256 assetsToMint = queue[index].assets - relayerFee;\\n_mintShares(queue[index].receiver, _epochId, assetsToMint);\\n```\\n\\nSo the user has only rolled his original assets, but since all his share of them is burned, he will not be able anymore to claim his winnings from them.\\nNote that if the user had called `withdraw` instead of rolling over, all his shares would be burned, but he would receive his `entitledShares`, and not just his original assets. We can see in this in `withdraw`. Note that `_assets` is burned (like in minting rollover) but `entitledShares` is sent (unlike minting rollover, which only remints _assets.)\\n```\\n        _burn(_owner, _id, _assets);\\n        _burnEmissions(_owner, _id, _assets);\\n        uint256 entitledShares;\\n        uint256 entitledEmissions = previewEmissionsWithdraw(_id, _assets);\\n        if (epochNull[_id] == false) {\\n            entitledShares = previewWithdraw(_id, _assets);\\n        } else {\\n            entitledShares = _assets;\\n        }\\n        if (entitledShares > 0) {\\n            SemiFungibleVault.asset.safeTransfer(_receiver, entitledShares);\\n        }\\n        if (entitledEmissions > 0) {\\n            emissionsToken.safeTransfer(_receiver, entitledEmissions);\\n        }\\n```\\n
Either remint the user his winnings also, or if you don't want to make him roll over the winnings, change the calculation so he can still withdraw his shares of the winnings.
User will lose his rewards when rolling over.
```\\nrolloverQueue[index].assets = _assets;\\n```\\n