// SPDX-License-Identifier: MIT pragma solidity ^0.8.20; interface IPool { error DepositsNotEqual(); error BelowMinimumK(); error FactoryAlreadySet(); error InsufficientLiquidity(); error InsufficientLiquidityMinted(); error InsufficientLiquidityBurned(); error InsufficientOutputAmount(); error InsufficientInputAmount(); error IsPaused(); error InvalidTo(); error K(); error NotEmergencyCouncil(); event Fees(address indexed sender, uint256 amount0, uint256 amount1); event Mint(address indexed sender, uint256 amount0, uint256 amount1); event Burn(address indexed sender, address indexed to, uint256 amount0, uint256 amount1); event Swap( address indexed sender, address indexed to, uint256 amount0In, uint256 amount1In, uint256 amount0Out, uint256 amount1Out ); event Sync(uint256 reserve0, uint256 reserve1); event Claim(address indexed sender, address indexed recipient, uint256 amount0, uint256 amount1); // Struct to capture time period obervations every 30 minutes, used for local oracles struct Observation { uint256 timestamp; uint256 reserve0Cumulative; uint256 reserve1Cumulative; } /// @notice Returns the decimal (dec), reserves (r), stable (st), and tokens (t) of token0 and token1 function metadata() external view returns (uint256 dec0, uint256 dec1, uint256 r0, uint256 r1, bool st, address t0, address t1); /// @notice Claim accumulated but unclaimed fees (claimable0 and claimable1) function claimFees() external returns (uint256, uint256); /// @notice Returns [token0, token1] function tokens() external view returns (address, address); /// @notice Address of token in the pool with the lower address value function token0() external view returns (address); /// @notice Address of token in the poool with the higher address value function token1() external view returns (address); /// @notice Address of linked PoolFees.sol function poolFees() external view returns (address); /// @notice Address of PoolFactory that created this contract function factory() external view returns (address); /// @notice Capture oracle reading every 30 minutes (1800 seconds) function periodSize() external view returns (uint256); /// @notice Amount of token0 in pool function reserve0() external view returns (uint256); /// @notice Amount of token1 in pool function reserve1() external view returns (uint256); /// @notice Timestamp of last update to pool function blockTimestampLast() external view returns (uint256); /// @notice Cumulative of reserve0 factoring in time elapsed function reserve0CumulativeLast() external view returns (uint256); /// @notice Cumulative of reserve1 factoring in time elapsed function reserve1CumulativeLast() external view returns (uint256); /// @notice Accumulated fees of token0 (global) function index0() external view returns (uint256); /// @notice Accumulated fees of token1 (global) function index1() external view returns (uint256); /// @notice Get an LP's relative index0 to index0 function supplyIndex0(address) external view returns (uint256); /// @notice Get an LP's relative index1 to index1 function supplyIndex1(address) external view returns (uint256); /// @notice Amount of unclaimed, but claimable tokens from fees of token0 for an LP function claimable0(address) external view returns (uint256); /// @notice Amount of unclaimed, but claimable tokens from fees of token1 for an LP function claimable1(address) external view returns (uint256); /// @notice Returns the value of K in the Pool, based on its reserves. function getK() external returns (uint256); /// @notice Set pool name /// Only callable by Voter.emergencyCouncil() /// @param __name String of new name function setName(string calldata __name) external; /// @notice Set pool symbol /// Only callable by Voter.emergencyCouncil() /// @param __symbol String of new symbol function setSymbol(string calldata __symbol) external; /// @notice Get the number of observations recorded function observationLength() external view returns (uint256); /// @notice Get the value of the most recent observation function lastObservation() external view returns (Observation memory); /// @notice True if pool is stable, false if volatile function stable() external view returns (bool); /// @notice Produces the cumulative price using counterfactuals to save gas and avoid a call to sync. function currentCumulativePrices() external view returns (uint256 reserve0Cumulative, uint256 reserve1Cumulative, uint256 blockTimestamp); /// @notice Provides twap price with user configured granularity, up to the full window size /// @param tokenIn . /// @param amountIn . /// @param granularity . /// @return amountOut . function quote(address tokenIn, uint256 amountIn, uint256 granularity) external view returns (uint256 amountOut); /// @notice Returns a memory set of TWAP prices /// Same as calling sample(tokenIn, amountIn, points, 1) /// @param tokenIn . /// @param amountIn . /// @param points Number of points to return /// @return Array of TWAP prices function prices(address tokenIn, uint256 amountIn, uint256 points) external view returns (uint256[] memory); /// @notice Same as prices with with an additional window argument. /// Window = 2 means 2 * 30min (or 1 hr) between observations /// @param tokenIn . /// @param amountIn . /// @param points . /// @param window . /// @return Array of TWAP prices function sample( address tokenIn, uint256 amountIn, uint256 points, uint256 window ) external view returns (uint256[] memory); /// @notice This low-level function should be called from a contract which performs important safety checks /// @param amount0Out Amount of token0 to send to `to` /// @param amount1Out Amount of token1 to send to `to` /// @param to Address to recieve the swapped output /// @param data Additional calldata for flashloans function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes calldata data) external; /// @notice This low-level function should be called from a contract which performs important safety checks /// standard uniswap v2 implementation /// @param to Address to receive token0 and token1 from burning the pool token /// @return amount0 Amount of token0 returned /// @return amount1 Amount of token1 returned function burn(address to) external returns (uint256 amount0, uint256 amount1); /// @notice This low-level function should be called by addLiquidity functions in Router.sol, which performs important safety checks /// standard uniswap v2 implementation /// @param to Address to receive the minted LP token /// @return liquidity Amount of LP token minted function mint(address to) external returns (uint256 liquidity); /// @notice Update reserves and, on the first call per block, price accumulators /// @return _reserve0 . /// @return _reserve1 . /// @return _blockTimestampLast . function getReserves() external view returns (uint256 _reserve0, uint256 _reserve1, uint256 _blockTimestampLast); /// @notice Get the amount of tokenOut given the amount of tokenIn /// @param amountIn Amount of token in /// @param tokenIn Address of token /// @return Amount out function getAmountOut(uint256 amountIn, address tokenIn) external view returns (uint256); /// @notice Force balances to match reserves /// @param to Address to receive any skimmed rewards function skim(address to) external; /// @notice Force reserves to match balances function sync() external; /// @notice Called on pool creation by PoolFactory /// @param _token0 Address of token0 /// @param _token1 Address of token1 /// @param _stable True if stable, false if volatile function initialize(address _token0, address _token1, bool _stable) external; }