wrong reward calculations because function _distributeETHRewardsToUserForToken() in SyndicateRewardsProcessor set the wrong value for claimed[_user][_token] 
Audit: 2022-11-stakehouse-findings
Severity: HIGH

# Lines of code

https://github.com/code-423n4/2022-11-stakehouse/blob/4b6828e9c807f2f7c569e6d721ca1289f7cf7112/contracts/liquid-staking/SyndicateRewardsProcessor.sol#L50-L73


# Vulnerability details

## Impact
Function `_distributeETHRewardsToUserForToken()` will distribute any due rewards from node running to `msg.sender` if they have an LP balance. it's used in `GiantMevAndFeesPool` to distribute rewards, but in that function the value of `claimed[_user][_token]` is set to wrong value so the calculations of user rewards would be wrong and contract would distribute funds wrongly.

## Proof of Concept
This is `_distributeETHRewardsToUserForToken()` code in `SyndicateRewardsProcessor`:
```
    /// @dev Any due rewards from node running can be distributed to msg.sender if they have an LP balance
    function _distributeETHRewardsToUserForToken(
        address _user,
        address _token,
        uint256 _balance,
        address _recipient
    ) internal {
        require(_recipient != address(0), "Zero address");
        uint256 balance = _balance;
        if (balance > 0) {
            // Calculate how much ETH rewards the address is owed / due 
            uint256 due = ((accumulatedETHPerLPShare * balance) / PRECISION) - claimed[_user][_token];
            if (due > 0) {
                claimed[_user][_token] = due;

                totalClaimed += due;

                (bool success, ) = _recipient.call{value: due}("");
                require(success, "Failed to transfer");

                emit ETHDistributed(_user, _recipient, due);
            }
        }
    }
```
This function is used to distribute user's ETH rewards, the code calculates the remaining user's rewards in contract and then transfer it to user and update user's claimed information. to calculated remaining user's rewards code uses: `due = ((accumulatedETHPerLPShare * balance) / PRECISION) - claimed[_user][_token]` and then code sets `claimed[_user][_token] = due;`. `accumulatedETHPerLPShare` is storing Total accumulated ETH per share of LP<>KNOT that has minted derivatives. imagine this steps:
1- `user1` balance in `token1` (giant pool token) is `10`, `accumulatedETHPerLPShare` is `1` and `claimed[user1][token1]` is `10` (claim is the max).
2-  some time passes and `accumulatedETHPerLPShare` increase to `2`.
3- `user1` calls `claimRewards()` to get his remaining rewards. code recalculated `accumulatedETHPerLPShare` and set it to `2`. code calculates user rewards as `due = (10*2) - 10 = 10` and transfer `10` ETH to user and set `claimed[user1][token1]` to `10`.
4- some time passes and `accumulatedETHPerLPShare` increase to `3`.
5- `user1` calls `claimRewards()` again to get his remaining rewards. code recalculated `accumulatedETHPerLPShare` and set it to `3`. code calculates user rewards as `due = (10*3) - 10 = 20` and transfer `20` ETH to user and set `claimed[user1][token1]` to `20`.
6- `user1` calls `claimRewards()` again to get his remaining rewards. code recalculated