Contract Name:
TreasuryStaking
Contract Source Code:
// File: contracts\openzeppelin\contracts\utils\Context.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
/**
* @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;
}
function _contextSuffixLength() internal view virtual returns (uint256) {
return 0;
}
}
// File: contracts\openzeppelin\contracts\access\Ownable.sol
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)
pragma solidity ^0.8.19;
/**
* @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.
*
* The initial owner is set to the address provided by the deployer. 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;
/**
* @dev The caller account is not authorized to perform an operation.
*/
error OwnableUnauthorizedAccount(address account);
/**
* @dev The owner is not a valid owner account. (eg. `address(0)`)
*/
error OwnableInvalidOwner(address owner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the address provided by the deployer as the initial owner.
*/
constructor(address initialOwner) {
if (initialOwner == address(0)) {
revert OwnableInvalidOwner(address(0));
}
_transferOwnership(initialOwner);
}
/**
* @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 {
if (owner() != _msgSender()) {
revert OwnableUnauthorizedAccount(_msgSender());
}
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby disabling 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 {
if (newOwner == address(0)) {
revert OwnableInvalidOwner(address(0));
}
_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: contracts\openzeppelin\contracts\utils\ReentrancyGuard.sol
// OpenZeppelin Contracts (last updated v5.0.0) (utils/ReentrancyGuard.sol)
pragma solidity ^0.8.19;
/**
* @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 EIP-1153 (transient storage) is available on the chain you're deploying at,
* consider using {ReentrancyGuardTransient} instead.
*
* 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;
/**
* @dev Unauthorized reentrant call.
*/
error ReentrancyGuardReentrantCall();
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() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
// On the first call to nonReentrant, _status will be NOT_ENTERED
if (_status == ENTERED) {
revert ReentrancyGuardReentrantCall();
}
// Any calls to nonReentrant after this point will fail
_status = ENTERED;
}
function _nonReentrantAfter() private {
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = NOT_ENTERED;
}
/**
* @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
* `nonReentrant` function in the call stack.
*/
function _reentrancyGuardEntered() internal view returns (bool) {
return _status == ENTERED;
}
}
// File: contracts\openzeppelin\contracts\token\ERC20\IERC20.sol
pragma solidity ^0.8.19;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
}
// File: contracts\openzeppelin\contracts\utils\introspection\IERC165.sol
// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol)
pragma solidity ^0.8.19;
/**
* @dev Interface of the ERC-165 standard, as defined in the
* https://eips.ethereum.org/EIPS/eip-165[ERC].
*
* 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[ERC section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
// File: contracts\openzeppelin\contracts\token\ERC721\IERC721.sol
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/IERC721.sol)
pragma solidity ^0.8.19;
/**
* @dev Required interface of an ERC-721 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 ERC-721 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 ERC-721
* 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 address zero.
*
* Emits an {ApprovalForAll} event.
*/
function setApprovalForAll(address operator, bool approved) external;
/**
* @dev Returns the account approved for `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function getApproved(uint256 tokenId) external view returns (address operator);
/**
* @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
*
* See {setApprovalForAll}
*/
function isApprovedForAll(address owner, address operator) external view returns (bool);
}
// File: contracts\openzeppelin\contracts\token\ERC721\extensions\IERC721Enumerable.sol
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/IERC721Enumerable.sol)
pragma solidity ^0.8.19;
/**
* @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/
interface IERC721Enumerable is IERC721 {
/**
* @dev Returns the total amount of tokens stored by the contract.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns a token ID owned by `owner` at a given `index` of its token list.
* Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
/**
* @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
* Use along with {totalSupply} to enumerate all tokens.
*/
function tokenByIndex(uint256 index) external view returns (uint256);
}
// File: contracts/sdaemon0x/treasury/TreasuryStakeMarker.sol
pragma solidity ^0.8.19;
interface TreasuryStakeMarker is IERC721Enumerable {
function mint(address to) external returns (uint256);
function burn(address to, uint256 tokenId) external;
function checkClaimableDatetime(uint256 tokenId) external;
function rarity(uint256 tokenId) external view returns (uint256);
}
interface TreasuryHolding {
function sync() external;
function getStakerVolume(address staker) external view returns (uint256);
function totalStaked() external view returns (uint256);
function get_nb_stake() external view returns (uint256);
function get_active(uint256 tokenId) external view returns (bool);
function get_amount(uint256 tokenId) external view returns (uint256);
}
contract TreasuryStaking is TreasuryHolding, ReentrancyGuard, Ownable {
IERC20 public sdeamon = IERC20(0x16a0BfC1C6e331788E0A5096911cDCd9943D2C9c);
TreasuryStakeMarker public nftContract;
uint256 public constant MATURATION_PERIOD = 15 days;
uint256 public min_stake_amount = 2000000 * 10 ** 18;
uint256 public totalStaked = 0;
uint256 public rewardPosition = 0;
uint256 public rewardBank = 0;
uint256 public bps_reward_exit = 500;
struct StakePosition {
uint256 amount;
uint256 rewardDebt;
uint256 stakeStartTime;
uint256 duration_lock;
bool active;
}
mapping(uint256 => StakePosition) public stakerPositions;
uint256[] public tokenIdsStaked;
event Staked(address indexed user, uint256 amount, uint256 tokenId);
event Unstaked(address indexed user, uint256 amount, uint256 tokenId);
event RewardClaimed(address indexed user, uint256 amount, uint256 tokenId);
constructor() Ownable(0x88524E752144C15dc1a12BA3978c2d700dc97498) {}
function init_NFT(address nftContract_) external onlyOwner {
nftContract = TreasuryStakeMarker(nftContract_);
}
function init_ERC20(address erc20_) external onlyOwner {
sdeamon = IERC20(erc20_);
}
function set_min_stake_amount(uint256 amount_) external onlyOwner {
min_stake_amount = amount_;
}
function stake(uint256 amount_, uint256 duration_lock) nonReentrant external {
require(address(nftContract) != address(0), "not init");
require(duration_lock <= 90 days, "useless value");
require(amount_ > min_stake_amount, "insufficient stake amount");
uint256 id = nftContract.mint(msg.sender);
totalStaked += amount_;
stakerPositions[id] = StakePosition(amount_, rewardPosition, block.timestamp, duration_lock, true);
tokenIdsStaked.push(id);
sdeamon.transferFrom(msg.sender, address(this), amount_);
emit Staked(msg.sender, amount_, id);
}
function compute_unstake_price(uint256 amount_) public view returns (uint256, uint256) {
uint256 fee = amount_ * bps_reward_exit / 10000;
return (amount_ - fee, fee);
}
function unstake(uint256 tokenId) external {
_claim_reward(tokenId);
require(address(nftContract) != address(0), "not init");
require(nftContract.ownerOf(tokenId) == msg.sender, "not your nft");
StakePosition storage position = stakerPositions[tokenId];
require(position.active, "Position already unstaked");
require(position.stakeStartTime < block.timestamp, "Too early");
if (position.duration_lock > 0) {
uint256 age = block.timestamp - position.stakeStartTime;
require(position.duration_lock < age, "locked");
}
position.active = false;
nftContract.burn(msg.sender, tokenId);
for (uint256 i = 0; i < tokenIdsStaked.length; i++) {
if (tokenIdsStaked[i] == tokenId) {
if (i < tokenIdsStaked.length - 1) tokenIdsStaked[i] = tokenIdsStaked[tokenIdsStaked.length - 1];
tokenIdsStaked.pop();
break;
}
}
uint256 amount_ = position.amount;
totalStaked -= amount_;
(uint256 totalAmoutToPay, uint256 fee) = compute_unstake_price(amount_);
sdeamon.transfer(msg.sender, totalAmoutToPay);
rewardPosition += fee;
rewardBank += fee;
emit Unstaked(msg.sender, amount_, tokenId);
}
function compute_maturation_time(uint256 duration_) public pure returns (uint256) {
if (duration_ >= MATURATION_PERIOD) return (10 ** 18);
return (duration_ * 10 ** 18) / MATURATION_PERIOD;
}
function compute_current_time(uint256 stakeStartTime) public view returns (uint256) {
require(stakeStartTime <= block.timestamp);
uint256 duration = block.timestamp - stakeStartTime;
return compute_maturation_time(duration);
}
function compute_multiplier(uint256 stakeStartTime, uint256 duration_lock) public view returns (uint256) {
uint256 multiplier = 0;
if (duration_lock > 0) {
multiplier += compute_maturation_time(duration_lock);
}
multiplier += compute_current_time(stakeStartTime);
return multiplier;
}
function get_active(uint256 tokenId) external view returns (bool) {
return stakerPositions[tokenId].active;
}
function get_amount(uint256 tokenId) external view returns (uint256) {
return stakerPositions[tokenId].amount;
}
function get_nb_stake() external view returns (uint256) {
return tokenIdsStaked.length;
}
function compute_reward(uint256 position, uint256 amount, uint256 stakeStartTime, uint256 duration_lock, uint256 reward_position, uint256 total_staked) public view returns (uint256) {
uint256 multiplier = compute_multiplier(stakeStartTime, duration_lock);
if (multiplier > 10 ** 18) multiplier = 10 ** 18;
uint256 posRel = reward_position - position;
uint256 volume = amount * 10 ** 18 / total_staked;
return posRel * volume * multiplier / 10 ** 36;
}
function getStakerVolume(address staker) external view returns (uint256) {
uint256 volume = 0;
for (uint256 i = 0; i < tokenIdsStaked.length; i++) {
uint256 tid = tokenIdsStaked[i];
StakePosition storage position = stakerPositions[tid];
if (nftContract.ownerOf(tid) == staker && position.active) {
volume += position.amount;
}
}
return volume;
}
function estimate_reward(address who, uint256 tokenId) public view returns (uint256) {
require(address(nftContract) != address(0), "not init");
require(nftContract.ownerOf(tokenId) == who, "not your nft");
StakePosition storage position = stakerPositions[tokenId];
require(position.active, "Position is not active");
return compute_reward(position.rewardDebt, position.amount, position.stakeStartTime, position.duration_lock, rewardPosition, totalStaked);
}
function claim_reward(uint256 tokenId) public {
nftContract.checkClaimableDatetime(tokenId);
_claim_reward(tokenId);
}
function _claim_reward(uint256 tokenId) internal {
require(address(nftContract) != address(0), "not init");
require(nftContract.ownerOf(tokenId) == msg.sender, "not your nft");
StakePosition storage position = stakerPositions[tokenId];
require(position.active, "Position is not active");
uint256 reward = compute_reward(position.rewardDebt, position.amount, position.stakeStartTime, position.duration_lock, rewardPosition, totalStaked);
position.rewardDebt = rewardPosition;
require(rewardBank >= reward, "no sufficient fund");
rewardBank -= reward;
sdeamon.transfer(msg.sender, reward);
emit RewardClaimed(msg.sender, reward, tokenId);
}
// allows to retrieve the rewards of all sdeamon tokens received out of staking
function sync() external {
uint256 amount_ = sdeamon.balanceOf(address(this));
uint256 newRewardBank = 0;
if (amount_ > totalStaked) {
newRewardBank = amount_ - totalStaked;
}
if (newRewardBank > rewardBank) {
uint256 diff = newRewardBank - rewardBank;
rewardPosition += diff;
}
rewardBank = newRewardBank;
}
function estimate_WAGMI(address who) public view returns (uint256) {
uint256 totalRewarded = 0;
uint256 reward = 0;
uint256 amount_ = 0;
for (uint256 i = 0; i < tokenIdsStaked.length; i++) {
uint256 tid = tokenIdsStaked[i];
totalRewarded += estimate_reward(who, tid);
if (nftContract.ownerOf(tid) == who) {
reward += estimate_reward(who, tid);
amount_ += stakerPositions[tid].amount;
}
}
uint256 rest = rewardBank - totalRewarded;
reward += (amount_ * rest) / totalStaked;
return reward;
}
function WAGMI() external onlyOwner {
require(totalStaked > 0, "No stakers");
for (uint256 i = 0; i < tokenIdsStaked.length; i++) {
claim_reward(tokenIdsStaked[i]);
}
uint256 totalReward = rewardBank;
if (totalReward > 0) {
rewardBank = 0;
for (uint256 i = 0; i < tokenIdsStaked.length; i++) {
uint256 tid = tokenIdsStaked[i];
StakePosition storage position = stakerPositions[tid];
if (position.active) {
address gowner = nftContract.ownerOf(tid);
uint256 reward = (position.amount * totalReward) / totalStaked;
sdeamon.transfer(gowner, reward);
emit RewardClaimed(gowner, reward, tid);
}
}
}
}
}