OverridableFeeManager

The OverridableFeeManager routes fee computation to different managers based on the calling pool.

Source: contracts/periphery/OverridableFeeManager.sol

Overview

OverridableFeeManager allows:

• Per-pool fee manager customization

• Default fee manager for pools without overrides

• Runtime configuration changes

State Variables

defaultFeeManager

address public defaultFeeManager;

The fee manager used when no override is set for a pool.

feeManagerOverride

mapping(address => address) public feeManagerOverride;

Pool-specific fee manager overrides.

Constructor

constructor(address _defaultFeeManager)

Parameter	Description
_defaultFeeManager	Default fee manager for pools without overrides

Example:

OverridableFeeManager manager = new OverridableFeeManager(
    tieredDiscount.address  // Default to tiered discounts
);

Functions

computeFee

function computeFee(uint24 fee) external override nonReentrant returns (uint24)

Routes fee computation to the appropriate manager.

Modifiers: nonReentrant - Prevents reentrancy attacks via malicious fee managers

Logic:

function computeFee(uint24 fee) external override nonReentrant returns (uint24) {
    if (feeManagerOverride[msg.sender] != address(0)) {
        return IFeeManager(feeManagerOverride[msg.sender]).computeFee(fee);
    }
    return IFeeManager(defaultFeeManager).computeFee(fee);
}

Flow:

Pool calls computeFee(fee)
    │
    ▼
Override exists for pool?
    │
    ├─ YES → Use override manager
    │
    └─ NO → Use default manager
    │
    ▼
Return computed fee

---

setFeeManagerOverride

function setFeeManagerOverride(address pool, address newFeeManager) external onlyOwner

Sets a fee manager override for a specific pool.

Access Control: Owner only

Parameters:

Name	Type	Description
pool	address	Pool address to override
newFeeManager	address	Fee manager for this pool (address(0) to remove override)

Example:

// Set override for stable pool (no discounts)
await overridable.setFeeManagerOverride(stablePool.address, noDiscount.address);

// Remove override (revert to default)
await overridable.setFeeManagerOverride(stablePool.address, ethers.constants.AddressZero);

---

setDefaultFeeManager

function setDefaultFeeManager(address _defaultFeeManager) external onlyOwner

Updates the default fee manager.

Access Control: Owner only

Parameters:

Name	Type	Description
_defaultFeeManager	address	New default fee manager

Usage Patterns

Different Managers for Different Pool Types

// Deploy fee managers
const tieredDiscount = await TieredDiscount.deploy(...);
const noDiscount = await NoDiscount.deploy();
const volumeDiscount = await VolumeDiscount.deploy(...);

// Deploy OverridableFeeManager with tiered as default
const overridable = await OverridableFeeManager.deploy(tieredDiscount.address);

// Create pools with the overridable manager
const volatilePool = await factory.createPool(
    WVC, USDT, 3000, 60, overridable.address
);

const stablePool = await factory.createPool(
    USDT, TOKEN_C, 100, 1, overridable.address
);

const whalePool = await factory.createPool(
    WVC, TOKEN_D, 500, 10, overridable.address
);

// Configure overrides
await overridable.setFeeManagerOverride(stablePool, noDiscount.address);  // No discount for stables
await overridable.setFeeManagerOverride(whalePool, volumeDiscount.address);  // Volume-based for whales

// Result:
// - volatilePool → tieredDiscount (default)
// - stablePool → noDiscount
// - whalePool → volumeDiscount

Gradual Rollout

// Start with no discounts everywhere
const overridable = await OverridableFeeManager.deploy(noDiscount.address);

// ... create pools ...

// Later, enable discounts for specific pools
await overridable.setFeeManagerOverride(popularPool, tieredDiscount.address);

// Eventually, make discounts the default
await overridable.setDefaultFeeManager(tieredDiscount.address);

Emergency Disable

// If TieredDiscount has a bug, quickly disable
await overridable.setDefaultFeeManager(noDiscount.address);

// Or disable for specific pool
await overridable.setFeeManagerOverride(affectedPool, noDiscount.address);

Configuration Examples

Stable Pairs No Discount

Default: TieredDiscount
Overrides:
  - USDT/STABLE_A → NoDiscount
  - USDT/STABLE_B → NoDiscount

Premium Pools

Default: NoDiscount
Overrides:
  - WVC/USDT (main) → TieredDiscount
  - TOKEN_A/WVC (main) → TieredDiscount

Test vs Production

Default: NoDiscount (conservative)
Overrides:
  - TestPool → TieredDiscount (testing new logic)

Querying Configuration

// Check default manager
const defaultManager = await overridable.defaultFeeManager();
console.log('Default:', defaultManager);

// Check specific pool override
const poolOverride = await overridable.feeManagerOverride(poolAddress);
if (poolOverride === ethers.constants.AddressZero) {
    console.log('Pool uses default manager');
} else {
    console.log('Pool override:', poolOverride);
}

// Determine actual manager for a pool
async function getPoolFeeManager(pool) {
    const override = await overridable.feeManagerOverride(pool);
    return override === ethers.constants.AddressZero
        ? await overridable.defaultFeeManager()
        : override;
}

Gas Considerations

OverridableFeeManager adds one extra external call:

Without Override:
  Pool → OverridableFeeManager → DefaultManager.computeFee()

With Override:
  Pool → OverridableFeeManager → OverrideManager.computeFee()

Approximate Additional Gas: ~2,600 (SLOAD for mapping lookup)

Security Considerations

Reentrancy Protection

The contract inherits from ReentrancyGuard and uses the nonReentrant modifier on computeFee() to prevent reentrancy attacks via malicious fee managers.

Manager Validation

The contract doesn't validate that override addresses implement IFeeManager:

// Owner should verify before setting
require(
    IFeeManager(feeManager).computeFee(1000) > 0,
    "Invalid fee manager"
);
await overridable.setFeeManagerOverride(pool, feeManager);

Access Control

Only owner can modify configuration:

• Consider using multisig

• Add timelock for production deployments

• Log all configuration changes

Default Manager Trust

All pools without overrides use the default:

• Ensure default manager is well-tested

• Be cautious changing default on live systems

Inheritance

contract OverridableFeeManager is IFeeManager, Ownable, ReentrancyGuard

The contract inherits:

• IFeeManager - Fee computation interface

• Ownable - Access control for configuration

• ReentrancyGuard - Reentrancy protection

Related

• IFeeManager Interface

• TieredDiscount

• Controller