[WIP] Add Uni V3, stCelo, rstCelo, Algebra

contracts/interfaces/algebra/IAlgebraFactory.sol

@@ -0,0 +1,135 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.5.0;
+
+/**
+ * @title The interface for the Algebra Factory
+ * @dev Credit to Uniswap Labs under GPL-2.0-or-later license:
+ * https://github.com/Uniswap/v3-core/tree/main/contracts/interfaces
+ */
+interface IAlgebraFactory {
+  /**
+   *  @notice Emitted when the owner of the factory is changed
+   *  @param newOwner The owner after the owner was changed
+   */
+  event Owner(address indexed newOwner);
+
+  /**
+   *  @notice Emitted when the vault address is changed
+   *  @param newVaultAddress The vault address after the address was changed
+   */
+  event VaultAddress(address indexed newVaultAddress);
+
+  /**
+   *  @notice Emitted when a pool is created
+   *  @param token0 The first token of the pool by address sort order
+   *  @param token1 The second token of the pool by address sort order
+   *  @param pool The address of the created pool
+   */
+  event Pool(address indexed token0, address indexed token1, address pool);
+
+  /**
+   *  @notice Emitted when the farming address is changed
+   *  @param newFarmingAddress The farming address after the address was changed
+   */
+  event FarmingAddress(address indexed newFarmingAddress);
+
+  event FeeConfiguration(
+    uint16 alpha1,
+    uint16 alpha2,
+    uint32 beta1,
+    uint32 beta2,
+    uint16 gamma1,
+    uint16 gamma2,
+    uint32 volumeBeta,
+    uint16 volumeGamma,
+    uint16 baseFee
+  );
+
+  /**
+   *  @notice Returns the current owner of the factory
+   *  @dev Can be changed by the current owner via setOwner
+   *  @return The address of the factory owner
+   */
+  function owner() external view returns (address);
+
+  /**
+   *  @notice Returns the current poolDeployerAddress
+   *  @return The address of the poolDeployer
+   */
+  function poolDeployer() external view returns (address);
+
+  /**
+   * @dev Is retrieved from the pools to restrict calling
+   * certain functions not by a tokenomics contract
+   * @return The tokenomics contract address
+   */
+  function farmingAddress() external view returns (address);
+
+  function vaultAddress() external view returns (address);
+
+  /**
+   *  @notice Returns the pool address for a given pair of tokens and a fee, or address 0 if it does not exist
+   *  @dev tokenA and tokenB may be passed in either token0/token1 or token1/token0 order
+   *  @param tokenA The contract address of either token0 or token1
+   *  @param tokenB The contract address of the other token
+   *  @return pool The pool address
+   */
+  function poolByPair(address tokenA, address tokenB) external view returns (address pool);
+
+  /**
+   *  @notice Creates a pool for the given two tokens and fee
+   *  @param tokenA One of the two tokens in the desired pool
+   *  @param tokenB The other of the two tokens in the desired pool
+   *  @dev tokenA and tokenB may be passed in either order: token0/token1 or token1/token0. tickSpacing is retrieved
+   *  from the fee. The call will revert if the pool already exists, the fee is invalid, or the token arguments
+   *  are invalid.
+   *  @return pool The address of the newly created pool
+   */
+  function createPool(address tokenA, address tokenB) external returns (address pool);
+
+  /**
+   *  @notice Updates the owner of the factory
+   *  @dev Must be called by the current owner
+   *  @param _owner The new owner of the factory
+   */
+  function setOwner(address _owner) external;
+
+  /**
+   * @dev updates tokenomics address on the factory
+   * @param _farmingAddress The new tokenomics contract address
+   */
+  function setFarmingAddress(address _farmingAddress) external;
+
+  /**
+   * @dev updates vault address on the factory
+   * @param _vaultAddress The new vault contract address
+   */
+  function setVaultAddress(address _vaultAddress) external;
+
+  /**
+   * @notice Changes initial fee configuration for new pools
+   * @dev changes coefficients for sigmoids: α / (1 + e^( (β-x) / γ))
+   * alpha1 + alpha2 + baseFee (max possible fee) must be <= type(uint16).max
+   * gammas must be > 0
+   * @param alpha1 max value of the first sigmoid
+   * @param alpha2 max value of the second sigmoid
+   * @param beta1 shift along the x-axis for the first sigmoid
+   * @param beta2 shift along the x-axis for the second sigmoid
+   * @param gamma1 horizontal stretch factor for the first sigmoid
+   * @param gamma2 horizontal stretch factor for the second sigmoid
+   * @param volumeBeta shift along the x-axis for the outer volume-sigmoid
+   * @param volumeGamma horizontal stretch factor the outer volume-sigmoid
+   * @param baseFee minimum possible fee
+   */
+  function setBaseFeeConfiguration(
+    uint16 alpha1,
+    uint16 alpha2,
+    uint32 beta1,
+    uint32 beta2,
+    uint16 gamma1,
+    uint16 gamma2,
+    uint32 volumeBeta,
+    uint16 volumeGamma,
+    uint16 baseFee
+  ) external;
+}

contracts/interfaces/algebra/IAlgebraPool.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.5.0;
+
+import './pool/IAlgebraPoolImmutables.sol';
+import './pool/IAlgebraPoolState.sol';
+import './pool/IAlgebraPoolDerivedState.sol';
+import './pool/IAlgebraPoolActions.sol';
+import './pool/IAlgebraPoolPermissionedActions.sol';
+import './pool/IAlgebraPoolEvents.sol';
+
+/**
+ * @title The interface for a Algebra Pool
+ * @dev The pool interface is broken up into many smaller pieces.
+ * Credit to Uniswap Labs under GPL-2.0-or-later license:
+ * https://github.com/Uniswap/v3-core/tree/main/contracts/interfaces
+ */
+interface IAlgebraPool is
+  IAlgebraPoolImmutables,
+  IAlgebraPoolState,
+  IAlgebraPoolDerivedState,
+  IAlgebraPoolActions,
+  IAlgebraPoolPermissionedActions,
+  IAlgebraPoolEvents
+{
+  // used only for combining interfaces
+}

contracts/interfaces/algebra/IAlgebraPoolDeployer.sol

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.5.0;
+
+/**
+ * @title An interface for a contract that is capable of deploying Algebra Pools
+ * @notice A contract that constructs a pool must implement this to pass arguments to the pool
+ * @dev This is used to avoid having constructor arguments in the pool contract, which results in the init code hash
+ * of the pool being constant allowing the CREATE2 address of the pool to be cheaply computed on-chain.
+ * Credit to Uniswap Labs under GPL-2.0-or-later license:
+ * https://github.com/Uniswap/v3-core/tree/main/contracts/interfaces
+ */
+interface IAlgebraPoolDeployer {
+  /**
+   *  @notice Emitted when the factory address is changed
+   *  @param factory The factory address after the address was changed
+   */
+  event Factory(address indexed factory);
+
+  /**
+   * @notice Get the parameters to be used in constructing the pool, set transiently during pool creation.
+   * @dev Called by the pool constructor to fetch the parameters of the pool
+   * Returns dataStorage The pools associated dataStorage
+   * Returns factory The factory address
+   * Returns token0 The first token of the pool by address sort order
+   * Returns token1 The second token of the pool by address sort order
+   */
+  function parameters()
+    external
+    view
+    returns (
+      address dataStorage,
+      address factory,
+      address token0,
+      address token1
+    );
+
+  /**
+   * @dev Deploys a pool with the given parameters by transiently setting the parameters storage slot and then
+   * clearing it after deploying the pool.
+   * @param dataStorage The pools associated dataStorage
+   * @param factory The contract address of the Algebra factory
+   * @param token0 The first token of the pool by address sort order
+   * @param token1 The second token of the pool by address sort order
+   * @return pool The deployed pool's address
+   */
+  function deploy(
+    address dataStorage,
+    address factory,
+    address token0,
+    address token1
+  ) external returns (address pool);
+
+  /**
+   * @dev Sets the factory address to the poolDeployer for permissioned actions
+   * @param factory The address of the Algebra factory
+   */
+  function setFactory(address factory) external;
+}

contracts/interfaces/algebra/IAlgebraVirtualPool.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.5.0;
+
+interface IAlgebraVirtualPool {
+  enum Status {
+    NOT_EXIST,
+    ACTIVE,
+    NOT_STARTED
+  }
+
+  /**
+   * @dev This function is called by the main pool when an initialized tick is crossed there.
+   * If the tick is also initialized in a virtual pool it should be crossed too
+   * @param nextTick The crossed tick
+   * @param zeroToOne The direction
+   */
+  function cross(int24 nextTick, bool zeroToOne) external;
+
+  /**
+   * @dev This function is called from the main pool before every swap To increase seconds per liquidity
+   * cumulative considering previous timestamp and liquidity. The liquidity is stored in a virtual pool
+   * @param currentTimestamp The timestamp of the current swap
+   * @return Status The status of virtual pool
+   */
+  function increaseCumulative(uint32 currentTimestamp) external returns (Status);
+}

contracts/interfaces/algebra/callback/IAlgebraFlashCallback.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.5.0;
+
+/**
+ *  @title Callback for IAlgebraPoolActions#flash
+ *  @notice Any contract that calls IAlgebraPoolActions#flash must implement this interface
+ *  @dev Credit to Uniswap Labs under GPL-2.0-or-later license:
+ *  https://github.com/Uniswap/v3-core/tree/main/contracts/interfaces
+ */
+interface IAlgebraFlashCallback {
+  /**
+   *  @notice Called to `msg.sender` after transferring to the recipient from IAlgebraPool#flash.
+   *  @dev In the implementation you must repay the pool the tokens sent by flash plus the computed fee amounts.
+   *  The caller of this method must be checked to be a AlgebraPool deployed by the canonical AlgebraFactory.
+   *  @param fee0 The fee amount in token0 due to the pool by the end of the flash
+   *  @param fee1 The fee amount in token1 due to the pool by the end of the flash
+   *  @param data Any data passed through by the caller via the IAlgebraPoolActions#flash call
+   */
+  function algebraFlashCallback(
+    uint256 fee0,
+    uint256 fee1,
+    bytes calldata data
+  ) external;
+}

contracts/interfaces/algebra/callback/IAlgebraMintCallback.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.5.0;
+
+/// @title Callback for IAlgebraPoolActions#mint
+/// @notice Any contract that calls IAlgebraPoolActions#mint must implement this interface
+/// @dev Credit to Uniswap Labs under GPL-2.0-or-later license:
+/// https://github.com/Uniswap/v3-core/tree/main/contracts/interfaces
+interface IAlgebraMintCallback {
+  /// @notice Called to `msg.sender` after minting liquidity to a position from IAlgebraPool#mint.
+  /// @dev In the implementation you must pay the pool tokens owed for the minted liquidity.
+  /// The caller of this method must be checked to be a AlgebraPool deployed by the canonical AlgebraFactory.
+  /// @param amount0Owed The amount of token0 due to the pool for the minted liquidity
+  /// @param amount1Owed The amount of token1 due to the pool for the minted liquidity
+  /// @param data Any data passed through by the caller via the IAlgebraPoolActions#mint call
+  function algebraMintCallback(
+    uint256 amount0Owed,
+    uint256 amount1Owed,
+    bytes calldata data
+  ) external;
+}

contracts/interfaces/algebra/callback/IAlgebraSwapCallback.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.5.0;
+
+/// @title Callback for IAlgebraPoolActions#swap
+/// @notice Any contract that calls IAlgebraPoolActions#swap must implement this interface
+/// @dev Credit to Uniswap Labs under GPL-2.0-or-later license:
+/// https://github.com/Uniswap/v3-core/tree/main/contracts/interfaces
+interface IAlgebraSwapCallback {
+  /// @notice Called to `msg.sender` after executing a swap via IAlgebraPool#swap.
+  /// @dev In the implementation you must pay the pool tokens owed for the swap.
+  /// The caller of this method must be checked to be a AlgebraPool deployed by the canonical AlgebraFactory.
+  /// amount0Delta and amount1Delta can both be 0 if no tokens were swapped.
+  /// @param amount0Delta The amount of token0 that was sent (negative) or must be received (positive) by the pool by
+  /// the end of the swap. If positive, the callback must send that amount of token0 to the pool.
+  /// @param amount1Delta The amount of token1 that was sent (negative) or must be received (positive) by the pool by
+  /// the end of the swap. If positive, the callback must send that amount of token1 to the pool.
+  /// @param data Any data passed through by the caller via the IAlgebraPoolActions#swap call
+  function algebraSwapCallback(
+    int256 amount0Delta,
+    int256 amount1Delta,
+    bytes calldata data
+  ) external;
+}