Contract

Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.12;

import "./SafeMath.sol";

contract PlasmaVesting {
    using SafeMath for uint256;

    address public ppay;
    address public recipient;

    uint256 public vestingAmount;
    uint256 public vestingBegin;
    uint256 public vestingCliff;
    uint256 public vestingEnd;

    uint256 public lastUpdate;

    constructor(
        address ppay_,
        address recipient_,
        uint256 vestingAmount_,
        uint256 vestingBegin_,
        uint256 vestingCliff_,
        uint256 vestingEnd_
    ) public {
        require(vestingBegin_ >= block.timestamp, 'PlasmaVesting::constructor: vesting begin too early');
        require(vestingCliff_ >= vestingBegin_, 'PlasmaVesting::constructor: cliff is too early');
        require(vestingEnd_ > vestingCliff_, 'PlasmaVesting::constructor: end is too early');

        ppay = ppay_;
        recipient = recipient_;

        vestingAmount = vestingAmount_;
        vestingBegin = vestingBegin_;
        vestingCliff = vestingCliff_;
        vestingEnd = vestingEnd_;

        lastUpdate = vestingBegin;
    }

    function setRecipient(address recipient_) external {
        require(msg.sender == recipient, 'PlasmaVesting::setRecipient: unauthorized');
        recipient = recipient_;
    }

    function claim() external returns (bool) {
        require(block.timestamp >= vestingCliff, 'PlasmaVesting::claim: not time yet');
        uint256 amount;
        if (block.timestamp >= vestingEnd) {
            amount = IPpay(ppay).balanceOf(address(this));
        } else {
            amount = vestingAmount.mul(block.timestamp - lastUpdate).div(vestingEnd - vestingBegin);
            lastUpdate = block.timestamp;
        }
        return IPpay(ppay).transfer(recipient, amount);
    }
}

interface IPpay {
    function balanceOf(address account) external view returns (uint256);
    function transfer(address dst, uint256 rawAmount) external returns (bool);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.12;

// From https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/math/Math.sol
// Subject to the MIT license.

/**
 * @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 addition of two unsigned integers, reverting with custom message on overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, errorMessage);

        return c;
    }

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

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on underflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot underflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        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-contracts/pull/522
        if (a == 0) {
            return 0;
        }

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

        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, string memory errorMessage) 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-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, errorMessage);

        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) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers.
     * Reverts 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) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, errorMessage);
        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) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message 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, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"ppay_","type":"address"},{"internalType":"address","name":"recipient_","type":"address"},{"internalType":"uint256","name":"vestingAmount_","type":"uint256"},{"internalType":"uint256","name":"vestingBegin_","type":"uint256"},{"internalType":"uint256","name":"vestingCliff_","type":"uint256"},{"internalType":"uint256","name":"vestingEnd_","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"claim","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"lastUpdate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ppay","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"recipient","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient_","type":"address"}],"name":"setRecipient","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"vestingAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"vestingBegin","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"vestingCliff","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"vestingEnd","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

85:1710:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;203:28;;;:::i;:::-;;;;;;;;;;;;;;;;1120:177;;;;;;;;;;;;;;;;-1:-1:-1;1120:177:0;;;;:::i;:::-;;1303:490;;;:::i;:::-;;;;;;;;;;;;;;;;;;172:24;;;:::i;:::-;;;;;;;;;;;;;;;;;;;147:19;;;:::i;303:25::-;;;:::i;335:::-;;;:::i;237:27::-;;;:::i;270:::-;;;:::i;203:28::-;;;;:::o;1120:177::-;1203:9;;;;1189:10;:23;1181:77;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1268:9;:22;;;;;;;;;;;;;;;1120:177::o;1303:490::-;1338:4;1381:12;;1362:15;:31;;1354:78;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1442:14;1489:10;;1470:15;:29;1466:265;;1530:4;;1524:36;;;;;;1554:4;1524:36;;;;;;1530:4;;;;;1524:21;;:36;;;;;;;;;;;;;;;1530:4;1524:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1524:36:0;;-1:-1:-1;1466:265:0;;;1600:78;1665:12;;1652:10;;:25;1600:47;1636:10;;1618:15;:28;1600:13;;:17;;:47;;;;:::i;:::-;:51;;:78::i;:::-;1705:15;1692:10;:28;1591:87;-1:-1:-1;1466:265:0;1753:4;;;;1768:9;1747:39;;;;;;1753:4;1768:9;;;1747:39;;;;;;;;;;;;1753:4;;;;;1747:20;;:39;;;;;;;;;;;;;;;;;;1753:4;1747:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1747:39:0;;-1:-1:-1;;1303:490:0;:::o;172:24::-;;;;;;:::o;147:19::-;;;;;;:::o;303:25::-;;;;:::o;335:::-;;;;:::o;237:27::-;;;;:::o;270:::-;;;;:::o;2689:459:1:-;2747:7;2988:6;2984:45;;-1:-1:-1;3017:1:1;3010:8;;2984:45;3051:5;;;3055:1;3051;:5;:1;3074:5;;;;;:10;3066:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3140:1;-1:-1:-1;2689:459:1;;;;;:::o;4300:130::-;4358:7;4384:39;4388:1;4391;4384:39;;;;;;;;;;;;;;;;;4991:7;5091:12;5084:5;5076:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5114:9;5130:1;5126;:5;;;;;;;4905:338;-1:-1:-1;;;;;4905:338:1:o

ipfs://51fa05ebd53daec732ff4f0f053b8029f8b006070907346980aa5163361e2949