Alm plugin

src/plugin/contracts/AlgebraBasePluginALM.sol

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity =0.8.20;
+
+import '@cryptoalgebra/integral-core/contracts/libraries/Plugins.sol';
+
+import '@cryptoalgebra/integral-core/contracts/interfaces/plugin/IAlgebraPlugin.sol';
+
+import './plugins/DynamicFeePlugin.sol';
+import './plugins/AlmPlugin.sol';
+import './plugins/SlidingFeePlugin.sol';
+import './plugins/VolatilityOraclePlugin.sol';
+
+/// @title Algebra Integral 1.2.1 adaptive fee plugin
+contract AlgebraBasePluginALM is AlmPlugin, DynamicFeePlugin, VolatilityOraclePlugin {
+  using Plugins for uint8;
+
+  /// @inheritdoc IAlgebraPlugin
+  uint8 public constant override defaultPluginConfig =
+    uint8(Plugins.AFTER_INIT_FLAG | Plugins.BEFORE_SWAP_FLAG | Plugins.AFTER_SWAP_FLAG | Plugins.DYNAMIC_FEE);
+
+  constructor(
+    address _pool,
+    address _factory,
+    address _pluginFactory,
+    AlgebraFeeConfiguration memory _config
+  ) AlgebraBasePlugin(_pool, _factory, _pluginFactory) DynamicFeePlugin(_config) {}
+
+  // ###### HOOKS ######
+
+  function beforeInitialize(address, uint160) external override onlyPool returns (bytes4) {
+    _updatePluginConfigInPool(defaultPluginConfig);
+    return IAlgebraPlugin.beforeInitialize.selector;
+  }
+
+  function afterInitialize(address, uint160, int24 tick) external override onlyPool returns (bytes4) {
+    _initialize_TWAP(tick);
+    return IAlgebraPlugin.afterInitialize.selector;
+  }
+
+  /// @dev unused
+  function beforeModifyPosition(address, address, int24, int24, int128, bytes calldata) external override onlyPool returns (bytes4, uint24) {
+    _updatePluginConfigInPool(defaultPluginConfig); // should not be called, reset config
+    return (IAlgebraPlugin.beforeModifyPosition.selector, 0);
+  }
+
+  /// @dev unused
+  function afterModifyPosition(address, address, int24, int24, int128, uint256, uint256, bytes calldata) external override onlyPool returns (bytes4) {
+    _updatePluginConfigInPool(defaultPluginConfig); // should not be called, reset config
+    return IAlgebraPlugin.afterModifyPosition.selector;
+  }
+
+  function beforeSwap(address, address, bool, int256, uint160, bool, bytes calldata) external override onlyPool returns (bytes4, uint24, uint24) {
+    _writeTimepoint();
+    uint88 volatilityAverage = _getAverageVolatilityLast();
+    uint24 fee = _getCurrentFee(volatilityAverage);
+    return (IAlgebraPlugin.beforeSwap.selector, fee, 0);
+  }
+
+  function afterSwap(address, address, bool, int256, uint160, int256, int256, bytes calldata) external override onlyPool returns (bytes4) {
+    ( , int24 currentTick, , ) = _getPoolState();
+    uint32 lastBlockTimestamp = _getLastBlockTimestamp();
+
+    bool failedToObtainTWAP;
+    int24 slowTwapTick;
+    int24 fastTwapTick;
+
+    if (_ableToGetTimepoints(slowTwapPeriod)) {
+      slowTwapTick = _getTwapTick(slowTwapPeriod);
+      fastTwapTick = _getTwapTick(fastTwapPeriod);
+    } else {
+      failedToObtainTWAP = true;
+    }
+
+	_obtainTWAPAndRebalance(currentTick, slowTwapTick, fastTwapTick, lastBlockTimestamp, failedToObtainTWAP);
+
+    return IAlgebraPlugin.afterSwap.selector;
+  }
+
+  /// @dev unused
+  function beforeFlash(address, address, uint256, uint256, bytes calldata) external override onlyPool returns (bytes4) {
+    _updatePluginConfigInPool(defaultPluginConfig); // should not be called, reset config
+    return IAlgebraPlugin.beforeFlash.selector;
+  }
+
+  /// @dev unused
+  function afterFlash(address, address, uint256, uint256, uint256, uint256, bytes calldata) external override onlyPool returns (bytes4) {
+    _updatePluginConfigInPool(defaultPluginConfig); // should not be called, reset config
+    return IAlgebraPlugin.afterFlash.selector;
+  }
+
+  function getCurrentFee() external view override returns (uint16 fee) {
+    uint88 volatilityAverage = _getAverageVolatilityLast();
+    fee = _getCurrentFee(volatilityAverage);
+  }
+}

src/plugin/contracts/AlgebraBasePluginALMFactory.sol

@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity =0.8.20;
+
+import './interfaces/IBasePluginV1Factory.sol';
+import './libraries/AdaptiveFee.sol';
+import './AlgebraBasePluginV1.sol';
+
+/// @title Algebra Integral 1.2.1 default plugin factory
+/// @notice This contract creates Algebra adaptive fee plugins for Algebra liquidity pools
+/// @dev This plugin factory can only be used for Algebra base pools
+contract AlgebraBasePluginALMFactory is IBasePluginV1Factory {
+  /// @inheritdoc IBasePluginV1Factory
+  bytes32 public constant override ALGEBRA_BASE_PLUGIN_FACTORY_ADMINISTRATOR = keccak256('ALGEBRA_BASE_PLUGIN_FACTORY_ADMINISTRATOR');
+
+  /// @inheritdoc IBasePluginV1Factory
+  address public immutable override algebraFactory;
+
+  /// @inheritdoc IBasePluginV1Factory
+  AlgebraFeeConfiguration public override defaultFeeConfiguration; // values of constants for sigmoids in fee calculation formula
+
+  /// @inheritdoc IBasePluginV1Factory
+  address public override farmingAddress;
+
+  /// @inheritdoc IBasePluginV1Factory
+  mapping(address poolAddress => address pluginAddress) public override pluginByPool;
+
+  modifier onlyAdministrator() {
+    require(IAlgebraFactory(algebraFactory).hasRoleOrOwner(ALGEBRA_BASE_PLUGIN_FACTORY_ADMINISTRATOR, msg.sender), 'Only administrator');
+    _;
+  }
+
+  constructor(address _algebraFactory) {
+    algebraFactory = _algebraFactory;
+    defaultFeeConfiguration = AdaptiveFee.initialFeeConfiguration();
+    emit DefaultFeeConfiguration(defaultFeeConfiguration);
+  }
+
+  /// @inheritdoc IAlgebraPluginFactory
+  function beforeCreatePoolHook(address pool, address, address, address, address, bytes calldata) external override returns (address) {
+    require(msg.sender == algebraFactory);
+    return _createPlugin(pool);
+  }
+
+  /// @inheritdoc IAlgebraPluginFactory
+  function afterCreatePoolHook(address, address, address) external view override {
+    require(msg.sender == algebraFactory);
+  }
+
+  /// @inheritdoc IBasePluginV1Factory
+  function createPluginForExistingPool(address token0, address token1) external override returns (address) {
+    IAlgebraFactory factory = IAlgebraFactory(algebraFactory);
+    require(factory.hasRoleOrOwner(factory.POOLS_ADMINISTRATOR_ROLE(), msg.sender));
+
+    address pool = factory.poolByPair(token0, token1);
+    require(pool != address(0), 'Pool not exist');
+
+    return _createPlugin(pool);
+  }
+
+  function _createPlugin(address pool) internal returns (address) {
+    require(pluginByPool[pool] == address(0), 'Already created');
+    IDynamicFeeManager volatilityOracle = new AlgebraBasePluginV1(pool, algebraFactory, address(this), defaultFeeConfiguration);
+    pluginByPool[pool] = address(volatilityOracle);
+    return address(volatilityOracle);
+  }
+
+  /// @inheritdoc IBasePluginV1Factory
+  function setDefaultFeeConfiguration(AlgebraFeeConfiguration calldata newConfig) external override onlyAdministrator {
+    AdaptiveFee.validateFeeConfiguration(newConfig);
+    defaultFeeConfiguration = newConfig;
+    emit DefaultFeeConfiguration(newConfig);
+  }
+
+  /// @inheritdoc IBasePluginV1Factory
+  function setFarmingAddress(address newFarmingAddress) external override onlyAdministrator {
+    require(farmingAddress != newFarmingAddress);
+    farmingAddress = newFarmingAddress;
+    emit FarmingAddress(newFarmingAddress);
+  }
+}