Core Contracts
Regnum Aurum Acquisition Corp
HardhatReal World AssetsNFT
77,280 USDC
View results
Previous Next
Submission Details
Severity: high
Valid

RToken::transfer() will transfer incorrect amount due to double scaling

momentum

Summary

RToken user balances are stored in scaled format. RToken::transfer() takes an amount parameter in underlying asset units. Due to an error scaling is performed twice resulting in an incorrect amount being transferred.

Vulnerability Details

RToken::transfer()(an override) scales the amount and then calls the base class method (ERC20::transfer()) with the scaled amount.
Internally ERC20::_upgrade() is called. But RToken overrides ERC20::_upgrade() too, and in that overriden method scaling is performed a second time on the already scaled value.
This results in the incorrect amount being transferred.

Impact

The amount transferred will differ from what the user expects.

POC

set up:

  1. run npm install and add .env file if you haven't already

  2. npm i --save-dev @nomicfoundation/hardhat-foundry - Install the hardhat-foundry plugin.

  3. Add require("@nomicfoundation/hardhat-foundry"); to the top of your hardhat.config.js file.

  4. Run npx hardhat init-foundry in your terminal. This will generate a foundry.toml file based on your Hardhat project’s existing configuration, and will install the forge-std library.

  5. mkdir test/foundry

  6. Create *.t.sol file inside /test/foundry and paste the POC inside.

  7. In foundry.toml update test = 'test/foundry'

running test:

forge test --match-test testRTokenTransferTransfersWrongAmount -vv

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
​
import "../../contracts/core/pools/LendingPool/LendingPool.sol";
import "../../contracts/libraries/pools/ReserveLibrary.sol";
import "../../lib/forge-std/src/Test.sol";
import "../../lib/forge-std/src/console.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "../../contracts/core/tokens/DebtToken.sol";
import "../../contracts/core/tokens/RToken.sol";
import "../../contracts/core/tokens/RAACNFT.sol";
import "../../contracts/core/primitives/RAACHousePrices.sol";
​
contract MockERC20 is ERC20 {
constructor(string memory name, string memory symbol) ERC20(name, symbol) {}
​
function mint(address to, uint256 amount) external {
_mint(to, amount);
}
​
function balanceOf(address account) public view override returns (uint256) {
return super.balanceOf(account);
}
}
​
contract ReserveLibraryTest is Test {
//address that deploys and owns contracts
address owner;
​
address user;
LendingPool lendingPool;
MockERC20 reserveAsset;
RToken rToken;
DebtToken debtToken;
RAACNFT raacNFt;
​
address priceOracle;
RAACHousePrices housePrices;
​
ReserveLibrary.ReserveData reserve;
ReserveLibrary.ReserveRateData rateData;
​
function setUp() public {
owner = makeAddr("owner");
​
initializeContracts(owner);
configureContracts(owner);
​
user = makeAddr("user");
}
​
function initializeContracts(address _owner) internal {
reserveAsset = new MockERC20("reserveMock", "mkTkn");
​
rToken = new RToken("rMock", "mkTkn", _owner, address(reserveAsset));
​
debtToken = new DebtToken("debtMock", "mkTkn", _owner);
priceOracle = makeAddr("priceOracle");
​
housePrices = new RAACHousePrices(_owner);
​
raacNFt = new RAACNFT(address(reserveAsset), address(housePrices), _owner);
​
lendingPool = new LendingPool(
address(reserveAsset), address(rToken), address(debtToken), address(raacNFt), address(housePrices), 1e26
);
}
​
function configureContracts(address _owner) internal {
vm.startPrank(_owner);
​
housePrices.setOracle(priceOracle);
debtToken.setReservePool(address(lendingPool));
rToken.setReservePool(address(lendingPool));
​
vm.stopPrank();
​
vm.prank(priceOracle);
housePrices.setHousePrice(1, 10_000);
}
​
function updateReserveStates() public {
(
address reserveRTokenAddress,
address reserveAssetAddress,
address reserveDebtTokenAddress,
uint256 totalLiquidity,
uint256 totalUsage,
uint128 liquidityIndex,
uint128 usageIndex,
uint40 lastUpdateTimestamp
) = lendingPool.reserve();
reserve = ReserveLibrary.ReserveData(
reserveRTokenAddress,
reserveAssetAddress,
reserveDebtTokenAddress,
totalLiquidity,
totalUsage,
liquidityIndex,
usageIndex,
lastUpdateTimestamp
);
​
(
uint256 currentLiquidityRate,
uint256 currentUsageRate,
uint256 primeRate,
uint256 baseRate,
uint256 optimalRate,
uint256 maxRate,
uint256 optimalUtilizationRate,
uint256 protocolFeeRate
) = lendingPool.rateData();
rateData = ReserveLibrary.ReserveRateData(
currentLiquidityRate,
currentUsageRate,
primeRate,
baseRate,
optimalRate,
maxRate,
optimalUtilizationRate,
protocolFeeRate
);
}
​
function testRTokenTransferTransfersWrongAmount() public {
address borrower = makeAddr("borrower");
address recipient = makeAddr("recipient");
​
//mint reserve asset
reserveAsset.mint(user, 10_000_000);
reserveAsset.mint(borrower, 10_000);
​
//deposit liquidity into the lending pool
vm.startPrank(user);
deposit(1000);
vm.stopPrank();
​
//borrow so that the utilization rate is not zero
vm.startPrank(borrower);
mintNFT();
depositNFT();
lendingPool.borrow(1000);
vm.stopPrank();
//fast forward time 1 block
skip(12);
​
//deposit liquidity into the lending pool
vm.startPrank(user);
deposit(9_999_000);
vm.stopPrank();
​
//fast forward time 1 block
skip(12);
//update indexes - workaround for getter method returning stale index data
updateReserveStates();
ReserveLibrary.updateReserveInterests(reserve, rateData);
​
//transfer
uint256 amountToTransfer = 10_000_000;
vm.startPrank(user);
rToken.transfer(recipient, amountToTransfer);
vm.stopPrank();
​
//assert balance of recipient is lower than expected
assertNotEq(amountToTransfer, rToken.balanceOf(recipient));
​
console.log("sender balance after transfer: %d", rToken.balanceOf(user));
console.log("recipient balance after transfer: %d", rToken.balanceOf(recipient));
}
​
function mintNFT() internal {
reserveAsset.approve(address(raacNFt), 10_000);
raacNFt.mint(1, 10_000);
}
​
function depositNFT() internal {
raacNFt.approve(address(lendingPool), 1);
lendingPool.depositNFT(1);
}
​
function deposit(uint256 amount) internal {
reserveAsset.approve(address(lendingPool), amount);
lendingPool.deposit(amount);
}
}

Tools Used

Manul review

Recommendations

Either perform the scaling in the methods that require it (RToken::mint(), RToken::burn(), RToken::transfer(), RToken::transferFrom()) or in the overriden RToken::update(), but not both.

Updates

Lead Judging Commences

inallhonesty Lead Judge 3 months ago
Submission Judgement Published
Validated
Assigned finding tags:

RToken::transfer and transferFrom double-scale amounts by dividing in both external functions and _update, causing users to transfer significantly less than intended

inallhonesty Lead Judge 3 months ago
Submission Judgement Published
Validated
Assigned finding tags:

RToken::transfer and transferFrom double-scale amounts by dividing in both external functions and _update, causing users to transfer significantly less than intended

Support

FAQs

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