Contract 0x255707b70bf90aa112006e1b07b9aea6de021424 6

 
 
Txn Hash Method
Block
From
To
Value [Txn Fee]
0x49376386475f5f86b69bae6214b1f94fe824c7f69fe7edee58663354f8ad7ed4Approve334888522022-09-24 1:47:5914 hrs 24 mins ago0x38eb9f75dc53d0f7d354f095cf1cf2e0417e6a2a IN  Tetu: TETU Token0 MATIC0.00186432 40
0x6fb549435c522150e1f93fbb0eb7d359f0e1c4c5dbf022574c924f0b402bcbb0Approve334845902022-09-23 23:21:2316 hrs 51 mins ago0x9034bfd6bb75fa1b75f22ffa8fc9ce27fca96a81 IN  Tetu: TETU Token0 MATIC0.001817712 39
0xeac81de542f760c1fa8894685a9c8980e2a4ecb376c208e0c5b82e200cea3a19Approve334706372022-09-23 15:08:281 day 1 hr ago0x5552b1cccfa9292e8edf9e6c1c0d2af3630a4835 IN  Tetu: TETU Token0 MATIC0.001537262617 32.982805908
0x9d1eadb4bc9de1346a103dcbeb70af13e96ff569ca24d2753bc82c41cc2bdabeApprove334577172022-09-23 7:36:381 day 8 hrs ago0xf774f030f0c0573dde70e85df8ca60cd26451657 IN  Tetu: TETU Token0 MATIC0.00163128 35
0xb6952fb80ee4ac70e9454094622e8d7ace7b65f7ff3e462226368bbc9d9ce1dbTransfer334452512022-09-23 0:23:331 day 15 hrs ago0x25864a712c80d33ba1ad7c23cffa18b46f2fc00c IN  Tetu: TETU Token0 MATIC0.00170633133.000000016
0x427d0eb3a8dc543499515cd1c3a0b75f0e891fb393ce72744b5af526b4f9400aApprove334387792022-09-22 20:41:011 day 19 hrs ago0xfe52607e1482fe634fd82ca82d74f12990d3dcbd IN  Tetu: TETU Token0 MATIC0.00139824 30.000000012
0xa0204e81c8b98120f3f6ec389540873cdac95d71b5f474ff7c5eb86f42864eacApprove334307712022-09-22 16:02:502 days 10 mins ago0x4cdc68367012a81ebcb9a60aa3e170b0bc7b3cf8 IN  Tetu: TETU Token0 MATIC0.001424107452 30.555000262
0x62a3b2fc172aef51ffcf1ff1f3c8f1eb572a857ee35e05d8f41ce475ba04830aApprove334288302022-09-22 14:52:122 days 1 hr ago0x1ea59465d0e3a6b26fe2e97529d0d35e1fb268f0 IN  Tetu: TETU Token0 MATIC0.00449394336 96.42
0x7a31f603edf78245063ac3f7c138644e5da91138c304a8f158605e4c10ca5793Approve334288282022-09-22 14:52:082 days 1 hr ago0x25a33eaf574da200ebb07ded74ebd18f11783cc3 IN  Tetu: TETU Token0 MATIC0.00146955024 31.53
0xeba3765ac232d687bfc63e35acd5a5de611873fab763222e9bd97c71c18132bdApprove334282672022-09-22 14:32:482 days 1 hr ago0x49925f8254c7d817e68de5997f2257ddbea8dbec IN  Tetu: TETU Token0 MATIC0.00181771239
0x65aebe792222daf3d85107ad1b61fa67c308e1d734de8c4ab7ad8b125fc68961Approve334281752022-09-22 14:29:402 days 1 hr ago0x49925f8254c7d817e68de5997f2257ddbea8dbec IN  Tetu: TETU Token0 MATIC0.001817712 39
0x0149f27f2c750ab8510d41da96aded4bc8f51bab3445af1061c8361fabc12160Approve334273852022-09-22 14:02:282 days 2 hrs ago0x0baab721f2a589935992614e972d8eb73f0fa16b IN  Tetu: TETU Token0 MATIC0.001817712 39
0x72140efe2d43e6e3bac76a7d7965e717acc61f3025c1ed5cfedebd9dfcd2ae6fApprove333744582022-09-21 7:05:423 days 9 hrs ago0xeb54669ac46b44d6a29eedda0daf7d9a8c4f7386 IN  Tetu: TETU Token0 MATIC0.001758448223 37.728463435
0xb7b6a9e78470fbd1d84b023f6cda92b8860e47238d815416475d23dfa6232905Transfer333647752022-09-21 1:23:563 days 14 hrs ago0xa311f7ca3eb2fb98123a807f9b8e4bbbdbdcb2ee IN  Tetu: TETU Token0 MATIC0.0068228223 228.900000012
0x155436fc10ab2dbe8c396b1e6ff79aa60d0e2ec01a568bba8f5da6f0d92ea352Approve333617222022-09-20 23:36:483 days 16 hrs ago0x5766d29cbfa45b32a03d6771153565095de879a1 IN  Tetu: TETU Token0 MATIC0.001717970872 36.859999832
0x8b3f5d214881bb3000fabad985472b29f779c5ae8b83be2a98ba3db7c58bb284Transfer333525742022-09-20 18:13:103 days 21 hrs ago0xa311f7ca3eb2fb98123a807f9b8e4bbbdbdcb2ee IN  Tetu: TETU Token0 MATIC0.007302715 245.000000014
0xb0c0f59269dddcfbc2a01c158ad3fd4af140b0fa54dd9b963ba8af1c58725a56Transfer333524522022-09-20 18:09:023 days 22 hrs ago0x4cb6f0ef0eeb503f8065af1a6e6d5dd46197d3d9 IN  Tetu: TETU Token0 MATIC0.014933307 501.000000017
0xaffb606274fb847710aa69899a6f91c0ceb1b4ed3e614ca4d7343f4dbd61fb1eTransfer333427092022-09-20 12:04:074 days 4 hrs agoTETU Reward: Deployer IN  Tetu: TETU Token0 MATIC0.001039910809 30.069999999
0x448263e179f310e55817645f19c3321855e960241be566070b1707db3369c46aApprove333416492022-09-20 11:25:354 days 4 hrs ago0x2b6046df9db627658049df9de040447addb2b298 IN  Tetu: TETU Token0 MATIC0.00153806433.000000012
0xf9fdb6b2c2f449f4189cac67e77a5ea019f00ffc79c05a587d95e56ff4e3c9e9Approve333385762022-09-20 9:39:484 days 6 hrs ago0xddaf77aa841d448d0a1a16fd05e9db10b28d0b6a IN  Tetu: TETU Token0 MATIC0.00139824 30.000000015
0x502b474846047eb69cc9533318ce88f0c4ecd95d55587d0939df6eb7fc421e3aApprove333343112022-09-20 7:08:464 days 9 hrs ago0x14d15f15f1151d82e0aa5f2443b7da68f981424c IN  Tetu: TETU Token0 MATIC0.00145696608 31.26
0x944c3556514bdbe483778aae2f8d8bdf9ec618eb182f3aebfc48f622ba6accb6Approve333285592022-09-20 3:44:344 days 12 hrs ago0x33d2a0068c60e9e9a157b713de8a4a65929dd5f1 IN  Tetu: TETU Token0 MATIC0.00140150256 30.07
0x8a49a7e77482911b0e4b85d0cc0e99c57261dbc91d2766f67a7d28a2902aaaedTransfer333283242022-09-20 3:36:324 days 12 hrs ago0xc8ad45663dc6b2103f925c5753505ea8e15ffc11 IN  Tetu: TETU Token0 MATIC0.00155049 30.000000013
0x75759bd20a5c81a22997aa6a25bd1c9122736ded925c2105a07cbf7d75e0b763Approve333165242022-09-19 20:50:414 days 19 hrs ago0x238643d4106c7c6206f8dc31acb59cd24c979d12 IN  Tetu: TETU Token0 MATIC0.001577023217 33.835891214
0x391f3fe283b11d977975cd7a5bec95de709e849feaf8677376a66ebc526e35aeTransfer333138522022-09-19 19:18:494 days 20 hrs ago0xd367ab4d74f103dba4c09cc19a7aa0c75967b8c3 IN  Tetu: TETU Token0 MATIC0.00089421 30.000000012
[ Download CSV Export 

OVERVIEW

TETU is a DeFi application built on Polygon that implement automated yield farming strategies in order to provide investors with a safe and secure method of receiving high yield on their investments.

Parent Txn Hash Block From To Value
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
RewardToken

Compiler Version
v0.8.4+commit.c7e474f2

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion

Contract Source Code (Solidity Standard Json-Input format)

File 1 of 9 : RewardToken.sol
// SPDX-License-Identifier: ISC
/**
* By using this software, you understand, acknowledge and accept that Tetu
* and/or the underlying software are provided “as is” and “as available”
* basis and without warranties or representations of any kind either expressed
* or implied. Any use of this open source software released under the ISC
* Internet Systems Consortium license is done at your own risk to the fullest
* extent permissible pursuant to applicable law any and all liability as well
* as all warranties, including any fitness for a particular purpose with respect
* to Tetu and/or the underlying software and the use thereof are disclaimed.
*/

pragma solidity 0.8.4;

import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Capped.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";

/// @title TETU token contract. Has strict weekly emission algorithm
/// @dev Use with TetuProxy
/// @author belbix
contract RewardToken is ERC20Burnable, ERC20Capped {
  using SafeMath for uint256;

  uint256 internal constant SCALE = 1e18;
  uint256 internal constant HALF_SCALE = 5e17;
  /// @notice Immutable owner of the contract
  address public immutable owner;

  /// @notice Maximum total supply -  1 billion
  uint256 public constant HARD_CAP = 1 * (10 ** 9) * SCALE;
  /// @notice Vesting period - 4 years
  uint256 public constant MINTING_PERIOD = 126227808;

  /// @notice Start date of minting
  uint256 public mintingStartTs;
  /// @notice End date of minting
  uint256 public mintingEndTs;

  /// @notice Contract constructor
  /// @param _owner Owner address, MintHelper by default
  constructor(address _owner)
  ERC20("TETU Reward Token", "TETU")
  ERC20Capped(HARD_CAP) {
    require(_owner != address(0), "zero address");
    owner = _owner;
  }

  /// @dev Strict access only for owner
  modifier onlyOwner() {
    require(msg.sender == owner, "not owner");
    _;
  }

  /// @notice Strat vesting period
  function startMinting() external onlyOwner {
    require(mintingStartTs == 0, "minting already started");
    mintingStartTs = block.timestamp;
    mintingEndTs = mintingStartTs.add(MINTING_PERIOD);
  }

  /// @notice Mint given amount for given address
  /// @param to Mint destination
  /// @param amount Amount of mint
  function mint(address to, uint256 amount) external onlyOwner {
    _mint(to, amount);
  }

  /// @dev Override function ERC20 implementation
  function _mint(address account, uint256 amount) internal override(ERC20, ERC20Capped) {
    super._mint(account, amount);
  }

  /// @dev This function will check each transfer and if it is a mint
  ///      will check that totalSupply will be not higher than maxTotalSupplyForCurrentBlock
  function _beforeTokenTransfer(address from, address to, uint256 amount) internal override {
    if (from == address(0)) {// it is mint
      require(mintingStartTs != 0, "minting not started");
      require(totalSupply().add(amount) <= maxTotalSupplyForCurrentBlock(), "limit exceeded");
    }
    super._beforeTokenTransfer(from, to, amount);
  }

  /// @notice Return quantity of weeks since minting started
  /// @return Quantity of weeks
  function currentWeek() public view returns (uint256){
    if (mintingStartTs == 0) {// not started yet
      return 0;
    }
    return block.timestamp.sub(mintingStartTs).div(1 weeks).add(1);
  }

  /// @notice Return maximum Total Supply for the current week.
  ///         The contract can't mint more than this value
  /// @return Maximum allowed supply
  function maxTotalSupplyForCurrentBlock() public view returns (uint256){
    uint256 allWeeks = MINTING_PERIOD / 1 weeks;

    uint256 week = Math.min(allWeeks, currentWeek());

    if (week == 0) {
      return 0;
    }
    if (week >= MINTING_PERIOD / 1 weeks) {
      return HARD_CAP;
    }

    uint256 finalMultiplier = _log2(allWeeks.add(1).mul(SCALE));

    uint256 baseWeekEmission = HARD_CAP / finalMultiplier;

    uint256 multiplier = _log2(week.add(1).mul(SCALE));

    uint256 maxTotalSupply = baseWeekEmission.mul(multiplier);

    return Math.min(maxTotalSupply, HARD_CAP);
  }

  /*********************************************
  *              PRB-MATH                      *
  *   https://github.com/hifi-finance/prb-math *
  **********************************************/

  /// @notice Calculates the binary logarithm of x.
  ///
  /// @dev Based on the iterative approximation algorithm.
  /// https://en.wikipedia.org/wiki/Binary_logarithm#Iterative_approximation
  ///
  /// Requirements:
  /// - x must be greater than or equal to SCALE, otherwise the result would be negative.
  ///
  /// Caveats:
  /// - The results are nor perfectly accurate to the last decimal,
  ///   due to the lossy precision of the iterative approximation.
  ///
  /// @param x The unsigned 60.18-decimal fixed-point number for which
  ///           to calculate the binary logarithm.
  /// @return result The binary logarithm as an unsigned 60.18-decimal fixed-point number.
  function _log2(uint256 x) public pure returns (uint256 result) {
    require(x >= SCALE, "log input should be greater 1e18");

    // Calculate the integer part of the logarithm
    // and add it to the result and finally calculate y = x * 2^(-n).
    uint256 n = mostSignificantBit(x / SCALE);

    // The integer part of the logarithm as an unsigned 60.18-decimal fixed-point number.
    // The operation can't overflow because n is maximum 255 and SCALE is 1e18.
    uint256 rValue = n * SCALE;

    // This is y = x * 2^(-n).
    uint256 y = x >> n;

    // If y = 1, the fractional part is zero.
    if (y == SCALE) {
      return rValue;
    }

    // Calculate the fractional part via the iterative approximation.
    // The "delta >>= 1" part is equivalent to "delta /= 2", but shifting bits is faster.
    for (uint256 delta = HALF_SCALE; delta > 0; delta >>= 1) {
      y = (y * y) / SCALE;

      // Is y^2 > 2 and so in the range [2,4)?
      if (y >= 2 * SCALE) {
        // Add the 2^(-m) factor to the logarithm.
        rValue += delta;

        // Corresponds to z/2 on Wikipedia.
        y >>= 1;
      }
    }
    return rValue;
  }

  /// @notice Finds the zero-based index of the first one in the binary representation of x.
  /// @dev See the note on msb in the "Find First Set"
  ///      Wikipedia article https://en.wikipedia.org/wiki/Find_first_set
  /// @param x The uint256 number for which to find the index of the most significant bit.
  /// @return msb The index of the most significant bit as an uint256.
  //noinspection NoReturn
  function mostSignificantBit(uint256 x) internal pure returns (uint256 msb) {
    if (x >= 2 ** 128) {
      x >>= 128;
      msb += 128;
    }
    if (x >= 2 ** 64) {
      x >>= 64;
      msb += 64;
    }
    if (x >= 2 ** 32) {
      x >>= 32;
      msb += 32;
    }
    if (x >= 2 ** 16) {
      x >>= 16;
      msb += 16;
    }
    if (x >= 2 ** 8) {
      x >>= 8;
      msb += 8;
    }
    if (x >= 2 ** 4) {
      x >>= 4;
      msb += 4;
    }
    if (x >= 2 ** 2) {
      x >>= 2;
      msb += 2;
    }
    if (x >= 2 ** 1) {
      // No need to shift x any more.
      msb += 1;
    }
  }

}

File 2 of 9 : ERC20Capped.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "../ERC20.sol";

/**
 * @dev Extension of {ERC20} that adds a cap to the supply of tokens.
 */
abstract contract ERC20Capped is ERC20 {
    uint256 private immutable _cap;

    /**
     * @dev Sets the value of the `cap`. This value is immutable, it can only be
     * set once during construction.
     */
    constructor(uint256 cap_) {
        require(cap_ > 0, "ERC20Capped: cap is 0");
        _cap = cap_;
    }

    /**
     * @dev Returns the cap on the token's total supply.
     */
    function cap() public view virtual returns (uint256) {
        return _cap;
    }

    /**
     * @dev See {ERC20-_mint}.
     */
    function _mint(address account, uint256 amount) internal virtual override {
        require(ERC20.totalSupply() + amount <= cap(), "ERC20Capped: cap exceeded");
        super._mint(account, amount);
    }
}

File 3 of 9 : ERC20Burnable.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "../ERC20.sol";
import "../../../utils/Context.sol";

/**
 * @dev Extension of {ERC20} that allows token holders to destroy both their own
 * tokens and those that they have an allowance for, in a way that can be
 * recognized off-chain (via event analysis).
 */
abstract contract ERC20Burnable is Context, ERC20 {
    /**
     * @dev Destroys `amount` tokens from the caller.
     *
     * See {ERC20-_burn}.
     */
    function burn(uint256 amount) public virtual {
        _burn(_msgSender(), amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, deducting from the caller's
     * allowance.
     *
     * See {ERC20-_burn} and {ERC20-allowance}.
     *
     * Requirements:
     *
     * - the caller must have allowance for ``accounts``'s tokens of at least
     * `amount`.
     */
    function burnFrom(address account, uint256 amount) public virtual {
        uint256 currentAllowance = allowance(account, _msgSender());
        require(currentAllowance >= amount, "ERC20: burn amount exceeds allowance");
        unchecked {
            _approve(account, _msgSender(), currentAllowance - amount);
        }
        _burn(account, amount);
    }
}

File 4 of 9 : SafeMath.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

File 5 of 9 : Math.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow, so we distribute.
        return (a / 2) + (b / 2) + (((a % 2) + (b % 2)) / 2);
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a / b + (a % b == 0 ? 0 : 1);
    }
}

File 6 of 9 : ERC20.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC20.sol";
import "./extensions/IERC20Metadata.sol";
import "../../utils/Context.sol";

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin guidelines: functions revert instead
 * of returning `false` on failure. This behavior is nonetheless conventional
 * and does not conflict with the expectations of ERC20 applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5,05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless this function is
     * overridden;
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * Requirements:
     *
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);

        uint256 currentAllowance = _allowances[sender][_msgSender()];
        require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
        unchecked {
            _approve(sender, _msgSender(), currentAllowance - amount);
        }

        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        uint256 currentAllowance = _allowances[_msgSender()][spender];
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(_msgSender(), spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `sender` to `recipient`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(
        address sender,
        address recipient,
        uint256 amount
    ) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

        uint256 senderBalance = _balances[sender];
        require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[sender] = senderBalance - amount;
        }
        _balances[recipient] += amount;

        emit Transfer(sender, recipient, amount);

        _afterTokenTransfer(sender, recipient, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        _balances[account] += amount;
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
        }
        _totalSupply -= amount;

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}

File 7 of 9 : IERC20.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @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 `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, 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 `sender` to `recipient` 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 sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

    /**
     * @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);
}

File 8 of 9 : IERC20Metadata.sol
// SPDX-License-Identifier: MIT

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

File 9 of 9 : Context.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

Settings
{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "libraries": {}
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"HARD_CAP","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MINTING_PERIOD","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"x","type":"uint256"}],"name":"_log2","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"cap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"currentWeek","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"maxTotalSupplyForCurrentBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"mintingEndTs","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mintingStartTs","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"startMinting","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

00000000000000000000000081367059892aa1d8503a79a0af9254dd0a09afbf

-----Decoded View---------------
Arg [0] : _owner (address): 0x81367059892aa1d8503a79a0af9254dd0a09afbf

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 00000000000000000000000081367059892aa1d8503a79a0af9254dd0a09afbf


Block Transaction Gas Used Reward
Age Block Fee Address BC Fee Address Voting Power Jailed Incoming
Block Uncle Number Difficulty Gas Used Reward
Loading
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.