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

uint256 constant EPOCH_DURATION = 7 days;

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

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

interface IERC20 {
    function totalSupply() external view returns (uint256);
    function transfer(address recipient, uint amount) external returns (bool);
    function decimals() external view returns (uint8);
    function symbol() external view returns (string memory);
    function balanceOf(address) external view returns (uint);
    function transferFrom(address sender, address recipient, uint amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint);
    function approve(address spender, uint value) external returns (bool);

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.20;

import {IERC165} from "../../utils/introspection/IERC165.sol";

/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon
     *   a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or
     *   {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon
     *   a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the address zero.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.20;

import {IERC721} from "../IERC721.sol";

/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

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

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

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

interface IMinter {
    function update_period() external returns (uint256);

    function check() external view returns (bool);

    function period() external view returns (uint256);

    function active_period() external view returns (uint256);

    function calculate_emission() external view returns (uint256);

    function calculate_growth(uint256 _weeklyMinted) external view returns (uint256);
}

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

interface IRewardsDistributor {
    function checkpoint_token() external;

    function voting_escrow() external view returns (address);

    function checkpoint_total_supply() external;

    function claimable(uint256 _tokenId) external view returns (uint256);
}

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

import {IERC721, IERC721Metadata} from "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";

interface IVotingEscrow is IERC721, IERC721Metadata {
    struct Point {
        int128 bias;
        int128 slope; // # -dweight / dt
        uint256 ts;
        uint256 blk; // block
    }

    struct LockedBalance {
        int128 amount;
        uint256 end;
    }

    function create_lock_for(uint256 _value, uint256 _lock_duration, address _to) external returns (uint256);

    function locked(uint256 id) external view returns (LockedBalance memory);

    function tokenOfOwnerByIndex(address _owner, uint256 _tokenIndex) external view returns (uint256);

    function token() external view returns (address);

    function team() external returns (address);

    function epoch() external view returns (uint256);

    function point_history(uint256 loc) external view returns (Point memory);

    function user_point_history(uint256 tokenId, uint256 loc) external view returns (Point memory);

    function user_point_epoch(uint256 tokenId) external view returns (uint256);

    function ownerOf(uint256) external view returns (address);

    function isApprovedOrOwner(address, uint256) external view returns (bool);

    function transferFrom(address, address, uint256) external;

    function voted(uint256) external view returns (bool);

    function voting(uint256 tokenId) external;

    function voter() external view returns (address);

    function abstain(uint256 tokenId) external;

    function checkpoint() external;

    function deposit_for(uint256 tokenId, uint256 value) external;

    function balanceOfNFT(uint256 _id) external view returns (uint256);

    function balanceOfNFTAt(uint _tokenId, uint _t) external view returns (uint);

    function balanceOf(address _owner) external view returns (uint256);

    function totalSupply() external view returns (uint256);

    function supply() external view returns (uint256);

    function decimals() external view returns (uint8);

    function isTransferWhitelisted(address account) external view returns (bool);

    function split(uint256[] memory amounts, uint256 _tokenId) external;
    function merge(uint256 _from, uint256 _to) external;

    function tokenId() external returns (uint256);

    function safeTransferFrom(address _from, address _to, uint256 _tokenId ) external;
}

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

library Math {
    function max(uint a, uint b) internal pure returns (uint) {
        return a >= b ? a : b;
    }
    function min(uint a, uint b) internal pure returns (uint) {
        return a < b ? a : b;
    }
    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;
        }
    }
    function cbrt(uint256 n) internal pure returns (uint256) { unchecked {
        uint256 x = 0;
        for (uint256 y = 1 << 255; y > 0; y >>= 3) {
            x <<= 1;
            uint256 z = 3 * x * (x + 1) + 1;
            if (n / y >= z) {
                n -= y * z;
                x += 1;
            }
        }
        return x;
    }}
}

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

pragma solidity ^0.8.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].
 */
abstract 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() {
        _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 making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

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

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == _ENTERED;
    }
}

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.0;

import "./libraries/Math.sol";
import "./interfaces/IERC20.sol";
import "./interfaces/IRewardsDistributor.sol";
import "./interfaces/IVotingEscrow.sol";
import "./interfaces/IMinter.sol";
import "contracts/Epoch.sol";

import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

/*

@title Curve Fee Distribution modified for ve(3,3) emissions
@author Thena Finance, Prometheus
@license MIT

*/

contract RewardDistributorV2 is ReentrancyGuard, IRewardsDistributor {
    event CheckpointToken(uint time, uint tokens);

    event Claimed(
        uint tokenId,
        uint amount,
        uint claim_epoch, //timestamp
        uint max_epoch
    );

    uint public start_time;
    uint public last_token_time;
    uint public last_week;
    uint public total_distributed;
    uint public token_claimed;
    uint public time_cursor;

    uint[1000000000000000] public tokens_per_week;
    uint[1000000000000000] public ve_supply;

    address public owner;
    address public voting_escrow;
    address public token;
    address public depositor;

    mapping(uint => uint) public time_cursor_of;
    mapping(address => bool) public lockAddress; // remove permissionless claim for an address owner

    constructor(address _voting_escrow, address _depositor) {
        uint _t = (block.timestamp / EPOCH_DURATION) * EPOCH_DURATION;
        last_token_time = _t;
        time_cursor = _t;

        address _token = IVotingEscrow(_voting_escrow).token();
        token = _token;

        voting_escrow = _voting_escrow;

        depositor = _depositor;
        start_time = _t;

        owner = msg.sender;

        require(IERC20(_token).approve(_voting_escrow, type(uint).max));
    }

    function timestamp() public view returns (uint) {
        return (block.timestamp / EPOCH_DURATION) * EPOCH_DURATION;
    }

    // checkpoint the total supply at the current timestamp. Called by depositor
    function checkpoint_total_supply() external {
        assert(msg.sender == depositor || msg.sender == owner);
        _checkpoint_total_supply();
    }

    function _checkpoint_total_supply() internal {
        address ve = voting_escrow;
        uint t = time_cursor;
        uint rounded_timestamp = (block.timestamp / EPOCH_DURATION) * EPOCH_DURATION;
        IVotingEscrow(ve).checkpoint();

        for (uint i = 0; i < 20; i++) {
            if (t > rounded_timestamp) {
                break;
            } else {
                uint epoch = _find_timestamp_epoch(ve, t);
                IVotingEscrow.Point memory pt = IVotingEscrow(ve).point_history(
                    epoch
                );
                int128 dt = 0;
                if (t > pt.ts) {
                    dt = int128(int256(t - pt.ts));
                }
                ve_supply[t] = Math.max(
                    uint(int256(pt.bias - pt.slope * dt)),
                    0
                );
            }
            t += EPOCH_DURATION;
        }

        time_cursor = t;
    }

    function _find_timestamp_epoch(
        address ve,
        uint _timestamp
    ) internal view returns (uint) {
        uint _min = 0;
        uint _max = IVotingEscrow(ve).epoch();
        for (uint i = 0; i < 128; i++) {
            if (_min >= _max) break;
            uint _mid = (_min + _max + 2) / 2;
            IVotingEscrow.Point memory pt = IVotingEscrow(ve).point_history(
                _mid
            );
            if (pt.ts <= _timestamp) {
                _min = _mid;
            } else {
                _max = _mid - 1;
            }
        }
        return _min;
    }

    // checkpoint the token to distribute for the last epoch
    function checkpoint_token() external {
        assert(msg.sender == depositor || msg.sender == owner);
        _checkpoint_token();
    }

    function _checkpoint_token() internal {
        last_week = (block.timestamp / EPOCH_DURATION) * EPOCH_DURATION;
        last_token_time = block.timestamp;

        uint token_balance = IERC20(token).balanceOf(address(this));
        uint diff = total_distributed - token_claimed;
        uint to_distribute = token_balance - diff;

        tokens_per_week[last_week] += to_distribute;
        total_distributed += to_distribute;

        emit CheckpointToken(block.timestamp, to_distribute);
    }

    function claimable(uint _tokenId) external view returns (uint) {
        uint t = time_cursor_of[_tokenId];
        if (t == 0) t = start_time;
        uint _last_week = last_week;
        uint to_claim = 0;
        for (uint i = 0; i < 100; i++) {
            if (t > _last_week) break;
            to_claim += _toClaim(_tokenId, t);
            t += EPOCH_DURATION;
        }
        return to_claim;
    }

    function claim_many(
        uint[] memory tokenIds
    ) external nonReentrant returns (bool) {
        require(tokenIds.length <= 25);
        for (uint i = 0; i < tokenIds.length; i++) {
            _claim(tokenIds[i]);
        }
        return true;
    }

    function claim(uint _tokenId) external nonReentrant returns (uint) {
        return _claim(_tokenId);
    }

    function _claim(uint _tokenId) internal returns (uint) {
        address _owner = IVotingEscrow(voting_escrow).ownerOf(_tokenId);

        // if lockAddress then check if msg.sender is allowed to call claim
        if (lockAddress[_owner])
            require(
                IVotingEscrow(voting_escrow).isApprovedOrOwner(
                    msg.sender,
                    _tokenId
                ),
                "not approved"
            );

        IVotingEscrow.LockedBalance memory _locked = IVotingEscrow(
            voting_escrow
        ).locked(_tokenId);
        require(_locked.amount > 0, "No existing lock found");
        require(
            _locked.end > block.timestamp,
            "Cannot add to expired lock. Withdraw"
        );

        uint t = time_cursor_of[_tokenId];
        if (t < start_time) t = start_time;
        uint _last_week = last_week;
        uint to_claim = 0;

        for (uint i = 0; i < 100; i++) {
            if (t > _last_week) break;
            to_claim += _toClaim(_tokenId, t);
            t += EPOCH_DURATION;
        }

        if (to_claim > 0)
            IVotingEscrow(voting_escrow).deposit_for(_tokenId, to_claim);
        time_cursor_of[_tokenId] = t;
        token_claimed += to_claim;

        emit Claimed(
            _tokenId,
            to_claim,
            last_week,
            _find_timestamp_epoch(voting_escrow, last_week)
        );

        return to_claim;
    }

    function _toClaim(uint id, uint t) internal view returns (uint to_claim) {
        IVotingEscrow.Point memory userData = IVotingEscrow(voting_escrow).user_point_history(id, 1);

        if (ve_supply[t] == 0) return 0;
        if (tokens_per_week[t] == 0) return 0;
        if (userData.ts > t) return 0;

        uint id_bal = IVotingEscrow(voting_escrow).balanceOfNFTAt(id, t);
        uint share = (id_bal * 1e18) / ve_supply[t];

        to_claim = (share * tokens_per_week[t]) / 1e18;
    }

    // prevent to claim rebase from any non-auth source. If true then require isApprovedOrOwner(msg.sender, _tokenId).
    // Saved per owner address to avoid recall after split/merge
    function _lockAddress(address caller) external {
        require(msg.sender == caller || msg.sender == owner);
        lockAddress[caller] = true;
    }

    function _unlockAddress(address caller) external {
        require(msg.sender == caller || msg.sender == owner);
        lockAddress[caller] = false;
    }

    /*  Owner Functions */

    function setDepositor(address _depositor) external {
        require(msg.sender == owner);
        depositor = _depositor;
    }

    function setOwner(address _owner) external {
        require(msg.sender == owner);
        owner = _owner;
    }

    function increaseOrRemoveAllowances(bool what) external {
        require(msg.sender == owner);
        what == true ? IERC20(token).approve(voting_escrow, type(uint).max) : IERC20(token).approve(voting_escrow, 0); 
    }

    function withdrawERC20(address _token) external {
        require(msg.sender == owner);
        require(_token != address(0));
        uint256 _balance = IERC20(_token).balanceOf(address(this));
        IERC20(_token).transfer(msg.sender, _balance);
    }
}

{
  "compilationTarget": {
    "contracts/RewardDistro.sol": "RewardDistributorV2"
  },
  "evmVersion": "shanghai",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}