Contract 0x3f3ea81fffb8c70f8aeae640e23314a1bbaf2bbc

/**
 *Submitted for verification at FtmScan.com on 2023-03-19
*/

// Sources flattened with hardhat v2.12.7 https://hardhat.org

// File contracts/staking/FullProtect.sol

// FULL PROTEC PEARLS AT ALL COST.

// File: @openzeppelin/contracts/utils/Context.sol
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

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

// File: @openzeppelin/contracts/access/Ownable.sol


// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

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 Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        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);
    }
}

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


// OpenZeppelin Contracts (last updated v4.8.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 functionCallWithValue(target, data, 0, "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");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or 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 {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // 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
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

// File: @openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

// 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/token/ERC20/utils/SafeERC20.sol


// OpenZeppelin Contracts (last updated v4.8.0) (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));
        }
    }

    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

    /**
     * @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/PearlsFullProtec.sol


pragma solidity ^0.8.0;

interface IPearlsToken {
    function mint(address to, uint256 amount) external;
    function totalSupply() external view returns (uint256);
    function transferUnderlying(address to, uint256 value) external returns (bool);
    function fragmentToPearls(uint256 value) external view returns (uint256);
    function pearlsToFragment(uint256 pearls) external view returns (uint256);
    function balanceOfUnderlying(address who) external view returns (uint256);
    function burn(uint256 amount) external;
}

contract PearlsFullProtec is Ownable {
    using SafeERC20 for IERC20;

    struct UserInfo {
        uint256 amount;
        uint256 lockEndedTimestamp;
    }

    IPearlsToken public pearls;
    uint256 public lockDuration;
    uint256 public totalStaked;
    bool public depositsEnabled;

    // Info of each user.
    mapping(address => UserInfo) public userInfo;

    // Events
    event Deposit(address indexed user, uint256 amount);
    event Withdraw(address indexed user, uint256 amount);
    event LogSetLockDuration(uint256 lockDuration);
    event LogSetDepositsEnabled(bool enabled);

    constructor(IPearlsToken _pearls, uint256 _lockDuration, bool _depositsEnabled) {
        pearls = _pearls;
        lockDuration = _lockDuration;
        depositsEnabled = _depositsEnabled;
    }

    function setDepositsEnabled(bool _enabled) external onlyOwner {
        depositsEnabled = _enabled;
        emit LogSetDepositsEnabled(_enabled);
    }

    function setLockDuration(uint256 _lockDuration) external onlyOwner {
      lockDuration = _lockDuration;
      emit LogSetLockDuration(_lockDuration);
    }

    function deposit(uint256 _amount) external {
        require(depositsEnabled, "deposits disabled");
        require(_amount > 0, "invalid amount");

        UserInfo storage user = userInfo[msg.sender];
        user.lockEndedTimestamp = block.timestamp + lockDuration;
        IERC20(address(pearls)).safeTransferFrom(address(msg.sender), address(this), _amount);
        pearls.burn(_amount);

        totalStaked += _amount;
        user.amount += _amount;
        emit Deposit(msg.sender, _amount);
    }

    function withdraw(uint256 _amount) external {
        require(_amount > 0, "invalid amount");

        UserInfo storage user = userInfo[msg.sender];
        require(user.lockEndedTimestamp <= block.timestamp, "still locked");
        require(user.amount >= _amount, "invalid amount");

        user.lockEndedTimestamp = block.timestamp + lockDuration;
        user.amount -= _amount;
        totalStaked -= _amount;
        pearls.mint(address(msg.sender), _amount);

        emit Withdraw(msg.sender, _amount);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IPearlsToken","name":"_pearls","type":"address"},{"internalType":"uint256","name":"_lockDuration","type":"uint256"},{"internalType":"bool","name":"_depositsEnabled","type":"bool"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"enabled","type":"bool"}],"name":"LogSetDepositsEnabled","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"lockDuration","type":"uint256"}],"name":"LogSetLockDuration","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":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"depositsEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lockDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pearls","outputs":[{"internalType":"contract IPearlsToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_enabled","type":"bool"}],"name":"setDepositsEnabled","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_lockDuration","type":"uint256"}],"name":"setLockDuration","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalStaked","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":[{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"lockEndedTimestamp","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000e63e0e297c7e8e8bac32666c137d0b2914acbcb00000000000000000000000000000000000000000000000000000000000093a800000000000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _pearls (address): 0xe63e0e297c7e8e8bac32666c137d0b2914acbcb0
Arg [1] : _lockDuration (uint256): 604800
Arg [2] : _depositsEnabled (bool): False

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 000000000000000000000000e63e0e297c7e8e8bac32666c137d0b2914acbcb0
Arg [1] : 0000000000000000000000000000000000000000000000000000000000093a80
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000000

23503:2220:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23709:27;;;;;;;;;160:25:1;;;148:2;133:18;23709:27:0;;;;;;;;23839:44;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;661:25:1;;;717:2;702:18;;695:34;;;;634:18;23839:44:0;487:248:1;25190:530:0;;;;;;:::i;:::-;;:::i;:::-;;24496:159;;;;;;:::i;:::-;;:::i;23776:27::-;;;;;;;;;;;;1090:14:1;;1083:22;1065:41;;1053:2;1038:18;23776:27:0;925:187:1;2920:103:0;;;:::i;23743:26::-;;;;;;2272:87;;;:::i;:::-;;;-1:-1:-1;;;;;1281:32:1;;;1263:51;;1251:2;1236:18;2272:87:0;1117:203:1;24334:154:0;;;;;;:::i;:::-;;:::i;24663:519::-;;;;;;:::i;:::-;;:::i;23676:26::-;;;;;-1:-1:-1;;;;;23676:26:0;;;3178:201;;;;;;:::i;:::-;;:::i;25190:530::-;25263:1;25253:7;:11;25245:38;;;;-1:-1:-1;;;25245:38:0;;;;;;;:::i;:::-;;;;;;;;;25329:10;25296:21;25320:20;;;:8;:20;;;;;25359:23;;;;25386:15;-1:-1:-1;25359:42:0;25351:67;;;;-1:-1:-1;;;25351:67:0;;2467:2:1;25351:67:0;;;2449:21:1;2506:2;2486:18;;;2479:30;-1:-1:-1;;;2525:18:1;;;2518:42;2577:18;;25351:67:0;2265:336:1;25351:67:0;25437:11;;:22;-1:-1:-1;25437:22:0;25429:49;;;;-1:-1:-1;;;25429:49:0;;;;;;;:::i;:::-;25535:12;;25517:30;;:15;:30;:::i;:::-;25491:23;;;:56;25558:22;;25573:7;;25491:4;;25558:11;;:22;;25573:7;;25558:22;:::i;:::-;;;;;;;;25606:7;25591:11;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;25624:6:0;;:41;;-1:-1:-1;;;25624:41:0;;25644:10;25624:41;;;3175:51:1;3242:18;;;3235:34;;;-1:-1:-1;;;;;25624:6:0;;;;:11;;3148:18:1;;25624:41:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;25683:29:0;;160:25:1;;;25692:10:0;;-1:-1:-1;25683:29:0;;-1:-1:-1;148:2:1;133:18;25683:29:0;;;;;;;;25234:486;25190:530;:::o;24496:159::-;2158:13;:11;:13::i;:::-;24572:12:::1;:28:::0;;;24614:33:::1;::::0;160:25:1;;;24614:33:0::1;::::0;148:2:1;133:18;24614:33:0::1;;;;;;;;24496:159:::0;:::o;2920:103::-;2158:13;:11;:13::i;:::-;2985:30:::1;3012:1;2985:18;:30::i;:::-;2920:103::o:0;2272:87::-;2318:7;2345:6;-1:-1:-1;;;;;2345:6:0;;2272:87::o;24334:154::-;2158:13;:11;:13::i;:::-;24407:15:::1;:26:::0;;-1:-1:-1;;24407:26:0::1;::::0;::::1;;::::0;;::::1;::::0;;;24449:31:::1;::::0;1065:41:1;;;24449:31:0::1;::::0;1053:2:1;1038:18;24449:31:0::1;925:187:1::0;24663:519:0;24725:15;;;;24717:45;;;;-1:-1:-1;;;24717:45:0;;3482:2:1;24717:45:0;;;3464:21:1;3521:2;3501:18;;;3494:30;-1:-1:-1;;;3540:18:1;;;3533:47;3597:18;;24717:45:0;3280:341:1;24717:45:0;24791:1;24781:7;:11;24773:38;;;;-1:-1:-1;;;24773:38:0;;;;;;;:::i;:::-;24857:10;24824:21;24848:20;;;:8;:20;;;;;24923:12;;24905:30;;:15;:30;:::i;:::-;24879:23;;;;:56;;;;24961:6;24946:85;;-1:-1:-1;;;;;24961:6:0;24995:10;25016:4;25023:7;24946:40;:85::i;:::-;25042:6;;:20;;-1:-1:-1;;;25042:20:0;;;;;160:25:1;;;-1:-1:-1;;;;;25042:6:0;;;;:11;;133:18:1;;25042:20:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25090:7;25075:11;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;25108:22:0;;25123:7;;25108:4;;:11;;:22;;25123:7;;25108:22;:::i;:::-;;;;-1:-1:-1;;25146:28:0;;160:25:1;;;25154:10:0;;25146:28;;148:2:1;133:18;25146:28:0;14:177:1;3178:201:0;2158:13;:11;:13::i;:::-;-1:-1:-1;;;;;3267:22:0;::::1;3259:73;;;::::0;-1:-1:-1;;;3259:73:0;;3828:2:1;3259:73:0::1;::::0;::::1;3810:21:1::0;3867:2;3847:18;;;3840:30;3906:34;3886:18;;;3879:62;-1:-1:-1;;;3957:18:1;;;3950:36;4003:19;;3259:73:0::1;3626:402:1::0;3259:73:0::1;3343:28;3362:8;3343:18;:28::i;:::-;3178:201:::0;:::o;2437:132::-;903:10;2501:7;:5;:7::i;:::-;-1:-1:-1;;;;;2501:23:0;;2493:68;;;;-1:-1:-1;;;2493:68:0;;4235:2:1;2493:68:0;;;4217:21:1;;;4254:18;;;4247:30;4313:34;4293:18;;;4286:62;4365:18;;2493:68:0;4033:356:1;3539:191:0;3613:16;3632:6;;-1:-1:-1;;;;;3649:17:0;;;-1:-1:-1;;;;;;3649:17:0;;;;;;3682:40;;3632:6;;;;;;;3682:40;;3613:16;3682:40;3602:128;3539:191;:::o;19342:248::-;19513:68;;;-1:-1:-1;;;;;4652:15:1;;;19513:68:0;;;4634:34:1;4704:15;;4684:18;;;4677:43;4736:18;;;;4729:34;;;19513:68:0;;;;;;;;;;4569:18:1;;;;19513:68:0;;;;;;;;-1:-1:-1;;;;;19513:68:0;-1:-1:-1;;;19513:68:0;;;19486:96;;19506:5;;19486:19;:96::i;:::-;19342:248;;;;:::o;22190:716::-;22614:23;22640:69;22668:4;22640:69;;;;;;;;;;;;;;;;;22648:5;-1:-1:-1;;;;;22640:27:0;;;:69;;;;;:::i;:::-;22724:17;;22614:95;;-1:-1:-1;22724:21:0;22720:179;;22821:10;22810:30;;;;;;;;;;;;:::i;:::-;22802:85;;;;-1:-1:-1;;;22802:85:0;;5226:2:1;22802:85:0;;;5208:21:1;5265:2;5245:18;;;5238:30;5304:34;5284:18;;;5277:62;-1:-1:-1;;;5355:18:1;;;5348:40;5405:19;;22802:85:0;5024:406:1;22802:85:0;22260:646;22190:716;;:::o;7727:229::-;7864:12;7896:52;7918:6;7926:4;7932:1;7935:12;7896:21;:52::i;:::-;7889:59;7727:229;-1:-1:-1;;;;7727:229:0:o;8847:455::-;9017:12;9075:5;9050:21;:30;;9042:81;;;;-1:-1:-1;;;9042:81:0;;5637:2:1;9042:81:0;;;5619:21:1;5676:2;5656:18;;;5649:30;5715:34;5695:18;;;5688:62;-1:-1:-1;;;5766:18:1;;;5759:36;5812:19;;9042:81:0;5435:402:1;9042:81:0;9135:12;9149:23;9176:6;-1:-1:-1;;;;;9176:11:0;9195:5;9202:4;9176:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9134:73;;;;9225:69;9252:6;9260:7;9269:10;9281:12;9225:26;:69::i;:::-;9218:76;8847:455;-1:-1:-1;;;;;;;8847:455:0:o;11420:644::-;11605:12;11634:7;11630:427;;;11662:10;:17;11683:1;11662:22;11658:290;;-1:-1:-1;;;;;5265:19:0;;;11872:60;;;;-1:-1:-1;;;11872:60:0;;6586:2:1;11872:60:0;;;6568:21:1;6625:2;6605:18;;;6598:30;6664:31;6644:18;;;6637:59;6713:18;;11872:60:0;6384:353:1;11872:60:0;-1:-1:-1;11969:10:0;11962:17;;11630:427;12012:33;12020:10;12032:12;12767:17;;:21;12763:388;;12999:10;12993:17;13056:15;13043:10;13039:2;13035:19;13028:44;12763:388;13126:12;13119:20;;-1:-1:-1;;;13119:20:0;;;;;;;;:::i;196:286:1:-;255:6;308:2;296:9;287:7;283:23;279:32;276:52;;;324:1;321;314:12;276:52;350:23;;-1:-1:-1;;;;;402:31:1;;392:42;;382:70;;448:1;445;438:12;382:70;471:5;196:286;-1:-1:-1;;;196:286:1:o;740:180::-;799:6;852:2;840:9;831:7;827:23;823:32;820:52;;;868:1;865;858:12;820:52;-1:-1:-1;891:23:1;;740:180;-1:-1:-1;740:180:1:o;1325:118::-;1411:5;1404:13;1397:21;1390:5;1387:32;1377:60;;1433:1;1430;1423:12;1448:241;1504:6;1557:2;1545:9;1536:7;1532:23;1528:32;1525:52;;;1573:1;1570;1563:12;1525:52;1612:9;1599:23;1631:28;1653:5;1631:28;:::i;1922:338::-;2124:2;2106:21;;;2163:2;2143:18;;;2136:30;-1:-1:-1;;;2197:2:1;2182:18;;2175:44;2251:2;2236:18;;1922:338::o;2606:127::-;2667:10;2662:3;2658:20;2655:1;2648:31;2698:4;2695:1;2688:15;2722:4;2719:1;2712:15;2738:128;2778:3;2809:1;2805:6;2802:1;2799:13;2796:39;;;2815:18;;:::i;:::-;-1:-1:-1;2851:9:1;;2738:128::o;2871:125::-;2911:4;2939:1;2936;2933:8;2930:34;;;2944:18;;:::i;:::-;-1:-1:-1;2981:9:1;;2871:125::o;4774:245::-;4841:6;4894:2;4882:9;4873:7;4869:23;4865:32;4862:52;;;4910:1;4907;4900:12;4862:52;4942:9;4936:16;4961:28;4983:5;4961:28;:::i;5842:258::-;5914:1;5924:113;5938:6;5935:1;5932:13;5924:113;;;6014:11;;;6008:18;5995:11;;;5988:39;5960:2;5953:10;5924:113;;;6055:6;6052:1;6049:13;6046:48;;;-1:-1:-1;;6090:1:1;6072:16;;6065:27;5842:258::o;6105:274::-;6234:3;6272:6;6266:13;6288:53;6334:6;6329:3;6322:4;6314:6;6310:17;6288:53;:::i;:::-;6357:16;;;;;6105:274;-1:-1:-1;;6105:274:1:o;6742:383::-;6891:2;6880:9;6873:21;6854:4;6923:6;6917:13;6966:6;6961:2;6950:9;6946:18;6939:34;6982:66;7041:6;7036:2;7025:9;7021:18;7016:2;7008:6;7004:15;6982:66;:::i;:::-;7109:2;7088:15;-1:-1:-1;;7084:29:1;7069:45;;;;7116:2;7065:54;;6742:383;-1:-1:-1;;6742:383:1:o

ipfs://79b23294f244febfafdc8cc3fde899c44408122926184084be8b10af569023c1