## Summary queryGraph always rounds up, which will ultimate lead to reverting transctions. This is because the PositionDecay.WeightIncrement depends on the returned earmarked amount by queryGraph being less than totalDebt - cumulativeEarmarked. This rounding up will break this invariant and cause all transcations to revert, locking the contract and all funds in it. ## Finding Description PositionDecay::WeightIncrement will check that the passed in increment is less than or equal to the total: ```sol function WeightIncrement(uint256 increment, uint256 total) internal pure returns (uint256) { unchecked { > require(increment <= total); //support ratios of 1.0 or less require(total <= type(uint128).max); //Overflow check for (total - increment)<<128 //By this check, and require(increment <= total <= uint128.max), we avoid div by zero if (increment == 0) { //log2(1.0) produces no weight increment return 0; } uint256 ratio = ((total - increment) << 128) / total; if (ratio == 0) { //return smallest weight increase where Exp2NegFrac returns zero return LOG2NEGFRAC_1+1; } return Log2NegFrac(ratio); } } ``` This is called by the AlchemistV3::_earmark function: ```sol function _earmark() internal { if (totalDebt == 0) return; if (block.number > lastEarmarkBlock) { uint256 amount = ITransmuter(transmuter).queryGraph(lastEarmarkBlock + 1, block.number); if (amount > 0) { > _earmarkWeight += PositionDecay.WeightIncrement(amount, totalDebt - cumulativeEarmarked); cumulativeEarmarked += amount; } lastEarmarkBlock = block.number; } } ``` However, we also see that the function will query the transmuter graph on each update and update the cumulative earmarked. However, the queryGraph function will round up any stored amounts: ```sol function queryGraph(uint256 startBlock, uint256 endBlock) external view returns (uint256) { int256 queried = _stakingGraph.queryStake(startBlock, endBlock); if (queried == 0) return 0; // + 1 for rounding error > return (queried / BLOCK_SCALING_FACTOR).toUint256() + 1; //return ((queried+(BLOCK_SCALING_FACTOR-1)) / BLOCK_SCALING_FACTOR).toUint256(); } ``` This means that over time the cumulative will go over the total, and the function will start reverting. This will affect virtually all functions of the protocol as they all do updates through _earmark before any intended state changes due to user interaction. ## Impact Explanation Locked user funds due to broken contract. ## Likelihood Explanation This will happen if the contract reaches a state where all debt is submitted for transmutation. ## Proof of Concept Before I show the coded PoC, first understand the math behind it and why it leads to a revert during call to repay(): This is the flow in the PoC: - A user deposits 100e18 collateral yield tokens - Same user takes out 50e18 debt - Same user creates a redemption for 50e18 tokens - After 1 block - someone calls poke() - this leads to a problematic rounding up - After 5256000 - which is end to transmutation period user tries to repay, but the transaction reverts. - The contract is broken and all functions revert. This happens because after 1 block, the amount to be earmarked from the user debt will be calculated as 50e18/5256000 ~ 9512937595129.37 This is stored in the graph as 9512937595129, however the poke querying after 1 block will return it as 9512937595130 - rounded up. As a result after the 5256000 blocks transmutation period, the invariant for PositionDecay::WeightIncrement will be broken and functions will start reverting. Here is a coded PoC showing the revert happening, place in AlchemistV3.t.sol: ```sol function testRepayWithEarmarkedDebt_MultiplePoke_Broken() external { uint256 amount = 100e18; vm.startPrank(address(0xbeef)); SafeERC20.safeApprove(address(fakeYieldToken), address(alchemist), amount + 100e18); alchemist.deposit(amount, address(0xbeef), 0); // a single position nft would have been minted to 0xbeef uint256 tokenId = AlchemistNFTHelper.getFirstTokenId(address(0xbeef), address(alchemistNFT)); alchemist.mint(tokenId, (amount / 2), address(0xbeef)); SafeERC20.safeApprove(address(alToken), address(transmuterLogic), 50e18); transmuterLogic.createRedemption(50e18); vm.stopPrank(); vm.roll(block.number + 1); alchemist.poke(tokenId); vm.roll(block.number + 5_256_000); vm.prank(address(0xbeef)); alchemist.repay(25e18, tokenId); } ``` Run this unit test with `forge test --mt testRepayWithEarmarkedDebt_MultiplePoke_Broken` To get a confirmation of the state of the contract and function calls, adjust the AlchemistV3::_earmark function as such: ```diff function _earmark() internal { if (totalDebt == 0) return; if (block.number > lastEarmarkBlock) { uint256 amount = ITransmuter(transmuter).queryGraph(lastEarmarkBlock + 1, block.number); if (amount > 0) { + console.log("amount: %d", amount); + console.log("totalDebt: %d", totalDebt); + console.log("cumulativeEarmarked: %d", cumulativeEarmarked); _earmarkWeight += PositionDecay.WeightIncrement(amount, totalDebt - cumulativeEarmarked); cumulativeEarmarked += amount; } lastEarmarkBlock = block.number; } } ``` And of course, add the console to the imports: ```diff + import {console} from "../lib/forge-std/src/console.sol"; ``` Running the test again shows these logs: ```sol amount: 9512937595130 totalDebt: 50000000000000000000 cumulativeEarmarked: 0 amount: 49999990487062404871 totalDebt: 50000000000000000000 cumulativeEarmarked: 9512937595130 ``` We can see that indeed the returned value is 9512937595130 instead of 9512937595129 as we predicted. If we do the calculation for the require statement in PositionDecay::WeightIncrement: `require(increment <= total);` Meaning that `amount <= totalDebt - cumulativeEarmarked` must be true. So if we substitute the values from above, we get: `49999990487062404871 <= 50000000000000000000 - 9512937595130`, which is equal to: `49999990487062404871 <= 49999990487062404870` Which is false, so the function reverts ## Recommendation Remove the rounding up during graph querying.

Competition	Date	Submissions	Payout
Reserve Protocol	Apr 30, 2026	1	$0
Alchemix	May 1, 2025	4	$89
Rheo	Feb 26, 2025	1	$0
Reserve Protocol	Jan 13, 2025	2	$319
Coinbase	Oct 30, 2024	1	$1,200
Omni Network	Oct 14, 2024	2	$393

gesha17

Public reviews