Contract 0x3fe30742ad8491402c8aee251ff57e3e9b18ff87 1

 
 
Txn Hash Method
Block
From
To
Value [Txn Fee]
0x8b7473fe7e8e6ffbe232e633d6e7bcf322a992790ea9cdcf660a7a31b9f90412Withdraw To334525132022-09-23 4:37:311 day 16 hrs ago0xa854a8ba05d62eb14c7b4e220e000a011905d677 IN  0x3fe30742ad8491402c8aee251ff57e3e9b18ff870 MATIC0.00254696 40.000000015
0x3d072e9dfbe5ee0f2689eb2cdeb3b650874476db0adf33e134d5fd162f6b5e88Withdraw To322692062022-08-24 13:42:3431 days 6 hrs ago0x104d86705c46e9422b803af522b43809f1c8e4e9 IN  0x3fe30742ad8491402c8aee251ff57e3e9b18ff870 MATIC0.001397589726 30.000208783
0x405113530329719b1375e227aab60d75e9d61ccad926b40ee2b75b2e5dadfbb1Withdraw To315465602022-08-05 11:27:3750 days 9 hrs ago0xc542cc1cdf2d93e244e2d71bcbbdaf1eb5da5da2 IN  0x3fe30742ad8491402c8aee251ff57e3e9b18ff870 MATIC0.001802986085 38.702315836
0x2dde46a8f0b004a10727b37780ff50cf1a4d2eb13697e3313d45ad648e493aa3Withdraw To299436892022-06-24 11:56:5592 days 8 hrs ago0x3ec269fa04127d2a9f6c37d2461eb3442373483c IN  0x3fe30742ad8491402c8aee251ff57e3e9b18ff870 MATIC0.002019191437 31.713886463
0x9dd47e6051afb651b7ffc00f8819ba805cdeb575fb45059c73c7d4943868dc69Withdraw To294722982022-06-12 9:51:38104 days 10 hrs ago0x6a68b9cf65d64d060854f2cbb6825b6026bde920 IN  0x3fe30742ad8491402c8aee251ff57e3e9b18ff870 MATIC0.001914526829 30.069999999
0x957d873c38bd760a7c7b3d00f77af1cf686577c81475916f8055b2a82ca41fdcWithdraw To293227062022-06-08 16:53:37108 days 3 hrs ago0xcd66a0ae53cc1f58b2e709e5def44d06a19c71ce IN  0x3fe30742ad8491402c8aee251ff57e3e9b18ff870 MATIC0.001914526829 30.069999998
0x2c1f4d804b4ad26ff2cd58536a4a97b1d7d888f66b2a0937264936f1f8271cb5Withdraw To288800082022-05-28 17:29:27119 days 3 hrs ago0x7ac248c11ce1f3db0f97f03510cdfec1e72c3e15 IN  0x3fe30742ad8491402c8aee251ff57e3e9b18ff870 MATIC0.001596464684 34.269194275
0xbc134b19cb84b0b67e6bc466d972366503a92023c7e16db84ca0d6557667f2afWithdraw To288117942022-05-27 0:27:46120 days 20 hrs ago0x17e071372ba2c7ec0d21030e27db41e9ab74b2eb IN  0x3fe30742ad8491402c8aee251ff57e3e9b18ff870 MATIC0.00324798651
0x31592252ffb38973be1b7cfc5f6b9f5acc3d02052be5a38f7a9449552e1596f3Withdraw To285541652022-05-20 16:05:17127 days 4 hrs ago0xd66bb2d2935487fcef48bf4e26b3101fbeb7d744 IN  0x3fe30742ad8491402c8aee251ff57e3e9b18ff870 MATIC0.002711438833 42.575115943
0x63252dac50da0c3386c3e1f194dd4e61e76d0643a06b417e2c98f0f843f13bd1Withdraw To282906382022-05-14 2:20:39133 days 18 hrs ago0x41c54ec24fa2786c44db9b7a7ca5e78f10f6eca9 IN  0x3fe30742ad8491402c8aee251ff57e3e9b18ff870 MATIC0.001400841017 30.069999937
0xbf06db03c4eb44510e2b4d0999538304d87054dd9830ca8749668b1f2169c04dWithdraw To280483672022-05-07 22:08:13139 days 22 hrs ago0x7d0c62a79805600f2c751c4d4be01c9c5a7d0339 IN  0x3fe30742ad8491402c8aee251ff57e3e9b18ff870 MATIC0.004515869504 96.936193372
0x8d715624d6a9e9e6aa9cf347a7a8c81b3b28753298daf438f5c6f3d1f3bfc096Withdraw To279005382022-05-04 4:25:45143 days 16 hrs ago0x74040b0f71568251908b09d0d6943088a206e0fd IN  0x3fe30742ad8491402c8aee251ff57e3e9b18ff870 MATIC0.00197426631
0x2fd631b266ae02abdb73bb2588c6b32d6300192daff7f09b2458efe0df618f1eWithdraw To278762342022-05-03 13:32:35144 days 7 hrs ago0xae7853a2ab2d63e2d9804a4dd848a4c7f035ebff IN  0x3fe30742ad8491402c8aee251ff57e3e9b18ff870 MATIC0.004637158891 72.812845699
0x6b6977a130dd0dda29ea45b1e8f6f42bc64074d3a9f774e5c4942af6fb4338bbWithdraw To277408472022-04-30 3:33:16147 days 17 hrs ago0x22d9961723598f031d54c5f98df08a2eded7f4e2 IN  0x3fe30742ad8491402c8aee251ff57e3e9b18ff870 MATIC0.001815899939 38.97952044
0xa4a55bef60ee08f895d37805bfdf964da951173a78e165d102d6ebc69bcdd011Withdraw To276935462022-04-28 22:45:18148 days 21 hrs ago0x011d0330f967b46df4895ecb6f0db37bc414bec7 IN  0x3fe30742ad8491402c8aee251ff57e3e9b18ff870 MATIC0.001989079108 31.232596001
0x790a9499c7bea8bd5ec26e89e73871daeb31dac72d1ac32aa2580daabfc73d6aWithdraw To275660092022-04-25 17:22:59152 days 3 hrs ago0xd8c84eac995150662cc052e6ac76ec184fcf1122 IN  0x3fe30742ad8491402c8aee251ff57e3e9b18ff870 MATIC0.006626910254 104.083781032
0x245dd1502b1883bcf60565334c8ecce29f3c130a8bddf96a1a67fdae0b57a046Withdraw To274127222022-04-21 19:10:44156 days 1 hr ago0x0b2466dbf5237751a9fc67646e9670fffe769c1f IN  0x3fe30742ad8491402c8aee251ff57e3e9b18ff870 MATIC0.001940341712 30.475454495
0x451d9ca8817aa7007ff84a001accf371c77dacea21d6efcbb31c897eb6a8d75cWithdraw To274125582022-04-21 19:05:08156 days 1 hr ago0x242e6fd94720e169f8078d8f08e1c3ab0b08cbea IN  0x3fe30742ad8491402c8aee251ff57e3e9b18ff870 MATIC0.002290154092 35.969688427
0x1ef81535a1d5b2390c5adf679a0eb01c2c3fd24ac3dad5b9fa0182bc7681f559Withdraw To274125512022-04-21 19:04:54156 days 1 hr ago0xf4c7685e996bbac45132ef41928494e05933e64e IN  0x3fe30742ad8491402c8aee251ff57e3e9b18ff870 MATIC0.001711658727 36.741912316
0x038be9ccd31b62746448062c3ce536b15c40abbc790b7570921968750284a4e5Withdraw To274125252022-04-21 19:03:58156 days 1 hr ago0x49d9c379407e6d046cffea3cd74f38b5fb2537a3 IN  0x3fe30742ad8491402c8aee251ff57e3e9b18ff870 MATIC0.002426744133 38.115003124
0xdfdeba6a727a3ac62a80c6e25588f4664a38e9fa757e9eef9a03cabba3f799dcWithdraw To274125162022-04-21 19:03:40156 days 1 hr ago0x21748c3df0d81089c25ec851f83189bed229a4a5 IN  0x3fe30742ad8491402c8aee251ff57e3e9b18ff870 MATIC0.002125326307 33.380865218
0x4719449efa05e55a7859d282c61c823f207ba4d022e9a357de685a24314392cdWithdraw To266095872022-04-01 8:12:14176 days 12 hrs ago0x97424388a67dc0d4dfd51e90e1b507d85da3bd52 IN  0x3fe30742ad8491402c8aee251ff57e3e9b18ff870 MATIC0.000240991519 3.785068391
0x5646f9fce8f3a6004903beac85dd3000c8ad92fc51e1bf038ab4335c101112e6Withdraw To263050802022-03-24 11:58:35184 days 8 hrs ago0x1a918a8386f75f382e2a1b2e10b807c39728caf2 IN  0x3fe30742ad8491402c8aee251ff57e3e9b18ff870 MATIC0.001925512521 30.234471027
0x3facace0f38c3c7ee0c3438dda6627394b8a9d71aa5d0e739012fc67f9a2eb6dWithdraw To262449502022-03-22 23:19:51185 days 21 hrs ago0xc37d735a0c740fb203ed1b7f777eeed6fa2ba0bf IN  0x3fe30742ad8491402c8aee251ff57e3e9b18ff870 MATIC0.002043345567 32.08469
0x4f71dd9e8b669ed930b9a7da307adf03ff8a5e7c5f5d441f7d827f8a760be258Withdraw To262356652022-03-22 17:39:09186 days 3 hrs ago0x5d496a7f09d3a61bae8b2a8f56f990bfabe77d2a IN  0x3fe30742ad8491402c8aee251ff57e3e9b18ff870 MATIC0.001426756555 30.626294508
[ Download CSV Export 
Parent Txn Hash Block From To Value
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
StreamedAirdropper

Compiler Version
v0.7.6+commit.7338295f

Optimization Enabled:
Yes with 10000 runs

Other Settings:
default evmVersion, GNU GPLv3 license

Contract Source Code (Solidity)

/**
 *Submitted for verification at polygonscan.com on 2021-07-01
*/

// original repo: https://github.com/1hive/honeyswap-farm
// SPDX-License-Identifier: GPL-3.0-only


// File: @openzeppelin/contracts/token/ERC20/IERC20.sol
pragma solidity ^0.7.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: @openzeppelin/contracts/math/SafeMath.sol
pragma solidity ^0.7.0;

/**
 * @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, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        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) {
        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) {
        // 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) {
        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) {
        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) {
        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");
        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) {
        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, reverting 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) {
        require(b > 0, "SafeMath: division by zero");
        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) {
        require(b > 0, "SafeMath: modulo by zero");
        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) {
        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.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryDiv}.
     *
     * 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) {
        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) {
        require(b > 0, errorMessage);
        return a % b;
    }
}

// File: @openzeppelin/contracts/utils/Address.sol
pragma solidity ^0.7.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on 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;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain`call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
      return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: value }(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// File: @openzeppelin/contracts/token/ERC20/SafeERC20.sol
pragma solidity ^0.7.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 IERC20;` 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));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    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, "SafeERC20: decreased allowance below zero");
        _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. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "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");
        }
    }
}

// File: @openzeppelin/contracts/math/Math.sol
pragma solidity ^0.7.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);
    }
}

// File: contracts/airdropper/IStreamedAirdropper.sol
pragma solidity ^0.7.6;

interface IStreamedAirdropper {
    function addVesting(address _user, uint256 _amount) external;
}

// File: contracts/airdropper/StreamedAirdropper.sol
pragma solidity ^0.7.6;

contract StreamedAirdropper is IStreamedAirdropper {
    using SafeERC20 for IERC20;
    using SafeMath for uint256;

    struct Vesting {
        uint256 amountLeft;
        uint256 lastWithdraw;
    }

    mapping(address => Vesting) public vestingUsers;

    IERC20 public immutable token;
    uint256 public immutable distributionStart;
    uint256 public immutable distributionEnd;

    event VestingAdded(address indexed user, uint256 amount);
    event Withdraw(
        address indexed user,
        address indexed recipient,
        uint256 withdrawAmount
    );

    constructor(
        IERC20 _token,
        uint256 _distributionStart,
        uint256 _distributionEnd
    ) {
        require(
            block.timestamp <= _distributionStart &&
            _distributionStart < _distributionEnd,
            "SA: Invalid distribution time"
        );
        token = _token;
        distributionStart = _distributionStart;
        distributionEnd = _distributionEnd;
    }

    function addVesting(address _user, uint256 _amount) external override {
        Vesting storage userVesting = vestingUsers[_user];
        userVesting.amountLeft = userVesting.amountLeft.add(_amount);
        token.safeTransferFrom(msg.sender, address(this), _amount);
        emit VestingAdded(_user, _amount);
    }

    function withdraw() external {
        _withdrawTokensTo(msg.sender);
    }

    function withdrawTo(address _recipient) external {
        _withdrawTokensTo(_recipient);
    }

    function pendingTokens(address _user) public view returns (uint256) {
        Vesting storage userVesting = vestingUsers[_user];
        uint256 amountLeft = userVesting.amountLeft;
        uint256 realLastWithdraw = userVesting.lastWithdraw;
        if (
            amountLeft == 0 ||
            realLastWithdraw >= distributionEnd ||
            block.timestamp <= distributionStart
        ) return 0;

        uint256 lastWithdraw = Math.max(distributionStart, realLastWithdraw);
        uint256 currentTime = Math.min(distributionEnd, block.timestamp);
        uint256 elapsedTime = currentTime.sub(lastWithdraw);
        uint256 remainingTime = distributionEnd.sub(lastWithdraw);
        return amountLeft.mul(elapsedTime).div(remainingTime);
    }

    function _withdrawTokensTo(address _recipient) internal {
        uint256 pendingTokens_ = pendingTokens(msg.sender);
        require(pendingTokens_ > 0, "SA: No pending tokens");
        Vesting storage userVesting = vestingUsers[msg.sender];
        userVesting.lastWithdraw = block.timestamp;
        userVesting.amountLeft = userVesting.amountLeft.sub(pendingTokens_);
        token.safeTransfer(_recipient, pendingTokens_);
        emit Withdraw(msg.sender, _recipient, pendingTokens_);
    }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"contract IERC20","name":"_token","type":"address"},{"internalType":"uint256","name":"_distributionStart","type":"uint256"},{"internalType":"uint256","name":"_distributionEnd","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"VestingAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"withdrawAmount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[{"internalType":"address","name":"_user","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"addVesting","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"distributionEnd","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"distributionStart","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"pendingTokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"vestingUsers","outputs":[{"internalType":"uint256","name":"amountLeft","type":"uint256"},{"internalType":"uint256","name":"lastWithdraw","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_recipient","type":"address"}],"name":"withdrawTo","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

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

00000000000000000000000037d1ebc3af809b8fadb45dce7077efc629b2b5bb0000000000000000000000000000000000000000000000000000000060ddae400000000000000000000000000000000000000000000000000000000061cafc40

-----Decoded View---------------
Arg [0] : _token (address): 0x37d1ebc3af809b8fadb45dce7077efc629b2b5bb
Arg [1] : _distributionStart (uint256): 1625140800
Arg [2] : _distributionEnd (uint256): 1640692800

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 00000000000000000000000037d1ebc3af809b8fadb45dce7077efc629b2b5bb
Arg [1] : 0000000000000000000000000000000000000000000000000000000060ddae40
Arg [2] : 0000000000000000000000000000000000000000000000000000000061cafc40


Deployed ByteCode Sourcemap

23205:2838:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24566:77;;;:::i;:::-;;23422:47;;;;;;;;;;;;;;;;-1:-1:-1;23422:47:0;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;24651:97;;;;;;;;;;;;;;;;-1:-1:-1;24651:97:0;;;;:::i;23514:42::-;;;:::i;:::-;;;;;;;;;;;;;;;;24236:322;;;;;;;;;;;;;;;;-1:-1:-1;24236:322:0;;;;;;;;;:::i;24756:771::-;;;;;;;;;;;;;;;;-1:-1:-1;24756:771:0;;;;:::i;23563:40::-;;;:::i;23478:29::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;24566:77;24606:29;24624:10;24606:17;:29::i;:::-;24566:77::o;23422:47::-;;;;;;;;;;;;;;;;;;;;:::o;24651:97::-;24711:29;24729:10;24711:17;:29::i;:::-;24651:97;:::o;23514:42::-;;;:::o;24236:322::-;24347:19;;;24317:27;24347:19;;;;;;;;;;24402:22;;:35;;24429:7;24402:26;:35::i;:::-;24377:60;;24448:58;:22;:5;:22;24471:10;24491:4;24498:7;24448:22;:58::i;:::-;24522:28;;;;;;;;;;;;;;;;;;;;;;24236:322;;;:::o;24756:771::-;24865:19;;;24815:7;24865:19;;;;;;;;;;24916:22;;24976:24;;;;25029:15;;;:67;;;25081:15;25061:16;:35;;25029:67;:120;;;;25132:17;25113:15;:36;;25029:120;25011:158;;;25168:1;25161:8;;;;;;;25011:158;25182:20;25205:45;25214:17;25233:16;25205:8;:45::i;:::-;25182:68;;25261:19;25283:42;25292:15;25309;25283:8;:42::i;:::-;25261:64;-1:-1:-1;25336:19:0;25358:29;25261:64;25374:12;25358:15;:29::i;:::-;25336:51;-1:-1:-1;25398:21:0;25422:33;:15;25442:12;25422:19;:33::i;:::-;25398:57;-1:-1:-1;25473:46:0;25398:57;25473:27;:10;25488:11;25473:14;:27::i;:::-;:31;;:46::i;:::-;25466:53;;;;;;;;;24756:771;;;;:::o;23563:40::-;;;:::o;23478:29::-;;;:::o;25535:505::-;25602:22;25627:25;25641:10;25627:13;:25::i;:::-;25602:50;;25688:1;25671:14;:18;25663:52;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25769:10;25726:27;25756:24;;;;;;;;;;25818:15;25791:24;;;:42;25869:22;;:42;;25896:14;25869:26;:42::i;:::-;25844:67;;25922:46;:18;:5;:18;25941:10;25953:14;25922:18;:46::i;:::-;25984:48;;;;;;;;;;;;25993:10;;25984:48;;;;;;;;;25535:505;;;:::o;5685:179::-;5743:7;5775:5;;;5799:6;;;;5791:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5855:1;-1:-1:-1;5685:179:0;;;;;:::o;19202:205::-;19330:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19353:27;19330:68;;;19303:96;;19323:5;;19303:19;:96::i;:::-;19202:205;;;;:::o;22329:107::-;22387:7;22419:1;22414;:6;;:14;;22427:1;22414:14;;;-1:-1:-1;22423:1:0;;22407:21;-1:-1:-1;22329:107:0:o;22512:106::-;22570:7;22601:1;22597;:5;:13;;22609:1;22597:13;;6147:158;6205:7;6238:1;6233;:6;;6225:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;6292:5:0;;;6147:158::o;6564:220::-;6622:7;6646:6;6642:20;;-1:-1:-1;6661:1:0;6654:8;;6642:20;6685:5;;;6689:1;6685;:5;:1;6709:5;;;;;:10;6701:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7262:153;7320:7;7352:1;7348;:5;7340:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7406:1;7402;:5;;;;;;;7262:153;-1:-1:-1;;;7262:153:0:o;19017:177::-;19127:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19150:23;19127:58;;;19100:86;;19120:5;;19100:19;:86::i;:::-;19017:177;;;:::o;21322:761::-;21746:23;21772:69;21800:4;21772:69;;;;;;;;;;;;;;;;;21780:5;21772:27;;;;:69;;;;;:::i;:::-;21856:17;;21746:95;;-1:-1:-1;21856:21:0;21852:224;;21998:10;21987:30;;;;;;;;;;;;;;;-1:-1:-1;21987:30:0;21979:85;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14030:195;14133:12;14165:52;14187:6;14195:4;14201:1;14204:12;14165:21;:52::i;:::-;14158:59;;14030:195;;;;;;:::o;15082:530::-;15209:12;15267:5;15242:21;:30;;15234:81;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15334:18;15345:6;15334:10;:18::i;:::-;15326:60;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15460:12;15474:23;15501:6;:11;;15521:5;15529:4;15501:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15459:75;;;;15552:52;15570:7;15579:10;15591:12;15552:17;:52::i;:::-;15545:59;15082:530;-1:-1:-1;;;;;;;15082:530:0:o;11112:422::-;11479:20;11518:8;;;11112:422::o;17622:742::-;17737:12;17766:7;17762:595;;;-1:-1:-1;17797:10:0;17790:17;;17762:595;17911:17;;:21;17907:439;;18174:10;18168:17;18235:15;18222:10;18218:2;18214:19;18207:44;18122:148;18317:12;18310:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Swarm Source

ipfs://740e8e234c7b93dcf3c2c0e43240332143dfff397ad2780cce30e388182bca25
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.