Contract 0x8954bc101f592d6b8442b38b1a3d744251dca1dd

 
Txn Hash Method
Block
From
To
Value [Txn Fee]
0x9550b7d6a1727cf69c55de68ece512d94e1d60a9cc4ee72806489fadcbae8e85Emergency Withdr...473406102022-09-20 14:31:4472 days 8 hrs ago0xd21649dad88c20d7ffe584c15297e1517dee5168 IN  Radiant DeFi: Masterchef0 FTM0.00016181
0x3298b0b30e1a5c9691b3c58c11e9fe1b94846b3a4ef3156753ae070c075de2d4Emergency Withdr...462050722022-09-02 13:20:5990 days 9 hrs ago0xae898f9d3996ec4d5be6a4e6c70fb327de848fa0 IN  Radiant DeFi: Masterchef0 FTM0.000173982593
0xe262e322b4d231998d1769296d50097557389de200ae3c709bb0fba378fc9068Emergency Withdr...413981682022-06-26 17:42:27158 days 5 hrs ago0xd21649dad88c20d7ffe584c15297e1517dee5168 IN  Radiant DeFi: Masterchef0 FTM0.00017397805
0x4e2f8765dc72b688133fe5133aac24d48d4e5a9a0c37f17c99cd7a600f9c2331Emergency Withdr...408297422022-06-19 2:31:04165 days 20 hrs ago0x3c7ac2ff76a1b4dcb2b69b1121fef5fb8dcdec43 IN  Radiant DeFi: Masterchef0 FTM0.004547650529
0xe93eb435401047693f2ca8fe8e0a3a9a1816cd7bc7fa86087ed51742cf29e30eEmergency Withdr...408296882022-06-19 2:30:11165 days 20 hrs ago0x3c7ac2ff76a1b4dcb2b69b1121fef5fb8dcdec43 IN  Radiant DeFi: Masterchef0 FTM0.009381201722
0x8d8fb6f4d32870aed61d7f240d9dce6602f39d4dde0ead4454cbfdcf9a8876cfEmergency Withdr...397797062022-06-04 17:11:20180 days 5 hrs ago0x7b1f04eda7537d689fff82a5afe294fc30d9eecf IN  Radiant DeFi: Masterchef0 FTM0.000506857561
0xdffaa496421a84945afc9dfae8c58cf8e3a163056c9bf9cf07ba620d392c80f8Emergency Withdr...391366712022-05-27 0:33:36188 days 22 hrs ago0x952cf57d0518bc03019d397e06a5a9dfcfde2caa IN  Radiant DeFi: Masterchef0 FTM0.003669881851
0x82e31ab294764bf3a49d83f20631a696438de5f5570c091b6eb0a83f8f92e215Emergency Withdr...389136982022-05-23 23:46:08191 days 23 hrs ago0xb8b64ca3a7f189e1880a519a654f854c447d6e77 IN  Radiant DeFi: Masterchef0 FTM0.018450490406
0xbe2e24351297fff9776e55f626b96e92dc381ffc4cbccbe75f0e9a2d2da8958cEmergency Withdr...388370612022-05-22 22:44:12193 days 3 mins ago0xe85fc09d80e47c9dddd85147546361a6990fbabf IN  Radiant DeFi: Masterchef0 FTM0.002194109786
0x742f9e66baf0b38fd98f952403f8ba5e573024922cc75b3640cd2f2cfa318577Harvest All386641022022-05-20 14:24:39195 days 8 hrs ago0x6386aae7b2de8e9fd895171f24f93d08545fb4f6 IN  Radiant DeFi: Masterchef0 FTM0.009284182509
0xe55c9d684f30e552f6729007a7da86ced35a207efbb12e5f578c861fa88a1aa2Emergency Withdr...384910472022-05-18 5:32:34197 days 17 hrs ago0x2e1ceef912b5003dbe56dc58550ede28d5a58fa7 IN  Radiant DeFi: Masterchef0 FTM0.027856847271
0x4c0d0ecd80a9ac3efb69e00d11b15e9150099a58b4f1e1cc0ae88eae9e48a8f3Emergency Withdr...382150852022-05-14 9:51:10201 days 12 hrs ago0xbef0bf5006f57912f7eb22fa263954105c79c87c IN  Radiant DeFi: Masterchef0 FTM0.020725345639
0x8d7303badde98f3f14dada875f452b0e59cb69e7c4e867aebbbf81cbc6ed57abEmergency Withdr...382148782022-05-14 9:47:10201 days 13 hrs ago0xbef0bf5006f57912f7eb22fa263954105c79c87c IN  Radiant DeFi: Masterchef0 FTM0.022146120417
0x66b0db913d074dc7d5aeeb9990f5fc9a42bc683fec569c9d7c4013cf38759a1eEmergency Withdr...381742832022-05-13 20:35:14202 days 2 hrs ago0x902fd8c41bd6107f54d9d2713648ecb3fae98818 IN  Radiant DeFi: Masterchef0 FTM0.039065915133
0xfc81e49d9bf9508f798da24510e7977febc2bf2ec8fbfd65722ab3904ff1ed3fEmergency Withdr...381367422022-05-13 6:14:56202 days 16 hrs ago0xf60f773494889f18fc7eabbcd5705334bb7cc6dc IN  Radiant DeFi: Masterchef0 FTM0.110157580256
0x2f12f6c3b3bb71a327d62eb1e2695289f5c30172fab85767da418e00b8ba9c9aEmergency Withdr...381067082022-05-12 17:07:15203 days 5 hrs ago0xc5f103fb2b831d461465cd80cc7fc09ec5e36051 IN  Radiant DeFi: Masterchef0 FTM0.093963879287
0xbd27ae6ddaa92b3e17b20ff71d0583ce23edb4e966b53a52f5a99e312587e2a5Emergency Withdr...381062332022-05-12 16:54:08203 days 5 hrs ago0xc5f103fb2b831d461465cd80cc7fc09ec5e36051 IN  Radiant DeFi: Masterchef0 FTM0.097628593685
0x6e4f2aadb0211ac09efc66afebd30c7ab98cd2bfa94bc49a771b9c6872ae9a84Emergency Withdr...379998832022-05-10 20:40:18205 days 2 hrs ago0xbcc4141d5264d5c886a81d151f60889ace68d11e IN  Radiant DeFi: Masterchef0 FTM0.016808765617
0x59978a1d2afd6f26f683653aa40b810985e08a9ea0d2dcdb4d186b8fde9f032bEmergency Withdr...379996452022-05-10 20:36:10205 days 2 hrs ago0xbcc4141d5264d5c886a81d151f60889ace68d11e IN  Radiant DeFi: Masterchef0 FTM0.023223873776
0x911f553bc53b7968b051ffb2fbf52c3f22c5cb7be9db3b2905e4cabefe08a8d7Emergency Withdr...379544792022-05-10 5:22:28205 days 17 hrs ago0xa126704e6eba3a6cb8a428c62f4e21af950a3fa9 IN  Radiant DeFi: Masterchef0 FTM0.034030473247
0x2d0c3fb05d845487013322c4903f183ba8990875b30913009f7692e1d7d43d4dEmergency Withdr...379387582022-05-09 23:18:11205 days 23 hrs ago0x33544bd96512fe8a94dfac8789bffd779334e27c IN  Radiant DeFi: Masterchef0 FTM0.028671696416
0xe954b02727176a3d0dab18a421fbf6f66cf6029a39a8dde1494dc5b086c33af0Emergency Withdr...379346762022-05-09 22:03:16206 days 44 mins ago0x4c119e41e094b136d0749fa3180e9e450795b844 IN  Radiant DeFi: Masterchef0 FTM0.049532153274
0x5e2b2005aa375dc3bffd99914b32e326971fc3a038c6d9792930d7647b01fc5dEmergency Withdr...379346542022-05-09 22:02:37206 days 44 mins ago0x4c119e41e094b136d0749fa3180e9e450795b844 IN  Radiant DeFi: Masterchef0 FTM0.077435879172
0x3a71fcd46678a531e615a48ecff1651e5f7bf04dc3786d5fcdf7f607d6b3bc32Emergency Withdr...379118392022-05-09 13:24:25206 days 9 hrs ago0xb96a1688ddce8da1f2e2add33962768224e39e4c IN  Radiant DeFi: Masterchef0 FTM0.035561320264
0x95e110826d56072e1d60830117a083c5199debc6d55b7756ebbbfacea5147019Emergency Withdr...379068412022-05-09 11:41:35206 days 11 hrs ago0xd21649dad88c20d7ffe584c15297e1517dee5168 IN  Radiant DeFi: Masterchef0 FTM0.107685798943
[ Download CSV Export 
Latest 1 internal transaction
Parent Txn Hash Block From To Value
0xba3ce0523fa8a240d7058bcb15317d8b98f34ddfbf9bc1a5ef261595b1a5ddc2365920682022-04-21 4:45:53224 days 18 hrs ago Radiant: Deployer  Contract Creation0 FTM
[ Download CSV Export 
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
RaysChef

Compiler Version
v0.8.10+commit.fc410830

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at FtmScan.com on 2022-04-21
*/

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    function decimals() external view returns (uint8);

    function totalSupply() external view returns (uint256);

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

    function transfer(address recipient, uint256 amount) external returns (bool);

    function allowance(address owner, address spender) external view returns (uint256);

    function approve(address spender, uint256 amount) external returns (bool);

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

    event Transfer(address indexed from, address indexed to, uint256 value);

    event Approval(address indexed owner, address indexed spender, uint256 value);
}

pragma solidity ^0.8.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;
        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");

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

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

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

pragma solidity ^0.8.0;
/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

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

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

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

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

        return true;
    }

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

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

        return true;
    }

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

        _beforeTokenTransfer(sender, recipient, amount);

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

        emit Transfer(sender, recipient, amount);

        _afterTokenTransfer(sender, recipient, amount);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.10;
/**
 * @title Rays Token
 * @author Radiant DeFi
 */
contract Rays is ERC20, Ownable {
    constructor() ERC20("Radiant", "RAYS") {}

    function mint(address _to, uint256 _amount) external onlyOwner {
        _mint(_to, _amount);
    }

    function burn(address _account, uint256 _amount) external onlyOwner {
        _burn(_account, _amount);
    }
    
    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

}

pragma solidity ^0.8.0;
// Solar Garden is a fork of MasterChef by SushiSwap
// The biggest change made is using per second instead of per block for rewards
// This is due to Fantoms extremely inconsistent block times
// Reentrency Guard has been added to Deposit and Withdrawl functions
// The other biggest change was the removal of the migration functions
//
// Note that it's ownable and the owner wields tremendous power.
//
// Have fun reading it. Hopefully it's bug-free. 
contract RaysChef is Ownable, ReentrancyGuard {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    // Info of each user.
    struct UserInfo {
        uint256 amount;     // How many LP tokens the user has provided.
        uint256 rewardDebt; // Reward debt. See explanation below.
        //
        // We do some fancy math here. Basically, any point in time, the amount of RAYS
        // entitled to a user but is pending to be distributed is:
        //
        //   pending reward = (user.amount * pool.accRaysPerShare) - user.rewardDebt
        //
        // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
        //   1. The pool's `accRaysPerShare` (and `lastRewardBlock`) gets updated.
        //   2. User receives the pending reward sent to his/her address.
        //   3. User's `amount` gets updated.
        //   4. User's `rewardDebt` gets updated.
    }

    // Info of each pool.
    struct PoolInfo {
        IERC20 lpToken;           // Address of LP token contract.
        uint256 allocPoint;       // How many allocation points assigned to this pool. SOLARRAYS to distribute per block.
        uint256 lastRewardTime;  // Last block time that RAYS distribution occurs.
        uint256 accRAYSPerShare; // Accumulated RAYS per share, times 1e12. See below.
        uint16 depositFeeBP;      // Deposit fee in basis points
    }

    // Catch some Rays!
    Rays public rays;

    // Treasury address.
    address public treasuryAddress;
    // Yield address for NFT Staking.
    address public yieldAddress;
    // Operations address.
    address public operationsAddress;
    // RAYS tokens created per second.
    uint256 public raysPerSecond;
    // set a max RAYS per second, which can never be higher than 1000 per second
    uint256 public constant maxRAYSPerSecond = 1000e18;
    // Max Allocation Points
    uint256 public constant MaxAllocPoint = 5000;

    // Info of each pool.
    PoolInfo[] public poolInfo;
    // Info of each user that stakes LP tokens.
    mapping (uint256 => mapping (address => UserInfo)) public userInfo;
    // Total allocation points. Must be the sum of all allocation points in all pools.
    uint256 public totalAllocPoint = 0;
    // The block time when RAYS mining starts.
    uint256 public startTime;
    // The block time when RAYS mining stops.
    uint256 public endTime;

    event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
    event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
    event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);

    constructor(
        Rays _rays,
        address _treasuryAddress,
        address _yieldAddress,
        address _operationsAddress,
        uint256 _raysPerSecond,
        uint256 _startTime,
        uint256 _endTime
    ) {
        rays = _rays;
        treasuryAddress = _treasuryAddress;
        yieldAddress = _yieldAddress;
        operationsAddress = _operationsAddress;
        raysPerSecond = _raysPerSecond;
        startTime = _startTime;
        endTime = _endTime;
    }

    function poolLength() external view returns (uint256) {
        return poolInfo.length;
    }

    // Changes RAYS token reward per second
    // Good practice to update pools without messing up the contract
    function setRAYSPerSecond(uint256 _raysPerSecond) external onlyOwner {
        require(_raysPerSecond <= maxRAYSPerSecond, "setRAYSPerSecond: too many RAYS!");
        // This MUST be done or pool rewards will be calculated with new Rays per second
        // This could unfairly punish small pools that dont have frequent deposits/withdraws/harvests
        massUpdatePools(); 

        raysPerSecond = _raysPerSecond;
    }

    function checkForDuplicate(IERC20 _lpToken) internal view {
        uint256 length = poolInfo.length;
        for (uint256 _pid = 0; _pid < length; _pid++) {
            require(poolInfo[_pid].lpToken != _lpToken, "add: pool already exists!!!!");
        }

    }

    // Add a new lp to the pool. Can only be called by the owner.
    function add(uint256 _allocPoint, IERC20 _lpToken, uint16 _depositFeeBP) external onlyOwner {
        require(_depositFeeBP <= 200, "add: invalid deposit fee basis points");
        require(_allocPoint <= MaxAllocPoint, "add: too many alloc points!!");

        checkForDuplicate(_lpToken); // ensure you can't add duplicate pools

        massUpdatePools();

        uint256 lastRewardTime = block.timestamp > startTime ? block.timestamp : startTime;
        totalAllocPoint = totalAllocPoint.add(_allocPoint);
        poolInfo.push(PoolInfo({
            lpToken: _lpToken,
            allocPoint: _allocPoint,
            lastRewardTime: lastRewardTime,
            accRAYSPerShare: 0,
            depositFeeBP: _depositFeeBP
        }));
    }

    // Update the given pool's RAYS allocation point. Can only be called by the owner.
    function set(uint256 _pid, uint256 _allocPoint, uint16 _depositFeeBP) external onlyOwner {
        require(_depositFeeBP <= 200, "set: invalid deposit fee basis points");
        require(_allocPoint <= MaxAllocPoint, "add: too many alloc points!!");

        massUpdatePools();

        totalAllocPoint = totalAllocPoint - poolInfo[_pid].allocPoint + _allocPoint;
        poolInfo[_pid].allocPoint = _allocPoint;
        poolInfo[_pid].depositFeeBP = _depositFeeBP;
    }

    // Return reward multiplier over the given _from to _to timestamp.
    function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) {
        _from = _from > startTime ? _from : startTime;
        if (_to < startTime) {
            return 0;
        }

        if (_to <= endTime) {
            return _to.sub(_from);
        } else if (_from >= endTime) {
            return 0;
        } else {
            return endTime.sub(_from);
        }
    }

    // View function to see pending RAYS on frontend.
    function pendingRAYS(uint256 _pid, address _user) external view returns (uint256) {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accRAYSPerShare = pool.accRAYSPerShare;
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        if (block.timestamp > pool.lastRewardTime && lpSupply != 0) {
            uint256 multiplier = getMultiplier(pool.lastRewardTime, block.timestamp);
            uint256 raysReward = multiplier.mul(raysPerSecond).mul(pool.allocPoint).div(totalAllocPoint);
            accRAYSPerShare = accRAYSPerShare.add(raysReward.mul(1e12).div(lpSupply));
        }
        return user.amount.mul(accRAYSPerShare).div(1e12).sub(user.rewardDebt);
    }

    // Update reward variables for all pools. Be careful of gas spending!
    function massUpdatePools() public {
        uint256 length = poolInfo.length;
        for (uint256 pid = 0; pid < length; ++pid) {
            updatePool(pid);
        }
    }

    // Update reward variables of the given pool to be up-to-date.
    function updatePool(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        if (block.timestamp <= pool.lastRewardTime) {
            return;
        }
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        if (lpSupply == 0) {
            pool.lastRewardTime = block.timestamp;
            return;
        }
        uint256 multiplier = getMultiplier(pool.lastRewardTime, block.timestamp);
        uint256 raysReward = multiplier.mul(raysPerSecond).mul(pool.allocPoint).div(totalAllocPoint);

        rays.mint(treasuryAddress, raysReward.div(4));
        rays.mint(operationsAddress, raysReward.div(4));
        rays.mint(yieldAddress, raysReward);
        rays.mint(address(this), raysReward);

        pool.accRAYSPerShare = pool.accRAYSPerShare.add(raysReward.mul(1e12).div(lpSupply));
        pool.lastRewardTime = block.timestamp;
    }

    function burn(uint256 _amount) public onlyOwner {
        rays.burn(msg.sender, _amount);
    }

    // Deposit LP tokens to MasterChef for RAYS allocation.
    function deposit(uint256 _pid, uint256 _amount) public nonReentrant {

        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];

        updatePool(_pid);

        if (user.amount > 0) {
            uint256 pending = user.amount.mul(pool.accRAYSPerShare).div(1e12).sub(user.rewardDebt);
            if(pending > 0) {
                safeRAYSTransfer(msg.sender, pending);
            }
        }

        if (_amount > 0) {
            pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
            if (pool.depositFeeBP > 0) {
                uint256 depositFee = _amount.mul(pool.depositFeeBP).div(10000);
                pool.lpToken.safeTransfer(operationsAddress, depositFee);
                user.amount = user.amount.add(_amount).sub(depositFee);
            } else {
                 user.amount = user.amount.add(_amount);
            }
        }
       
        user.rewardDebt = user.amount.mul(pool.accRAYSPerShare).div(1e12);
        emit Deposit(msg.sender, _pid, _amount);
    }

    // Withdraw LP tokens from MasterChef.
    function withdraw(uint256 _pid, uint256 _amount) public nonReentrant {  
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];

        require(user.amount >= _amount, "withdraw: not good");

        updatePool(_pid);

        uint256 pending = user.amount.mul(pool.accRAYSPerShare).div(1e12).sub(user.rewardDebt);

        user.amount = user.amount.sub(_amount);
        user.rewardDebt = user.amount.mul(pool.accRAYSPerShare).div(1e12);

        if(pending > 0) {
            safeRAYSTransfer(msg.sender, pending);
        }
        pool.lpToken.safeTransfer(address(msg.sender), _amount);
        
        emit Withdraw(msg.sender, _pid, _amount);
    }

        function harvestAll() public nonReentrant {
            uint256 length = poolInfo.length;
            uint calc;
            uint pending;
            UserInfo storage user;
            PoolInfo storage pool;
            uint totalPending;
            for (uint256 pid = 0; pid < length; ++pid) {
                user = userInfo[pid][msg.sender];
                if (user.amount > 0) {
                    pool = poolInfo[pid];
                    updatePool(pid);

                    calc = user.amount.mul(pool.accRAYSPerShare).div(1e12);
                    pending = calc.sub(user.rewardDebt);
                    user.rewardDebt = calc;

                if(pending > 0) {
                    totalPending+=pending;
                }
            }
        }
        if (totalPending > 0) {
            safeRAYSTransfer(msg.sender, totalPending);
        }
    }

    // Withdraw without caring about rewards. EMERGENCY ONLY.
    function emergencyWithdraw(uint256 _pid) public nonReentrant {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];

        uint oldUserAmount = user.amount;
        user.amount = 0;
        user.rewardDebt = 0;

        pool.lpToken.safeTransfer(address(msg.sender), oldUserAmount);
        emit EmergencyWithdraw(msg.sender, _pid, oldUserAmount);

    }

    // Safe RAYS transfer function, just in case if rounding error causes pool to not have enough RAYS.
    function safeRAYSTransfer(address _to, uint256 _amount) internal {
        uint256 raysBal = rays.balanceOf(address(this));
        if (_amount > raysBal) {
            rays.transfer(_to, raysBal);
        } else {
            rays.transfer(_to, _amount);
        }
    }

    // Update yield address by the previous yield address.
    function yield(address _yieldAddress) public {
        require(msg.sender == yieldAddress, "Nice try but not today");
        yieldAddress = _yieldAddress;
    }

    // Update operations address by the previous operations address.
    function operations(address _operationsAddress) public {
        require(msg.sender == operationsAddress, "Nice try but not today");
        operationsAddress = _operationsAddress;
    }

    // Update end time.
    function UpdateEndTime(uint256 _endTime) public onlyOwner {
        endTime = _endTime;
    }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"contract Rays","name":"_rays","type":"address"},{"internalType":"address","name":"_treasuryAddress","type":"address"},{"internalType":"address","name":"_yieldAddress","type":"address"},{"internalType":"address","name":"_operationsAddress","type":"address"},{"internalType":"uint256","name":"_raysPerSecond","type":"uint256"},{"internalType":"uint256","name":"_startTime","type":"uint256"},{"internalType":"uint256","name":"_endTime","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EmergencyWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"MaxAllocPoint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_endTime","type":"uint256"}],"name":"UpdateEndTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"contract IERC20","name":"_lpToken","type":"address"},{"internalType":"uint16","name":"_depositFeeBP","type":"uint16"}],"name":"add","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"endTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_from","type":"uint256"},{"internalType":"uint256","name":"_to","type":"uint256"}],"name":"getMultiplier","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"harvestAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"massUpdatePools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"maxRAYSPerSecond","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_operationsAddress","type":"address"}],"name":"operations","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"operationsAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"pendingRAYS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"contract IERC20","name":"lpToken","type":"address"},{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"lastRewardTime","type":"uint256"},{"internalType":"uint256","name":"accRAYSPerShare","type":"uint256"},{"internalType":"uint16","name":"depositFeeBP","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rays","outputs":[{"internalType":"contract Rays","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"raysPerSecond","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"uint16","name":"_depositFeeBP","type":"uint16"}],"name":"set","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_raysPerSecond","type":"uint256"}],"name":"setRAYSPerSecond","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAllocPoint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"treasuryAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"updatePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_yieldAddress","type":"address"}],"name":"yield","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"yieldAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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

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

000000000000000000000000e3ef2768709fae1c2c2aec0533235b312970933d000000000000000000000000c3f8125c3b365a77f5c2dfc917acba337093f732000000000000000000000000a8e4c487ccf2522c543adce15e3ab59caf3dceca0000000000000000000000004d49c520d6838bcf983c0b4904bc98ebc3a0762a00000000000000000000000000000000000000000000003635c9adc5dea00000000000000000000000000000000000000000000000000000000000006262d10000000000000000000000000000000000000000000000000000000000627eaaaf

-----Decoded View---------------
Arg [0] : _rays (address): 0xe3ef2768709fae1c2c2aec0533235b312970933d
Arg [1] : _treasuryAddress (address): 0xc3f8125c3b365a77f5c2dfc917acba337093f732
Arg [2] : _yieldAddress (address): 0xa8e4c487ccf2522c543adce15e3ab59caf3dceca
Arg [3] : _operationsAddress (address): 0x4d49c520d6838bcf983c0b4904bc98ebc3a0762a
Arg [4] : _raysPerSecond (uint256): 1000000000000000000000
Arg [5] : _startTime (uint256): 1650643200
Arg [6] : _endTime (uint256): 1652468399

-----Encoded View---------------
7 Constructor Arguments found :
Arg [0] : 000000000000000000000000e3ef2768709fae1c2c2aec0533235b312970933d
Arg [1] : 000000000000000000000000c3f8125c3b365a77f5c2dfc917acba337093f732
Arg [2] : 000000000000000000000000a8e4c487ccf2522c543adce15e3ab59caf3dceca
Arg [3] : 0000000000000000000000004d49c520d6838bcf983c0b4904bc98ebc3a0762a
Arg [4] : 00000000000000000000000000000000000000000000003635c9adc5dea00000
Arg [5] : 000000000000000000000000000000000000000000000000000000006262d100
Arg [6] : 00000000000000000000000000000000000000000000000000000000627eaaaf


Deployed ByteCode Sourcemap

38677:12587:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42893:764;;;;;;:::i;:::-;;:::i;:::-;;41891:95;41963:8;:15;41891:95;;;881:25:1;;;869:2;854:18;41891:95:0;;;;;;;;40692:26;;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;1390:32:1;;;1372:51;;1454:2;1439:18;;1432:34;;;;1482:18;;;1475:34;;;;1540:2;1525:18;;1518:34;1601:6;1589:19;1583:3;1568:19;;1561:48;1359:3;1344:19;40692:26:0;1102:513:1;40935:34:0;;;;;;43753:480;;;;;;:::i;:::-;;:::i;51166:95::-;;;;;;:::i;:::-;;:::i;41102:22::-;;;;;;46804:97;;;;;;:::i;:::-;;:::i;48118:729::-;;;;;;:::i;:::-;;:::i;40408:28::-;;;;;;45891:905;;;;;;:::i;:::-;;:::i;49821:422::-;;;;;;:::i;:::-;;:::i;45635:180::-;;;:::i;22210:103::-;;;:::i;41024:24::-;;;;;;21559:87;21605:7;21632:6;-1:-1:-1;;;;;21632:6:0;21559:87;;;-1:-1:-1;;;;;2362:32:1;;;2344:51;;2332:2;2317:18;21559:87:0;2198:203:1;44313:412:0;;;;;;:::i;:::-;;:::i;48859:891::-;;;:::i;40774:66::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2908:25:1;;;2964:2;2949:18;;2942:34;;;;2881:18;40774:66:0;2734:248:1;40525:50:0;;40568:7;40525:50;;50702:164;;;;;;:::i;:::-;;:::i;40267:27::-;;;;;-1:-1:-1;;;;;40267:27:0;;;50944:189;;;;;;:::i;:::-;;:::i;40140:16::-;;;;;-1:-1:-1;;;;;40140:16:0;;;40191:30;;;;;-1:-1:-1;;;;;40191:30:0;;;42109:432;;;;;;:::i;:::-;;:::i;44788:764::-;;;;;;:::i;:::-;;:::i;46970:1096::-;;;;;;:::i;:::-;;:::i;40329:32::-;;;;;-1:-1:-1;;;;;40329:32:0;;;22468:201;;;;;;:::i;:::-;;:::i;40612:44::-;;40652:4;40612:44;;42893:764;21605:7;21632:6;-1:-1:-1;;;;;21632:6:0;20481:10;21779:23;21771:68;;;;-1:-1:-1;;;21771:68:0;;;;;;;:::i;:::-;;;;;;;;;43021:3:::1;43004:13;:20;;;;42996:70;;;::::0;-1:-1:-1;;;42996:70:0;;4031:2:1;42996:70:0::1;::::0;::::1;4013:21:1::0;4070:2;4050:18;;;4043:30;4109:34;4089:18;;;4082:62;-1:-1:-1;;;4160:18:1;;;4153:35;4205:19;;42996:70:0::1;3829:401:1::0;42996:70:0::1;40652:4;43085:11;:28;;43077:69;;;::::0;-1:-1:-1;;;43077:69:0;;4437:2:1;43077:69:0::1;::::0;::::1;4419:21:1::0;4476:2;4456:18;;;4449:30;4515;4495:18;;;4488:58;4563:18;;43077:69:0::1;4235:352:1::0;43077:69:0::1;43159:27;43177:8;43159:17;:27::i;:::-;43239:17;:15;:17::i;:::-;43269:22;43312:9;;43294:15;:27;:57;;43342:9;;43294:57;;;43324:15;43294:57;43380:15;::::0;43269:82;;-1:-1:-1;43380:32:0::1;::::0;43400:11;43380:19:::1;:32::i;:::-;43362:15;:50:::0;43437:211:::1;::::0;;::::1;::::0;::::1;::::0;;-1:-1:-1;;;;;43437:211:0;;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;;-1:-1:-1;43437:211:0;;;;;;::::1;::::0;;::::1;::::0;;;;;;43423:8:::1;:226:::0;;::::1;::::0;::::1;::::0;;;;;;;::::1;::::0;;::::1;::::0;;::::1;::::0;;-1:-1:-1;;;;;;43423:226:0::1;::::0;;;::::1;;::::0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;43423:226:0::1;::::0;;;::::1;::::0;;;::::1;::::0;;42893:764::o;40692:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;40692:26:0;;;;-1:-1:-1;40692:26:0;;;;;;;:::o;43753:480::-;21605:7;21632:6;-1:-1:-1;;;;;21632:6:0;20481:10;21779:23;21771:68;;;;-1:-1:-1;;;21771:68:0;;;;;;;:::i;:::-;43878:3:::1;43861:13;:20;;;;43853:70;;;::::0;-1:-1:-1;;;43853:70:0;;4794:2:1;43853:70:0::1;::::0;::::1;4776:21:1::0;4833:2;4813:18;;;4806:30;4872:34;4852:18;;;4845:62;-1:-1:-1;;;4923:18:1;;;4916:35;4968:19;;43853:70:0::1;4592:401:1::0;43853:70:0::1;40652:4;43942:11;:28;;43934:69;;;::::0;-1:-1:-1;;;43934:69:0;;4437:2:1;43934:69:0::1;::::0;::::1;4419:21:1::0;4476:2;4456:18;;;4449:30;4515;4495:18;;;4488:58;4563:18;;43934:69:0::1;4235:352:1::0;43934:69:0::1;44016:17;:15;:17::i;:::-;44110:11;44082:8;44091:4;44082:14;;;;;;;;:::i;:::-;;;;;;;;;;;:25;;;44064:15;;:43;;;;:::i;:::-;:57;;;;:::i;:::-;44046:15;:75;;;;44160:11;44132:8;44141:4;44132:14;;;;;;;;:::i;:::-;;;;;;;;;;;:25;;:39;;;;44212:13;44182:8;44191:4;44182:14;;;;;;;;:::i;:::-;;;;;;;;;;;:27;;;:43;;;;;;;;;;;;;;;;;;43753:480:::0;;;:::o;51166:95::-;21605:7;21632:6;-1:-1:-1;;;;;21632:6:0;20481:10;21779:23;21771:68;;;;-1:-1:-1;;;21771:68:0;;;;;;;:::i;:::-;51235:7:::1;:18:::0;51166:95::o;46804:97::-;21605:7;21632:6;-1:-1:-1;;;;;21632:6:0;20481:10;21779:23;21771:68;;;;-1:-1:-1;;;21771:68:0;;;;;;;:::i;:::-;46863:4:::1;::::0;:30:::1;::::0;-1:-1:-1;;;46863:30:0;;46873:10:::1;46863:30;::::0;::::1;5699:51:1::0;5766:18;;;5759:34;;;-1:-1:-1;;;;;46863:4:0;;::::1;::::0;:9:::1;::::0;5672:18:1;;46863:30:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;46804:97:::0;:::o;48118:729::-;24705:1;25303:7;;:19;;25295:63;;;;-1:-1:-1;;;25295:63:0;;;;;;;:::i;:::-;24705:1;25436:7;:18;;;;48200:21:::1;48224:8;48233:4;48224:14;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;48273;;;:8:::1;:14:::0;;;;;;48288:10:::1;48273:26:::0;;;;;;;48320:11;;48224:14:::1;::::0;;::::1;::::0;;::::1;::::0;-1:-1:-1;48320:22:0;-1:-1:-1;48320:22:0::1;48312:53;;;::::0;-1:-1:-1;;;48312:53:0;;6366:2:1;48312:53:0::1;::::0;::::1;6348:21:1::0;6405:2;6385:18;;;6378:30;-1:-1:-1;;;6424:18:1;;;6417:48;6482:18;;48312:53:0::1;6164:342:1::0;48312:53:0::1;48378:16;48389:4;48378:10;:16::i;:::-;48407:15;48425:68;48477:4;:15;;;48425:47;48467:4;48425:37;48441:4;:20;;;48425:4;:11;;;:15;;:37;;;;:::i;:::-;:41:::0;::::1;:47::i;:::-;:51:::0;::::1;:68::i;:::-;48520:11:::0;;48407:86;;-1:-1:-1;48520:24:0::1;::::0;48536:7;48520:15:::1;:24::i;:::-;48506:38:::0;;;48589:20:::1;::::0;::::1;::::0;48573:47:::1;::::0;48615:4:::1;::::0;48573:37:::1;::::0;48506:38;48573:15:::1;:37::i;:47::-;48555:15;::::0;::::1;:65:::0;48636:11;;48633:80:::1;;48664:37;48681:10;48693:7;48664:16;:37::i;:::-;48723:12:::0;;:55:::1;::::0;-1:-1:-1;;;;;48723:12:0::1;48757:10;48770:7:::0;48723:25:::1;:55::i;:::-;48804:35;::::0;881:25:1;;;48825:4:0;;48813:10:::1;::::0;48804:35:::1;::::0;869:2:1;854:18;48804:35:0::1;;;;;;;-1:-1:-1::0;;24661:1:0;25615:22;;-1:-1:-1;;;48118:729:0:o;45891:905::-;45943:21;45967:8;45976:4;45967:14;;;;;;;;:::i;:::-;;;;;;;;;;;45943:38;;46015:4;:19;;;45996:15;:38;45992:77;;46051:7;45891:905;:::o;45992:77::-;46098:12;;:37;;-1:-1:-1;;;46098:37:0;;46129:4;46098:37;;;2344:51:1;46079:16:0;;-1:-1:-1;;;;;46098:12:0;;:22;;2317:18:1;;46098:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;46079:56;-1:-1:-1;46150:13:0;46146:104;;-1:-1:-1;46202:15:0;46180:19;;;;:37;-1:-1:-1;45891:905:0:o;46146:104::-;46260:18;46281:51;46295:4;:19;;;46316:15;46281:13;:51::i;:::-;46260:72;;46343:18;46364:71;46419:15;;46364:50;46398:4;:15;;;46364:29;46379:13;;46364:10;:14;;:29;;;;:::i;:::-;:33;;:50::i;:71::-;46448:4;;46458:15;;46343:92;;-1:-1:-1;;;;;;46448:4:0;;;;:9;;46458:15;46475:17;46343:92;46490:1;46475:14;:17::i;:::-;46448:45;;-1:-1:-1;;;;;;46448:45:0;;;;;;;-1:-1:-1;;;;;5717:32:1;;;46448:45:0;;;5699:51:1;5766:18;;;5759:34;5672:18;;46448:45:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;46504:4:0;;46514:17;;-1:-1:-1;;;;;46504:4:0;;;;-1:-1:-1;46504:9:0;;-1:-1:-1;46514:17:0;46533;:10;46548:1;46533:14;:17::i;:::-;46504:47;;-1:-1:-1;;;;;;46504:47:0;;;;;;;-1:-1:-1;;;;;5717:32:1;;;46504:47:0;;;5699:51:1;5766:18;;;5759:34;5672:18;;46504:47:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;46562:4:0;;46572:12;;;46562:35;;-1:-1:-1;;;46562:35:0;;-1:-1:-1;;;;;46572:12:0;;;46562:35;;;5699:51:1;;;;5766:18;;;5759:34;;;46562:4:0;;;;-1:-1:-1;46562:9:0;;-1:-1:-1;5672:18:1;;46562:35:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;46608:4:0;;:36;;-1:-1:-1;;;46608:36:0;;46626:4;46608:36;;;5699:51:1;5766:18;;;5759:34;;;-1:-1:-1;;;;;46608:4:0;;;;-1:-1:-1;46608:9:0;;-1:-1:-1;5672:18:1;;46608:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46680:60;46705:34;46730:8;46705:20;46720:4;46705:10;:14;;:20;;;;:::i;:34::-;46680:20;;;;;:24;:60::i;:::-;46657:20;;;:83;-1:-1:-1;;46773:15:0;46751:19;;;;:37;;;;-1:-1:-1;;45891:905:0:o;49821:422::-;24705:1;25303:7;;:19;;25295:63;;;;-1:-1:-1;;;25295:63:0;;;;;;;:::i;:::-;24705:1;25436:7;:18;;;;49893:21:::1;49917:8;49926:4;49917:14;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;49966;;;:8:::1;:14:::0;;;;;;49981:10:::1;49966:26:::0;;;;;;;50026:11;;50048:15;;;-1:-1:-1;50074:15:0;::::1;:19:::0;;;;49917:14:::1;::::0;;::::1;;50106:12:::0;;49917:14;;-1:-1:-1;49966:26:0;;50026:11;50106:61:::1;::::0;-1:-1:-1;;;;;50106:12:0;;;::::1;::::0;50026:11;50106:25:::1;:61::i;:::-;50183:50;::::0;881:25:1;;;50213:4:0;;50201:10:::1;::::0;50183:50:::1;::::0;869:2:1;854:18;50183:50:0::1;;;;;;;;-1:-1:-1::0;;24661:1:0;25615:22;;-1:-1:-1;;49821:422:0:o;45635:180::-;45697:8;:15;45680:14;45723:85;45751:6;45745:3;:12;45723:85;;;45781:15;45792:3;45781:10;:15::i;:::-;45759:5;;;:::i;:::-;;;45723:85;;;;45669:146;45635:180::o;22210:103::-;21605:7;21632:6;-1:-1:-1;;;;;21632:6:0;20481:10;21779:23;21771:68;;;;-1:-1:-1;;;21771:68:0;;;;;;;:::i;:::-;22275:30:::1;22302:1;22275:18;:30::i;:::-;22210:103::o:0;44313:412::-;44385:7;44421:9;;44413:5;:17;:37;;44441:9;;44413:37;;;44433:5;44413:37;44405:45;;44471:9;;44465:3;:15;44461:56;;;-1:-1:-1;44504:1:0;44497:8;;44461:56;44540:7;;44533:3;:14;44529:189;;44571:14;:3;44579:5;44571:7;:14::i;:::-;44564:21;;;;44529:189;44616:7;;44607:5;:16;44603:115;;-1:-1:-1;44647:1:0;44640:8;;44603:115;44688:7;;:18;;44700:5;44688:11;:18::i;44603:115::-;44313:412;;;;:::o;48859:891::-;24705:1;25303:7;;:19;;25295:63;;;;-1:-1:-1;;;25295:63:0;;;;;;;:::i;:::-;24705:1;25436:7;:18;48933:8:::1;:15:::0;48916:14:::1;::::0;;;;;49118:524:::1;49146:6;49140:3;:12;49118:524;;;49187:13;::::0;;;:8:::1;:13;::::0;;;;;;;49201:10:::1;49187:25:::0;;;;;;;49235:11;;49187:25;;-1:-1:-1;49235:15:0;49231:400:::1;;49282:8;49291:3;49282:13;;;;;;;;:::i;:::-;;;;;;;;;;;49275:20;;49318:15;49329:3;49318:10;:15::i;:::-;49381:20;::::0;::::1;::::0;49365:11;;:47:::1;::::0;49407:4:::1;::::0;49365:37:::1;::::0;:15:::1;:37::i;:47::-;49358:54;;49445:25;49454:4;:15;;;49445:4;:8;;:25;;;;:::i;:::-;49493:15;::::0;::::1;:22:::0;;;49435:35;-1:-1:-1;49539:11:0;;49536:80:::1;;49575:21;49589:7:::0;49575:21;::::1;:::i;:::-;;;49536:80;49154:5;::::0;::::1;:::i;:::-;;;49118:524;;;-1:-1:-1::0;49656:16:0;;49652:91:::1;;49689:42;49706:10;49718:12;49689:16;:42::i;:::-;-1:-1:-1::0;;24661:1:0;25615:22;;-1:-1:-1;;;;48859:891:0:o;50702:164::-;50780:12;;-1:-1:-1;;;;;50780:12:0;50766:10;:26;50758:61;;;;-1:-1:-1;;;50758:61:0;;7042:2:1;50758:61:0;;;7024:21:1;7081:2;7061:18;;;7054:30;-1:-1:-1;;;7100:18:1;;;7093:52;7162:18;;50758:61:0;6840:346:1;50758:61:0;50830:12;:28;;-1:-1:-1;;;;;;50830:28:0;-1:-1:-1;;;;;50830:28:0;;;;;;;;;;50702:164::o;50944:189::-;51032:17;;-1:-1:-1;;;;;51032:17:0;51018:10;:31;51010:66;;;;-1:-1:-1;;;51010:66:0;;7042:2:1;51010:66:0;;;7024:21:1;7081:2;7061:18;;;7054:30;-1:-1:-1;;;7100:18:1;;;7093:52;7162:18;;51010:66:0;6840:346:1;51010:66:0;51087:17;:38;;-1:-1:-1;;;;;;51087:38:0;-1:-1:-1;;;;;51087:38:0;;;;;;;;;;50944:189::o;42109:432::-;21605:7;21632:6;-1:-1:-1;;;;;21632:6:0;20481:10;21779:23;21771:68;;;;-1:-1:-1;;;21771:68:0;;;;;;;:::i;:::-;40568:7:::1;42197:14;:34;;42189:79;;;::::0;-1:-1:-1;;;42189:79:0;;7393:2:1;42189:79:0::1;::::0;::::1;7375:21:1::0;;;7412:18;;;7405:30;7471:34;7451:18;;;7444:62;7523:18;;42189:79:0::1;7191:356:1::0;42189:79:0::1;42472:17;:15;:17::i;:::-;42503:13;:30:::0;42109:432::o;44788:764::-;44861:7;44881:21;44905:8;44914:4;44905:14;;;;;;;;:::i;:::-;;;;;;;;;44954;;;:8;:14;;;;;;-1:-1:-1;;;;;44954:21:0;;;;;;;;;;44905:14;;;;;;;;45012:20;;;;45062:12;;:37;;-1:-1:-1;;;45062:37:0;;45093:4;45062:37;;;2344:51:1;44905:14:0;;-1:-1:-1;44954:21:0;;44905:14;45062:12;;;;;:22;;2317:18:1;;45062:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;45043:56;;45132:4;:19;;;45114:15;:37;:54;;;;-1:-1:-1;45155:13:0;;;45114:54;45110:354;;;45185:18;45206:51;45220:4;:19;;;45241:15;45206:13;:51::i;:::-;45185:72;;45272:18;45293:71;45348:15;;45293:50;45327:4;:15;;;45293:29;45308:13;;45293:10;:14;;:29;;;;:::i;:71::-;45272:92;-1:-1:-1;45397:55:0;45417:34;45442:8;45417:20;45272:92;45432:4;45417:14;:20::i;:34::-;45397:15;;:19;:55::i;:::-;45379:73;;45170:294;;45110:354;45481:63;45528:4;:15;;;45481:42;45518:4;45481:32;45497:15;45481:4;:11;;;:15;;:32;;;;:::i;:63::-;45474:70;44788:764;-1:-1:-1;;;;;;;44788:764:0:o;46970:1096::-;24705:1;25303:7;;:19;;25295:63;;;;-1:-1:-1;;;25295:63:0;;;;;;;:::i;:::-;24705:1;25436:7;:18;;;;47051:21:::1;47075:8;47084:4;47075:14;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;47124;;;:8:::1;:14:::0;;;;;;47139:10:::1;47124:26:::0;;;;;;;47075:14:::1;::::0;;::::1;::::0;;::::1;::::0;-1:-1:-1;47163:16:0::1;47133:4:::0;47163:10:::1;:16::i;:::-;47196:11:::0;;:15;47192:236:::1;;47228:15;47246:68;47298:4;:15;;;47246:47;47288:4;47246:37;47262:4;:20;;;47246:4;:11;;;:15;;:37;;;;:::i;:68::-;47228:86:::0;-1:-1:-1;47332:11:0;;47329:88:::1;;47364:37;47381:10;47393:7;47364:16;:37::i;:::-;47213:215;47192:236;47444:11:::0;;47440:484:::1;;47472:12:::0;;:74:::1;::::0;-1:-1:-1;;;;;47472:12:0::1;47510:10;47531:4;47538:7:::0;47472:29:::1;:74::i;:::-;47565:17;::::0;::::1;::::0;::::1;;:21:::0;47561:352:::1;;47640:17;::::0;::::1;::::0;47607:18:::1;::::0;47628:41:::1;::::0;47663:5:::1;::::0;47628:30:::1;::::0;:7;;47640:17:::1;;47628:11;:30::i;:41::-;47714:17;::::0;47688:12;;47607:62;;-1:-1:-1;47688:56:0::1;::::0;-1:-1:-1;;;;;47688:12:0;;::::1;::::0;47714:17:::1;47607:62:::0;47688:25:::1;:56::i;:::-;47777:11:::0;;:40:::1;::::0;47806:10;;47777:24:::1;::::0;47793:7;47777:15:::1;:24::i;:40::-;47763:54:::0;;-1:-1:-1;47561:352:0::1;;;47873:11:::0;;:24:::1;::::0;47889:7;47873:15:::1;:24::i;:::-;47859:38:::0;;47561:352:::1;47977:20;::::0;::::1;::::0;47961:11;;:47:::1;::::0;48003:4:::1;::::0;47961:37:::1;::::0;:15:::1;:37::i;:47::-;47943:15;::::0;::::1;:65:::0;48024:34:::1;::::0;881:25:1;;;48044:4:0;;48032:10:::1;::::0;48024:34:::1;::::0;869:2:1;854:18;48024:34:0::1;735:177:1::0;22468:201:0;21605:7;21632:6;-1:-1:-1;;;;;21632:6:0;20481:10;21779:23;21771:68;;;;-1:-1:-1;;;21771:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;22557:22:0;::::1;22549:73;;;::::0;-1:-1:-1;;;22549:73:0;;7754:2:1;22549:73:0::1;::::0;::::1;7736:21:1::0;7793:2;7773:18;;;7766:30;7832:34;7812:18;;;7805:62;-1:-1:-1;;;7883:18:1;;;7876:36;7929:19;;22549:73:0::1;7552:402:1::0;22549:73:0::1;22633:28;22652:8;22633:18;:28::i;:::-;22468:201:::0;:::o;42549:269::-;42635:8;:15;42618:14;42661:148;42691:6;42684:4;:13;42661:148;;;42756:8;-1:-1:-1;;;;;42730:34:0;:8;42739:4;42730:14;;;;;;;;:::i;:::-;;;;;;;;;;;;;;:22;-1:-1:-1;;;;;42730:22:0;:34;;42722:75;;;;-1:-1:-1;;;42722:75:0;;8161:2:1;42722:75:0;;;8143:21:1;8200:2;8180:18;;;8173:30;8239;8219:18;;;8212:58;8287:18;;42722:75:0;7959:352:1;42722:75:0;42699:6;;;;:::i;:::-;;;;42661:148;;;;42607:211;42549:269;:::o;15669:98::-;15727:7;15754:5;15758:1;15754;:5;:::i;:::-;15747:12;15669:98;-1:-1:-1;;;15669:98:0:o;16407:::-;16465:7;16492:5;16496:1;16492;:5;:::i;16806:98::-;16864:7;16891:5;16895:1;16891;:5;:::i;16050:98::-;16108:7;16135:5;16139:1;16135;:5;:::i;50356:278::-;50450:4;;:29;;-1:-1:-1;;;50450:29:0;;50473:4;50450:29;;;2344:51:1;50432:15:0;;-1:-1:-1;;;;;50450:4:0;;:14;;2317:18:1;;50450:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;50432:47;;50504:7;50494;:17;50490:137;;;50528:4;;:27;;-1:-1:-1;;;50528:27:0;;-1:-1:-1;;;;;5717:32:1;;;50528:27:0;;;5699:51:1;5766:18;;;5759:34;;;50528:4:0;;;;:13;;5672:18:1;;50528:27:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;42661:148;42607:211;42549:269;:::o;50490:137::-;50588:4;;:27;;-1:-1:-1;;;50588:27:0;;-1:-1:-1;;;;;5717:32:1;;;50588:27:0;;;5699:51:1;5766:18;;;5759:34;;;50588:4:0;;;;:13;;5672:18:1;;50588:27:0;5525:274:1;9635:211:0;9779:58;;-1:-1:-1;;;;;5717:32:1;;9779:58:0;;;5699:51:1;5766:18;;;5759:34;;;9752:86:0;;9772:5;;-1:-1:-1;;;9802:23:0;5672:18:1;;9779:58:0;;;;-1:-1:-1;;9779:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;9779:58:0;-1:-1:-1;;;;;;9779:58:0;;;;;;;;;;9752:19;:86::i;22829:191::-;22903:16;22922:6;;-1:-1:-1;;;;;22939:17:0;;;-1:-1:-1;;;;;;22939:17:0;;;;;;22972:40;;22922:6;;;;;;;22972:40;;22903:16;22972:40;22892:128;22829:191;:::o;9854:248::-;10025:68;;-1:-1:-1;;;;;9251:15:1;;;10025:68:0;;;9233:34:1;9303:15;;9283:18;;;9276:43;9335:18;;;9328:34;;;9998:96:0;;10018:5;;-1:-1:-1;;;10048:27:0;9168:18:1;;10025:68:0;8993:375:1;12208:716:0;12632:23;12658:69;12686:4;12658:69;;;;;;;;;;;;;;;;;12666:5;-1:-1:-1;;;;;12658:27:0;;;:69;;;;;:::i;:::-;12742:17;;12632:95;;-1:-1:-1;12742:21:0;12738:179;;12839:10;12828:30;;;;;;;;;;;;:::i;:::-;12820:85;;;;-1:-1:-1;;;12820:85:0;;9575:2:1;12820:85:0;;;9557:21:1;9614:2;9594:18;;;9587:30;9653:34;9633:18;;;9626:62;-1:-1:-1;;;9704:18:1;;;9697:40;9754:19;;12820:85:0;9373:406:1;4559:229:0;4696:12;4728:52;4750:6;4758:4;4764:1;4767:12;4728:21;:52::i;:::-;4721:59;4559:229;-1:-1:-1;;;;4559:229:0:o;5679:510::-;5849:12;5907:5;5882:21;:30;;5874:81;;;;-1:-1:-1;;;5874:81:0;;9986:2:1;5874:81:0;;;9968:21:1;10025:2;10005:18;;;9998:30;10064:34;10044:18;;;10037:62;-1:-1:-1;;;10115:18:1;;;10108:36;10161:19;;5874:81:0;9784:402:1;5874:81:0;2076:20;;5966:60;;;;-1:-1:-1;;;5966:60:0;;10393:2:1;5966:60:0;;;10375:21:1;10432:2;10412:18;;;10405:30;10471:31;10451:18;;;10444:59;10520:18;;5966:60:0;10191:353:1;5966:60:0;6040:12;6054:23;6081:6;-1:-1:-1;;;;;6081:11:0;6100:5;6107:4;6081:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6039:73;;;;6130:51;6147:7;6156:10;6168:12;8515;8544:7;8540:530;;;-1:-1:-1;8575:10:0;8568:17;;8540:530;8689:17;;:21;8685:374;;8887:10;8881:17;8948:15;8935:10;8931:2;8927:19;8920:44;8685:374;9030:12;9023:20;;-1:-1:-1;;;9023:20:0;;;;;;;;:::i;14:139:1:-;-1:-1:-1;;;;;97:31:1;;87:42;;77:70;;143:1;140;133:12;158:159;225:20;;285:6;274:18;;264:29;;254:57;;307:1;304;297:12;254:57;158:159;;;:::o;322:408::-;411:6;419;427;480:2;468:9;459:7;455:23;451:32;448:52;;;496:1;493;486:12;448:52;532:9;519:23;509:33;;592:2;581:9;577:18;564:32;605:39;638:5;605:39;:::i;:::-;663:5;-1:-1:-1;687:37:1;720:2;705:18;;687:37;:::i;:::-;677:47;;322:408;;;;;:::o;917:180::-;976:6;1029:2;1017:9;1008:7;1004:23;1000:32;997:52;;;1045:1;1042;1035:12;997:52;-1:-1:-1;1068:23:1;;917:180;-1:-1:-1;917:180:1:o;1620:320::-;1696:6;1704;1712;1765:2;1753:9;1744:7;1740:23;1736:32;1733:52;;;1781:1;1778;1771:12;1733:52;1817:9;1804:23;1794:33;;1874:2;1863:9;1859:18;1846:32;1836:42;;1897:37;1930:2;1919:9;1915:18;1897:37;:::i;1945:248::-;2013:6;2021;2074:2;2062:9;2053:7;2049:23;2045:32;2042:52;;;2090:1;2087;2080:12;2042:52;-1:-1:-1;;2113:23:1;;;2183:2;2168:18;;;2155:32;;-1:-1:-1;1945:248:1:o;2406:323::-;2474:6;2482;2535:2;2523:9;2514:7;2510:23;2506:32;2503:52;;;2551:1;2548;2541:12;2503:52;2587:9;2574:23;2564:33;;2647:2;2636:9;2632:18;2619:32;2660:39;2693:5;2660:39;:::i;:::-;2718:5;2708:15;;;2406:323;;;;;:::o;2987:255::-;3046:6;3099:2;3087:9;3078:7;3074:23;3070:32;3067:52;;;3115:1;3112;3105:12;3067:52;3154:9;3141:23;3173:39;3206:5;3173:39;:::i;3468:356::-;3670:2;3652:21;;;3689:18;;;3682:30;3748:34;3743:2;3728:18;;3721:62;3815:2;3800:18;;3468:356::o;4998:127::-;5059:10;5054:3;5050:20;5047:1;5040:31;5090:4;5087:1;5080:15;5114:4;5111:1;5104:15;5130:127;5191:10;5186:3;5182:20;5179:1;5172:31;5222:4;5219:1;5212:15;5246:4;5243:1;5236:15;5262:125;5302:4;5330:1;5327;5324:8;5321:34;;;5335:18;;:::i;:::-;-1:-1:-1;5372:9:1;;5262:125::o;5392:128::-;5432:3;5463:1;5459:6;5456:1;5453:13;5450:39;;;5469:18;;:::i;:::-;-1:-1:-1;5505:9:1;;5392:128::o;5804:355::-;6006:2;5988:21;;;6045:2;6025:18;;;6018:30;6084:33;6079:2;6064:18;;6057:61;6150:2;6135:18;;5804:355::o;6511:184::-;6581:6;6634:2;6622:9;6613:7;6609:23;6605:32;6602:52;;;6650:1;6647;6640:12;6602:52;-1:-1:-1;6673:16:1;;6511:184;-1:-1:-1;6511:184:1:o;6700:135::-;6739:3;-1:-1:-1;;6760:17:1;;6757:43;;;6780:18;;:::i;:::-;-1:-1:-1;6827:1:1;6816:13;;6700:135::o;8316:168::-;8356:7;8422:1;8418;8414:6;8410:14;8407:1;8404:21;8399:1;8392:9;8385:17;8381:45;8378:71;;;8429:18;;:::i;:::-;-1:-1:-1;8469:9:1;;8316:168::o;8489:217::-;8529:1;8555;8545:132;;8599:10;8594:3;8590:20;8587:1;8580:31;8634:4;8631:1;8624:15;8662:4;8659:1;8652:15;8545:132;-1:-1:-1;8691:9:1;;8489:217::o;8711:277::-;8778:6;8831:2;8819:9;8810:7;8806:23;8802:32;8799:52;;;8847:1;8844;8837:12;8799:52;8879:9;8873:16;8932:5;8925:13;8918:21;8911:5;8908:32;8898:60;;8954:1;8951;8944:12;10549:258;10621:1;10631:113;10645:6;10642:1;10639:13;10631:113;;;10721:11;;;10715:18;10702:11;;;10695:39;10667:2;10660:10;10631:113;;;10762:6;10759:1;10756:13;10753:48;;;-1:-1:-1;;10797:1:1;10779:16;;10772:27;10549:258::o;10812:274::-;10941:3;10979:6;10973:13;10995:53;11041:6;11036:3;11029:4;11021:6;11017:17;10995:53;:::i;:::-;11064:16;;;;;10812:274;-1:-1:-1;;10812:274:1:o;11091:383::-;11240:2;11229:9;11222:21;11203:4;11272:6;11266:13;11315:6;11310:2;11299:9;11295:18;11288:34;11331:66;11390:6;11385:2;11374:9;11370:18;11365:2;11357:6;11353:15;11331:66;:::i;:::-;11458:2;11437:15;-1:-1:-1;;11433:29:1;11418:45;;;;11465:2;11414:54;;11091:383;-1:-1:-1;;11091:383:1:o

Swarm Source

ipfs://47b015951733cbe5eaa3f9b3b173d4b8ec0a565b562a247f45c356c37e249231
Block Transaction Gas Used Reward
Age Block Fee Address BC Fee Address Voting Power Jailed Incoming
Validator ID :
0 FTM

Amount Staked
0

Amount Delegated
0

Staking Total
0

Staking Start Epoch
0

Staking Start Time
0

Proof of Importance
0

Origination Score
0

Validation Score
0

Active
0

Online
0

Downtime
0 s
Address Amount claimed Rewards Created On Epoch Created On
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.