Contract 0x7FBa4B8Dc5E7616e59622806932DBea72537A56b 1

 
Txn Hash Method
Block
From
To
Value
0x9e3b35313f3721e48fe937245e59300b6b7c15ec87372e1010b0291d0c65e932Exit(pending)2021-09-05 4:18:2812 days 16 hrs ago0xfadf3b9b73d76f7272e65a1e1efaab06a6ec973a IN Uniswap V2: ETH/USDC UNI Pool0 Ether(Pending)(Pending)
0x73de97d0cc955ac63dee9a39aa640f5ff343f5defcb2ccf76b7206f4def35534Get Reward131762482021-09-07 3:33:2010 days 17 hrs ago0x5fd9b0b7e15b4d106624ea9cf96602996c9c344d IN  Uniswap V2: ETH/USDC UNI Pool0 Ether0.003926469373 79.024078201
0x6b75490e4aa3cd39ed72aded82eeb8aa928a5da37278dd49477c606f09964514Exit131399422021-09-01 12:58:4916 days 7 hrs ago0x2089ee57ab76afc9559f533e63d31958f1abb71b IN  Uniswap V2: ETH/USDC UNI Pool0 Ether0.007133105252 79.021416806
0x997e4a981fa967dc4e482335afbed446c585676f47e63fadf375c115e1220fb6Get Reward131399332021-09-01 12:56:3316 days 7 hrs ago0x2089ee57ab76afc9559f533e63d31958f1abb71b IN  Uniswap V2: ETH/USDC UNI Pool0 Ether0.006428695582 69.383148051
0xb5d7d4b0ed1dcf5e152e8a70fdc188da4952e75c019753bbe70493f4fe4ce269Exit130590602021-08-20 0:49:4428 days 19 hrs ago0x4b223aab8a57d6ef8db11a08e6910379b73344bf IN  Uniswap V2: ETH/USDC UNI Pool0 Ether0.007778170457.2
0xf11f9df360b5a214b7376c6b16a47dd62940a8e6a51f97ec3d1c931f86eb138aExit129740142021-08-06 22:14:4041 days 22 hrs ago0xd8ea0a381fd344062a8c595846a27447763a976f IN  Uniswap V2: ETH/USDC UNI Pool0 Ether0.006147250868.1
0x4f3d461363863ad6f3ab932567465dd09368fe0a16354ab57c2cf2aa4a722038Exit129337632021-07-31 14:09:0248 days 6 hrs ago0xed82d84c47740aff924d4b7f1ef04c26d3ad60dc IN  Uniswap V2: ETH/USDC UNI Pool0 Ether0.00293441427
0x0bd1248fd35dba60b6942edbbb748114f6315ea8de0842c6dc067c1931c32758Exit129069432021-07-27 7:56:0652 days 12 hrs ago0xce75b5cb1a609d4f186080e952397998c21816dd IN  Uniswap V2: ETH/USDC UNI Pool0 Ether0.00173891216
0x521a8874c8417a8cef8c69765befd20c14ac24539adad959f5eccc22b284f3e5Exit128943502021-07-25 8:24:5154 days 12 hrs ago0xfa5175d9c5bbde5b7283bb1d2346e8376cc79694 IN  Uniswap V2: ETH/USDC UNI Pool0 Ether0.001353149216.9
0x7375cd1e48a8ef1ca83fbeeb76935c8cad0802313099805f5ad7bfaa63370ac8Get Reward128942352021-07-25 7:59:1054 days 12 hrs ago0xfa5175d9c5bbde5b7283bb1d2346e8376cc79694 IN  Uniswap V2: ETH/USDC UNI Pool0 Ether0.00213106523
0x202b81624e2c2810888736a2f115c542d7b3748f91aa98e656dd608d1728a995Exit128788302021-07-22 22:19:2156 days 22 hrs ago0x8b3d116bfde0ad9888455fe9b565cbb434e8eee9 IN  Uniswap V2: ETH/USDC UNI Pool0 Ether0.003043924424.2
0x7faf66525cd71805a021c3a0f188c80123589db8aef0ac5b37aca712ace5fdacExit128653132021-07-20 19:34:1959 days 1 hr ago0x8a6c8dbd3fe8dcd9a84eeebd534f7ccb33f64e09 IN  Uniswap V2: ETH/USDC UNI Pool0 Ether0.00301876824
0xa07b73f871fa91369986b72b48c03ddbaf751c3a540b90550127f1f902e0b9a7Exit128632452021-07-20 11:52:0059 days 8 hrs ago0x2a4de8a61cb7882c06c9c45ea187adbdf7ccc286 IN  Uniswap V2: ETH/USDC UNI Pool0 Ether0.00239100422
0x91c6f0141d202308c30d5e56059f01b826fc50336a3c6acf4191f57083430774Exit128120862021-07-12 11:06:2767 days 9 hrs ago0xd51062a4af7b76ee0b2893ef8b52acc155393e3d IN  Uniswap V2: ETH/USDC UNI Pool0 Ether0.00168142821
0x518c2886d92755eff23bee5d2f5573940562a6babd5ea9ddbe31d238dab28887Exit127984302021-07-10 7:54:5969 days 12 hrs ago0xef22db40285de645fb24cc646e30665f66cbe5d3 IN  Uniswap V2: ETH/USDC UNI Pool0 Ether0.001521962212.1
0x7f780c6fcd3c1a5c122d4d0b129a74a3bbda79d0c5a7d9aa7c881cccf0cb8b60Exit127966772021-07-10 1:27:3369 days 19 hrs ago0xcc29f9b383385a0b52134a8c9bf408e70f8f26c6 IN  Uniswap V2: ETH/USDC UNI Pool0 Ether0.00176094814
0x3e5c77c00803ffa143dd0098abf47887caf26736c14269ffebbd39347e37b663Exit127661462021-07-05 7:27:2474 days 13 hrs ago0x165c830d28e41c0a2de9109876a627ddc0c2dc89 IN  Uniswap V2: ETH/USDC UNI Pool0 Ether0.0008694568
0x28b2ee2cca3024787805897efa8a975401d797ae78f47a46aeb2383611f3d845Exit127566652021-07-03 20:08:0976 days 32 mins ago0xbbbcf43508ed0d5999fbd0590ef030b2f5dfe2f2 IN  Uniswap V2: ETH/USDC UNI Pool0 Ether0.00074990586.9
0x92e816ea7d1876017489a6a81d262055899b964d0257d5315c2bfd176f0a19b6Exit127525752021-07-03 4:43:4176 days 15 hrs ago0x95e83813064afe9c3223158442a21c8e6302ec08 IN  Uniswap V2: ETH/USDC UNI Pool0 Ether0.0010062568
0xf9dcec66475db74a62973a5b4dcf2dcdb62e8dae0e3272dee3c49f11a6d40043Exit127483842021-07-02 13:07:3177 days 7 hrs ago0xc8c04ba093a51e56dd161c9f6ca0f56e5d6d1e78 IN  Uniswap V2: ETH/USDC UNI Pool0 Ether0.000400345
0xee05855073f10f2ca4e46d0b86309820539af321b027fa97f7b9c0b788f2aa5aExit127237392021-06-28 17:07:2481 days 3 hrs ago0x6e3cd4f11f5e34ec43514171ec2f52a021ad1976 IN  Uniswap V2: ETH/USDC UNI Pool0 Ether0.0044023735
0x2bc2f2816c0eb23a339acf85c329d371d55e6dfb9a5431a36805552db0e35310Exit126968032021-06-24 12:22:5985 days 8 hrs ago0x622d36b2df4f97328f0ebb030fe51cc1fb8613ce IN  Uniswap V2: ETH/USDC UNI Pool0 Ether0.0007024215
0x19cbc57a212f8efe28efab3d325989aaba84e59ec050873ce4ebfa196a843581Exit126967982021-06-24 12:20:4985 days 8 hrs ago0x622d36b2df4f97328f0ebb030fe51cc1fb8613ce IN  Uniswap V2: ETH/USDC UNI Pool0 Ether0.00144122418
0xa50377aa0c53fcf7f30e98051812233497b1b9409e646e29224ed96e0386ccdeExit126707382021-06-20 10:33:1889 days 10 hrs ago0x0db52ebf79f1b86408666095e537de787b19250a IN  Uniswap V2: ETH/USDC UNI Pool0 Ether0.00282573226
0x92e759a9380c9e4741cab2f6a7b6835de6cae5b06c944e877fb9b13d6eb46677Get Reward126669592021-06-19 20:28:1490 days 12 mins ago0xc8c04ba093a51e56dd161c9f6ca0f56e5d6d1e78 IN  Uniswap V2: ETH/USDC UNI Pool0 Ether0.000380136
[ Download CSV Export 

OVERVIEW

ETH/USDC pool on Uniswap V2.

Latest 1 internal transaction
Parent Txn Hash Block From To Value
0x30984ae54b6700d3d96504c7683c6963674779e7efce479f178eb37a9df482c5108751962020-09-16 20:05:58366 days 35 mins ago 0x3032ab3fa8c01d786d29dade018d7f2017918e12  Contract Creation0 Ether
[ Download CSV Export 
Loading

Contract Source Code Verified (Similar Match)
Note: This contract matches the deployed ByteCode of the Source Code for Contract 0x6c3e4cb2e96b01f4b866965a91ed4437839a121a

Contract Name:
StakingRewards

Compiler Version
v0.5.16+commit.9c3226ce

Optimization Enabled:
Yes with 999999 runs

Other Settings:
default evmVersion, None license

Contract Source Code (Solidity)

/**
 *Submitted for verification at Etherscan.io on 2020-09-16
*/

pragma solidity ^0.5.16;

/**
 * @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 Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @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) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @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) {
        require(b <= a, "SafeMath: subtraction overflow");
        uint256 c = a - b;

        return c;
    }

    /**
     * @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) {
        // 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-solidity/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts 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) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, "SafeMath: division by zero");
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts 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) {
        require(b != 0, "SafeMath: modulo by zero");
        return a % b;
    }
}

/**
 * @dev Interface of the ERC20 standard as defined in the EIP. Does not include
 * the optional functions; to access them see `ERC20Detailed`.
 */
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.
     *
     * > 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);
}

/**
 * @dev Optional functions from the ERC20 standard.
 */
contract ERC20Detailed is IERC20 {
    string private _name;
    string private _symbol;
    uint8 private _decimals;

    /**
     * @dev Sets the values for `name`, `symbol`, and `decimals`. All three of
     * these values are immutable: they can only be set once during
     * construction.
     */
    constructor (string memory name, string memory symbol, uint8 decimals) public {
        _name = name;
        _symbol = symbol;
        _decimals = decimals;
    }

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

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view 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.
     *
     * > Note that 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 returns (uint8) {
        return _decimals;
    }
}


/**
 * @dev Collection of functions related to the address type,
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * This test is non-exhaustive, and there may be false-negatives: during the
     * execution of a contract's constructor, its address will be reported as
     * not containing a contract.
     *
     * > It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies in extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }
}

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for ERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require((value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).add(value);
        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(value);
        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves.

        // A Solidity high level call has three parts:
        //  1. The target address is checked to verify it contains contract code
        //  2. The call itself is made, and success asserted
        //  3. The return value is decoded, which in turn checks the size of the returned data.
        // solhint-disable-next-line max-line-length
        require(address(token).isContract(), "SafeERC20: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = address(token).call(data);
        require(success, "SafeERC20: low-level call failed");

        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the `nonReentrant` modifier
 * available, which can be aplied 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.
 */
contract ReentrancyGuard {
    /// @dev counter to allow mutex lock with only one SSTORE operation
    uint256 private _guardCounter;

    constructor () internal {
        // The counter starts at one to prevent changing it from zero to a non-zero
        // value, which is a more expensive operation.
        _guardCounter = 1;
    }

    /**
     * @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() {
        _guardCounter += 1;
        uint256 localCounter = _guardCounter;
        _;
        require(localCounter == _guardCounter, "ReentrancyGuard: reentrant call");
    }
}

// Inheritancea
interface IStakingRewards {
    // Views
    function lastTimeRewardApplicable() external view returns (uint256);

    function rewardPerToken() external view returns (uint256);

    function earned(address account) external view returns (uint256);

    function getRewardForDuration() external view returns (uint256);

    function totalSupply() external view returns (uint256);

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

    // Mutative

    function stake(uint256 amount) external;

    function withdraw(uint256 amount) external;

    function getReward() external;

    function exit() external;
}

contract RewardsDistributionRecipient {
    address public rewardsDistribution;

    function notifyRewardAmount(uint256 reward) external;

    modifier onlyRewardsDistribution() {
        require(msg.sender == rewardsDistribution, "Caller is not RewardsDistribution contract");
        _;
    }
}

contract StakingRewards is IStakingRewards, RewardsDistributionRecipient, ReentrancyGuard {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    /* ========== STATE VARIABLES ========== */

    IERC20 public rewardsToken;
    IERC20 public stakingToken;
    uint256 public periodFinish = 0;
    uint256 public rewardRate = 0;
    uint256 public rewardsDuration = 60 days;
    uint256 public lastUpdateTime;
    uint256 public rewardPerTokenStored;

    mapping(address => uint256) public userRewardPerTokenPaid;
    mapping(address => uint256) public rewards;

    uint256 private _totalSupply;
    mapping(address => uint256) private _balances;

    /* ========== CONSTRUCTOR ========== */

    constructor(
        address _rewardsDistribution,
        address _rewardsToken,
        address _stakingToken
    ) public {
        rewardsToken = IERC20(_rewardsToken);
        stakingToken = IERC20(_stakingToken);
        rewardsDistribution = _rewardsDistribution;
    }

    /* ========== VIEWS ========== */

    function totalSupply() external view returns (uint256) {
        return _totalSupply;
    }

    function balanceOf(address account) external view returns (uint256) {
        return _balances[account];
    }

    function lastTimeRewardApplicable() public view returns (uint256) {
        return Math.min(block.timestamp, periodFinish);
    }

    function rewardPerToken() public view returns (uint256) {
        if (_totalSupply == 0) {
            return rewardPerTokenStored;
        }
        return
            rewardPerTokenStored.add(
                lastTimeRewardApplicable().sub(lastUpdateTime).mul(rewardRate).mul(1e18).div(_totalSupply)
            );
    }

    function earned(address account) public view returns (uint256) {
        return _balances[account].mul(rewardPerToken().sub(userRewardPerTokenPaid[account])).div(1e18).add(rewards[account]);
    }

    function getRewardForDuration() external view returns (uint256) {
        return rewardRate.mul(rewardsDuration);
    }

    /* ========== MUTATIVE FUNCTIONS ========== */

    function stakeWithPermit(uint256 amount, uint deadline, uint8 v, bytes32 r, bytes32 s) external nonReentrant updateReward(msg.sender) {
        require(amount > 0, "Cannot stake 0");
        _totalSupply = _totalSupply.add(amount);
        _balances[msg.sender] = _balances[msg.sender].add(amount);

        // permit
        IUniswapV2ERC20(address(stakingToken)).permit(msg.sender, address(this), amount, deadline, v, r, s);

        stakingToken.safeTransferFrom(msg.sender, address(this), amount);
        emit Staked(msg.sender, amount);
    }

    function stake(uint256 amount) external nonReentrant updateReward(msg.sender) {
        require(amount > 0, "Cannot stake 0");
        _totalSupply = _totalSupply.add(amount);
        _balances[msg.sender] = _balances[msg.sender].add(amount);
        stakingToken.safeTransferFrom(msg.sender, address(this), amount);
        emit Staked(msg.sender, amount);
    }

    function withdraw(uint256 amount) public nonReentrant updateReward(msg.sender) {
        require(amount > 0, "Cannot withdraw 0");
        _totalSupply = _totalSupply.sub(amount);
        _balances[msg.sender] = _balances[msg.sender].sub(amount);
        stakingToken.safeTransfer(msg.sender, amount);
        emit Withdrawn(msg.sender, amount);
    }

    function getReward() public nonReentrant updateReward(msg.sender) {
        uint256 reward = rewards[msg.sender];
        if (reward > 0) {
            rewards[msg.sender] = 0;
            rewardsToken.safeTransfer(msg.sender, reward);
            emit RewardPaid(msg.sender, reward);
        }
    }

    function exit() external {
        withdraw(_balances[msg.sender]);
        getReward();
    }

    /* ========== RESTRICTED FUNCTIONS ========== */

    function notifyRewardAmount(uint256 reward) external onlyRewardsDistribution updateReward(address(0)) {
        if (block.timestamp >= periodFinish) {
            rewardRate = reward.div(rewardsDuration);
        } else {
            uint256 remaining = periodFinish.sub(block.timestamp);
            uint256 leftover = remaining.mul(rewardRate);
            rewardRate = reward.add(leftover).div(rewardsDuration);
        }

        // Ensure the provided reward amount is not more than the balance in the contract.
        // This keeps the reward rate in the right range, preventing overflows due to
        // very high values of rewardRate in the earned and rewardsPerToken functions;
        // Reward + leftover must be less than 2^256 / 10^18 to avoid overflow.
        uint balance = rewardsToken.balanceOf(address(this));
        require(rewardRate <= balance.div(rewardsDuration), "Provided reward too high");

        lastUpdateTime = block.timestamp;
        periodFinish = block.timestamp.add(rewardsDuration);
        emit RewardAdded(reward);
    }

    /* ========== MODIFIERS ========== */

    modifier updateReward(address account) {
        rewardPerTokenStored = rewardPerToken();
        lastUpdateTime = lastTimeRewardApplicable();
        if (account != address(0)) {
            rewards[account] = earned(account);
            userRewardPerTokenPaid[account] = rewardPerTokenStored;
        }
        _;
    }

    /* ========== EVENTS ========== */

    event RewardAdded(uint256 reward);
    event Staked(address indexed user, uint256 amount);
    event Withdrawn(address indexed user, uint256 amount);
    event RewardPaid(address indexed user, uint256 reward);
}

interface IUniswapV2ERC20 {
    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address","name":"_rewardsDistribution","type":"address"},{"internalType":"address","name":"_rewardsToken","type":"address"},{"internalType":"address","name":"_stakingToken","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"RewardAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"RewardPaid","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Staked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdrawn","type":"event"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"earned","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"exit","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"getReward","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"getRewardForDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"lastTimeRewardApplicable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"lastUpdateTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"reward","type":"uint256"}],"name":"notifyRewardAmount","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"periodFinish","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"rewardPerToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"rewardPerTokenStored","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"rewardRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"rewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"rewardsDistribution","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"rewardsDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"rewardsToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"stake","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"stakeWithPermit","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"stakingToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userRewardPerTokenPaid","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdraw","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"}]

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

Deployed ByteCode Sourcemap

15865:5669:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;15865:5669:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17630:198;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;17630:198:0;;;;:::i;:::-;;;;;;;;;;;;;;;;16412:42;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;16412:42:0;;;;:::i;16932:93::-;;;:::i;17836:121::-;;;:::i;18962:357::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;18962:357:0;;:::i;:::-;;16221:40;;;:::i;19803:1083::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;19803:1083:0;;:::i;19327:307::-;;;:::i;15600:34::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;17033:112;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;17033:112:0;;;;:::i;16114:26::-;;;:::i;16185:29::-;;;:::i;17153:131::-;;;:::i;16348:57::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;16348:57:0;;;;:::i;18585:369::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;18585:369:0;;:::i;16268:29::-;;;:::i;17292:330::-;;;:::i;16081:26::-;;;:::i;16304:35::-;;;:::i;19642:97::-;;;:::i;16147:31::-;;;:::i;18019:558::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;18019:558:0;;;;;;;;;;;;;;;;;;;;;;;;:::i;17630:198::-;17803:16;;;17684:7;17803:16;;;:7;:16;;;;;;;;;17755:22;:31;;;;;;17711:109;;17803:16;17711:87;;17793:4;;17711:77;;17734:53;;:16;:14;:16::i;:::-;:20;:53;:20;:53;:::i;:::-;17711:18;;;;;;;:9;:18;;;;;;;:77;:22;:77;:::i;:::-;:81;:87;:81;:87;:::i;:::-;:91;:109;:91;:109;:::i;:::-;17704:116;17630:198;-1:-1:-1;;17630:198:0:o;16412:42::-;;;;;;;;;;;;;:::o;16932:93::-;17005:12;;16932:93;;:::o;17836:121::-;17891:7;17918:31;17933:15;;17918:10;;:14;;:31;;;;:::i;:::-;17911:38;;17836:121;:::o;18962:357::-;14718:1;14701:18;;;;;;;;19029:10;21012:16;:14;:16::i;:::-;20989:20;:39;21056:26;:24;:26::i;:::-;21039:14;:43;21097:21;;;;21093:157;;21154:15;21161:7;21154:6;:15::i;:::-;21135:16;;;;;;;:7;:16;;;;;;;;:34;;;;21218:20;;21184:22;:31;;;;;;:54;21093:157;19069:1;19060:6;:10;19052:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19118:12;;:24;;19135:6;19118:24;:16;:24;:::i;:::-;19103:12;:39;19187:10;19177:21;;;;:9;:21;;;;;;:33;;19203:6;19177:33;:25;:33;:::i;:::-;19163:10;19153:21;;;;:9;:21;;;;;:57;;;;19221:12;;:45;;19153:21;19221:12;;;;19259:6;19221:25;:45::i;:::-;19282:29;;;;;;;;19292:10;;19282:29;;;;;;;;;;14777:1;14813:13;;14797:12;:29;14789:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18962:357;;:::o;16221:40::-;;;;:::o;19803:1083::-;15772:19;;;;15758:10;:33;15750:88;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19901:1;21012:16;:14;:16::i;:::-;20989:20;:39;21056:26;:24;:26::i;:::-;21039:14;:43;21097:21;;;;21093:157;;21154:15;21161:7;21154:6;:15::i;:::-;21135:16;;;;;;;:7;:16;;;;;;;;:34;;;;21218:20;;21184:22;:31;;;;;;:54;21093:157;19939:12;;19920:15;:31;19916:318;;19992:15;;19981:27;;:6;;:27;:10;:27;:::i;:::-;19968:10;:40;19916:318;;;20061:12;;20041:17;;20061:33;;20078:15;20061:33;:16;:33;:::i;:::-;20041:53;;20109:16;20128:25;20142:10;;20128:9;:13;;:25;;;;:::i;:::-;20206:15;;20109:44;;-1:-1:-1;20181:41:0;;:20;:6;20109:44;20181:20;:10;:20;:::i;:41::-;20168:10;:54;-1:-1:-1;;19916:318:0;20609:12;;:37;;;;;;20640:4;20609:37;;;;;;20594:12;;20609;;;:22;;:37;;;;;;;;;;;;;;:12;:37;;;5:2:-1;;;;30:1;27;20:12;5:2;20609:37:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;20609:37:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;20609:37:0;20691:15;;20609:37;;-1:-1:-1;20679:28:0;;20609:37;;20679:28;:11;:28;:::i;:::-;20665:10;;:42;;20657:79;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20766:15;20749:14;:32;;;20827:15;;20807:36;;20766:15;20807:36;:19;:36;:::i;:::-;20792:12;:51;20859:19;;;;;;;;;;;;;;;;;21260:1;15849;19803:1083;:::o;19327:307::-;14718:1;14701:18;;;;;;;;19381:10;21012:16;:14;:16::i;:::-;20989:20;:39;21056:26;:24;:26::i;:::-;21039:14;:43;21097:21;;;;21093:157;;21154:15;21161:7;21154:6;:15::i;:::-;21135:16;;;;;;;:7;:16;;;;;;;;:34;;;;21218:20;;21184:22;:31;;;;;;:54;21093:157;19429:10;19404:14;19421:19;;;:7;:19;;;;;;19455:10;;19451:176;;19490:10;19504:1;19482:19;;;:7;:19;;;;;:23;19520:12;;:45;;19482:19;19520:12;;;;19558:6;19520:25;:45::i;:::-;19585:30;;;;;;;;19596:10;;19585:30;;;;;;;;;;19451:176;21260:1;14777;14813:13;;14797:12;:29;14789:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19327:307;:::o;15600:34::-;;;;;;:::o;17033:112::-;17119:18;;17092:7;17119:18;;;:9;:18;;;;;;;17033:112::o;16114:26::-;;;;;;:::o;16185:29::-;;;;:::o;17153:131::-;17210:7;17237:39;17246:15;17263:12;;17237:8;:39::i;16348:57::-;;;;;;;;;;;;;:::o;18585:369::-;14718:1;14701:18;;;;;;;;18651:10;21012:16;:14;:16::i;:::-;20989:20;:39;21056:26;:24;:26::i;:::-;21039:14;:43;21097:21;;;;21093:157;;21154:15;21161:7;21154:6;:15::i;:::-;21135:16;;;;;;;:7;:16;;;;;;;;:34;;;;21218:20;;21184:22;:31;;;;;;:54;21093:157;18691:1;18682:6;:10;18674:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18737:12;;:24;;18754:6;18737:24;:16;:24;:::i;:::-;18722:12;:39;18806:10;18796:21;;;;:9;:21;;;;;;:33;;18822:6;18796:33;:25;:33;:::i;:::-;18782:10;18772:21;;;;:9;:21;;;;;:57;;;;18840:12;;:64;;18772:21;18840:12;;;;18890:4;18897:6;18840:29;:64::i;:::-;18920:26;;;;;;;;18927:10;;18920:26;;;;;;;;;;14777:1;14813:13;;14797:12;:29;14789:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16268:29;;;;:::o;17292:330::-;17339:7;17363:12;;17379:1;17363:17;17359:77;;;-1:-1:-1;17404:20:0;;17397:27;;17359:77;17466:148;17509:90;17586:12;;17509:72;17576:4;17509:62;17560:10;;17509:46;17540:14;;17509:26;:24;:26::i;:46::-;:50;:62;:50;:62;:::i;:90::-;17466:20;;;:148;:24;:148;:::i;16081:26::-;;;;;;:::o;16304:35::-;;;;:::o;19642:97::-;19697:10;19687:21;;;;:9;:21;;;;;;19678:31;;:8;:31::i;:::-;19720:11;:9;:11::i;:::-;19642:97::o;16147:31::-;;;;:::o;18019:558::-;14718:1;14701:18;;;;;;;;18141:10;21012:16;:14;:16::i;:::-;20989:20;:39;21056:26;:24;:26::i;:::-;21039:14;:43;21097:21;;;;21093:157;;21154:15;21161:7;21154:6;:15::i;:::-;21135:16;;;;;;;:7;:16;;;;;;;;:34;;;;21218:20;;21184:22;:31;;;;;;:54;21093:157;18181:1;18172:6;:10;18164:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18227:12;;:24;;18244:6;18227:24;:16;:24;:::i;:::-;18212:12;:39;18296:10;18286:21;;;;:9;:21;;;;;;:33;;18312:6;18286:33;:25;:33;:::i;:::-;18272:10;18262:21;;;;:9;:21;;;;;;:57;;;;18375:12;;18351:99;;;;;;;;;;;;18417:4;18351:99;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18262:21;18375:12;;;;18351:45;;:99;;;;;18262:21;18351:99;;;;;;18262:21;18375:12;18351:99;;;5:2:-1;;;;30:1;27;20:12;5:2;18351:99:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;18463:12:0;;:64;;-1:-1:-1;18463:12:0;;;-1:-1:-1;18493:10:0;18513:4;18520:6;18463:64;:29;:64;:::i;:::-;18543:26;;;;;;;;18550:10;;18543:26;;;;;;;;;;14777:1;14813:13;;14797:12;:29;14789:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18019:558;;;;;;:::o;2088:184::-;2146:7;2179:1;2174;:6;;2166:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2238:5:0;;;2088:184::o;2523:470::-;2581:7;2825:6;2821:47;;-1:-1:-1;2855:1:0;2848:8;;2821:47;2892:5;;;2896:1;2892;:5;:1;2916:5;;;;;:10;2908:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2984:1;2523:470;-1:-1:-1;;;2523:470:0:o;3461:333::-;3519:7;3618:1;3614;:5;3606:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3661:9;3677:1;3673;:5;;;;;;;3461:333;-1:-1:-1;;;;3461:333:0:o;1632:181::-;1690:7;1722:5;;;1746:6;;;;1738:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10280:176;10389:58;;;10412:14;10389:58;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;10389:58:0;;;;;;;;25:18:-1;;61:17;;10389:58:0;182:15:-1;10412:23:0;179:29:-1;160:49;;10363:85:0;;10382:5;;10363:18;:85::i;:::-;10280:176;;;:::o;375:106::-;433:7;464:1;460;:5;:13;;472:1;460:13;;;-1:-1:-1;468:1:0;;453:20;-1:-1:-1;375:106:0:o;10464:204::-;10591:68;;;10614:18;10591:68;;;;;;;;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;10591:68:0;;;;;;;;25:18:-1;;61:17;;10591:68:0;182:15:-1;10614:27:0;179:29:-1;160:49;;10565:95:0;;10584:5;;10565:18;:95::i;:::-;10464:204;;;;:::o;12274:1114::-;12878:27;12886:5;12878:25;;;:27::i;:::-;12870:71;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13015:12;13029:23;13064:5;13056:19;;13076:4;13056:25;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;176:10;;164:23;;139:12;;;;;98:2;89:12;;;;114;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;13056:25:0;;;;;;;;;;;;;;;;;;;;;;;;14:1:-1;21;16:31;;;;75:4;69:11;64:16;;144:4;140:9;133:4;115:16;111:27;107:43;104:1;100:51;94:4;87:65;169:16;166:1;159:27;225:16;222:1;215:4;212:1;208:12;193:49;7:242;;16:31;36:4;31:9;;7:242;;13014:67:0;;;;13100:7;13092:52;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13161:17;;:21;13157:224;;13303:10;13292:30;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;13292:30:0;13284:85;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9293:422;9660:20;9699:8;;;9293:422::o

Swarm Source

bzzr://f909fa3a0910f3b22e95648cbca716b06606dafe47e4b95662d41e95d993a437
Block Transaction Difficulty Gas Used Reward
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.