Contract Address Details

pragma solidity ^0.8.13;

import { IPool } from "./interfaces/IPool.sol";
import { IPoolFactory } from "./interfaces/factories/IPoolFactory.sol";
import { IERC20, IERC20Metadata } from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import { Address } from "@openzeppelin/contracts/utils/Address.sol";
import { Clones } from "@openzeppelin/contracts/proxy/Clones.sol";

contract VaraOracle {
  address public immutable factoryV1;
  address public immutable factoryV2;
  bytes32 public immutable initcodeHashV1;
  uint8 constant maxHop = 10;

  constructor(address _factoryV1, address _factoryV2, bytes32 _initcodeHashV1) {
    factoryV1 = _factoryV1;
    factoryV2 = _factoryV2;
    initcodeHashV1 = _initcodeHashV1;
  }

  struct BalanceInfo {
    uint256 bal0;
    uint256 bal1;
    bool isStable;
    bool isV1;
  }

  struct Path {
    uint8 to_i;
    uint256 rate;
  }

  struct ReturnVal {
    bool mod;
    bool isStable;
    bool isV1;
    uint256 bal0;
    uint256 bal1;
  }

  struct Arrays {
    uint256[] rates;
    Path[] paths;
    int[] decimals;
    uint8[] visited;
  }

  struct IterVars {
    uint256 cur_rate;
    uint256 rate;
    uint8 from_i;
    uint8 to_i;
    bool seen;
  }

  function _get_bal(
    IERC20 from,
    IERC20 to,
    uint256 in_bal0
  ) internal view returns (ReturnVal memory out) {
    bool b0_v1;
    bool b2_v1;
    (uint256 b0, uint256 b1) = _getBalances(from, to, false, false);
    (uint256 temp0, uint256 temp1) = _getBalances(from, to, false, true);
    if (b0 < temp0) {
      (b0, b1) = (temp0, temp1);
      b0_v1 = true;
    }

    (uint256 b2, uint256 b3) = _getBalances(from, to, true, false);
    (temp0, temp1) = _getBalances(from, to, true, true);
    if (b2 < temp0) {
      (b2, b3) = (temp0, temp1);
      b2_v1 = true;
    }
    if (b0 > in_bal0 || b2 > in_bal0) {
      out.mod = true;
      if (b0 > b2) {
        (out.bal0, out.bal1, out.isStable, out.isV1) = (b0, b1, false, b0_v1);
      } else {
        (out.bal0, out.bal1, out.isStable, out.isV1) = (b2, b3, true, b2_v1);
      }
    }
  }

  function getManyRatesWithConnectors(
    uint8 src_len,
    IERC20Metadata[] memory connectors
  ) external view returns (uint256[] memory rates) {
    uint8 j_max = min(maxHop, uint8(connectors.length - src_len));
    Arrays memory arr;
    arr.rates = new uint256[](src_len);
    arr.paths = new Path[]((connectors.length - src_len));
    arr.decimals = new int[](connectors.length);

    // Caching decimals of all connector tokens
    {
      for (uint8 i = 0; i < connectors.length; i++) {
        arr.decimals[i] = int(uint(connectors[i].decimals()));
      }
    }

    // Iterating through srcTokens
    for (uint8 src = 0; src < src_len; src++) {
      IterVars memory vars;
      vars.cur_rate = 1;
      vars.from_i = src;
      arr.visited = new uint8[](connectors.length - src_len);
      // Counting hops
      for (uint8 j = 0; j < j_max; j++) {
        BalanceInfo memory balInfo = BalanceInfo(0, 0, false, false);
        vars.to_i = 0;
        // Going through all connectors
        for (uint8 i = src_len; i < connectors.length; i++) {
          // Check if the current connector has been used to prevent cycles
          vars.seen = false;
          {
            for (uint8 c = 0; c < j; c++) {
              if (arr.visited[c] == i) {
                vars.seen = true;
                break;
              }
            }
          }
          if (vars.seen) {
            continue;
          }
          ReturnVal memory out = _get_bal(connectors[vars.from_i], connectors[i], balInfo.bal0);
          if (out.mod) {
            balInfo.isStable = out.isStable;
            balInfo.bal0 = out.bal0;
            balInfo.bal1 = out.bal1;
            balInfo.isV1 = out.isV1;
            vars.to_i = i;
          }
        }

        if (vars.to_i == 0) {
          arr.rates[src] = 0;
          break;
        }

        if (balInfo.isStable) {
          vars.rate = _stableRate(
            connectors[vars.from_i],
            connectors[vars.to_i],
            arr.decimals[vars.from_i] - arr.decimals[vars.to_i],
            balInfo.isV1
          );
        } else {
          vars.rate = _volatileRate(
            balInfo.bal0,
            balInfo.bal1,
            arr.decimals[vars.from_i] - arr.decimals[vars.to_i]
          );
        }

        vars.cur_rate *= vars.rate;
        if (j > 0) {
          vars.cur_rate /= 1e18;
        }

        // If from_i points to a connector, cache swap rate for connectors[from_i] : connectors[to_i]
        if (vars.from_i >= src_len) {
          arr.paths[vars.from_i - src_len] = Path(vars.to_i, vars.rate);
        }
        // If from_i points to a srcToken, check if to_i is a connector which has already been expanded.
        // If so, directly follow the cached path to dstToken to get the final rate.
        else {
          if (arr.paths[vars.to_i - src_len].rate > 0) {
            while (true) {
              vars.cur_rate = (vars.cur_rate * arr.paths[vars.to_i - src_len].rate) / 1e18;
              vars.to_i = arr.paths[vars.to_i - src_len].to_i;
              if (vars.to_i == connectors.length - 1) {
                arr.rates[src] = vars.cur_rate;
                break;
              }
            }
          }
        }
        arr.visited[j] = vars.to_i;

        // Next token is dstToken, stop
        if (vars.to_i == connectors.length - 1) {
          arr.rates[src] = vars.cur_rate;
          break;
        }
        vars.from_i = vars.to_i;
      }
    }
    return arr.rates;
  }

  function _volatileRate(
    uint256 b0,
    uint256 b1,
    int dec_diff
  ) internal pure returns (uint256 rate) {
    // b0 has less 0s
    if (dec_diff < 0) {
      rate = (1e18 * b1) / (b0 * 10 ** (uint(-dec_diff)));
    }
    // b0 has more 0s
    else {
      rate = (1e18 * 10 ** (uint(dec_diff)) * b1) / b0;
    }
  }

  function _stableRate(
    IERC20Metadata t0,
    IERC20 t1,
    int dec_diff,
    bool isV1
  ) internal view returns (uint256 rate) {
    uint256 t0_dec = t0.decimals();
    address currentPair = _orderedPairFor(t0, t1, true, isV1);
    // newOut in t1
    uint256 newOut = IPool(currentPair).getAmountOut((10 ** t0_dec), address(t0));

    // t0 has less 0s
    if (dec_diff < 0) {
      rate = (1e18 * newOut) / (10 ** t0_dec * 10 ** (uint(-dec_diff)));
    }
    // t0 has more 0s
    else {
      rate = (1e18 * (newOut * 10 ** (uint(dec_diff)))) / (10 ** t0_dec);
    }
  }

  // calculates the CREATE2 address for a pair without making any external calls
  function _pairFor(
    IERC20 tokenA,
    IERC20 tokenB,
    bool stable,
    bool v1
  ) private view returns (address pair) {
    if (v1) {
      pair = address(
        uint160(
          uint256(
            keccak256(
              abi.encodePacked(
                hex"ff",
                factoryV1,
                keccak256(abi.encodePacked(tokenA, tokenB, stable)),
                initcodeHashV1
              )
            )
          )
        )
      );
    } else {
      bytes32 salt = keccak256(abi.encodePacked(tokenA, tokenB, stable));
      pair = Clones.predictDeterministicAddress(
        IPoolFactory(factoryV2).implementation(),
        salt,
        factoryV2
      );
    }
  }

  // returns the reserves of a pool if it exists, preserving the order of srcToken and dstToken
  function _getBalances(
    IERC20 srcToken,
    IERC20 dstToken,
    bool stable,
    bool v1
  ) internal view returns (uint256 srcBalance, uint256 dstBalance) {
    (IERC20 token0, IERC20 token1) = srcToken < dstToken
      ? (srcToken, dstToken)
      : (dstToken, srcToken);
    address pairAddress = _pairFor(token0, token1, stable, v1);

    // if the pair doesn't exist, return 0
    if (!Address.isContract(pairAddress)) {
      srcBalance = 0;
      dstBalance = 0;
    } else {
      (uint256 reserve0, uint256 reserve1, ) = IPool(pairAddress).getReserves();
      (srcBalance, dstBalance) = srcToken == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
    }
  }

  // fetch pair from tokens using correct order
  function _orderedPairFor(
    IERC20 tokenA,
    IERC20 tokenB,
    bool stable,
    bool isV1
  ) internal view returns (address pairAddress) {
    (IERC20 token0, IERC20 token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
    pairAddress = _pairFor(token0, token1, stable, isV1);
  }

  function min(uint8 a, uint8 b) internal pure returns (uint8) {
    return a < b ? a : b;
  }
}
        

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (proxy/Clones.sol)

pragma solidity ^0.8.0;

/**
 * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for
 * deploying minimal proxy contracts, also known as "clones".
 *
 * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies
 * > a minimal bytecode implementation that delegates all calls to a known, fixed address.
 *
 * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`
 * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the
 * deterministic method.
 *
 * _Available since v3.4._
 */
library Clones {
    /**
     * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.
     *
     * This function uses the create opcode, which should never revert.
     */
    function clone(address implementation) internal returns (address instance) {
        /// @solidity memory-safe-assembly
        assembly {
            // Cleans the upper 96 bits of the `implementation` word, then packs the first 3 bytes
            // of the `implementation` address with the bytecode before the address.
            mstore(0x00, or(shr(0xe8, shl(0x60, implementation)), 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000))
            // Packs the remaining 17 bytes of `implementation` with the bytecode after the address.
            mstore(0x20, or(shl(0x78, implementation), 0x5af43d82803e903d91602b57fd5bf3))
            instance := create(0, 0x09, 0x37)
        }
        require(instance != address(0), "ERC1167: create failed");
    }

    /**
     * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.
     *
     * This function uses the create2 opcode and a `salt` to deterministically deploy
     * the clone. Using the same `implementation` and `salt` multiple time will revert, since
     * the clones cannot be deployed twice at the same address.
     */
    function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {
        /// @solidity memory-safe-assembly
        assembly {
            // Cleans the upper 96 bits of the `implementation` word, then packs the first 3 bytes
            // of the `implementation` address with the bytecode before the address.
            mstore(0x00, or(shr(0xe8, shl(0x60, implementation)), 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000))
            // Packs the remaining 17 bytes of `implementation` with the bytecode after the address.
            mstore(0x20, or(shl(0x78, implementation), 0x5af43d82803e903d91602b57fd5bf3))
            instance := create2(0, 0x09, 0x37, salt)
        }
        require(instance != address(0), "ERC1167: create2 failed");
    }

    /**
     * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.
     */
    function predictDeterministicAddress(
        address implementation,
        bytes32 salt,
        address deployer
    ) internal pure returns (address predicted) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40)
            mstore(add(ptr, 0x38), deployer)
            mstore(add(ptr, 0x24), 0x5af43d82803e903d91602b57fd5bf3ff)
            mstore(add(ptr, 0x14), implementation)
            mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73)
            mstore(add(ptr, 0x58), salt)
            mstore(add(ptr, 0x78), keccak256(add(ptr, 0x0c), 0x37))
            predicted := keccak256(add(ptr, 0x43), 0x55)
        }
    }

    /**
     * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.
     */
    function predictDeterministicAddress(
        address implementation,
        bytes32 salt
    ) internal view returns (address predicted) {
        return predictDeterministicAddress(implementation, salt, address(this));
    }
}
          

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
          

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;

import "../IERC20.sol";

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}
          

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}
          

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

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);

    function metadata()
        external
        view
        returns (uint256 dec0, uint256 dec1, uint256 r0, uint256 r1, bool st, address t0, address t1);

    function claimFees() external returns (uint256, uint256);

    function tokens() external view returns (address, address);

    function token0() external view returns (address);

    function token1() external view returns (address);

    function stable() external view returns (bool);

    function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes calldata data) external;

    function burn(address to) external returns (uint256 amount0, uint256 amount1);

    function mint(address to) external returns (uint256 liquidity);

    function getReserves() external view returns (uint256 _reserve0, uint256 _reserve1, uint256 _blockTimestampLast);

    function getAmountOut(uint256, address) external view returns (uint256);

    function skim(address to) external;

    function initialize(address _token0, address _token1, bool _stable) external;
}
          

pragma solidity ^0.8.0;

interface IPoolFactory {
  event SetFeeManager(address feeManager);
  event SetPauser(address pauser);
  event SetPauseState(bool state);
  event SetVoter(address voter);
  event PoolCreated(
    address indexed token0,
    address indexed token1,
    bool indexed stable,
    address pool,
    uint256
  );
  event SetCustomFee(address indexed pool, uint256 fee);

  error FeeInvalid();
  error FeeTooHigh();
  error InvalidPool();
  error NotFeeManager();
  error NotPauser();
  error NotSinkConverter();
  error NotVoter();
  error PoolAlreadyExists();
  error SameAddress();
  error ZeroFee();
  error ZeroAddress();

  /// @notice returns the number of pools created from this factory
  function allPoolsLength() external view returns (uint256);

  /// @notice Is a valid pool created by this factory.
  /// @param .
  function isPool(address pool) external view returns (bool);

  /// @notice Support for Velodrome v1 which wraps around isPool(pool);
  /// @param .
  function isPair(address pool) external view returns (bool);

  /// @notice Return address of pool created by this factory
  /// @param tokenA .
  /// @param tokenB .
  /// @param stable True if stable, false if volatile
  function getPool(address tokenA, address tokenB, bool stable) external view returns (address);

  /// @notice Support for v3-style pools which wraps around getPool(tokenA,tokenB,stable)
  /// @dev fee is converted to stable boolean.
  /// @param tokenA .
  /// @param tokenB .
  /// @param fee  1 if stable, 0 if volatile, else returns address(0)
  function getPool(address tokenA, address tokenB, uint24 fee) external view returns (address);

  /// @notice Support for Velodrome v1 pools as a "pool" was previously referenced as "pair"
  /// @notice Wraps around getPool(tokenA,tokenB,stable)
  function getPair(address tokenA, address tokenB, bool stable) external view returns (address);

  /// @dev Only called once to set to Voter.sol - Voter does not have a function
  ///      to call this contract method, so once set it's immutable.
  ///      This also follows convention of setVoterAndDistributor() in VotingEscrow.sol
  /// @param _voter .
  function setVoter(address _voter) external;

  function setSinkConverter(address _sinkConvert, address _vara, address _varaV2) external;

  function setPauser(address _pauser) external;

  function setPauseState(bool _state) external;

  function setFeeManager(address _feeManager) external;

  /// @notice Set default fee for stable and volatile pools.
  /// @dev Throws if higher than maximum fee.
  ///      Throws if fee is zero.
  /// @param _stable Stable or volatile pool.
  /// @param _fee .
  function setFee(bool _stable, uint256 _fee) external;

  /// @notice Set overriding fee for a pool from the default
  /// @dev A custom fee of zero means the default fee will be used.
  function setCustomFee(address _pool, uint256 _fee) external;

  /// @notice Returns fee for a pool, as custom fees are possible.
  function getFee(address _pool, bool _stable) external view returns (uint256);

  /// @notice Create a pool given two tokens and if they're stable/volatile
  /// @dev token order does not matter
  /// @param tokenA .
  /// @param tokenB .
  /// @param stable .
  function createPool(address tokenA, address tokenB, bool stable) external returns (address pool);

  /// @notice Support for v3-style pools which wraps around createPool(tokena,tokenB,stable)
  /// @dev fee is converted to stable boolean
  /// @dev token order does not matter
  /// @param tokenA .
  /// @param tokenB .
  /// @param fee 1 if stable, 0 if volatile, else revert
  function createPool(address tokenA, address tokenB, uint24 fee) external returns (address pool);

  /// @notice Support for Velodrome v1 which wraps around createPool(tokenA,tokenB,stable)
  function createPair(address tokenA, address tokenB, bool stable) external returns (address pool);

  function isPaused() external view returns (bool);

  function vara() external view returns (address);

  function varaV2() external view returns (address);

  function voter() external view returns (address);

  function sinkConverter() external view returns (address);

  function implementation() external view returns (address);
}
          

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (proxy/Clones.sol)

pragma solidity ^0.8.0;

/**
 * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for
 * deploying minimal proxy contracts, also known as "clones".
 *
 * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies
 * > a minimal bytecode implementation that delegates all calls to a known, fixed address.
 *
 * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`
 * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the
 * deterministic method.
 *
 * _Available since v3.4._
 */
library Clones {
    /**
     * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.
     *
     * This function uses the create opcode, which should never revert.
     */
    function clone(address implementation) internal returns (address instance) {
        /// @solidity memory-safe-assembly
        assembly {
            // Cleans the upper 96 bits of the `implementation` word, then packs the first 3 bytes
            // of the `implementation` address with the bytecode before the address.
            mstore(0x00, or(shr(0xe8, shl(0x60, implementation)), 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000))
            // Packs the remaining 17 bytes of `implementation` with the bytecode after the address.
            mstore(0x20, or(shl(0x78, implementation), 0x5af43d82803e903d91602b57fd5bf3))
            instance := create(0, 0x09, 0x37)
        }
        require(instance != address(0), "ERC1167: create failed");
    }

    /**
     * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.
     *
     * This function uses the create2 opcode and a `salt` to deterministically deploy
     * the clone. Using the same `implementation` and `salt` multiple time will revert, since
     * the clones cannot be deployed twice at the same address.
     */
    function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {
        /// @solidity memory-safe-assembly
        assembly {
            // Cleans the upper 96 bits of the `implementation` word, then packs the first 3 bytes
            // of the `implementation` address with the bytecode before the address.
            mstore(0x00, or(shr(0xe8, shl(0x60, implementation)), 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000))
            // Packs the remaining 17 bytes of `implementation` with the bytecode after the address.
            mstore(0x20, or(shl(0x78, implementation), 0x5af43d82803e903d91602b57fd5bf3))
            instance := create2(0, 0x09, 0x37, salt)
        }
        require(instance != address(0), "ERC1167: create2 failed");
    }

    /**
     * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.
     */
    function predictDeterministicAddress(
        address implementation,
        bytes32 salt,
        address deployer
    ) internal pure returns (address predicted) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40)
            mstore(add(ptr, 0x38), deployer)
            mstore(add(ptr, 0x24), 0x5af43d82803e903d91602b57fd5bf3ff)
            mstore(add(ptr, 0x14), implementation)
            mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73)
            mstore(add(ptr, 0x58), salt)
            mstore(add(ptr, 0x78), keccak256(add(ptr, 0x0c), 0x37))
            predicted := keccak256(add(ptr, 0x43), 0x55)
        }
    }

    /**
     * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.
     */
    function predictDeterministicAddress(
        address implementation,
        bytes32 salt
    ) internal view returns (address predicted) {
        return predictDeterministicAddress(implementation, salt, address(this));
    }
}
          

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
          

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;

import "../IERC20.sol";

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}
          

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}
          

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

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);

    function metadata()
        external
        view
        returns (uint256 dec0, uint256 dec1, uint256 r0, uint256 r1, bool st, address t0, address t1);

    function claimFees() external returns (uint256, uint256);

    function tokens() external view returns (address, address);

    function token0() external view returns (address);

    function token1() external view returns (address);

    function stable() external view returns (bool);

    function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes calldata data) external;

    function burn(address to) external returns (uint256 amount0, uint256 amount1);

    function mint(address to) external returns (uint256 liquidity);

    function getReserves() external view returns (uint256 _reserve0, uint256 _reserve1, uint256 _blockTimestampLast);

    function getAmountOut(uint256, address) external view returns (uint256);

    function skim(address to) external;

    function initialize(address _token0, address _token1, bool _stable) external;
}
          

pragma solidity ^0.8.0;

interface IPoolFactory {
  event SetFeeManager(address feeManager);
  event SetPauser(address pauser);
  event SetPauseState(bool state);
  event SetVoter(address voter);
  event PoolCreated(
    address indexed token0,
    address indexed token1,
    bool indexed stable,
    address pool,
    uint256
  );
  event SetCustomFee(address indexed pool, uint256 fee);

  error FeeInvalid();
  error FeeTooHigh();
  error InvalidPool();
  error NotFeeManager();
  error NotPauser();
  error NotSinkConverter();
  error NotVoter();
  error PoolAlreadyExists();
  error SameAddress();
  error ZeroFee();
  error ZeroAddress();

  /// @notice returns the number of pools created from this factory
  function allPoolsLength() external view returns (uint256);

  /// @notice Is a valid pool created by this factory.
  /// @param .
  function isPool(address pool) external view returns (bool);

  /// @notice Support for Velodrome v1 which wraps around isPool(pool);
  /// @param .
  function isPair(address pool) external view returns (bool);

  /// @notice Return address of pool created by this factory
  /// @param tokenA .
  /// @param tokenB .
  /// @param stable True if stable, false if volatile
  function getPool(address tokenA, address tokenB, bool stable) external view returns (address);

  /// @notice Support for v3-style pools which wraps around getPool(tokenA,tokenB,stable)
  /// @dev fee is converted to stable boolean.
  /// @param tokenA .
  /// @param tokenB .
  /// @param fee  1 if stable, 0 if volatile, else returns address(0)
  function getPool(address tokenA, address tokenB, uint24 fee) external view returns (address);

  /// @notice Support for Velodrome v1 pools as a "pool" was previously referenced as "pair"
  /// @notice Wraps around getPool(tokenA,tokenB,stable)
  function getPair(address tokenA, address tokenB, bool stable) external view returns (address);

  /// @dev Only called once to set to Voter.sol - Voter does not have a function
  ///      to call this contract method, so once set it's immutable.
  ///      This also follows convention of setVoterAndDistributor() in VotingEscrow.sol
  /// @param _voter .
  function setVoter(address _voter) external;

  function setSinkConverter(address _sinkConvert, address _vara, address _varaV2) external;

  function setPauser(address _pauser) external;

  function setPauseState(bool _state) external;

  function setFeeManager(address _feeManager) external;

  /// @notice Set default fee for stable and volatile pools.
  /// @dev Throws if higher than maximum fee.
  ///      Throws if fee is zero.
  /// @param _stable Stable or volatile pool.
  /// @param _fee .
  function setFee(bool _stable, uint256 _fee) external;

  /// @notice Set overriding fee for a pool from the default
  /// @dev A custom fee of zero means the default fee will be used.
  function setCustomFee(address _pool, uint256 _fee) external;

  /// @notice Returns fee for a pool, as custom fees are possible.
  function getFee(address _pool, bool _stable) external view returns (uint256);

  /// @notice Create a pool given two tokens and if they're stable/volatile
  /// @dev token order does not matter
  /// @param tokenA .
  /// @param tokenB .
  /// @param stable .
  function createPool(address tokenA, address tokenB, bool stable) external returns (address pool);

  /// @notice Support for v3-style pools which wraps around createPool(tokena,tokenB,stable)
  /// @dev fee is converted to stable boolean
  /// @dev token order does not matter
  /// @param tokenA .
  /// @param tokenB .
  /// @param fee 1 if stable, 0 if volatile, else revert
  function createPool(address tokenA, address tokenB, uint24 fee) external returns (address pool);

  /// @notice Support for Velodrome v1 which wraps around createPool(tokenA,tokenB,stable)
  function createPair(address tokenA, address tokenB, bool stable) external returns (address pool);

  function isPaused() external view returns (bool);

  function vara() external view returns (address);

  function varaV2() external view returns (address);

  function voter() external view returns (address);

  function sinkConverter() external view returns (address);

  function implementation() external view returns (address);
}