QuantAMM

49,600 OP

View results

Previous Next

Submission Details

Severity: low

Invalid

Compounding Total Weight Deviation in ChannelFollowingUpdateRule

iepathos

Summary

The ChannelFollowingUpdateRule contract exhibits a compounding deviation from the fundamental invariant that pool weights must sum exactly to 1e18 (100%). Under extreme conditions, the deviation grows linearly at +10 wei per update, leading to significant cumulative errors over time. Even under normal conditions, the rule shows consistent negative deviations. This compounding behavior makes this a more severe issue than similar weight deviations in other rules.

Vulnerability Details

Location: pkg/pool-quantamm/contracts/rules/ChannelFollowingUpdateRule.sol

The issue occurs in the weight calculation logic where there's no validation that the sum of weights equals 1e18, and more critically, where deviations compound over time:

// Weight calculation lacks total weight validation:

newWeightsConverted[locals.i] = _prevWeights[locals.i] +

locals.kappa[0].mul(locals.signal[locals.i] - locals.normalizationFactor);

// No validation of total weight sum

// Each update compounds the previous deviation

Proof of Concept:

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.24;

import "forge-std/Test.sol";

import "@prb/math/contracts/PRBMathSD59x18.sol";

import "../../../contracts/mock/mockRules/MockChannelFollowing.sol";

import "../../../contracts/mock/MockPool.sol";

import "../utils.t.sol";

contract QuantammChannelFollowingTotalWeightTest is Test, QuantAMMTestUtils {

MockChannelFollowingRule public rule;

MockPool public mockPool;

int256[][] public parameters;

int256[] public prevWeights;

int256[] public data;

int256[] public variances;

int256[] public prevMovingAverages;

int128[] public lambda;

function setUp() public {

rule = new MockChannelFollowingRule(address(this));

mockPool = new MockPool(3600, 1 ether, address(rule));

// Setup normal parameters

setupParameters();

setupInitialState();

}

function setupParameters() private {

parameters = new int256[][]();

// [0] Kappa - normal update magnitude

parameters[0] = new int256[]();

parameters[0][0] = 0.1e18; // Standard kappa

// [1] Width - standard channel width

parameters[1] = new int256[]();

parameters[1][0] = 0.5e18; // Standard width

// [2] Amplitude - normal amplitude

parameters[2] = new int256[]();

parameters[2][0] = 0.2e18; // Standard amplitude

// [3] Exponents - standard trend following

parameters[3] = new int256[]();

parameters[3][0] = 1e18; // Linear trend following

// [4] Inverse Scaling - standard

parameters[4] = new int256[]();

parameters[4][0] = 0.541519e18;

// [5] Pre-exp Scaling - standard

parameters[5] = new int256[]();

parameters[5][0] = 1e18;

// [6] Use moving average

parameters[6] = new int256[]();

parameters[6][0] = 0;

}

function setupInitialState() private {

// Standard initial weights

prevWeights = new int256[](2);

prevWeights[0] = 0.5e18; // 50%

prevWeights[1] = 0.5e18; // 50%

// Normal price movements

data = new int256[](2);

data[0] = 1.01e18; // 1% increase

data[1] = 0.99e18; // 1% decrease

// Standard variances

variances = new int256[](2);

variances[0] = 1e18;

variances[1] = 1e18;

// Standard moving averages

prevMovingAverages = new int256[](4);

prevMovingAverages[0] = 1e18;

prevMovingAverages[1] = 1e18;

prevMovingAverages[2] = 1e18;

prevMovingAverages[3] = 1e18;

lambda = new int128[](1);

lambda[0] = int128(0.95e18); // Standard lambda

}

// Helper function for absolute value

function abs(int256 x) internal pure returns (int256) {

return x >= 0 ? x : -x;

}

function testChannelFollowingTotalWeightNormal() public {

// Use existing normal parameters

setupParameters();

setupInitialState();

runTotalWeightTest("Normal Conditions");

}

function testChannelFollowingTotalWeightExtreme() public {

setupParameters();

setupInitialState();

// Modify to extreme parameters

parameters[0][0] = 10e18; // Aggressive kappa

parameters[1][0] = 0.1e18; // Narrow width

parameters[2][0] = 5e18; // High amplitude

// Extreme initial weights

prevWeights[0] = 0.99e18; // 99%

prevWeights[1] = 0.01e18; // 1%

// Extreme price movements

data[0] = 20e18; // Price increased 20x

data[1] = 0.05e18; // Price dropped 95%

runTotalWeightTest("Extreme Conditions");

}

function runTotalWeightTest(string memory testType) private {

mockPool.setNumberOfAssets(2);

rule.initialisePoolRuleIntermediateValues(

address(mockPool),

prevMovingAverages,

variances,

);

int256[] memory results;

int256 maxPositiveDeviation;

int256 maxNegativeDeviation;

emit log_string("=== Test Type: ");

emit log_string(testType);

emit log_string(" ===");

// First update

rule.CalculateUnguardedWeights(

prevWeights,

data,

address(mockPool),

parameters,

lambda,

prevMovingAverages

);

results = rule.GetResultWeights();

prevWeights = results;

// Track updates

for (uint i = 0; i < 24; i++) {

rule.CalculateUnguardedWeights(

prevWeights,

data,

address(mockPool),

parameters,

lambda,

prevMovingAverages

);

results = rule.GetResultWeights();

int256 totalWeight = results[0] + results[1];

int256 deviation = totalWeight - 1e18;

emit log_named_uint("Update", i + 1);

emit log_named_int("Total weight", totalWeight);

emit log_named_int("Deviation", deviation);

// Track maximum deviations

if (deviation > maxPositiveDeviation) {

maxPositiveDeviation = deviation;

}

if (deviation < maxNegativeDeviation) {

maxNegativeDeviation = deviation;

}

prevWeights = results;

}

emit log_string("=== Final Results ===");

emit log_named_int("Max positive deviation", maxPositiveDeviation);

emit log_named_int("Max negative deviation", maxNegativeDeviation);

// Different assertions based on test type

if (keccak256(bytes(testType)) == keccak256(bytes("Normal Conditions"))) {

assertLt(

abs(maxNegativeDeviation),

3, // Normal conditions should have very small deviation

"Normal conditions should have minimal negative deviation"

);

assertEq(

maxPositiveDeviation,

"Normal conditions should not have positive deviation"

);

} else {

// Extreme conditions have different expectations

assertTrue(

maxPositiveDeviation > 0,

"Extreme conditions should show positive deviation"

);

}

Test Results:

Normal Conditions (Small but consistent deviation):

=== Test Type:

Normal Conditions

===

Update: 1

Total weight: 1000000000000000000

Deviation: 0

Update: 2

Total weight: 1000000000000000000

Deviation: 0

Update: 3