Contract 0xAd87AeC6877865B3522226328B22518b0E4DCABD

// SPDX-License-Identifier: MIT
// 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);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.0;

import "../IERC721.sol";

/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the token collection symbol.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165.sol";

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

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

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

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

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

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

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

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

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

/*
ERC721StakingModule

https://github.com/FanbaseEU/Staking_Ethereum_SmartContracts

SPDX-License-Identifier: MIT
*/

pragma solidity 0.8.4;

import "@openzeppelin/contracts/token/ERC721/IERC721.sol";

import "./interfaces/IStakingModule.sol";

/**
 * @title ERC721 staking module
 *
 * @notice this staking module allows users to deposit one or more ERC721
 * tokens in exchange for shares credited to their address. When the user
 * unstakes, these shares will be burned and a reward will be distributed.
 */
contract ERC721StakingModule is IStakingModule {
	// constant
	uint256 public constant SHARES_PER_TOKEN = 10**18;

	// members
	IERC721 private immutable _token;
	address public immutable _factory;

	mapping(address => uint256) public counts;
	mapping(uint256 => address) public owners;
	mapping(address => mapping(uint256 => uint256)) public tokenByOwner;
	mapping(uint256 => uint256) public tokenIndex;

	/**
	 * @param token_ the token that will be rewarded
	 */
	constructor(address token_, address factory_) {
		require(
			IERC165(token_).supportsInterface(0x80ac58cd),
			"Interface ID not matched"
		);
		_token = IERC721(token_);
		_factory = factory_;
	}

	/**
	 * @inheritdoc IStakingModule
	 */
	function tokens()
		external
		view
		override
		returns (address[] memory tokens_)
	{
		tokens_ = new address[](1);
		tokens_[0] = address(_token);
	}

	/**
	 * @inheritdoc IStakingModule
	 */
	function balances(address user)
		external
		view
		override
		returns (uint256[] memory balances_)
	{
		balances_ = new uint256[](1);
		balances_[0] = counts[user];
	}

	/**
	 * @inheritdoc IStakingModule
	 */
	function factory() external view override returns (address) {
		return _factory;
	}

	/**
	 * @inheritdoc IStakingModule
	 */
	function totals()
		external
		view
		override
		returns (uint256[] memory totals_)
	{
		totals_ = new uint256[](1);
		totals_[0] = _token.balanceOf(address(this));
	}

	/**
	 * @inheritdoc IStakingModule
	 */
	function stake(
		address user,
		uint256 amount,
		bytes calldata data
	) external override onlyOwner returns (address, uint256) {
		// validate
		require(amount > 0, "Staking amount must be greater than 0");
		require(amount <= _token.balanceOf(user), "Insufficient balance");
		require(data.length == 32 * amount, "Invalid calldata");

		uint256 count = counts[user];

		// stake
		for (uint256 i = 0; i < amount; i++) {
			// get token id
			uint256 id;
			uint256 pos = 132 + 32 * i;
			assembly {
				id := calldataload(pos)
			}

			// ownership mappings
			owners[id] = user;
			uint256 len = count + i;
			tokenByOwner[user][len] = id;
			tokenIndex[id] = len;

			// transfer to module
			_token.transferFrom(user, address(this), id);
		}

		// update position
		counts[user] = count + amount;

		// emit
		uint256 shares = amount * SHARES_PER_TOKEN;
		emit Staked(user, address(_token), amount, shares);

		return (user, shares);
	}

	/**
	 * @inheritdoc IStakingModule
	 */
	function unstake(
		address user,
		uint256 amount,
		bytes calldata data
	) external override onlyOwner returns (address, uint256) {
		// validate
		require(amount > 0, "Unstaking amount must be greater than 0");
		uint256 count = counts[user];
		require(amount <= count, "Insufficient staked balance");
		require(data.length == 32 * amount, "Invalid calldata");

		// unstake
		for (uint256 i = 0; i < amount; i++) {
			// get token id
			uint256 id;
			uint256 pos = 132 + 32 * i;
			assembly {
				id := calldataload(pos)
			}

			// ownership
			require(owners[id] == user, "Only owner can unstake");
			delete owners[id];

			// clean up ownership mappings
			uint256 lastIndex = count - 1 - i;
			if (amount != count) {
				// reindex on partial unstake
				uint256 index = tokenIndex[id];
				if (index != lastIndex) {
					uint256 lastId = tokenByOwner[user][lastIndex];
					tokenByOwner[user][index] = lastId;
					tokenIndex[lastId] = index;
				}
			}
			delete tokenByOwner[user][lastIndex];
			delete tokenIndex[id];

			// transfer to user
			_token.safeTransferFrom(address(this), user, id);
		}

		// update position
		counts[user] = count - amount;

		// emit
		uint256 shares = amount * SHARES_PER_TOKEN;
		emit Unstaked(user, address(_token), amount, shares);

		return (user, shares);
	}

	/**
	 * @inheritdoc IStakingModule
	 */
	function claim(
		address user,
		uint256 amount,
		bytes calldata
	) external override onlyOwner returns (address, uint256) {
		// validate
		require(amount > 0, "Claiming amount must be greater than 0");
		require(amount <= counts[user], "Insufficient balance");

		uint256 shares = amount * SHARES_PER_TOKEN;
		emit Claimed(user, address(_token), amount, shares);
		return (user, shares);
	}

	/**
	 * @inheritdoc IStakingModule
	 */
	function update(address) external override {}

	/**
	 * @inheritdoc IStakingModule
	 */
	function clean() external override {}
}

/*
ERC721StakingModuleInfo

https://github.com/FanbaseEU/Staking_Ethereum_SmartContracts

SPDX-License-Identifier: MIT
*/

pragma solidity 0.8.4;

import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";

import "../interfaces/IStakingModule.sol";
import "../ERC721StakingModule.sol";

/**
 * @title ERC721 staking module info library
 *
 * @notice this library provides read-only convenience functions to query
 * additional information about the ERC721StakingModule contract.
 */
library ERC721StakingModuleInfo {
    /**
     * @notice convenience function to get token metadata in a single call
     * @param module address of staking module
     * @return address
     * @return name
     * @return symbol
     * @return decimals
     */
    function token(address module)
        public
        view
        returns (
            address,
            string memory,
            string memory,
            uint8
        )
    {
        IStakingModule m = IStakingModule(module);
        IERC721Metadata tkn = IERC721Metadata(m.tokens()[0]);
        if (!tkn.supportsInterface(0x5b5e139f)) {
            return (address(tkn), "", "", 0);
        }
        return (address(tkn), tkn.name(), tkn.symbol(), 0);
    }

    /**
     * @notice quote the share value for an amount of tokens
     * @param module address of staking module
     * @param addr account address of interest
     * @param amount number of tokens. if zero, return entire share balance
     * @return number of shares
     */
    function shares(
        address module,
        address addr,
        uint256 amount
    ) public view returns (uint256) {
        ERC721StakingModule m = ERC721StakingModule(module);

        // return all user shares
        if (amount == 0) {
            return m.counts(addr) * m.SHARES_PER_TOKEN();
        }

        require(amount <= m.counts(addr), "smni1");
        return amount * m.SHARES_PER_TOKEN();
    }

    /**
     * @notice get shares per token
     * @param module address of staking module
     * @return current shares per token
     */
    function sharesPerToken(address module) public view returns (uint256) {
        ERC721StakingModule m = ERC721StakingModule(module);
        return m.SHARES_PER_TOKEN() * 1e18;
    }

    /**
     * @notice get staked token ids for user
     * @param module address of staking module
     * @param addr account address of interest
     * @param amount number of tokens to enumerate
     * @param start token index to start at
     * @return ids array of token ids
     */
    function tokenIds(
        address module,
        address addr,
        uint256 amount,
        uint256 start
    ) public view returns (uint256[] memory ids) {
        ERC721StakingModule m = ERC721StakingModule(module);
        uint256 sz = m.counts(addr);
        require(start + amount <= sz, "smni2");

        if (amount == 0) {
            amount = sz - start;
        }

        ids = new uint256[](amount);

        for (uint256 i = 0; i < amount; i++) {
            ids[i] = m.tokenByOwner(addr, i + start);
        }
    }
}

/*
IEvents

https://github.com/FanbaseEU/Staking_Ethereum_SmartContracts

SPDX-License-Identifier: MIT
 */

pragma solidity 0.8.4;

/**
 * @title GYSR event system
 *
 * @notice common interface to define GYSR event system
 */
interface IEvents {
    // staking
    event Staked(
        address indexed user,
        address indexed token,
        uint256 amount,
        uint256 shares
    );
    event Unstaked(
        address indexed user,
        address indexed token,
        uint256 amount,
        uint256 shares
    );
    event Claimed(
        address indexed user,
        address indexed token,
        uint256 amount,
        uint256 shares
    );

    // rewards
    event RewardsDistributed(
        address indexed user,
        address indexed token,
        uint256 amount,
        uint256 shares
    );
    event RewardsFunded(
        address indexed token,
        uint256 amount,
        uint256 shares,
        uint256 timestamp
    );
    event RewardsUnlocked(address indexed token, uint256 shares);
    event RewardsExpired(
        address indexed token,
        uint256 amount,
        uint256 shares,
        uint256 timestamp
    );

    // gysr
    event GysrSpent(address indexed user, uint256 amount);
    event GysrVested(address indexed user, uint256 amount);
    event GysrWithdrawn(uint256 amount);
}

/*
IStakingModule

https://github.com/FanbaseEU/Staking_Ethereum_SmartContracts

SPDX-License-Identifier: MIT
*/

pragma solidity 0.8.4;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

import "./IEvents.sol";

import "../OwnerController.sol";

/**
 * @title Staking module interface
 *
 * @notice this contract defines the common interface that any staking module
 * must implement to be compatible with the modular Pool architecture.
 */
abstract contract IStakingModule is OwnerController, IEvents {
    // constants
    uint256 public constant DECIMALS = 18;

    /**
     * @return array of staking tokens
     */
    function tokens() external view virtual returns (address[] memory);

    /**
     * @notice get balance of user
     * @param user address of user
     * @return balances of each staking token
     */
    function balances(address user)
        external
        view
        virtual
        returns (uint256[] memory);

    /**
     * @return address of module factory
     */
    function factory() external view virtual returns (address);

    /**
     * @notice get total staked amount
     * @return totals for each staking token
     */
    function totals() external view virtual returns (uint256[] memory);

    /**
     * @notice stake an amount of tokens for user
     * @param user address of user
     * @param amount number of tokens to stake
     * @param data additional data
     * @return address of staking account
     * @return number of shares minted for stake
     */
    function stake(
        address user,
        uint256 amount,
        bytes calldata data
    ) external virtual returns (address, uint256);

    /**
     * @notice unstake an amount of tokens for user
     * @param user address of user
     * @param amount number of tokens to unstake
     * @param data additional data
     * @return address of staking account
     * @return number of shares burned for unstake
     */
    function unstake(
        address user,
        uint256 amount,
        bytes calldata data
    ) external virtual returns (address, uint256);

    /**
     * @notice quote the share value for an amount of tokens without unstaking
     * @param user address of user
     * @param amount number of tokens to claim with
     * @param data additional data
     * @return address of staking account
     * @return number of shares that the claim amount is worth
     */
    function claim(
        address user,
        uint256 amount,
        bytes calldata data
    ) external virtual returns (address, uint256);

    /**
     * @notice method called by anyone to update accounting
     * @param user address of user for update
     * @dev will only be called ad hoc and should not contain essential logic
     */
    function update(address user) external virtual;

    /**
     * @notice method called by owner to clean up and perform additional accounting
     * @dev will only be called ad hoc and should not contain any essential logic
     */
    function clean() external virtual;
}

/*
OwnerController

https://github.com/FanbaseEU/Staking_Ethereum_SmartContracts

SPDX-License-Identifier: MIT
*/

pragma solidity 0.8.4;

/**
 * @title Owner controller
 *
 * @notice this base contract implements an owner-controller access model.
 *
 * @dev the contract is an adapted version of the OpenZeppelin Ownable contract.
 * It allows the owner to designate an additional account as the controller to
 * perform restricted operations.
 *
 * Other changes include supporting role verification with a require method
 * in addition to the modifier option, and removing some unneeded functionality.
 *
 * Original contract here:
 * https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/Ownable.sol
 */
contract OwnerController {
    address private _owner;
    address private _controller;

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

    event ControlTransferred(
        address indexed previousController,
        address indexed newController
    );

    constructor() {
        _owner = msg.sender;
        _controller = msg.sender;
        emit OwnershipTransferred(address(0), _owner);
        emit ControlTransferred(address(0), _owner);
    }

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

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

    /**
     * @dev Modifier that throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(_owner == msg.sender, "Only owner can perform this action");
        _;
    }

    /**
     * @dev Modifier that throws if called by any account other than the controller.
     */
    modifier onlyController() {
        require(_controller == msg.sender, "Only controller can perform this action");
        _;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    function requireOwner() internal view {
        require(_owner == msg.sender, "Only owner can perform this action");
    }

    /**
     * @dev Throws if called by any account other than the controller.
     */
    function requireController() internal view {
        require(_controller == msg.sender, "Only controller can perform this action");
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`). This can
     * include renouncing ownership by transferring to the zero address.
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual {
        requireOwner();
        require(newOwner != address(0), "New owner address can't be zero");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }

    /**
     * @dev Transfers control of the contract to a new account (`newController`).
     * Can only be called by the owner.
     */
    function transferControl(address newController) public virtual {
        requireOwner();
        require(newController != address(0), "New controller address can't be zero");
        emit ControlTransferred(_controller, newController);
        _controller = newController;
    }
}

{
  "optimizer": {
    "enabled": true,
    "runs": 1000
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

[{"inputs":[{"internalType":"address","name":"module","type":"address"},{"internalType":"address","name":"addr","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"shares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"module","type":"address"}],"name":"sharesPerToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"module","type":"address"}],"name":"token","outputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"string","name":"","type":"string"},{"internalType":"string","name":"","type":"string"},{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"module","type":"address"},{"internalType":"address","name":"addr","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"start","type":"uint256"}],"name":"tokenIds","outputs":[{"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"stateMutability":"view","type":"function"}]

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