Contract 0x1a82b680B47919Fd0c4B945F9d492A8688EE8933

 

Contract Overview

Balance:
0 Ether

EtherValue:
$0.00

Token:
Txn Hash
Method
Block
From
To
Value
0xc92af30a939818730e4bf7e59797175b363e3fc2f1a619b49fe48959bafafc62Get Reward156475362022-09-30 17:06:475 hrs 47 mins ago0x31a7cffb31765b8dc02dd562c7563c9471c35b22 IN  0x1a82b680b47919fd0c4b945f9d492a8688ee89330 Ether0.00246406 23.12521556
0x150b0db2f3dd7e08136a3a40f58cc41bc35e8ede6d15a30d21d1708cfcff1095Get Reward156467802022-09-30 14:34:238 hrs 19 mins ago0x2988959e46bdb31a54835b4957b62ba8847d3e36 IN  0x1a82b680b47919fd0c4b945f9d492a8688ee89330 Ether0.00220671 20.32847013
0xa32e03be46b5948ba759808bbb06cefd45aff434e2e784645805cfe03fff610dNotify Deposit156456632022-09-30 10:50:1112 hrs 4 mins ago0x0c32ac798f6dac640e5bb42cb21de059e7c26a5a IN  0x1a82b680b47919fd0c4b945f9d492a8688ee89330 Ether0.0007238 9.08431382
0x88ac5552c204fc4cc3e0d0bb2fdafcf9459341b0a4cf7a9f8eacbf7dbe7ed29aGet Reward156426492022-09-30 0:43:2322 hrs 10 mins ago0x61f2436876cd34718e03387b461bc15127ddacc6 IN  0x1a82b680b47919fd0c4b945f9d492a8688ee89330 Ether0.00131342 12.06692208
0xf5bc037df4909afd2f77224ceeedadcc9efd9243975f2dbc24f20735d61e0973Get Reward156420122022-09-29 22:35:591 day 18 mins ago0x989047a72c106eb6b895ffb1c205f085614f1ece IN  0x1a82b680b47919fd0c4b945f9d492a8688ee89330 Ether0.0007304 11.0045775
0x4f0d20ae507f120bbdeefcb937fdb0f0f74d0b5d8da28333429111a4bae9cb0aNotify Deposit156416192022-09-29 21:15:591 day 1 hr ago0x99912c8a5e6f54c7cadf428aa3442a1d6d90eea1 IN  0x1a82b680b47919fd0c4b945f9d492a8688ee89330 Ether0.00098599 12.37509244
0x7c3c96a36a6a1b03490016a9400adf55179af2b4b970a5d27aca9d855aecda8fNotify Deposit156395562022-09-29 14:20:231 day 8 hrs ago0xa938ca686c05c9b0839875d924b12704767f1715 IN  0x1a82b680b47919fd0c4b945f9d492a8688ee89330 Ether0.00210423 19.04402857
0xd2a41026c152214dbcbc4a8a9fa7e38ae111138faf0f9437cdfae341495337a3Notify Deposit156383462022-09-29 10:16:111 day 12 hrs ago0x628f9801b3edf1a1c4b7231185ac40b70d34ba29 IN  0x1a82b680b47919fd0c4b945f9d492a8688ee89330 Ether0.00081551 7.3806767
0xa2d5d9ccff80d1bcb1afb00be45d483eed0e7f22fce6f0f86e1aa2a93edf23caNotify Deposit156342262022-09-28 20:28:352 days 2 hrs ago0x589ffaeab4a99275660a9fa4274cb58f7329f4df IN  0x1a82b680b47919fd0c4b945f9d492a8688ee89330 Ether0.00127701 13.1955955
0xb788394c225971e590b682210caf1ea60ae5d3b4dc9258fcf771044c075b7cbeNotify Deposit156239602022-09-27 10:00:473 days 12 hrs ago0x461e76a4fe9f27605d4097a646837c32f1ccc31c IN  0x1a82b680b47919fd0c4b945f9d492a8688ee89330 Ether0.00096518 8.73527891
0xb6e80ff55cc218579ba5b7b479471aceebceb2d2ac0da5301cbe5682aa4077d5Notify Deposit156205252022-09-26 22:29:594 days 24 mins ago0x549b03e6f654626f2b0c37201e582d399b3d20c7 IN  0x1a82b680b47919fd0c4b945f9d492a8688ee89330 Ether0.0013142 11.89402546
0x1f4353f08bfcb127d9807059f52007dde48648c8f2daa9380fdca45dc0b9a947Notify Deposit156187432022-09-26 16:29:474 days 6 hrs ago0xa94d636ee974d375f8f6d51da15fa5023e7513ab IN  0x1a82b680b47919fd0c4b945f9d492a8688ee89330 Ether0.00312179 28.25333744
0x92b373174f6cc7fdbf10ff8d84cca82974cbb53499a97ee18d6a103f6b1937bbGet Reward156178082022-09-26 13:20:594 days 9 hrs ago0xc6709e64ccb02dd98fee9c10da859ee74fe9ba35 IN  0x1a82b680b47919fd0c4b945f9d492a8688ee89330 Ether0.00115255 12.60269023
0xc58b7e520ad1a1507b9bd8f05c210a63067c16de6d6d918dd155bb898480a6d7Notify Deposit156156062022-09-26 5:57:474 days 16 hrs ago0x48327499e4d71ed983dc7e024dded4ebb19bdb28 IN  0x1a82b680b47919fd0c4b945f9d492a8688ee89330 Ether0.00066749 6.02512251
0xbec8407980c8a8d6e0ed41d011c797144ea3a511eb4a753d459131a67b8848d1Get Reward156117992022-09-25 17:11:475 days 5 hrs ago0x2988959e46bdb31a54835b4957b62ba8847d3e36 IN  0x1a82b680b47919fd0c4b945f9d492a8688ee89330 Ether0.00128259 11.81534602
0x1a66ac09baf3829e2f64ea906cd862eff6234037a7609526155c411a15e0d780Get Reward156056142022-09-24 20:30:236 days 2 hrs ago0x30a20b0281df39e6337c3cbe5865e6fdcdcce3f1 IN  0x1a82b680b47919fd0c4b945f9d492a8688ee89330 Ether0.00057295 5.27809052
0x4a5e62b74525de1bbb764411970ec70320ba4de81a74eb32cd79c993d0f91bc7Get Reward156005962022-09-24 3:41:476 days 19 hrs agoENS Name brodiebruce.eth IN  0x1a82b680b47919fd0c4b945f9d492a8688ee89330 Ether0.00054437 5.01483218
0xf786768ccd49859d42644aa45ad77ce98c65ba94e71dd31dacb926c649035f68Notify Deposit155973832022-09-23 16:57:357 days 5 hrs ago0xc55e747bdde1b8f85662bd7a04d1cbdec43493b0 IN  0x1a82b680b47919fd0c4b945f9d492a8688ee89330 Ether0.00109773 11.02413867
0x871d325aefc2794b1f25df4a25c5066f52955528873c6a364cda154eb979f24fGet Reward155973662022-09-23 16:53:597 days 6 hrs ago0xc55e747bdde1b8f85662bd7a04d1cbdec43493b0 IN  0x1a82b680b47919fd0c4b945f9d492a8688ee89330 Ether0.0007484 8.36650356
0x4205c82c28e743fe596c0fd8e9ec2f647322291cf29e213cc3057f93f0818e98Notify Deposit155904482022-09-22 17:43:478 days 5 hrs agoENS Name thesquidadel.eth IN  0x1a82b680b47919fd0c4b945f9d492a8688ee89330 Ether0.00302334 28.70168816
0x345a116a31213f247115527d80a258a5334ad7a1e40438344c6a620ec0d7e1afGet Reward155892512022-09-22 13:42:478 days 9 hrs agoENS Name lalm.eth IN  0x1a82b680b47919fd0c4b945f9d492a8688ee89330 Ether0.00106272 10.2781332
0x0255baed45bb89f357d4e7773340439958e669a5a893a8d59901775d2e812588Get Reward155877892022-09-22 8:48:358 days 14 hrs ago0x9412e1c500c6ff7c211ead40abafa21db0d72305 IN  0x1a82b680b47919fd0c4b945f9d492a8688ee89330 Ether0.00065908 7.6374387
0x557653f6dd27e5bf431612744f59e4c876b749af1811ab73b1dc63f641cb5670Notify Deposit155873922022-09-22 7:28:598 days 15 hrs agoENS Name yagga.eth IN  0x1a82b680b47919fd0c4b945f9d492a8688ee89330 Ether0.00041817 6.14558535
0xb10c73ff420edd5c442ebdeb778ee1d4bd521f10057e4a010c21452a2f3412a6Notify Deposit155869232022-09-22 5:54:118 days 17 hrs ago0x055733d53eb3ddfb8395e9c9856dee0ec26283a8 IN  0x1a82b680b47919fd0c4b945f9d492a8688ee89330 Ether0.00047446 5.02507706
0x610632530d48e39abc8f30d73df2eaecd1914254db63c40751b98878cae2a412Notify Deposit155869032022-09-22 5:50:118 days 17 hrs agoENS Name yagga.eth IN  0x1a82b680b47919fd0c4b945f9d492a8688ee89330 Ether0.00053481 4.82091155
[ Download CSV Export 
View more zero value Internal Transactions in Advanced View mode
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
Rewards

Compiler Version
v0.8.13+commit.abaa5c0e

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at Etherscan.io on 2022-06-17
*/

// File: @openzeppelin/contracts/utils/introspection/IERC165.sol


// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

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

// File: @openzeppelin/contracts/token/ERC721/IERC721.sol


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

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

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

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

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

// File: @openzeppelin/contracts/security/ReentrancyGuard.sol


// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

        _;

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

// File: @openzeppelin/contracts/utils/Address.sol


// OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @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
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 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");

        (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");

        (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");

        (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");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal 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

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

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

// File: @openzeppelin/contracts/interfaces/IERC20.sol


// OpenZeppelin Contracts v4.4.1 (interfaces/IERC20.sol)

pragma solidity ^0.8.0;


// File: @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.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 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'
        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) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            uint256 newAllowance = oldAllowance - 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. 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
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

// File: contracts/veRewards.sol


pragma solidity ^0.8.13;





interface IERC4626 is IERC20 {
    // The address of the underlying token used for the Vault for accounting, depositing, and withdrawing.
    function asset() external view returns(address assetTokenAddress);

    // Total amount of the underlying asset that is “managed” by Vault.
    function totalAssets() external view returns(uint256 totalManagedAssets);

    // The amount of shares that the Vault would exchange for the amount of assets provided, in an ideal scenario where all the conditions are met.
    function convertToShares(uint256 assets) external view returns(uint256 shares); 

    // The amount of assets that the Vault would exchange for the amount of shares provided, in an ideal scenario where all the conditions are met.
    function convertToAssets(uint256 shares) external view returns(uint256 assets);
 
    // Maximum amount of the underlying asset that can be deposited into the Vault for the receiver, through a deposit call.
    function maxDeposit(address receiver) external view returns(uint256 maxAssets);

    // Allows an on-chain or off-chain user to simulate the effects of their deposit at the current block, given current on-chain conditions.
    function previewDeposit(uint256 assets) external view returns(uint256 shares);

    // Mints shares Vault shares to receiver by depositing exactly amount of underlying tokens.
    function deposit(uint256 assets, address receiver) external returns(uint256 shares);

    // Maximum amount of shares that can be minted from the Vault for the receiver, through a mint call.
    function maxMint(address receiver) external view returns(uint256 maxShares); 

    // Allows an on-chain or off-chain user to simulate the effects of their mint at the current block, given current on-chain conditions.
    function previewMint(uint256 shares) external view returns(uint256 assets);

    // Mints exactly shares Vault shares to receiver by depositing amount of underlying tokens.
    function mint(uint256 shares, address receiver) external returns(uint256 assets);

    // Maximum amount of the underlying asset that can be withdrawn from the owner balance in the Vault, through a withdraw call.
    function maxWithdraw(address owner) external view returns(uint256 maxAssets);

    // Allows an on-chain or off-chain user to simulate the effects of their withdrawal at the current block, given current on-chain conditions.
    function previewWithdraw(uint256 assets) external view returns(uint256 shares);

    // Burns shares from owner and sends exactly assets of underlying tokens to receiver.
    function withdraw(uint256 assets, address receiver, address owner) external returns(uint256 shares);

    // Maximum amount of Vault shares that can be redeemed from the owner balance in the Vault, through a redeem call.
    function maxRedeem(address owner) external view returns(uint256 maxShares);

    // Allows an on-chain or off-chain user to simulate the effects of their redeemption at the current block, given current on-chain conditions.
    function previewRedeem(uint256 shares) external view returns(uint256 assets);

    // Burns exactly shares from owner and sends assets of underlying tokens to receiver.
    function redeem(uint256 shares, address receiver, address owner) external returns(uint256 assets);

    event Deposit(address indexed caller, address indexed owner, uint256 assets, uint256 shares);
    event Withdraw(address indexed caller, address indexed receiver, address indexed owner, uint256 assets, uint256 shares);
}

interface IVeVault is IERC4626 {
    function asset() external view  returns (address assetTokenAddress);
    function totalAssets() external view  returns (uint256 totalManagedAssets);
    function totalSupply() external view  returns (uint256);
    function balanceOf(address account) external view  returns (uint256);
    function convertToShares(uint256 assets, uint256 lockTime) external view returns (uint256 shares);
    function convertToShares(uint256 assets)  external view returns (uint256 shares);
    function convertToAssets(uint256 shares, uint256 lockTime) external view returns (uint256 assets);
    function convertToAssets(uint256 shares)  external view returns (uint256 assets);
    function maxDeposit(address)  external pure returns (uint256 maxAssets);
    function previewDeposit(uint256 assets, uint256 lockTime) external view returns (uint256 shares);
    function previewDeposit(uint256 assets)  external view returns (uint256 shares);
    function maxMint(address)  external pure returns (uint256 maxShares);
    function previewMint(uint256 shares, uint256 lockTime) external view returns (uint256 assets);
    function previewMint(uint256 shares)  external view returns (uint256 assets);
    function maxWithdraw(address owner)  external view returns (uint256 maxAssets);
    function previewWithdraw(uint256 assets, uint256 lockTime) external view returns (uint256 shares);
    function previewWithdraw(uint256 assets)  external view returns (uint256 shares);
    function maxRedeem(address owner)  external view returns (uint256 maxShares);
    function previewRedeem(uint256 shares, uint256 lockTime) external view returns (uint256 assets);
    function previewRedeem(uint256 shares)  external view returns (uint256 assets);
    function allowance(address, address)  external view returns (uint256);
    function assetBalanceOf(address account) external view returns (uint256);
    function unlockDate(address account) external view returns (uint256);
    function gracePeriod() external view returns (uint256);
    function penaltyPercentage() external view returns (uint256);
    function minLockTime() external view returns (uint256);
    function maxLockTime() external view returns (uint256);
    function transfer(address, uint256) external  returns (bool);
    function approve(address, uint256) external  returns (bool);
    function transferFrom(address, address, uint256) external  returns (bool);
    function veMult(address owner) external view returns (uint256);
    function deposit(uint256 assets, address receiver, uint256 lockTime) external returns (uint256 shares);
    function deposit(uint256 assets, address receiver)  external returns (uint256 shares);
    function mint(uint256 shares, address receiver, uint256 lockTime) external returns (uint256 assets);
    function mint(uint256 shares, address receiver)  external returns (uint256 assets);
    function withdraw(uint256 assets, address receiver, address owner)  external returns (uint256 shares);
    function redeem(uint256 shares, address receiver, address owner)  external returns (uint256 assets);
    function exit() external returns (uint256 shares);
    function changeUnlockRule(bool flag) external;
    function changeGracePeriod(uint256 newGracePeriod) external;
    function changeEpoch(uint256 newEpoch) external;
    function changeMinPenalty(uint256 newMinPenalty) external;
    function changeMaxPenalty(uint256 newMaxPenalty) external;
    function changeWhitelistRecoverERC20(address tokenAddress, bool flag) external;
    function recoverERC20(address tokenAddress, uint256 tokenAmount) external;
    function recoverERC721(address tokenAddress, uint256 tokenId) external;

    event PayPenalty(address indexed caller, address indexed owner, uint256 assets);
    event Burn(address indexed user, uint256 shares);
    event Mint(address indexed user, uint256 shares);
    event Recovered(address token, uint256 amount);
    event RecoveredNFT(address tokenAddress, uint256 tokenId);
    event ChangeWhitelistERC20(address indexed tokenAddress, bool whitelistState);
}

// https://docs.synthetix.io/contracts/source/contracts/Owned
abstract contract Owned {
    address public owner;
    address public nominatedOwner;

    constructor(address _owner) {
        require(_owner != address(0), "Owner address cannot be 0");
        owner = _owner;
        emit OwnerChanged(address(0), _owner);
    }

    function nominateNewOwner(address _owner) external onlyOwner {
        nominatedOwner = _owner;
        emit OwnerNominated(_owner);
    }

    function acceptOwnership() external {
        require(msg.sender == nominatedOwner, "You must be nominated before you can accept ownership");
        emit OwnerChanged(owner, nominatedOwner);
        owner = nominatedOwner;
        nominatedOwner = address(0);
    }

    modifier onlyOwner {
        _onlyOwner();
        _;
    }

    function _onlyOwner() private view {
        require(msg.sender == owner, "Only the contract owner may perform this action");
    }

    event OwnerNominated(address newOwner);
    event OwnerChanged(address oldOwner, address newOwner);
}

// https://docs.synthetix.io/contracts/source/contracts/Pausable
abstract contract Pausable is Owned {
    uint public lastPauseTime;
    bool public paused;

    constructor() {
        // This contract is abstract, and thus cannot be instantiated directly
        require(owner != address(0), "Owner must be set");
        // Paused will be false, and lastPauseTime will be 0 upon initialisation
    }

    /**
     * @notice Change the paused state of the contract
     * @dev Only the contract owner may call this.
     */
    function setPaused(bool _paused) external onlyOwner {
        // Ensure we're actually changing the state before we do anything
        if (_paused == paused) {
            return;
        }

        // Set our paused state.
        paused = _paused;

        // If applicable, set the last pause time.
        if (paused) {
            lastPauseTime = block.timestamp;
        }

        // Let everyone know that our pause state has changed.
        emit PauseChanged(paused);
    }

    event PauseChanged(bool isPaused);

    modifier notPaused {
        require(!paused, "This action cannot be performed while the contract is paused");
        _;
    }
}

// https://docs.synthetix.io/contracts/source/contracts/RewardsDistributionRecipient
abstract contract RewardsDistributionRecipient is Owned {
    address public rewardsDistribution;

    function notifyRewardAmount(uint256 reward) virtual external;

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

    function setRewardsDistribution(address _rewardsDistribution) external onlyOwner {
        rewardsDistribution = _rewardsDistribution;
    }
}

error RewardTooHigh();
error RewardPeriodNotComplete(uint256 finish);
error NotWhitelisted();
error InsufficientBalance(uint256 available, uint256 required);

/** 
 * @title Implements a reward system which grant rewards based on veToken balance 
 * @author gcontarini jocorrei
 * @notice This implementation was inspired by the StakingReward contract from Synthetixio
 * @dev Implement a new constructor to deploy this contract 
 */
contract Rewards is RewardsDistributionRecipient, ReentrancyGuard, Pausable {
    using SafeERC20 for IERC20;

    struct Account {
        uint256 rewardPerTokenPaid;
        uint256 rewards;
        uint256 dueDate;
    }

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

    address public rewardsToken;
    address public vault;                    // address of the ve vault
    uint256 public periodFinish = 0;         // end of the rewardDuration period
    uint256 public rewardRate = 0;           // rewards per second distributed by the contract ==> rewardavailable / rewardDuration
    uint256 public rewardsDuration = 7 days; // the rewards inside the contract are gone be distributed during this period
    uint256 public lastUpdateTime;           // when the reward period started
    uint256 public rewardPerTokenStored;     // amounts of reward per staked token

    mapping(address => Account) public accounts;
    
    // Only allow recoverERC20 from this list
    mapping(address => bool) public whitelistRecoverERC20;

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

    constructor(
        address _owner,
        address _vault,
        address _rewardsDistribution,
        address _rewardsToken
    ) Owned(_owner) {
        rewardsToken = _rewardsToken;
        rewardsDistribution = _rewardsDistribution;
        vault = _vault;
        lastUpdateTime = block.timestamp;
    }

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

    /**
     * @notice Get the vault address
     */
    function getVaultAddress() public view returns (address) {
        return vault;
    }

    /**
     * @notice Pick the correct date for applying the reward
     * Apply until the end of periodFinish or until
     * unlockDate for funds in the veVault
     * @return date which the reward is applicable for and address
     */
    function lastTimeRewardApplicable(address owner) public view returns (uint256) {
        if (owner != address(0) && accounts[owner].dueDate < periodFinish) {
            return block.timestamp < accounts[owner].dueDate ? block.timestamp : accounts[owner].dueDate;
        }
        return block.timestamp < periodFinish ? block.timestamp : periodFinish;
    }

    /**
     * @notice Calculate how much reward must be given for an user
     * per token in veVault. 
     * @dev If dueDate is less than the period finish,
     * a "negative" reward is applied to ensure that
     * rewards are applied only until this date.
     * @return amount of reward per token an addres is elegible to receive so far
     */
    function rewardPerToken(address owner) public view returns (uint256) {
        uint256 _totalSupply = IVeVault(vault).totalSupply();

        if (_totalSupply == 0) {
            return rewardPerTokenStored;
        }
        uint256 userLastTime = lastTimeRewardApplicable(owner);
        
        // Apply a negative reward per token when
        // due date is already over.
        if (userLastTime < lastUpdateTime) {
            return rewardPerTokenStored
                - ((lastUpdateTime - userLastTime)
                    * rewardRate
                    * 1e18
                    / _totalSupply
                );
        }
        return rewardPerTokenStored
                + ((userLastTime - lastUpdateTime)
                    * rewardRate
                    * 1e18
                    / _totalSupply
                );
    }
    
    /**
     * @notice Calculates how much rewards a staker earned 
     * until this moment.
     * @dev Only apply reward until period finish or unlock date.
     * @return amount of reward available to claim 
     */
    function earned(address owner) public view returns (uint256) {
        uint256 currentReward = rewardPerToken(owner);
        uint256 paidReward = accounts[owner].rewardPerTokenPaid;

        uint256 moreReward = 0;
        if (currentReward > paidReward) {
            moreReward = IVeVault(vault).balanceOf(owner)
                            * (currentReward - paidReward)
                            / 1e18;
        }
        return accounts[owner].rewards + moreReward;
    }

    /**
     * @notice Total rewards that will be paid during the distribution
     */
    function getRewardForDuration() external view returns (uint256) {
        return rewardRate * rewardsDuration;
    }

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

    /**
     * @notice Notify the reward contract about a deposit in the
     * veVault contract. This is important to assure the
     * contract will account user's rewards.
     * @return account full information
     */
    function notifyDeposit() public updateReward(msg.sender) returns(Account memory) {
        emit NotifyDeposit(msg.sender, accounts[owner].rewardPerTokenPaid, accounts[owner].dueDate);
        return accounts[owner];
    }

    /**
     * @notice Claim rewards for user.
     * @dev In case of no rewards claimable
     * just update the user status and do nothing.
     */
    function getReward() public updateReward(msg.sender) {
        uint256 reward = accounts[msg.sender].rewards;
        if (reward <= 0) return;
        
        accounts[msg.sender].rewards = 0;
        IERC20(rewardsToken).safeTransfer(msg.sender, reward);
        emit RewardPaid(msg.sender, reward);
    }

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

    /**
     * @notice Set the contract to start distribuiting rewards
     * for ve holders.
     * @param reward: amount of tokens to be distributed
     */
    function notifyRewardAmount(uint256 reward)
            external
            override 
            onlyRewardsDistribution 
            updateReward(address(0)) {
        if (block.timestamp >= periodFinish) {
            rewardRate = reward / rewardsDuration;
        } else {
            uint256 remaining = periodFinish - block.timestamp;
            uint256 leftover = remaining * rewardRate;
            rewardRate = (reward + leftover) / 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 = IERC20(rewardsToken).balanceOf(address(this));
        if (rewardRate > balance / rewardsDuration) revert RewardTooHigh();

        lastUpdateTime = block.timestamp;
        periodFinish = block.timestamp + rewardsDuration;
        emit RewardAdded(reward);
    }
    
    /**
     * @notice Allow owner to change reward duration
     * Only allow the change if period finish has already ended
     */
    function setRewardsDuration(uint256 _rewardsDuration) external onlyOwner {
        if (block.timestamp <= periodFinish) revert RewardPeriodNotComplete(periodFinish);

        rewardsDuration = _rewardsDuration;
        emit RewardsDurationUpdated(rewardsDuration);
    }

    /**
     * @notice Added to support to recover ERC20 token within a whitelist 
     */
    function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyOwner {
        if (whitelistRecoverERC20[tokenAddress] == false) revert NotWhitelisted();
        
        uint balance = IERC20(tokenAddress).balanceOf(address(this));
        if (balance < tokenAmount) revert InsufficientBalance({
                available: balance,
                required: tokenAmount
        });
        
        IERC20(tokenAddress).safeTransfer(owner, tokenAmount);
        emit Recovered(tokenAddress, tokenAmount);
    }

    /**
     * @dev It's possible to owner whitelist the underlying token
     * and do some kind of rugpull. To prevent that, it'recommended
     * that owner is a multisig address. Also, it emits an event
     * of changes in the ERC20 whitelist as a safety check.
     * @notice Owner can whitelist an ERC20 to recover it afterwards.
     * Emits and event to notify all users about it 
     * @param flag: true to allow recover for the token
     */
    function changeWhitelistRecoverERC20(address tokenAddress, bool flag) external onlyOwner {
        whitelistRecoverERC20[tokenAddress] = flag;
        emit ChangeWhitelistERC20(tokenAddress, flag);
    }

    /**
     * @notice Added to support to recover ERC721 
     */
    function recoverERC721(address tokenAddress, uint256 tokenId) external onlyOwner {
        IERC721(tokenAddress).safeTransferFrom(address(this), owner, tokenId);
        emit RecoveredNFT(tokenAddress, tokenId);
    }

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

    /**
     * @dev Update user rewards accordlingly to
     * the current timestamp.
     */
    modifier updateReward(address owner) {
        rewardPerTokenStored = rewardPerToken(address(0));
        lastUpdateTime = lastTimeRewardApplicable(address(0));

        if (owner != address(0)) {
            if (accounts[owner].rewardPerTokenPaid == 0)
                accounts[owner].rewardPerTokenPaid = rewardPerTokenStored;
            accounts[owner].dueDate = IVeVault(vault).unlockDate(owner);
            accounts[owner].rewards = earned(owner);
            accounts[owner].rewardPerTokenPaid = rewardPerToken(address(0));
        }
        _;
    }

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

    event RewardAdded(uint256 reward);
    event RewardPaid(address indexed user, uint256 reward);
    event RewardsDurationUpdated(uint256 newDuration);
    event NotifyDeposit(address indexed user, uint256 rewardPerTokenPaid, uint256 dueDate);
    event Recovered(address token, uint256 amount);
    event RecoveredNFT(address tokenAddress, uint256 tokenId);
    event ChangeWhitelistERC20(address indexed tokenAddress, bool whitelistState);
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_vault","type":"address"},{"internalType":"address","name":"_rewardsDistribution","type":"address"},{"internalType":"address","name":"_rewardsToken","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"uint256","name":"available","type":"uint256"},{"internalType":"uint256","name":"required","type":"uint256"}],"name":"InsufficientBalance","type":"error"},{"inputs":[],"name":"NotWhitelisted","type":"error"},{"inputs":[{"internalType":"uint256","name":"finish","type":"uint256"}],"name":"RewardPeriodNotComplete","type":"error"},{"inputs":[],"name":"RewardTooHigh","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"tokenAddress","type":"address"},{"indexed":false,"internalType":"bool","name":"whitelistState","type":"bool"}],"name":"ChangeWhitelistERC20","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"rewardPerTokenPaid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"dueDate","type":"uint256"}],"name":"NotifyDeposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldOwner","type":"address"},{"indexed":false,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnerChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnerNominated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"isPaused","type":"bool"}],"name":"PauseChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Recovered","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"tokenAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"RecoveredNFT","type":"event"},{"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":false,"internalType":"uint256","name":"newDuration","type":"uint256"}],"name":"RewardsDurationUpdated","type":"event"},{"inputs":[],"name":"acceptOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"accounts","outputs":[{"internalType":"uint256","name":"rewardPerTokenPaid","type":"uint256"},{"internalType":"uint256","name":"rewards","type":"uint256"},{"internalType":"uint256","name":"dueDate","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"bool","name":"flag","type":"bool"}],"name":"changeWhitelistRecoverERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"earned","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getRewardForDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getVaultAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastPauseTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"lastTimeRewardApplicable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastUpdateTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"nominateNewOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"nominatedOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"notifyDeposit","outputs":[{"components":[{"internalType":"uint256","name":"rewardPerTokenPaid","type":"uint256"},{"internalType":"uint256","name":"rewards","type":"uint256"},{"internalType":"uint256","name":"dueDate","type":"uint256"}],"internalType":"struct Rewards.Account","name":"","type":"tuple"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"reward","type":"uint256"}],"name":"notifyRewardAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"periodFinish","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"uint256","name":"tokenAmount","type":"uint256"}],"name":"recoverERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"recoverERC721","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"rewardPerToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardPerTokenStored","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardsDistribution","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardsDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardsToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"_paused","type":"bool"}],"name":"setPaused","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_rewardsDistribution","type":"address"}],"name":"setRewardsDistribution","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_rewardsDuration","type":"uint256"}],"name":"setRewardsDuration","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"vault","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"whitelistRecoverERC20","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"}]

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

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

0000000000000000000000004a848f44146ca6d1d6aa34bcdf3c41093def176100000000000000000000000044dd83e0598e7a3709cf0b2e59d3319418068a650000000000000000000000004a848f44146ca6d1d6aa34bcdf3c41093def176100000000000000000000000098585dfc8d9e7d48f0b1ae47ce33332cf4237d96

-----Decoded View---------------
Arg [0] : _owner (address): 0x4a848F44146Ca6D1D6AA34bcdF3C41093deF1761
Arg [1] : _vault (address): 0x44dd83E0598e7A3709cF0b2e59D3319418068a65
Arg [2] : _rewardsDistribution (address): 0x4a848F44146Ca6D1D6AA34bcdF3C41093deF1761
Arg [3] : _rewardsToken (address): 0x98585dFc8d9e7D48F0b1aE47ce33332CF4237D96

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 0000000000000000000000004a848f44146ca6d1d6aa34bcdf3c41093def1761
Arg [1] : 00000000000000000000000044dd83e0598e7a3709cf0b2e59d3319418068a65
Arg [2] : 0000000000000000000000004a848f44146ca6d1d6aa34bcdf3c41093def1761
Arg [3] : 00000000000000000000000098585dfc8d9e7d48f0b1ae47ce33332cf4237d96


Deployed ByteCode Sourcemap

35232:10027:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38951:490;;;;;;:::i;:::-;;:::i;:::-;;;529:25:1;;;517:2;502:18;38951:490:0;;;;;;;;32236:141;;;;;;:::i;:::-;;:::i;:::-;;33528:500;;;;;;:::i;:::-;;:::i;34638:142::-;;;;;;:::i;:::-;;:::i;39539:118::-;;;:::i;35843:39::-;;;;;;40877:1125;;;;;;:::i;:::-;;:::i;40335:314::-;;;:::i;34364:34::-;;;;;-1:-1:-1;;;;;34364:34:0;;;;;;-1:-1:-1;;;;;1283:32:1;;;1265:51;;1253:2;1238:18;34364:34:0;1119:203:1;32012:29:0;;;;;-1:-1:-1;;;;;32012:29:0;;;33123:18;;;;;;;;;;;;1492:14:1;;1485:22;1467:41;;1455:2;1440:18;33123::0;1327:187:1;36133:43:0;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1721:25:1;;;1777:2;1762:18;;1755:34;;;;1805:18;;;1798:34;1709:2;1694:18;36133:43:0;1519:319:1;37113:364:0;;;;;;:::i;:::-;;:::i;36772:88::-;36847:5;;-1:-1:-1;;;;;36847:5:0;36772:88;;39948:224;;;:::i;:::-;;;;2057:13:1;;2039:32;;2127:4;2115:17;;;2109:24;2087:20;;;2080:54;2178:17;;;2172:24;2150:20;;;2143:54;2027:2;2012:18;39948:224:0;1843:360:1;32385:271:0;;;:::i;35710:29::-;;;;;;43820:220;;;;;;:::i;:::-;;:::i;42528:537::-;;;;;;:::i;:::-;;:::i;31985:20::-;;;;;-1:-1:-1;;;;;31985:20:0;;;36236:53;;;;;;:::i;:::-;;;;;;;;;;;;;;;;33091:25;;;;;;35967:29;;;;;;42151:275;;;;;;:::i;:::-;;:::i;35521:27::-;;;;;;;;-1:-1:-1;;;;;35521:27:0;;;43536:206;;;;;;:::i;:::-;;:::i;36047:35::-;;;;;;35628:31;;;;;;37845:868;;;;;;:::i;:::-;;:::i;35555:20::-;;;;;-1:-1:-1;;;;;35555:20:0;;;38951:490;39003:7;39023:21;39047;39062:5;39047:14;:21::i;:::-;-1:-1:-1;;;;;39100:15:0;;39079:18;39100:15;;;:8;:15;;;;;:34;39023:45;;-1:-1:-1;39184:26:0;;;39180:200;;;39364:4;39305:26;39321:10;39305:13;:26;:::i;:::-;39249:5;;39240:32;;-1:-1:-1;;;39240:32:0;;-1:-1:-1;;;;;1283:32:1;;;39240::0;;;1265:51:1;39249:5:0;;;;39240:25;;1238:18:1;;39240:32:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:92;;;;:::i;:::-;:128;;;;:::i;:::-;39227:141;;39180:200;-1:-1:-1;;;;;39397:15:0;;;;;;:8;:15;;;;;:23;;;:36;;39423:10;;39397:36;:::i;:::-;39390:43;38951:490;-1:-1:-1;;;;;38951:490:0:o;32236:141::-;32694:12;:10;:12::i;:::-;32308:14:::1;:23:::0;;-1:-1:-1;;;;;;32308:23:0::1;-1:-1:-1::0;;;;;32308:23:0;::::1;::::0;;::::1;::::0;;;32347:22:::1;::::0;1265:51:1;;;32347:22:0::1;::::0;1253:2:1;1238:18;32347:22:0::1;;;;;;;;32236:141:::0;:::o;33528:500::-;32694:12;:10;:12::i;:::-;33681:6:::1;::::0;::::1;;33670:17;;::::0;::::1;;33666:56:::0;33704:7:::1;33666:56;33768:6;:16:::0;;-1:-1:-1;;33768:16:0::1;::::0;::::1;;::::0;;::::1;::::0;;;::::1;33853:6:::0;33849:70:::1;;;33892:15;33876:13;:31:::0;33849:70:::1;34013:6;::::0;34000:20:::1;::::0;34013:6:::1;::::0;;::::1;1492:14:1::0;1485:22;1467:41;;34000:20:0::1;::::0;1455:2:1;1440:18;34000:20:0::1;1327:187:1::0;32717:1:0::1;33528:500:::0;:::o;34638:142::-;32694:12;:10;:12::i;:::-;34730:19:::1;:42:::0;;-1:-1:-1;;;;;;34730:42:0::1;-1:-1:-1::0;;;;;34730:42:0;;;::::1;::::0;;;::::1;::::0;;34638:142::o;39539:118::-;39594:7;39634:15;;39621:10;;:28;;;;:::i;:::-;39614:35;;39539:118;:::o;40877:1125::-;34544:19;;-1:-1:-1;;;;;34544:19:0;34530:10;:33;34522:88;;;;-1:-1:-1;;;34522:88:0;;3968:2:1;34522:88:0;;;3950:21:1;4007:2;3987:18;;;3980:30;4046:34;4026:18;;;4019:62;-1:-1:-1;;;4097:18:1;;;4090:40;4147:19;;34522:88:0;;;;;;;;;41038:1:::1;44262:26;44285:1;44262:14;:26::i;:::-;44239:20;:49:::0;44316:36:::1;44349:1;44316:24;:36::i;:::-;44299:14;:53:::0;-1:-1:-1;;;;;44369:19:0;::::1;::::0;44365:377:::1;;-1:-1:-1::0;;;;;44409:15:0;::::1;;::::0;;;:8:::1;:15;::::0;;;;:34;:39;;44405:119:::1;;44504:20;::::0;-1:-1:-1;;;;;44467:15:0;::::1;;::::0;;;:8:::1;:15;::::0;;;;:57;44405:119:::1;44574:5;::::0;44565:33:::1;::::0;-1:-1:-1;;;44565:33:0;;-1:-1:-1;;;;;1283:32:1;;;44565:33:0::1;::::0;::::1;1265:51:1::0;44574:5:0;;::::1;::::0;44565:26:::1;::::0;1238:18:1;;44565:33:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;44539:15:0;::::1;;::::0;;;:8:::1;:15;::::0;;;;:23:::1;;:59:::0;44639:13:::1;44548:5:::0;44639:6:::1;:13::i;:::-;-1:-1:-1::0;;;;;44613:15:0;::::1;;::::0;;;:8:::1;:15;::::0;;;;:23:::1;;:39:::0;;;;44704:26:::1;::::0;:14:::1;:26::i;:::-;-1:-1:-1::0;;;;;44667:15:0;::::1;;::::0;;;:8:::1;:15;::::0;;;;:63;44365:377:::1;41076:12:::2;;41057:15;:31;41053:305;;41127:15;::::0;41118:24:::2;::::0;:6;:24:::2;:::i;:::-;41105:10;:37:::0;41053:305:::2;;;41175:17;41210:15;41195:12;;:30;;;;:::i;:::-;41175:50;;41240:16;41271:10;;41259:9;:22;;;;:::i;:::-;41331:15;::::0;41240:41;;-1:-1:-1;41310:17:0::2;41240:41:::0;41310:6;:17:::2;:::i;:::-;41309:37;;;;:::i;:::-;41296:10;:50:::0;-1:-1:-1;;41053:305:0::2;41740:12;::::0;41733:45:::2;::::0;-1:-1:-1;;;41733:45:0;;41772:4:::2;41733:45;::::0;::::2;1265:51:1::0;41718:12:0::2;::::0;41740::::2;::::0;::::2;-1:-1:-1::0;;;;;41740:12:0::2;::::0;41733:30:::2;::::0;1238:18:1;;41733:45:0::2;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;41718:60;;41816:15;;41806:7;:25;;;;:::i;:::-;41793:10;;:38;41789:66;;;41840:15;;-1:-1:-1::0;;;41840:15:0::2;;;;;;;;;;;41789:66;41885:15;41868:14;:32:::0;;;41944:15:::2;::::0;41926:33:::2;::::0;::::2;:::i;:::-;41911:12;:48:::0;41975:19:::2;::::0;529:25:1;;;41975:19:0::2;::::0;517:2:1;502:18;41975:19:0::2;;;;;;;;41042:960;34621:1:::1;40877:1125:::0;:::o;40335:314::-;40376:10;44262:26;44285:1;44262:14;:26::i;:::-;44239:20;:49;44316:36;44349:1;44316:24;:36::i;:::-;44299:14;:53;-1:-1:-1;;;;;44369:19:0;;;44365:377;;-1:-1:-1;;;;;44409:15:0;;;;;;:8;:15;;;;;:34;:39;;44405:119;;44504:20;;-1:-1:-1;;;;;44467:15:0;;;;;;:8;:15;;;;;:57;44405:119;44574:5;;44565:33;;-1:-1:-1;;;44565:33:0;;-1:-1:-1;;;;;1283:32:1;;;44565:33:0;;;1265:51:1;44574:5:0;;;;44565:26;;1238:18:1;;44565:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;44539:15:0;;;;;;:8;:15;;;;;:23;;:59;44639:13;44548:5;44639:6;:13::i;:::-;-1:-1:-1;;;;;44613:15:0;;;;;;:8;:15;;;;;:23;;:39;;;;44704:26;;:14;:26::i;:::-;-1:-1:-1;;;;;44667:15:0;;;;;;:8;:15;;;;;:63;44365:377;40425:10:::1;40399:14;40416:20:::0;;;:8:::1;:20;::::0;;;;:28:::1;;::::0;40459:11;40455:24:::1;;40472:7;33528:500:::0;:::o;40455:24::-:1;40508:10;40530:1;40499:20:::0;;;:8:::1;:20;::::0;;;;:28:::1;;:32:::0;40549:12:::1;::::0;40542:53:::1;::::0;40549:12:::1;::::0;;::::1;-1:-1:-1::0;;;;;40549:12:0::1;::::0;40588:6;40542:33:::1;:53::i;:::-;40611:30;::::0;529:25:1;;;40622:10:0::1;::::0;40611:30:::1;::::0;517:2:1;502:18;40611:30:0::1;;;;;;;;40388:261;40335:314:::0;:::o;37113:364::-;37183:7;-1:-1:-1;;;;;37207:19:0;;;;;;:61;;-1:-1:-1;37256:12:0;;-1:-1:-1;;;;;37230:15:0;;;;;;:8;:15;;;;;:23;;;:38;37207:61;37203:186;;;-1:-1:-1;;;;;37310:15:0;;;;;;:8;:15;;;;;:23;;;37292:15;:41;:85;;-1:-1:-1;;;;;37354:15:0;;;;;;:8;:15;;;;;:23;;;37292:85;;;37336:15;37292:85;37285:92;37113:364;-1:-1:-1;;37113:364:0:o;37203:186::-;37424:12;;37406:15;:30;:63;;37457:12;;37406:63;;39948:224;40013:14;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;40013:14:0;39993:10;44262:26;44285:1;44262:14;:26::i;:::-;44239:20;:49;44316:36;44349:1;44316:24;:36::i;:::-;44299:14;:53;-1:-1:-1;;;;;44369:19:0;;;44365:377;;-1:-1:-1;;;;;44409:15:0;;;;;;:8;:15;;;;;:34;:39;;44405:119;;44504:20;;-1:-1:-1;;;;;44467:15:0;;;;;;:8;:15;;;;;:57;44405:119;44574:5;;44565:33;;-1:-1:-1;;;44565:33:0;;-1:-1:-1;;;;;1283:32:1;;;44565:33:0;;;1265:51:1;44574:5:0;;;;44565:26;;1238:18:1;;44565:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;44539:15:0;;;;;;:8;:15;;;;;:23;;:59;44639:13;44548:5;44639:6;:13::i;:::-;-1:-1:-1;;;;;44613:15:0;;;;;;:8;:15;;;;;:23;;:39;;;;44704:26;;:14;:26::i;:::-;-1:-1:-1;;;;;44667:15:0;;;;;;:8;:15;;;;;:63;44365:377;40071:15:::1;40080:5:::0;;-1:-1:-1;;;;;40080:5:0::1;40071:15:::0;;:8:::1;:15;::::0;;;;;;;;:34;;40107:23:::1;::::0;;::::1;::::0;40045:86;;4351:25:1;;;4392:18;;;4385:34;;;;40059:10:0::1;::::0;40045:86:::1;::::0;4324:18:1;40045:86:0::1;;;;;;;-1:-1:-1::0;;40149:15:0::1;40158:5:::0;;-1:-1:-1;;;;;40158:5:0::1;40149:15:::0;;:8:::1;:15;::::0;;;;;;;;40142:22;;::::1;::::0;::::1;::::0;;;;;;40158:5;40142:22;::::1;::::0;;;::::1;::::0;;;;::::1;;::::0;;;;;;;;;39948:224::o;32385:271::-;32454:14;;-1:-1:-1;;;;;32454:14:0;32440:10;:28;32432:94;;;;-1:-1:-1;;;32432:94:0;;4632:2:1;32432:94:0;;;4614:21:1;4671:2;4651:18;;;4644:30;4710:34;4690:18;;;4683:62;-1:-1:-1;;;4761:18:1;;;4754:51;4822:19;;32432:94:0;4430:417:1;32432:94:0;32555:5;;;32562:14;32542:35;;;-1:-1:-1;;;;;32555:5:0;;;5064:34:1;;32562:14:0;;;;5129:2:1;5114:18;;5107:43;32542:35:0;;4999:18:1;32542:35:0;;;;;;;32596:14;;;;32588:22;;-1:-1:-1;;;;;;32588:22:0;;;-1:-1:-1;;;;;32596:14:0;;32588:22;;;;32621:27;;;32385:271::o;43820:220::-;32694:12;:10;:12::i;:::-;43966:5:::1;::::0;43912:69:::1;::::0;-1:-1:-1;;;43912:69:0;;43959:4:::1;43912:69;::::0;::::1;5401:34:1::0;-1:-1:-1;;;;;43966:5:0;;::::1;5451:18:1::0;;;5444:43;5503:18;;;5496:34;;;43912:38:0;;::::1;::::0;::::1;::::0;5336:18:1;;43912:69:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;43997:35:0::1;::::0;;-1:-1:-1;;;;;5733:32:1;;5715:51;;5797:2;5782:18;;5775:34;;;43997:35:0::1;::::0;-1:-1:-1;5688:18:1;;-1:-1:-1;43997:35:0::1;;;;;;;43820:220:::0;;:::o;42528:537::-;32694:12;:10;:12::i;:::-;-1:-1:-1;;;;;42627:35:0;::::1;;::::0;;;:21:::1;:35;::::0;;;;;::::1;;:44;;::::0;;42623:73:::1;;42680:16;;-1:-1:-1::0;;;42680:16:0::1;;;;;;;;;;;42623:73;42732:45;::::0;-1:-1:-1;;;42732:45:0;;42771:4:::1;42732:45;::::0;::::1;1265:51:1::0;42717:12:0::1;::::0;-1:-1:-1;;;;;42732:30:0;::::1;::::0;::::1;::::0;1238:18:1;;42732:45:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;42717:60;;42802:11;42792:7;:21;42788:143;;;42822:109;::::0;-1:-1:-1;;;42822:109:0;;::::1;::::0;::::1;4351:25:1::0;;;4392:18;;;4385:34;;;4324:18;;42822:109:0::1;4177:248:1::0;42788:143:0::1;42986:5;::::0;42952:53:::1;::::0;-1:-1:-1;;;;;42952:33:0;;::::1;::::0;42986:5:::1;42993:11:::0;42952:33:::1;:53::i;:::-;43021:36;::::0;;-1:-1:-1;;;;;5733:32:1;;5715:51;;5797:2;5782:18;;5775:34;;;43021:36:0::1;::::0;5688:18:1;43021:36:0::1;5541:274:1::0;42151:275:0;32694:12;:10;:12::i;:::-;42258::::1;;42239:15;:31;42235:81;;42303:12;;42279:37;;-1:-1:-1::0;;;42279:37:0::1;;;;;;529:25:1::0;;517:2;502:18;;383:177;42235:81:0::1;42329:15;:34:::0;;;42379:39:::1;::::0;529:25:1;;;42379:39:0::1;::::0;517:2:1;502:18;42379:39:0::1;383:177:1::0;43536:206:0;32694:12;:10;:12::i;:::-;-1:-1:-1;;;;;43636:35:0;::::1;;::::0;;;:21:::1;:35;::::0;;;;;;;;:42;;-1:-1:-1;;43636:42:0::1;::::0;::::1;;::::0;;::::1;::::0;;;43694:40;;1467:41:1;;;43694:40:0::1;::::0;1440:18:1;43694:40:0::1;1327:187:1::0;37845:868:0;37905:7;37925:20;37957:5;;;;;;;;;-1:-1:-1;;;;;37957:5:0;-1:-1:-1;;;;;37948:27:0;;:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;37925:52;;37994:12;38010:1;37994:17;37990:77;;-1:-1:-1;;38035:20:0;;;37845:868;-1:-1:-1;37845:868:0:o;37990:77::-;38077:20;38100:31;38125:5;38100:24;:31::i;:::-;38077:54;;38260:14;;38245:12;:29;38241:258;;;38456:12;38394:10;;38357:12;38340:14;;:29;;;;:::i;:::-;38339:65;;;;:::i;:::-;:93;;38428:4;38339:93;:::i;:::-;:129;;;;:::i;:::-;38298:20;;:189;;;;:::i;:::-;38291:196;37845:868;-1:-1:-1;;;;37845:868:0:o;38241:258::-;38674:12;38612:10;;38573:14;;38558:12;:29;;;;:::i;:::-;38557:65;;;;:::i;:::-;:93;;38646:4;38557:93;:::i;:::-;:129;;;;:::i;:::-;38516:20;;:189;;;;:::i;32734:133::-;32802:5;;-1:-1:-1;;;;;32802:5:0;32788:10;:19;32780:79;;;;-1:-1:-1;;;32780:79:0;;6022:2:1;32780:79:0;;;6004:21:1;6061:2;6041:18;;;6034:30;6100:34;6080:18;;;6073:62;-1:-1:-1;;;6151:18:1;;;6144:45;6206:19;;32780:79:0;5820:411:1;32780:79:0;32734:133::o;20781:211::-;20925:58;;;-1:-1:-1;;;;;5733:32:1;;20925:58:0;;;5715:51:1;5782:18;;;;5775:34;;;20925:58:0;;;;;;;;;;5688:18:1;;;;20925:58:0;;;;;;;;-1:-1:-1;;;;;20925:58:0;-1:-1:-1;;;20925:58:0;;;20898:86;;20918:5;;20898:19;:86::i;:::-;20781:211;;;:::o;23354:716::-;23778:23;23804:69;23832:4;23804:69;;;;;;;;;;;;;;;;;23812:5;-1:-1:-1;;;;;23804:27:0;;;:69;;;;;:::i;:::-;23888:17;;23778:95;;-1:-1:-1;23888:21:0;23884:179;;23985:10;23974:30;;;;;;;;;;;;:::i;:::-;23966:85;;;;-1:-1:-1;;;23966:85:0;;6688:2:1;23966:85:0;;;6670:21:1;6727:2;6707:18;;;6700:30;6766:34;6746:18;;;6739:62;-1:-1:-1;;;6817:18:1;;;6810:40;6867:19;;23966:85:0;6486:406:1;12531:229:0;12668:12;12700:52;12722:6;12730:4;12736:1;12739:12;12700:21;:52::i;:::-;12693:59;;12531:229;;;;;;:::o;13651:510::-;13821:12;13879:5;13854:21;:30;;13846:81;;;;-1:-1:-1;;;13846:81:0;;7099:2:1;13846:81:0;;;7081:21:1;7138:2;7118:18;;;7111:30;7177:34;7157:18;;;7150:62;-1:-1:-1;;;7228:18:1;;;7221:36;7274:19;;13846:81:0;6897:402:1;13846:81:0;-1:-1:-1;;;;;10081:19:0;;;13938:60;;;;-1:-1:-1;;;13938:60:0;;7506:2:1;13938:60:0;;;7488:21:1;7545:2;7525:18;;;7518:30;7584:31;7564:18;;;7557:59;7633:18;;13938:60:0;7304:353:1;13938:60:0;14012:12;14026:23;14053:6;-1:-1:-1;;;;;14053:11:0;14072:5;14079:4;14053:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14011:73;;;;14102:51;14119:7;14128:10;14140:12;14102:16;:51::i;:::-;14095:58;13651:510;-1:-1:-1;;;;;;;13651:510:0:o;16337:712::-;16487:12;16516:7;16512:530;;;-1:-1:-1;16547:10:0;16540:17;;16512:530;16661:17;;:21;16657:374;;16859:10;16853:17;16920:15;16907:10;16903:2;16899:19;16892:44;16657:374;17002:12;16995:20;;-1:-1:-1;;;16995:20:0;;;;;;;;:::i;14:173:1:-;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:70;;177:1;174;167:12;111:70;14:173;;;:::o;192:186::-;251:6;304:2;292:9;283:7;279:23;275:32;272:52;;;320:1;317;310:12;272:52;343:29;362:9;343:29;:::i;565:118::-;651:5;644:13;637:21;630:5;627:32;617:60;;673:1;670;663:12;688:241;744:6;797:2;785:9;776:7;772:23;768:32;765:52;;;813:1;810;803:12;765:52;852:9;839:23;871:28;893:5;871:28;:::i;934:180::-;993:6;1046:2;1034:9;1025:7;1021:23;1017:32;1014:52;;;1062:1;1059;1052:12;1014:52;-1:-1:-1;1085:23:1;;934:180;-1:-1:-1;934:180:1:o;2208:254::-;2276:6;2284;2337:2;2325:9;2316:7;2312:23;2308:32;2305:52;;;2353:1;2350;2343:12;2305:52;2376:29;2395:9;2376:29;:::i;:::-;2366:39;2452:2;2437:18;;;;2424:32;;-1:-1:-1;;;2208:254:1:o;2467:315::-;2532:6;2540;2593:2;2581:9;2572:7;2568:23;2564:32;2561:52;;;2609:1;2606;2599:12;2561:52;2632:29;2651:9;2632:29;:::i;:::-;2622:39;;2711:2;2700:9;2696:18;2683:32;2724:28;2746:5;2724:28;:::i;:::-;2771:5;2761:15;;;2467:315;;;;;:::o;2787:127::-;2848:10;2843:3;2839:20;2836:1;2829:31;2879:4;2876:1;2869:15;2903:4;2900:1;2893:15;2919:125;2959:4;2987:1;2984;2981:8;2978:34;;;2992:18;;:::i;:::-;-1:-1:-1;3029:9:1;;2919:125::o;3049:184::-;3119:6;3172:2;3160:9;3151:7;3147:23;3143:32;3140:52;;;3188:1;3185;3178:12;3140:52;-1:-1:-1;3211:16:1;;3049:184;-1:-1:-1;3049:184:1:o;3238:168::-;3278:7;3344:1;3340;3336:6;3332:14;3329:1;3326:21;3321:1;3314:9;3307:17;3303:45;3300:71;;;3351:18;;:::i;:::-;-1:-1:-1;3391:9:1;;3238:168::o;3411:217::-;3451:1;3477;3467:132;;3521:10;3516:3;3512:20;3509:1;3502:31;3556:4;3553:1;3546:15;3584:4;3581:1;3574:15;3467:132;-1:-1:-1;3613:9:1;;3411:217::o;3633:128::-;3673:3;3704:1;3700:6;3697:1;3694:13;3691:39;;;3710:18;;:::i;:::-;-1:-1:-1;3746:9:1;;3633:128::o;6236:245::-;6303:6;6356:2;6344:9;6335:7;6331:23;6327:32;6324:52;;;6372:1;6369;6362:12;6324:52;6404:9;6398:16;6423:28;6445:5;6423:28;:::i;7662:258::-;7734:1;7744:113;7758:6;7755:1;7752:13;7744:113;;;7834:11;;;7828:18;7815:11;;;7808:39;7780:2;7773:10;7744:113;;;7875:6;7872:1;7869:13;7866:48;;;7910:1;7901:6;7896:3;7892:16;7885:27;7866:48;;7662:258;;;:::o;7925:274::-;8054:3;8092:6;8086:13;8108:53;8154:6;8149:3;8142:4;8134:6;8130:17;8108:53;:::i;:::-;8177:16;;;;;7925:274;-1:-1:-1;;7925:274:1:o;8204:383::-;8353:2;8342:9;8335:21;8316:4;8385:6;8379:13;8428:6;8423:2;8412:9;8408:18;8401:34;8444:66;8503:6;8498:2;8487:9;8483:18;8478:2;8470:6;8466:15;8444:66;:::i;:::-;8571:2;8550:15;-1:-1:-1;;8546:29:1;8531:45;;;;8578:2;8527:54;;8204:383;-1:-1:-1;;8204:383:1:o

Swarm Source

ipfs://5954e56aec6fe8a59bb51b84e44f2497596091e20f6ac7efadcd92aedf82f88d
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.

A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.