Core Contracts

Regnum Aurum Acquisition Corp

HardhatReal World AssetsNFT

77,280 USDC

View results

Previous Next

Submission Details

Severity: high

Valid

Gauge weights is incorrectly updated by vote()

h2134

Summary

Gauge weights is incorrectly updated by vote().

Vulnerability Details

vote() in GaugeController is used to update gauge weights based on user's veToken balance. This function gets user's current veToken balance (votingPower), and calls _updateGaugeWeight() to perform the update.

GaugeController::vote()

uint256 votingPower = veRAACToken.balanceOf(msg.sender);

if (votingPower == 0) revert NoVotingPower();

uint256 oldWeight = userGaugeVotes[msg.sender][gauge];

userGaugeVotes[msg.sender][gauge] = weight;

_updateGaugeWeight(gauge, oldWeight, weight, votingPower);

In _updateGaugeWeight(), new gauge weight is calculated as below:

GaugeController::_updateGaugeWeight()

Gauge storage g = gauges[gauge];

uint256 oldGaugeWeight = g.weight;

@> uint256 newGaugeWeight = oldGaugeWeight - (oldWeight * votingPower / WEIGHT_PRECISION)

@> + (newWeight * votingPower / WEIGHT_PRECISION);

g.weight = newGaugeWeight;

There are issues in the calculation:

A gauge's weight is expected to be in an range of [1, 10000], as WEIGHT_PRECISION is 10000, suppose a gauge is added with 5000 weight, when the gauge is updated, the old weight is added to the new weight, meaning the gauge weight can be more than 10000 if user votes with a weight more than 5000;
When calculates newGaugeWeight, the value is no less than newWeight * votingPower / WEIGHT_PRECISION, because votingPower is in veToken decimals, i.e. 18, this leads to the gauge weight is in 1e18 decimals instead of in basis point;
In the calculation, oldGaugeWeight can be less than oldWeight * votingPower / WEIGHT_PRECISION if a user revotes after minting more veTokens, and transaction will revert due to underflow error;
A single user can easily manipulate a gauge weight through voting.

Impact

Gauge weight is not updated correctly throught voting.

POC

Run forge test --mt testAudit_GaugeControllerVoteErrors.

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.19;

import {Test, console, stdError} from "forge-std/Test.sol";

import "@openzeppelin/contracts/utils/math/SafeCast.sol";

import "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";

import "../contracts/libraries/math/WadRayMath.sol";

import "../contracts/core/pools/LendingPool/LendingPool.sol";

import "../contracts/core/pools/StabilityPool/StabilityPool.sol";

import "../contracts/mocks/core/tokens/crvUSDToken.sol";

import "../contracts/core/tokens/RToken.sol";

import "../contracts/core/tokens/DebtToken.sol";

import "../contracts/core/tokens/DeToken.sol";

import "../contracts/core/tokens/RAACToken.sol";

import "../contracts/core/tokens/RAACNFT.sol";

import "../contracts/core/tokens/veRAACToken.sol";

import "../contracts/core/primitives/RAACHousePrices.sol";

import "../contracts/core/minters/RAACMinter/RAACMinter.sol";

import "../contracts/core/collectors/FeeCollector.sol";

import "../contracts/core/collectors/Treasury.sol";

import "../contracts/core/governance/proposals/Governance.sol";

import "../contracts/core/governance/proposals/TimelockController.sol";

import "../contracts/core/governance/boost/BoostController.sol";

import "../contracts/core/governance/gauges/RAACGauge.sol";

import "../contracts/core/governance/gauges/GaugeController.sol";

import "../contracts/mocks/core/pools/MockPool.sol";

import "../contracts/mocks/core/tokens/MockToken.sol";

contract Audit is Test {

using WadRayMath for uint256;

using SafeCast for uint256;

address owner = makeAddr("Owner");

address repairFund = makeAddr("RepairFund");

LendingPool lendingPool;

StabilityPool stabilityPool;

RAACHousePrices raacHousePrices;

crvUSDToken crvUSD;

RToken rToken;

DebtToken debtToken;

DEToken deToken;

RAACToken raacToken;

RAACNFT raacNft;

veRAACToken veRaacToken;

RAACMinter raacMinter;

FeeCollector feeCollector;

Treasury treasury;

Governance governance;

TimelockController timelockController;

BoostController boostController;

GaugeController gaugeController;

RAACGauge raacGauge;

MockToken gaugeRewardToken;

MockToken gaugeStakingToken;

function setUp() public {

vm.warp(1740000000);

vm.startPrank(owner);

raacHousePrices = new RAACHousePrices(owner);

// Deploy tokens

raacToken = new RAACToken(owner, 100, 50);

veRaacToken = new veRAACToken(address(raacToken));

crvUSD = new crvUSDToken(owner);

rToken = new RToken("RToken", "RToken", owner, address(crvUSD));

debtToken = new DebtToken("DebtToken", "DT", owner);

raacNft = new RAACNFT(address(crvUSD), address(raacHousePrices), owner);

deToken = new DEToken("DEToken", "DEToken", owner, address(rToken));

// Deploy Treasury and FeeCollector

treasury = new Treasury(owner);

feeCollector = new FeeCollector(

address(raacToken),

address(veRaacToken),

address(treasury),

repairFund,

owner

);

// Deploy LendingPool

lendingPool = new LendingPool(

address(crvUSD),

address(rToken),

address(debtToken),

address(raacNft),

address(raacHousePrices),

0.1e27

);

// Deploy stabilityPool Proxy

bytes memory data = abi.encodeWithSelector(

StabilityPool.initialize.selector,

address(rToken),

address(deToken),

address(raacToken),

address(owner),

address(crvUSD),

address(lendingPool)

);

address stabilityPoolProxy = address(

new TransparentUpgradeableProxy(

address(new StabilityPool(owner)),

owner,

data

)

);

stabilityPool = StabilityPool(stabilityPoolProxy);

// RAACMinter

raacMinter = new RAACMinter(

address(raacToken),

address(stabilityPool),

address(lendingPool),

owner

);

// Governance

address[] memory proposers;

address[] memory executors;

timelockController = new TimelockController(2 days, proposers, executors, owner);

governance = new Governance(address(veRaacToken), address(timelockController));

// Boost

boostController = new BoostController(address(veRaacToken));

// Gauges

gaugeController = new GaugeController(address(veRaacToken));

gaugeRewardToken = new MockToken("Reward Token", "RWD", 18);

gaugeStakingToken = new MockToken("veRAAC Token", "veRAAC", 18);

raacGauge = new RAACGauge(address(gaugeRewardToken), address(gaugeStakingToken), address(gaugeController));

// Initialization

raacHousePrices.setOracle(owner);

rToken.setReservePool(address(lendingPool));

debtToken.setReservePool(address(lendingPool));

deToken.setStabilityPool(address(stabilityPool));

stabilityPool.setRAACMinter(address(raacMinter));

lendingPool.setStabilityPool(address(stabilityPool));

raacToken.setMinter(address(raacMinter));

raacToken.setFeeCollector(address(feeCollector));

raacToken.manageWhitelist(address(feeCollector), true);

raacToken.manageWhitelist(address(raacMinter), true);

raacToken.manageWhitelist(address(stabilityPool), true);

raacToken.manageWhitelist(address(veRaacToken), true);

timelockController.grantRole(keccak256("PROPOSER_ROLE"), address(governance));

timelockController.grantRole(keccak256("EXECUTOR_ROLE"), address(governance));

timelockController.grantRole(keccak256("CANCELLER_ROLE"), address(governance));

timelockController.grantRole(keccak256("EMERGENCY_ROLE"), address(governance));

vm.stopPrank();

vm.label(address(crvUSD), "crvUSD");

vm.label(address(rToken), "RToken");

vm.label(address(debtToken), "DebtToken");

vm.label(address(deToken), "DEToken");

vm.label(address(raacToken), "RAACToken");

vm.label(address(raacNft), "RAAC NFT");

vm.label(address(lendingPool), "LendingPool");

vm.label(address(stabilityPool), "StabilityPool");

vm.label(address(raacMinter), "RAACMinter");

vm.label(address(veRaacToken), "veRAAC");

vm.label(address(feeCollector), "FeeCollector");

vm.label(address(treasury), "Treasury");

vm.label(address(governance), "Governance");

vm.label(address(timelockController), "TimelockController");

vm.label(address(boostController), "BoostController");

vm.label(address(gaugeController), "GaugeController");

vm.label(address(raacGauge), "RAACGauge");

vm.label(address(gaugeRewardToken), "GaugeRewardToken");

vm.label(address(gaugeStakingToken), "GaugeStakingToken");

}

function testAudit_GaugeControllerVoteErrors() public {

// Add gauge

vm.prank(owner);

gaugeController.addGauge(address(raacGauge), IGaugeController.GaugeType.RAAC, 5000);

address alice = makeAddr("Alice");

// Mint veRAAC tokens

deal(address(raacToken), alice, 100e18);

vm.startPrank(alice);

raacToken.approve(address(veRaacToken), 100e18);

veRaacToken.lock(100e18, 1460 days);

vm.stopPrank();

// Vote

vm.prank(alice);

gaugeController.vote(address(raacGauge), 6000);

uint256 gaugeWeight = gaugeController.getGaugeWeight(address(raacGauge));

// Invalid gauge weight

assertEq(gaugeWeight, 60000000000000005000);

// Mint more veRAAC tokens

deal(address(raacToken), alice, 100e18);

vm.startPrank(alice);

raacToken.approve(address(veRaacToken), 100e18);

veRaacToken.lock(100e18, 1460 days);

vm.stopPrank();

// Cannot revote

vm.prank(alice);

vm.expectRevert(stdError.arithmeticError);

gaugeController.vote(address(raacGauge), 3000);

}

Tools Used

Manual Review

Recommendations

Update gauge weight propoerly in vote().

Updates

Lead Judging Commences

inallhonesty Lead Judge 3 months ago

Submission Judgement Published

Validated

Assigned finding tags:

GaugeController::_updateGaugeWeight uses current voting power for both old and new vote calculations, causing underflows when voting power increases and incorrect gauge weights

Prize pool breakdown

Total prize

77,280 USDC

nSLOC

3,864

20 USDC / LOC

High Medium

74,000

Low

3,280

Live

The contest is live. Earn rewards by submitting a finding.

Judging

Submissions are being carefully reviewed by our judges.

View all submissions

Appeals

This is your time to appeal against judgements on your submissions.

Appeals Review

Appeals are being carefully reviewed by our judges.

Rewards Distribution

The contest is complete and the rewards are being distributed.

View results

Support

FAQs

Can't find an answer? Chat with us on Discord, Twitter or Linkedin.