Cryo Explorer Ethereum Mainnet

pragma solidity >=0.6.6;

import './PublicPresale.sol';
import './xCAVO.sol';
import './EXCV.sol';
import './TeamDistribution.sol';
import './PrivatePresale.sol';

contract CAVO is PublicPresale, PrivatePresale, TeamDistribution {
    
    uint private constant PUBLIC_PRESALE_DURATION_IN_BLOCKS = 7 * 6500;
    uint32 private constant PRESALE_VESTING_PERIOD_IN_BLOCKS = 7 * 6500;
    
    uint private constant PRIVATE_PRESALE_DISTRIBUTED_CAVO_IN_WEI = 1460.769 ether;
    
    address private constant PUBLIC_PRESALE_OWNER = 0xAb96C12881A2E9Ffa6706Ae68bCFA4EcD1A8bf21;

    address[] private teamAddresses = [
        0x381657fdE9bfE7558837757aC54249Ef748CACB7, // A.M.
        0x564569020c298D2487445CCa5C5ef3eD8cd408A3, // Y.O.
        0xDfe2abc3d395a87a1476f5B707E77f5F23B1d88b, // A.
        0x8CF3329E378c6196F35f5cB7eea5040873f8AC8C, // D.B.
        0x8B9a2b2d9a41909D613C81F2f344E364cD62b63C, // Z.
        0x57B93A6b8954938DE455BE95c9AA7843b99D7DEa, // V.
        0xf0393FB1e988317ca6E3fb986874D019dE712c7d, // M.
        0x698f4a1f42c3601579A3E40a9e4D90C2032C443a  // X.
    ];

    uint[] private teamAmounts = [
        40000 ether, // A.M.
        40000 ether, // Y.O.
        15000 ether, // A.
        10000 ether, // D.B.
        50000 ether, // Z.
        30000 ether, // V.
        10000 ether, // M.
        5000  ether  // X.
    ];
    
    constructor() 
        public 
        PublicPresale(PUBLIC_PRESALE_OWNER, PRESALE_VESTING_PERIOD_IN_BLOCKS, PUBLIC_PRESALE_DURATION_IN_BLOCKS) 
        PrivatePresale(PRESALE_VESTING_PERIOD_IN_BLOCKS, PRIVATE_PRESALE_DISTRIBUTED_CAVO_IN_WEI) 
        TeamDistribution(PRESALE_VESTING_PERIOD_IN_BLOCKS, teamAddresses, teamAmounts) 
    {
        address _xCAVO;
        address _EXCV;
        bytes memory xCAVOBytecode = type(xCAVO).creationCode;
        bytes memory EXCVBytecode = type(EXCV).creationCode;
        bytes32 xCAVOSalt = keccak256(abi.encodePacked("xCAVO"));
        bytes32 EXCVSalt = keccak256(abi.encodePacked("EXCV"));
        assembly {
            _xCAVO := create2(0, add(xCAVOBytecode, 32), mload(xCAVOBytecode), xCAVOSalt)
            _EXCV := create2(0, add(EXCVBytecode, 32), mload(EXCVBytecode), EXCVSalt)
        }
        xCAVOToken = _xCAVO;
        EXCVToken = _EXCV;

        _mint(address(this), totalTeamDistribution.add(totalPrivatePresaleDistribution));
    }
}

pragma solidity >=0.6.6;

import './interfaces/IExcavoERC20.sol';
import './interfaces/ICAVO.sol';
import './libraries/Math.sol';
import "./xEXCV.sol";

contract EXCV is IEXCV, IExcavoERC20, ReentrancyGuard {
    using SafeMath for uint;

    string public constant override name = 'EXCV';
    string public constant override symbol = 'EXCV';
    uint8 public constant override decimals = 18;

    uint public constant override MAX_SUPPLY = 10**9 * 10**18;
    // TODO: make sure, it's OK
    uint public constant override CREATOR_SUPPLY = 600 * 5 * 10**18;

    address public override immutable xEXCVToken;
    address public override factory;

    uint public override totalSupply;
    mapping(address => uint) public override balanceOf;
    mapping(address => mapping(address => uint)) public override allowance;
    address private immutable creator;

    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    constructor() public {
        creator = msg.sender;
        address _xEXCV;
        bytes memory bytecode = type(xEXCV).creationCode;
        bytes32 salt = keccak256(abi.encodePacked("xEXCV"));
        assembly {
            _xEXCV := create2(0, add(bytecode, 32), mload(bytecode), salt)
        }
        xEXCVToken = _xEXCV;
    }

    function initialize(address _factory) external override nonReentrant {
        require(factory == address(0) && msg.sender == creator, "EXCV: FORBIDDEN");
        factory = _factory;
        IxEXCV(xEXCVToken).initialize(_factory);
        _mint(ICAVO(creator).creator(), CREATOR_SUPPLY);
    }

    function _mint(address to, uint value) internal {
        uint _value = Math.min(value, MAX_SUPPLY.sub(totalSupply));
        totalSupply = totalSupply.add(_value);
        balanceOf[to] = balanceOf[to].add(_value);
        emit Transfer(address(0), to, _value);
    }

    function _approve(address owner, address spender, uint value) private {
        allowance[owner][spender] = value;
        emit Approval(owner, spender, value);
    }

    function _transfer(address from, address to, uint value) private {
        balanceOf[from] = balanceOf[from].sub(value);
        balanceOf[to] = balanceOf[to].add(value);
        emit Transfer(from, to, value);
    }

    function mint(address to, uint value) external override nonReentrant {
        require(msg.sender == xEXCVToken, "EXCV: FORBIDDEN");
        _mint(to, value);
    }

    function approve(address spender, uint value) external virtual override nonReentrant returns (bool) {
        _approve(msg.sender, spender, value);
        return true;
    }

    function transfer(address to, uint value) external virtual override returns (bool) {
        _transfer(msg.sender, to, value);
        return true;
    }

    function transferFrom(address from, address to, uint value) external virtual override nonReentrant returns (bool) {
        if (allowance[from][msg.sender] != uint(-1)) {
            allowance[from][msg.sender] = allowance[from][msg.sender].sub(value);
        }
        _transfer(from, to, value);
        return true;
    }
}

pragma solidity >=0.6.6;

import './interfaces/IxCAVO.sol';
import './interfaces/ICAVO.sol';
import "./interfaces/IERC20.sol";
import "./interfaces/IEXCV.sol";
import "./interfaces/IExcavoPair.sol";
import "./interfaces/IExcavoFactory.sol";
import './libraries/SafeMath.sol';
import "./libraries/ExcavoLibrary.sol";
import './libraries/UQ112x112.sol';
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

contract xCAVO is IxCAVO, IERC20, ReentrancyGuard {
    using SafeMath for uint;
    
    event Redeem(address indexed sender, address indexed recipient, uint amount);

    string public constant override name = 'xCAVO';
    string public constant override symbol = 'xCAVO';
    uint8 public constant override decimals = 18;
    uint private constant Q112 = 2**112;
    uint private constant WEI_IN_CAVO = 10**18;
    uint private constant VESTING_PERIOD = 7020000; // 36 * 30 * 6500 = 7020000 = 36 months in blocks
    
    address public immutable override getCAVO;
    address public override excvEthPair;
    address public override cavoEthPair;
    address public override getEXCV;

    mapping(address => uint) private lastAccumulatedMintableCAVOAmount;
    mapping(address => uint) private lastAccumulatedUnclaimedLiquidity;

    uint public override accumulatedMintableCAVOAmount;
    uint private firstBlockNumber;
    uint private lastBlockNumber;
    uint internal expectedPriceInUQ;

    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    constructor() public {
        getCAVO = msg.sender;
    }

    function initialize(address _factory, address _EXCV) external override nonReentrant  {
        require(getEXCV == address(0) && excvEthPair == address(0) && cavoEthPair == address(0) && msg.sender == getCAVO, "xCAVO: FORBIDDEN"); 
        getEXCV = _EXCV;
        address WETH = IExcavoFactory(_factory).WETHToken();
        excvEthPair = ExcavoLibrary.pairFor(_factory, getEXCV, WETH);
        cavoEthPair = ExcavoLibrary.pairFor(_factory, getCAVO, WETH);
    }

    function registerPairCreation() external override nonReentrant {
        require(firstBlockNumber == 0 && msg.sender == cavoEthPair, "xCAVO: FORBIDDEN");
        firstBlockNumber = block.number;
        lastBlockNumber = block.number;
    }

    function totalSupply() external view override returns (uint) {
        return IERC20(getCAVO).totalSupply();
    }

    function balanceOf(address owner) external view override returns (uint) {
        uint totalUnclaimedLiquidity = IExcavoPair(excvEthPair).accumulatedLiquidityGrowth() - lastAccumulatedUnclaimedLiquidity[owner];
        if (totalUnclaimedLiquidity == 0) {
            return 0;
        }
        uint totalMintableCAVO = accumulatedMintableCAVOAmount - lastAccumulatedMintableCAVOAmount[owner];
        uint liquidity = IExcavoPair(excvEthPair).unclaimedLiquidityOf(owner);
        return liquidity.mul(totalMintableCAVO) / totalUnclaimedLiquidity;
    }

    function redeem(address recipient) external override nonReentrant {
        uint liquidity = IExcavoPair(excvEthPair).claimAllLiquidity(msg.sender);
        uint accumulatedUnclaimedLiquidity = IExcavoPair(excvEthPair).accumulatedUnclaimedLiquidity();
        uint totalUnclaimedLiquidity = accumulatedUnclaimedLiquidity - lastAccumulatedUnclaimedLiquidity[msg.sender]; // overflow desired
        if (totalUnclaimedLiquidity == 0) {
            revert('xCAVO: INSUFFICIENT_MINTED_AMOUNT');
        }
        uint totalMintableCAVO = accumulatedMintableCAVOAmount - lastAccumulatedMintableCAVOAmount[msg.sender]; // overflow desired
        uint mintedAmount = liquidity.mul(totalMintableCAVO) / totalUnclaimedLiquidity;
        require(mintedAmount > 0, 'xCAVO: INSUFFICIENT_MINTED_AMOUNT');
        lastAccumulatedUnclaimedLiquidity[msg.sender] = accumulatedUnclaimedLiquidity;
        lastAccumulatedMintableCAVOAmount[msg.sender] = accumulatedMintableCAVOAmount;
        ICAVO(getCAVO).mint(recipient, mintedAmount);
        emit Redeem(msg.sender, recipient, mintedAmount);
    }

    function mint(uint priceInUQ) external override nonReentrant {
        require(msg.sender == cavoEthPair, "xCAVO: FORBIDDEN");

        if (block.number - firstBlockNumber >= VESTING_PERIOD || block.number == lastBlockNumber) {
            return;
        }
        uint priceChangeInUQ = Q112.mul(block.number.sub(lastBlockNumber)).mul(3).div(6500000);
        if (expectedPriceInUQ + priceChangeInUQ < expectedPriceInUQ) {
            return; // overflow: stop minting
        }
        expectedPriceInUQ += priceChangeInUQ; // cannot overflow
        if (priceInUQ >= expectedPriceInUQ) {
            // mintedAmount = 10^6 * (N - Nprev) * (N + Nprev - 2 * N0) / ((36 * 30 * 6500)^2)
            // ((36 * 30 * 6500)**2) = 49280400000000
            // 10**6 = 1000000
            uint mintedAmount = block.number.sub(lastBlockNumber).mul(1000000)
                .mul(block.number.add(lastBlockNumber).sub(firstBlockNumber.mul(2)))
                .mul(WEI_IN_CAVO)
                .div(49280400000000);
            if (mintedAmount > 0) {
                accumulatedMintableCAVOAmount = accumulatedMintableCAVOAmount + mintedAmount; // overflow desired
            }
        }
        lastBlockNumber = block.number;
    }

    function allowance(address /*owner*/, address /*spender*/) external view override returns (uint) {
        revert("xCAVO: FORBIDDEN");
    }

    function approve(address /*spender*/, uint /*value*/) external override returns (bool) {
        revert("xCAVO: FORBIDDEN");
    }

    function transfer(address /*to*/, uint /*value*/) external override returns (bool) {
        revert("xCAVO: FORBIDDEN");
    }

    function transferFrom(address /*from*/, address /*to*/, uint /*value*/) external override returns (bool) {
        revert("xCAVO: FORBIDDEN");
    }
}

pragma solidity >=0.6.6;

import "./interfaces/IxEXCV.sol";
import "./interfaces/IERC20.sol";
import "./interfaces/IEXCV.sol";
import "./interfaces/IExcavoFactory.sol";
import "./interfaces/IExcavoPair.sol";
import "./libraries/ExcavoLibrary.sol";
import './libraries/Math.sol';
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

contract xEXCV is IxEXCV, IERC20, ReentrancyGuard {
    // each time user adds liquidity to EXCV generating pairs, add active pair address
    // each time user removes liquidity to EXCV generating pairs, remove active pair address
    using SafeMath for uint;

    event Redeem(address indexed sender, address indexed recipient, uint amount);

    uint constant MIN_LIQUIDITY_PAIR_COUNT = 3;
    
    address public immutable override getEXCV;
    address public override factory;
    address public override excvEthPair;
    address[] private _liquidityPairs;

    string public constant override symbol = "xEXCV";
    string public constant override name = "xEXCV";
    uint8 public constant override decimals = 18; 

    constructor() public {
        getEXCV = msg.sender;
    }

    function initialize(address _factory) external override nonReentrant {
        require(msg.sender == getEXCV && factory == address(0) && excvEthPair == address(0), "xEXCV: FORBIDDEN");
        factory = _factory;
        address WETH = IExcavoFactory(_factory).WETHToken();
        excvEthPair = ExcavoLibrary.pairFor(_factory, getEXCV, WETH);
    }

    function addPair(address tokenA, address tokenB) external override nonReentrant {
        require(ExcavoLibrary.pairFor(factory, tokenA, tokenB) == msg.sender, "xEXCV: FORBIDDEN");
        if (!_pairExists(msg.sender)) {
            _liquidityPairs.push(msg.sender);
        }
    }

    function redeem(address recipient) external override nonReentrant {
        address[] memory pairs = _liquidityPairs;
        uint _circulatingSupply = circulatingSupply();
        uint excvQuantity;
        for (uint i = 0; i < pairs.length; i++) {
            uint lastK = IExcavoPair(pairs[i]).totalSupply();
            uint claimedLiquidity = IExcavoPair(pairs[i]).claimAllLiquidity(msg.sender);
            excvQuantity = excvQuantity.add(claimedLiquidity.mul(_circulatingSupply).div(lastK));
        }
        IEXCV(getEXCV).mint(recipient, excvQuantity);
        emit Redeem(msg.sender, recipient, excvQuantity);
    }

    function redeemPair(address recipient, address pair, uint claimedLiquidityAmount) external override nonReentrant {
        require(_pairExists(pair), "xEXCV: unknown pair");

        uint _circulatingSupply = circulatingSupply();
        uint lastK = IExcavoPair(pair).totalSupply();
        IExcavoPair(pair).claimLiquidity(msg.sender, claimedLiquidityAmount);
        uint excvQuantity = claimedLiquidityAmount.mul(_circulatingSupply).div(lastK);

        IEXCV(getEXCV).mint(recipient, excvQuantity);
        emit Redeem(msg.sender, recipient, excvQuantity);
    }

    function totalSupply() external view override returns (uint) {
        return IERC20(getEXCV).totalSupply();
    }

    function balanceOf(address owner) external view override returns (uint) {
        address[] memory pairs = _liquidityPairs;
        uint _circulatingSupply = circulatingSupply();
        uint excvQuantity;
        for (uint i = 0; i < pairs.length; i++) {
            uint accumulatedLiquidity = IExcavoPair(pairs[i]).unclaimedLiquidityOf(owner);
            uint lastK = IExcavoPair(pairs[i]).totalSupply();
            excvQuantity = excvQuantity.add(accumulatedLiquidity.mul(_circulatingSupply).div(lastK));
        }
        return excvQuantity;
    }

    function liquidityPairs() external view override returns (address[] memory) {
        return _liquidityPairs;
    }

    function pairBalanceOf(address owner, address pair) external view override returns (uint) {
        if (!_pairExists(pair)) {
            return 0;
        }
        uint lastK = IExcavoPair(pair).totalSupply();
        if (lastK == 0) {
            return 0;
        }
        uint _circulatingSupply = circulatingSupply();
        uint accumulatedLiquidity = IExcavoPair(pair).unclaimedLiquidityOf(owner);
        return accumulatedLiquidity.mul(_circulatingSupply) / lastK;
    }

    function circulatingSupply() private view returns (uint) {
        (uint reserve0, uint reserve1, ) = IExcavoPair(excvEthPair).getReserves();
        return IExcavoPair(excvEthPair).token0() == getEXCV ? reserve0 : reserve1;
    }

    function _pairExists(address pair) private view returns (bool) {
        address[] memory pairs = _liquidityPairs;
        for (uint i = 0; i < pairs.length; ++i) {
            if (pairs[i] == pair) {
                return true;
            }
        }
        return false;
    }

    function allowance(address /*owner*/, address /*spender*/) external view override returns (uint) {
        revert("xEXCV: FORBIDDEN");
    }

    function approve(address /*spender*/, uint /*value*/) external override returns (bool) {
        revert("xEXCV: FORBIDDEN");
    }

    function transfer(address /*to*/, uint /*value*/) external override returns (bool) {
        revert("xEXCV: FORBIDDEN");
    }

    function transferFrom(address /*from*/, address /*to*/, uint /*value*/) external override returns (bool) {
        revert("xEXCV: FORBIDDEN");
    }
}

pragma solidity >=0.6.6;

import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import './libraries/SafeMath.sol';
import './libraries/Math.sol';
import './interfaces/ICAVO.sol';
import './interfaces/IExcavoERC20.sol';
import './interfaces/IxCAVO.sol';
import './interfaces/IEXCV.sol';
import './interfaces/IExcavoFactory.sol';

contract BaseCAVO is ICAVO, IExcavoERC20, ReentrancyGuard {
    using SafeMath for uint;

    string public constant override name = 'CAVO';
    string public constant override symbol = 'CAVO';
    uint8 public constant override decimals = 18;
    
    uint public constant override MAX_SUPPLY = 10**6 * 10**18;
    uint public constant override CREATOR_SUPPLY = 200 ether + 120 ether;

    address public override xCAVOToken;
    address public immutable override creator;
    address public override EXCVToken;

    uint public override totalSupply;
    mapping(address => uint) public override balanceOf;
    mapping(address => mapping(address => uint)) public override allowance;
    mapping(address => uint) private lastBalanceOf;
    mapping(address => uint) private lastBalanceBlockOf;

    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    constructor() public {
        creator = msg.sender;
        _mint(msg.sender, CREATOR_SUPPLY);
    }

    function initialize(address _factory) external override nonReentrant {
        require(msg.sender == creator && IEXCV(EXCVToken).factory() == address(0), 'EXCV: FORBIDDEN');
        IEXCV(EXCVToken).initialize(_factory);
        IxCAVO(xCAVOToken).initialize(_factory, EXCVToken);
    }

    function virtualBalanceOf(address account) external view override returns (uint) {
        uint balance = balanceOf[account];
        if (block.number - lastBalanceBlockOf[account] > 0) {
            return balance;
        }
        uint lastBalance = lastBalanceOf[account];
        return balance < lastBalance ? balance : lastBalance;
    }

    function mint(address account, uint256 amount) external override nonReentrant {
        require(msg.sender == xCAVOToken, 'Excavo: FORBIDDEN');
        _mint(account, amount);
    }

    function _mint(address to, uint value) internal {
        _saveLastBalance(to);
        uint _value = Math.min(value, MAX_SUPPLY.sub(totalSupply));
        totalSupply = totalSupply.add(_value);
        balanceOf[to] = balanceOf[to].add(_value);
        emit Transfer(address(0), to, _value);
    }

    function _approve(address owner, address spender, uint value) private {
        allowance[owner][spender] = value;
        emit Approval(owner, spender, value);
    }

    function _transfer(address from, address to, uint value) internal {
        _saveLastBalance(from);
        _saveLastBalance(to);
        balanceOf[from] = balanceOf[from].sub(value);
        balanceOf[to] = balanceOf[to].add(value);
        emit Transfer(from, to, value);
    }

    function approve(address spender, uint value) external virtual override returns (bool) {
        _approve(msg.sender, spender, value);
        return true;
    }

    function transfer(address to, uint value) external virtual override returns (bool) {
        _transfer(msg.sender, to, value);
        return true;
    }

    function transferFrom(address from, address to, uint value) external virtual override returns (bool) {
        if (allowance[from][msg.sender] != uint(-1)) {
            allowance[from][msg.sender] = allowance[from][msg.sender].sub(value);
        }
        _transfer(from, to, value);
        return true;
    }

    function _saveLastBalance(address account) private {
        if (block.number - lastBalanceBlockOf[account] > 0) {
            lastBalanceOf[account] = balanceOf[account];
            lastBalanceBlockOf[account] = block.number;
        } 
    }
}

pragma solidity >=0.6.6;

import '@openzeppelin/contracts/utils/ReentrancyGuard.sol';
import './libraries/TransferHelper.sol';
import './libraries/Math.sol';
import './libraries/SafeMath.sol';
import './libraries/DistributionLibrary.sol';
import './interfaces/ICAVO.sol';
import './interfaces/IExcavoERC20.sol';
import './interfaces/IxCAVO.sol';
import './interfaces/IPublicPresale.sol';
import './BaseCAVO.sol';

contract PublicPresale is BaseCAVO, IPublicPresale {
    
    using SafeMath for uint;
    using DistributionLibrary for DistributionLibrary.Data;

    event PublicPresalePurchase(address indexed recipient, uint amount);
    event PublicDistributed(address indexed recipient, uint amount);

    address public immutable override presaleOwner;
    uint private presaleDurationInBlocks;
    uint private presaleStartBlock;
    
    DistributionLibrary.Data private distribution;

    constructor(address _presaleOwner, uint32 _vestingBlocksInPeriod, uint _presaleDurationInBlocks) public {
        presaleOwner = _presaleOwner;
        distribution.blocksInPeriod = _vestingBlocksInPeriod;
        presaleDurationInBlocks = _presaleDurationInBlocks;
    }

    function availablePublicPresaleAmountOf(address account) external view override returns (uint) {
        return distribution.availableAmountOf(account);
    }

    function publicPresaleClaim(uint amount) external override nonReentrant {
        distribution.claim(amount);
        emit PublicDistributed(msg.sender, amount);
    }

    function startPublicPresaleDistribution() external override nonReentrant {
        require(presaleStartBlock != 0 && block.number >= presaleStartBlock.add(presaleDurationInBlocks), 'PublicPresale: INVALID_PARAMS');
        distribution.start();
    }

    function startPublicPresale() external override nonReentrant {
        require(presaleStartBlock == 0 && msg.sender == creator, 'PublicPresale: FORBIDDEN');
        presaleStartBlock = block.number;
    }

    receive() external payable nonReentrant {
        require(block.number >= presaleStartBlock && block.number < presaleStartBlock.add(presaleDurationInBlocks), 'PublicPresale: INACTIVE');
        // P = 0.5 ETH/CAVO
        uint mintedCAVO = msg.value.mul(100).div(50);
        payable(presaleOwner).transfer(msg.value);
        _mint(address(this), mintedCAVO);
        distribution.maxAmountOf[msg.sender] = distribution.maxAmountOf[msg.sender].add(mintedCAVO);
        emit PublicPresalePurchase(msg.sender, mintedCAVO);
    }
}

pragma solidity >=0.6.6;

import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import './libraries/TransferHelper.sol';
import './libraries/SafeMath.sol';
import './libraries/DistributionLibrary.sol';
import './interfaces/ICAVO.sol';
import './interfaces/IExcavoERC20.sol';
import './interfaces/IxCAVO.sol';
import './interfaces/IPrivatePresale.sol';

abstract contract PrivatePresale is IPrivatePresale, ICAVO, IExcavoERC20, ReentrancyGuard {
    using SafeMath for uint;
    using DistributionLibrary for DistributionLibrary.Data;

    event PrivateDistributionInitialized(address indexed recipient, uint amount);
    event PrivateDistributed(address indexed recipient, uint amount);

    DistributionLibrary.Data private distribution;
    uint public override totalPrivatePresaleDistribution;
    uint public override privatePresaleDistributed;

    constructor(uint32 _blocksInPeriod, uint _totalPrivatePresaleDistribution) public {
        distribution.blocksInPeriod = _blocksInPeriod;
        totalPrivatePresaleDistribution = _totalPrivatePresaleDistribution;
    }

    function distribute(address[] calldata _accounts, uint[] calldata _amounts) external override nonReentrant {
        require(msg.sender == ICAVO(address(this)).creator(), 'PrivatePresale: FORBIDDEN');
        require(_accounts.length == _amounts.length, 'PrivatePresale: INVALID_LENGTH');
        uint _distributed = privatePresaleDistributed;
        for (uint i = 0; i < _accounts.length; ++i) {
            uint max = distribution.maxAmountOf[_accounts[i]].add(_amounts[i]);
            distribution.maxAmountOf[_accounts[i]] = max;
            _distributed = _distributed.add(_amounts[i]);
            emit PrivateDistributionInitialized(_accounts[i], max);
        }
        require(_distributed <= totalPrivatePresaleDistribution, 'PrivatePresale: LIMIT_EXCEEDED');
        privatePresaleDistributed = _distributed;
    }

    function editDistributed(address _account, uint _amount) external override nonReentrant {
        // disabled if admin has started the private presale distribution
        require(distribution.unlockBlock == 0 && msg.sender == ICAVO(address(this)).creator(), 'PrivatePresale: FORBIDDEN');
        uint _distributed = privatePresaleDistributed.sub(distribution.maxAmountOf[_account]).add(_amount);
        distribution.maxAmountOf[_account] = _amount;
        require(_distributed <= totalPrivatePresaleDistribution, 'PrivatePresale: LIMIT_EXCEEDED');
        privatePresaleDistributed = _distributed;
        emit PrivateDistributionInitialized(_account, _amount);
    }

    function availablePrivatePresaleAmountOf(address account) external view override returns (uint) {
        return distribution.availableAmountOf(account);
    }

    function privatePresaleClaim(uint amount) external override nonReentrant {
        distribution.claim(amount);
        emit PrivateDistributed(msg.sender, amount);
    }

    function startPrivatePresaleDistribution() external override nonReentrant {
        // called, once admin has distributed all of the presale tokens
        require(privatePresaleDistributed == totalPrivatePresaleDistribution, 'PrivatePresale: DISTRIBUTION_UNFINISHED');
        distribution.start();
    }
}

pragma solidity >=0.6.6;

// a library for performing various math operations

library Math {
    function min(uint x, uint y) internal pure returns (uint z) {
        z = x < y ? x : y;
    }

    // babylonian method (https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method)
    function sqrt(uint y) internal pure returns (uint z) {
        if (y > 3) {
            z = y;
            uint x = y / 2 + 1;
            while (x < z) {
                z = x;
                x = (y / x + x) / 2;
            }
        } else if (y != 0) {
            z = 1;
        }
    }
}

pragma solidity >=0.6.6;

import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import './libraries/TransferHelper.sol';
import './libraries/Math.sol';
import './libraries/SafeMath.sol';
import './libraries/DistributionLibrary.sol';
import './interfaces/ICAVO.sol';
import './interfaces/IExcavoERC20.sol';
import './interfaces/IxCAVO.sol';
import './interfaces/ITeamDistribution.sol';

abstract contract TeamDistribution is ITeamDistribution, ICAVO, IExcavoERC20, ReentrancyGuard {
    using SafeMath for uint;
    using DistributionLibrary for DistributionLibrary.Data;

    event TeamDistributed(address indexed recipient, uint amount);

    uint public override totalTeamDistribution;
    DistributionLibrary.Data private distribution;

    constructor(uint32 _blocksInPeriod, address[] memory _team, uint[] memory _amounts) public {
        require(_team.length == _amounts.length, 'TeamDistribution: INVALID_PARAMS');
        uint total;
        for (uint i = 0; i < _team.length; ++i) {
            distribution.maxAmountOf[_team[i]] = _amounts[i];
            total = total.add(_amounts[i]);
        }
        totalTeamDistribution = total;
        distribution.blocksInPeriod = _blocksInPeriod;
    }

    function availableTeamMemberAmountOf(address account) external view override returns (uint) {
        return distribution.availableAmountOf(account);
    }

    function teamMemberClaim(uint amount) external override nonReentrant {
        distribution.claim(amount);
        emit TeamDistributed(msg.sender, amount);
    }

    function startTeamDistribution() external override nonReentrant {
        distribution.start();
    }
}

pragma solidity >=0.6.6;

interface ICAVO {
    function MAX_SUPPLY() external pure returns(uint);
    function CREATOR_SUPPLY() external pure returns(uint);
    function creator() external returns (address);
    function xCAVOToken() external view returns (address);
    function EXCVToken() external view returns (address);
    function mint(address to, uint value) external;
    function initialize(address _factory) external;
    function virtualBalanceOf(address account) external view returns (uint);
}   

pragma solidity >=0.6.6;

interface IEXCV {
    function MAX_SUPPLY() external pure returns(uint);
    function CREATOR_SUPPLY() external pure returns(uint);
    function xEXCVToken() external view returns (address);
    function factory() external view returns (address);

    function mint(address to, uint value) external;
    function initialize(address _factory) external;
}

pragma solidity >=0.6.6;

interface IERC20 {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function decimals() external view returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);
}

pragma solidity >=0.6.6;

interface IxCAVO {
    function excvEthPair() external view returns (address);
    function cavoEthPair() external view returns (address);
    function getEXCV() external view returns (address);
    function getCAVO() external view returns (address);
    
    function redeem(address recipient) external;
    function initialize(address _factory, address _EXCV) external;
    function registerPairCreation() external;
    function mint(uint price) external;
    function accumulatedMintableCAVOAmount() external view returns (uint);
}

pragma solidity >=0.6.6;

interface IxEXCV {
    function liquidityPairs() external view returns (address[] memory);
    function factory() external view returns (address);
    function excvEthPair() external view returns (address);
    function getEXCV() external view returns (address);

    function initialize(address _factory) external;
    function redeem(address recipient) external;
    function redeemPair(address recipient, address pair, uint claimedLiquidityAmount) external;
    function addPair(address tokenA, address tokenB) external;
    function pairBalanceOf(address owner, address pair) external view returns (uint);
}

pragma solidity >=0.6.6;

// a library for performing overflow-safe math, courtesy of DappHub (https://github.com/dapphub/ds-math)

library SafeMath {
    function add(uint x, uint y) internal pure returns (uint z) {
        require((z = x + y) >= x, 'ds-math-add-overflow');
    }

    function sub(uint x, uint y) internal pure returns (uint z) {
        require((z = x - y) <= x, 'ds-math-sub-underflow');
    }

    function mul(uint x, uint y) internal pure returns (uint z) {
        require(y == 0 || (z = x * y) / y == x, 'ds-math-mul-overflow');
    }

    function div(uint x, uint y) internal pure returns (uint z) {
        require(y > 0, "SafeMath: division by zero");
        z = x / y;
    }
}

pragma solidity >=0.6.6;

// a library for handling binary fixed point numbers (https://en.wikipedia.org/wiki/Q_(number_format))

// range: [0, 2**112 - 1]
// resolution: 1 / 2**112

library UQ112x112 {
    uint224 constant Q112 = 2**112;

    // encode a uint112 as a UQ112x112
    function encode(uint112 y) internal pure returns (uint224 z) {
        z = uint224(y) * Q112; // never overflows
    }

    // divide a UQ112x112 by a uint112, returning a UQ112x112
    function uqdiv(uint224 x, uint112 y) internal pure returns (uint224 z) {
        z = x / uint224(y);
    }
}

pragma solidity >=0.6.6;

import './IExcavoERC20.sol';

interface IExcavoPair is IExcavoERC20 {
    event Mint(address indexed sender, uint amount0, uint amount1);
    event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
    event Swap(
        address indexed sender,
        uint amount0In,
        uint amount1In,
        uint amount0Out,
        uint amount1Out,
        address indexed to
    );
    event Sync(uint112 reserve0, uint112 reserve1);

    function MINIMUM_LIQUIDITY() external pure returns (uint);
    function factory() external view returns (address);
    function token0() external view returns (address);
    function token1() external view returns (address);
    function router() external view returns (address);
    function accumulatedLiquidityGrowth() external view returns (uint);
    function accumulatedUnclaimedLiquidity() external view returns (uint);
    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
    function price0CumulativeLast() external view returns (uint);
    function price1CumulativeLast() external view returns (uint);

    function mint(address to) external returns (uint liquidity);
    function burn(address to) external returns (uint amount0, uint amount1);
    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata _data, uint discount) external;
    function skim(address to) external;
    function sync() external;

    function initialize(address, address, address) external;
    function setxEXCV(address) external;

    function unclaimedLiquidityOf(address) external view returns (uint);
    function claimLiquidity(address account, uint256 amount) external returns (uint claimAmount);
    function claimAllLiquidity(address account) external returns (uint claimAmount);

    function compoundLiquidity() external;
    function setCAVO(address _CAVO, address _xCAVO) external;   
}

pragma solidity >=0.6.6;

interface IExcavoERC20 {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    function name() external pure returns (string memory);
    function symbol() external pure returns (string memory);
    function decimals() external pure returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);
}

pragma solidity >=0.6.6;

import '../interfaces/IExcavoPair.sol';
import "./SafeMath.sol";
import './Math.sol';

library ExcavoLibrary {
    using SafeMath for uint;

    // returns sorted token addresses, used to handle return values from pairs sorted in this order
    function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
        require(tokenA != tokenB, 'ExcavoLibrary: IDENTICAL_ADDRESSES');
        (token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
        require(token0 != address(0), 'ExcavoLibrary: ZERO_ADDRESS');
    }

    // calculates the CREATE2 address for a pair without making any external calls
    function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
        (address token0, address token1) = sortTokens(tokenA, tokenB);
        pair = address(uint(keccak256(abi.encodePacked(
                hex'ff',
                factory,
                keccak256(abi.encodePacked(token0, token1)),
                hex'3b4596e5d4f0ba0faf3c029e2a152a4931e4da86804417810c5960569e839f1e' // init code hash
            ))));
    }

    // fetches and sorts the reserves for a pair
    function getReserves(address factory, address tokenA, address tokenB) internal view returns (uint reserveA, uint reserveB) {
        (address token0,) = sortTokens(tokenA, tokenB);
        (uint reserve0, uint reserve1,) = IExcavoPair(pairFor(factory, tokenA, tokenB)).getReserves();
        (reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
    }

    // given some amount of an asset and pair reserves, returns an equivalent amount of the other asset
    function quote(uint amountA, uint reserveA, uint reserveB) internal pure returns (uint amountB) {
        require(amountA > 0, 'ExcavoLibrary: INSUFFICIENT_AMOUNT');
        require(reserveA > 0 && reserveB > 0, 'ExcavoLibrary: INSUFFICIENT_LIQUIDITY');
        amountB = amountA.mul(reserveB) / reserveA;
    }

    // given an input amount of an asset and pair reserves, returns the maximum output amount of the other asset
    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut, uint discount) internal pure returns (uint amountOut) {
        require(amountIn > 0, 'ExcavoLibrary: INSUFFICIENT_INPUT_AMOUNT');
        require(reserveIn > 0 && reserveOut > 0, 'ExcavoLibrary: INSUFFICIENT_LIQUIDITY');
        uint amountInWithFee = amountIn.mul(10000 - 4 * discount);
        uint numerator = amountInWithFee.mul(reserveOut);
        uint denominator = reserveIn.mul(10000).add(amountInWithFee);
        amountOut = numerator / denominator;
    }

    // given an output amount of an asset and pair reserves, returns a required input amount of the other asset
    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut, uint discount) internal pure returns (uint amountIn) {
        require(amountOut > 0, 'ExcavoLibrary: INSUFFICIENT_OUTPUT_AMOUNT');
        require(reserveIn > 0 && reserveOut > 0, 'ExcavoLibrary: INSUFFICIENT_LIQUIDITY');
        uint numerator = reserveIn.mul(amountOut).mul(10000);
        uint denominator = reserveOut.sub(amountOut).mul(10000 - 4 * discount);
        amountIn = (numerator / denominator).add(1);
    }

    // performs chained getAmountOut calculations on any number of pairs
    function getAmountsOut(address factory, uint amountIn, address[] memory path, uint discount) internal view returns (uint[] memory amounts) {
        require(path.length >= 2, 'ExcavoLibrary: INVALID_PATH');
        amounts = new uint[](path.length);
        amounts[0] = amountIn;
        for (uint i; i < path.length - 1; i++) {
            (uint reserveIn, uint reserveOut) = getReserves(factory, path[i], path[i + 1]);
            amounts[i + 1] = getAmountOut(amounts[i], reserveIn, reserveOut, discount);
        }
    }

    // performs chained getAmountIn calculations on any number of pairs
    function getAmountsIn(address factory, uint amountOut, address[] memory path, uint discount) internal view returns (uint[] memory amounts) {
        require(path.length >= 2, 'ExcavoLibrary: INVALID_PATH');
        amounts = new uint[](path.length);
        amounts[amounts.length - 1] = amountOut;
        for (uint i = path.length - 1; i > 0; i--) {
            (uint reserveIn, uint reserveOut) = getReserves(factory, path[i - 1], path[i]);
            amounts[i - 1] = getAmountIn(amounts[i], reserveIn, reserveOut, discount);
        }
    }
}

// SPDX-License-Identifier: GPL-3.0-or-later

pragma solidity >=0.6.6;

// helper methods for interacting with ERC20 tokens and sending ETH that do not consistently return true/false
library TransferHelper {
    function safeApprove(address token, address to, uint value) internal {
        // bytes4(keccak256(bytes('approve(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: APPROVE_FAILED');
    }

    function safeTransfer(address token, address to, uint value) internal {
        // bytes4(keccak256(bytes('transfer(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED');
    }

    function safeTransferFrom(address token, address from, address to, uint value) internal {
        // bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FROM_FAILED');
    }

    function safeTransferETH(address to, uint value) internal {
        (bool success,) = to.call{value:value}(new bytes(0));
        require(success, 'TransferHelper: ETH_TRANSFER_FAILED');
    }
}

pragma solidity >=0.6.6;

interface IExcavoFactory {
    event PairCreated(address indexed token0, address indexed token1, address pair, uint);
    
    function EXCVToken() external view returns (address);
    function CAVOToken() external view returns (address);
    function WETHToken() external view returns (address);

    function feeToSetter() external view returns (address);
    function router() external view returns(address);

    function getPair(address tokenA, address tokenB) external view returns (address pair);
    function allPairs(uint) external view returns (address pair);
    function allPairsLength() external view returns (uint);

    function createPair(address tokenA, address tokenB) external returns (address pair);
    function initialize(address) external;
}

pragma solidity >=0.6.6;

interface IPublicPresale {
    function presaleOwner() external view returns (address);
    function availablePublicPresaleAmountOf(address account) external view returns (uint);

    function publicPresaleClaim(uint amount) external;
    function startPublicPresaleDistribution() external;
    function startPublicPresale() external;
}   

pragma solidity >=0.6.6;

interface IPrivatePresale {
    function totalPrivatePresaleDistribution() external view returns (uint);
    function privatePresaleDistributed() external view returns (uint);
    function availablePrivatePresaleAmountOf(address account) external view returns (uint);

    function distribute(address[] calldata _accounts, uint[] calldata _amounts) external;
    function editDistributed(address _account, uint _amount) external;
    function privatePresaleClaim(uint amount) external;
    function startPrivatePresaleDistribution() external;
}   

pragma solidity >=0.6.6;

interface ITeamDistribution {
    function totalTeamDistribution() external view returns (uint);
    function availableTeamMemberAmountOf(address account) external view returns (uint);

    function teamMemberClaim(uint amount) external;
    function startTeamDistribution() external;
}   

pragma solidity >=0.6.6;

import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import './TransferHelper.sol';
import './Math.sol';
import './SafeMath.sol';
import '../interfaces/ICAVO.sol';

library DistributionLibrary {
    using SafeMath for uint;

    struct Data {
        mapping(address => uint) claimedAmountOf;
        mapping(address => uint) maxAmountOf;
        uint unlockBlock;
        uint32 blocksInPeriod;
    }

    function availableAmountOf(Data storage self, address account) internal view returns (uint) {
        if (self.unlockBlock == 0 || block.number <= self.unlockBlock || self.maxAmountOf[account] == 0) {
            return 0;
        }
        uint unlockedAmountPerPeriod = self.maxAmountOf[account].mul(10).div(100);
        uint unlockPeriodInBlocks = self.maxAmountOf[account].div(unlockedAmountPerPeriod).mul(self.blocksInPeriod);
        return Math.min(self.unlockBlock.add(unlockPeriodInBlocks), block.number)
            .sub(self.unlockBlock)
            .div(self.blocksInPeriod)
            .mul(unlockedAmountPerPeriod)
            .sub(self.claimedAmountOf[account]);
    }

    function start(Data storage self) internal {
        require(self.unlockBlock == 0 && msg.sender == ICAVO(address(this)).creator(), 'DistributionLibrary: FORBIDDEN');
        self.unlockBlock = block.number;
    }

    function claim(Data storage self, uint amount) internal {
        require(amount <= availableAmountOf(self, msg.sender), 'DistributionLibrary: OVERDRAFT');
        self.claimedAmountOf[msg.sender] = self.claimedAmountOf[msg.sender].add(amount);
        TransferHelper.safeTransfer(address(this), msg.sender, amount);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor () internal {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}