编译器
0.8.16+commit.07a7930e
文件 1 的 36：Context.sol
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
文件 2 的 36：Counters.sol
pragma solidity ^0.8.0;
library Counters {
struct Counter {
uint256 _value;
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
unchecked {
counter._value += 1;
}
}
function decrement(Counter storage counter) internal {
uint256 value = counter._value;
require(value > 0, "Counter: decrement overflow");
unchecked {
counter._value = value - 1;
}
}
function reset(Counter storage counter) internal {
counter._value = 0;
}
}
文件 3 的 36：ECDSA.sol
pragma solidity ^0.8.0;
import "../Strings.sol";
library ECDSA {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS,
InvalidSignatureV
}
function _throwError(RecoverError error) private pure {
if (error == RecoverError.NoError) {
return;
} else if (error == RecoverError.InvalidSignature) {
revert("ECDSA: invalid signature");
} else if (error == RecoverError.InvalidSignatureLength) {
revert("ECDSA: invalid signature length");
} else if (error == RecoverError.InvalidSignatureS) {
revert("ECDSA: invalid signature 's' value");
}
}
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else {
return (address(0), RecoverError.InvalidSignatureLength);
}
}
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, signature);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError) {
bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
uint8 v = uint8((uint256(vs) >> 255) + 27);
return tryRecover(hash, v, r, s);
}
function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, r, vs);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address, RecoverError) {
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS);
}
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature);
}
return (signer, RecoverError.NoError);
}
function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, v, r, s);
_throwError(error);
return recovered;
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32 message) {
assembly {
mstore(0x00, "\x19Ethereum Signed Message:\n32")
mstore(0x1c, hash)
message := keccak256(0x00, 0x3c)
}
}
function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 data) {
assembly {
let ptr := mload(0x40)
mstore(ptr, "\x19\x01")
mstore(add(ptr, 0x02), domainSeparator)
mstore(add(ptr, 0x22), structHash)
data := keccak256(ptr, 0x42)
}
}
function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x00", validator, data));
}
}
文件 4 的 36：EIP712.sol
pragma solidity ^0.8.8;
import "./ECDSA.sol";
import "../ShortStrings.sol";
import "../../interfaces/IERC5267.sol";
abstract contract EIP712 is IERC5267 {
using ShortStrings for *;
bytes32 private constant _TYPE_HASH =
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
bytes32 private immutable _cachedDomainSeparator;
uint256 private immutable _cachedChainId;
address private immutable _cachedThis;
bytes32 private immutable _hashedName;
bytes32 private immutable _hashedVersion;
ShortString private immutable _name;
ShortString private immutable _version;
string private _nameFallback;
string private _versionFallback;
constructor(string memory name, string memory version) {
_name = name.toShortStringWithFallback(_nameFallback);
_version = version.toShortStringWithFallback(_versionFallback);
_hashedName = keccak256(bytes(name));
_hashedVersion = keccak256(bytes(version));
_cachedChainId = block.chainid;
_cachedDomainSeparator = _buildDomainSeparator();
_cachedThis = address(this);
}
function _domainSeparatorV4() internal view returns (bytes32) {
if (address(this) == _cachedThis && block.chainid == _cachedChainId) {
return _cachedDomainSeparator;
} else {
return _buildDomainSeparator();
}
}
function _buildDomainSeparator() private view returns (bytes32) {
return keccak256(abi.encode(_TYPE_HASH, _hashedName, _hashedVersion, block.chainid, address(this)));
}
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
}
function eip712Domain()
public
view
virtual
override
returns (
bytes1 fields,
string memory name,
string memory version,
uint256 chainId,
address verifyingContract,
bytes32 salt,
uint256[] memory extensions
)
{
return (
hex"0f",
_name.toStringWithFallback(_nameFallback),
_version.toStringWithFallback(_versionFallback),
block.chainid,
address(this),
bytes32(0),
new uint256[](0)
);
}
}
文件 5 的 36：ERC1155Holder.sol
pragma solidity ^0.8.0;
import "./ERC1155Receiver.sol";
contract ERC1155Holder is ERC1155Receiver {
function onERC1155Received(
address,
address,
uint256,
uint256,
bytes memory
) public virtual override returns (bytes4) {
return this.onERC1155Received.selector;
}
function onERC1155BatchReceived(
address,
address,
uint256[] memory,
uint256[] memory,
bytes memory
) public virtual override returns (bytes4) {
return this.onERC1155BatchReceived.selector;
}
}
文件 6 的 36：ERC1155Receiver.sol
pragma solidity ^0.8.0;
import "../IERC1155Receiver.sol";
import "../../../utils/introspection/ERC165.sol";
abstract contract ERC1155Receiver is ERC165, IERC1155Receiver {
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return interfaceId == type(IERC1155Receiver).interfaceId || super.supportsInterface(interfaceId);
}
}
文件 7 的 36：ERC165.sol
pragma solidity ^0.8.0;
import "./IERC165.sol";
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
文件 8 的 36：ERC20.sol
pragma solidity ^0.8.0;
import "./IERC20.sol";
import "./extensions/IERC20Metadata.sol";
import "../../utils/Context.sol";
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address from, address to, uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
_balances[to] += amount;
}
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
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;
unchecked {
_balances[account] += amount;
}
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
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);
}
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);
}
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
文件 9 的 36：ERC20Burnable.sol
pragma solidity ^0.8.0;
import "../ERC20.sol";
import "../../../utils/Context.sol";
abstract contract ERC20Burnable is Context, ERC20 {
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
_spendAllowance(account, _msgSender(), amount);
_burn(account, amount);
}
}
文件 10 的 36：ERC20Permit.sol
pragma solidity ^0.8.0;
import "./IERC20Permit.sol";
import "../ERC20.sol";
import "../../../utils/cryptography/ECDSA.sol";
import "../../../utils/cryptography/EIP712.sol";
import "../../../utils/Counters.sol";
abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 {
using Counters for Counters.Counter;
mapping(address => Counters.Counter) private _nonces;
bytes32 private constant _PERMIT_TYPEHASH =
keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 private _PERMIT_TYPEHASH_DEPRECATED_SLOT;
constructor(string memory name) EIP712(name, "1") {}
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public virtual override {
require(block.timestamp <= deadline, "ERC20Permit: expired deadline");
bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));
bytes32 hash = _hashTypedDataV4(structHash);
address signer = ECDSA.recover(hash, v, r, s);
require(signer == owner, "ERC20Permit: invalid signature");
_approve(owner, spender, value);
}
function nonces(address owner) public view virtual override returns (uint256) {
return _nonces[owner].current();
}
function DOMAIN_SEPARATOR() external view override returns (bytes32) {
return _domainSeparatorV4();
}
function _useNonce(address owner) internal virtual returns (uint256 current) {
Counters.Counter storage nonce = _nonces[owner];
current = nonce.current();
nonce.increment();
}
}
文件 11 的 36：IERC1155Receiver.sol
pragma solidity ^0.8.0;
import "../../utils/introspection/IERC165.sol";
interface IERC1155Receiver is IERC165 {
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external returns (bytes4);
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external returns (bytes4);
}
文件 12 的 36：IERC165.sol
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
文件 13 的 36：IERC20.sol
pragma solidity ^0.8.0;
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 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 from, address to, uint256 amount) external returns (bool);
}
文件 14 的 36：IERC20Metadata.sol
pragma solidity ^0.8.0;
import "../IERC20.sol";
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
文件 15 的 36：IERC20Permit.sol
pragma solidity ^0.8.0;
interface IERC20Permit {
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
function nonces(address owner) external view returns (uint256);
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
文件 16 的 36：IERC5267.sol
pragma solidity ^0.8.0;
interface IERC5267 {
event EIP712DomainChanged();
function eip712Domain()
external
view
returns (
bytes1 fields,
string memory name,
string memory version,
uint256 chainId,
address verifyingContract,
bytes32 salt,
uint256[] memory extensions
);
}
文件 17 的 36：IKeyProtocolVariables.sol
pragma solidity 0.8.16;
interface IKeyProtocolVariables {
function xTokenMintFee() external view returns (uint256);
function securityDepositMonths() external view returns (uint8);
function xTokensSecurityWallet() external view returns (address);
function landxOperationalWallet() external view returns (address);
function landxChoiceWallet() external view returns (address);
function landXOperationsPercentage() external view returns (uint256);
function landXChoicePercentage() external view returns (uint256);
function lndxHoldersPercentage() external view returns (uint256);
function hedgeFundAllocation() external view returns (uint256);
function hedgeFundWallet() external view returns (address);
function preLaunch() external view returns (bool);
function sellXTokenSlippage() external view returns (uint256);
function buyXTokenSlippage() external view returns (uint256);
function cTokenSellFee() external view returns (uint256);
function validatorCommission() external view returns (uint256);
function validatorCommisionWallet() external view returns (address);
function payRentFee() external view returns (uint256);
function maxValidatorFee() external view returns (uint256);
}文件 18 的 36：ILNDX.sol
pragma solidity 0.8.16;
interface ILNDX {
function feeToDistribute(uint256 amount) external;
}文件 19 的 36：ILandXNFT.sol
pragma solidity 0.8.16;
interface ILandXNFT {
function tillableArea(uint256 id) external view returns (uint256);
function cropShare(uint256 id) external view returns (uint256);
function crop(uint256 id) external view returns (string memory);
function validatorFee(uint256 id) external view returns (uint256);
function validator(uint256 id) external view returns (address);
function initialOwner(uint256 id) external view returns (address);
function balanceOf(address account, uint256 id)
external
view
returns (uint256);
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
}文件 20 的 36：IOraclePrices.sol
pragma solidity 0.8.16;
interface IOraclePrices {
function prices(string memory grain) external view returns (uint256);
function getXTokenPrice(address xToken) external view returns (uint256);
function usdc() external view returns (address);
}文件 21 的 36：IRentFoundation.sol
pragma solidity 0.8.16;
interface IRentFoundation {
function initialRentApplied(uint256 tokenID) external view returns (bool);
function spentSecurityDeposit(uint256 tokenID) external view returns (bool);
function payInitialRent(uint256 tokenID, uint256 amount) external;
function buyOutPreview(uint256 tokenID) external view returns(bool, uint256);
function buyOut(uint256 tokenID) external returns(uint256);
function sellCToken(address account, uint256 amount) external;
}文件 22 的 36：ISwapRouter.sol
pragma solidity >=0.7.5;
pragma abicoder v2;
import '@uniswap/v3-core/contracts/interfaces/callback/IUniswapV3SwapCallback.sol';
interface ISwapRouter is IUniswapV3SwapCallback {
struct ExactInputSingleParams {
address tokenIn;
address tokenOut;
uint24 fee;
address recipient;
uint256 deadline;
uint256 amountIn;
uint256 amountOutMinimum;
uint160 sqrtPriceLimitX96;
}
function exactInputSingle(ExactInputSingleParams calldata params) external payable returns (uint256 amountOut);
struct ExactInputParams {
bytes path;
address recipient;
uint256 deadline;
uint256 amountIn;
uint256 amountOutMinimum;
}
function exactInput(ExactInputParams calldata params) external payable returns (uint256 amountOut);
struct ExactOutputSingleParams {
address tokenIn;
address tokenOut;
uint24 fee;
address recipient;
uint256 deadline;
uint256 amountOut;
uint256 amountInMaximum;
uint160 sqrtPriceLimitX96;
}
function exactOutputSingle(ExactOutputSingleParams calldata params) external payable returns (uint256 amountIn);
struct ExactOutputParams {
bytes path;
address recipient;
uint256 deadline;
uint256 amountOut;
uint256 amountInMaximum;
}
function exactOutput(ExactOutputParams calldata params) external payable returns (uint256 amountIn);
}
文件 23 的 36：ITWAP.sol
pragma solidity >=0.7.4;
interface ITWAP {
function getPrice(address tokenIn, address tokenOut) external view returns (uint);
}文件 24 的 36：IUniswapV3SwapCallback.sol
pragma solidity >=0.5.0;
interface IUniswapV3SwapCallback {
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata data
) external;
}
文件 25 的 36：IcToken.sol
pragma solidity 0.8.16;
interface IcToken {
function crop() external view returns (string memory);
function mint(address account, uint256 amount) external;
}文件 26 的 36：IxToken.sol
pragma solidity 0.8.16;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IxToken is IERC20 {
function previewNonDistributedYield() external view returns(uint256);
function getNonDistributedYield() external returns(uint256);
function stake(uint256 amount) external;
function unstake(uint256 amount) external;
function xBasketTransfer(address _from, uint256 amount) external;
function Staked(address)
external
view
returns (uint256 amount, uint256 startTime);
function availableToClaim(address account) external view returns (uint256);
function claim() external;
}文件 27 的 36：IxTokenRouter.sol
pragma solidity 0.8.16;
interface IxTokenRouter {
function getXToken(string memory _name) external view returns (address);
function getCToken(string memory _name) external view returns (address);
}文件 28 的 36：Math.sol
pragma solidity ^0.8.0;
library Math {
enum Rounding {
Down,
Up,
Zero
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
uint256 prod0;
uint256 prod1;
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
require(denominator > prod1, "Math: mulDiv overflow");
uint256 remainder;
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
uint256 twos = denominator & (~denominator + 1);
assembly {
denominator := div(denominator, twos)
prod0 := div(prod0, twos)
twos := add(div(sub(0, twos), twos), 1)
}
prod0 |= prod1 * twos;
uint256 inverse = (3 * denominator) ^ 2;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
result = prod0 * inverse;
return result;
}
}
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 result = 1 << (log2(a) >> 1);
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
}
}
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
}
}
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
}
}
}
文件 29 的 36：Ownable.sol
pragma solidity ^0.8.0;
import "../utils/Context.sol";
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
文件 30 的 36：ShortStrings.sol
pragma solidity ^0.8.8;
import "./StorageSlot.sol";
type ShortString is bytes32;
library ShortStrings {
bytes32 private constant _FALLBACK_SENTINEL = 0x00000000000000000000000000000000000000000000000000000000000000FF;
error StringTooLong(string str);
error InvalidShortString();
function toShortString(string memory str) internal pure returns (ShortString) {
bytes memory bstr = bytes(str);
if (bstr.length > 31) {
revert StringTooLong(str);
}
return ShortString.wrap(bytes32(uint256(bytes32(bstr)) | bstr.length));
}
function toString(ShortString sstr) internal pure returns (string memory) {
uint256 len = byteLength(sstr);
string memory str = new string(32);
assembly {
mstore(str, len)
mstore(add(str, 0x20), sstr)
}
return str;
}
function byteLength(ShortString sstr) internal pure returns (uint256) {
uint256 result = uint256(ShortString.unwrap(sstr)) & 0xFF;
if (result > 31) {
revert InvalidShortString();
}
return result;
}
function toShortStringWithFallback(string memory value, string storage store) internal returns (ShortString) {
if (bytes(value).length < 32) {
return toShortString(value);
} else {
StorageSlot.getStringSlot(store).value = value;
return ShortString.wrap(_FALLBACK_SENTINEL);
}
}
function toStringWithFallback(ShortString value, string storage store) internal pure returns (string memory) {
if (ShortString.unwrap(value) != _FALLBACK_SENTINEL) {
return toString(value);
} else {
return store;
}
}
function byteLengthWithFallback(ShortString value, string storage store) internal view returns (uint256) {
if (ShortString.unwrap(value) != _FALLBACK_SENTINEL) {
return byteLength(value);
} else {
return bytes(store).length;
}
}
}
文件 31 的 36：SignedMath.sol
pragma solidity ^0.8.0;
library SignedMath {
function max(int256 a, int256 b) internal pure returns (int256) {
return a > b ? a : b;
}
function min(int256 a, int256 b) internal pure returns (int256) {
return a < b ? a : b;
}
function average(int256 a, int256 b) internal pure returns (int256) {
int256 x = (a & b) + ((a ^ b) >> 1);
return x + (int256(uint256(x) >> 255) & (a ^ b));
}
function abs(int256 n) internal pure returns (uint256) {
unchecked {
return uint256(n >= 0 ? n : -n);
}
}
}
文件 32 的 36：StorageSlot.sol
pragma solidity ^0.8.0;
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
struct StringSlot {
string value;
}
struct BytesSlot {
bytes value;
}
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
assembly {
r.slot := slot
}
}
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
assembly {
r.slot := slot
}
}
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
assembly {
r.slot := slot
}
}
function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
assembly {
r.slot := slot
}
}
function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
assembly {
r.slot := store.slot
}
}
function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
assembly {
r.slot := store.slot
}
}
}
文件 33 的 36：Strings.sol
pragma solidity ^0.8.0;
import "./math/Math.sol";
import "./math/SignedMath.sol";
library Strings {
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
assembly {
mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
function toString(int256 value) internal pure returns (string memory) {
return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value))));
}
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, Math.log256(value) + 1);
}
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
function equal(string memory a, string memory b) internal pure returns (bool) {
return keccak256(bytes(a)) == keccak256(bytes(b));
}
}
文件 34 的 36：TransferHelper.sol
pragma solidity >=0.6.0;
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
library TransferHelper {
function safeTransferFrom(
address token,
address from,
address to,
uint256 value
) internal {
(bool success, bytes memory data) =
token.call(abi.encodeWithSelector(IERC20.transferFrom.selector, from, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'STF');
}
function safeTransfer(
address token,
address to,
uint256 value
) internal {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.transfer.selector, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'ST');
}
function safeApprove(
address token,
address to,
uint256 value
) internal {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.approve.selector, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'SA');
}
function safeTransferETH(address to, uint256 value) internal {
(bool success, ) = to.call{value: value}(new bytes(0));
require(success, 'STE');
}
}
文件 35 的 36：draft-ERC20Permit.sol
pragma solidity ^0.8.0;
import "./ERC20Permit.sol";
文件 36 的 36：xToken.sol
pragma solidity 0.8.16;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/draft-ERC20Permit.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol";
import "@uniswap/v3-periphery/contracts/libraries/TransferHelper.sol";
import "@uniswap/v3-periphery/contracts/interfaces/ISwapRouter.sol";
import "./interfaces/IKeyProtocolVariables.sol";
import "./interfaces/ILandXNFT.sol";
import "./interfaces/IxTokenRouter.sol";
import "./interfaces/IOraclePrices.sol";
import "./interfaces/IRentFoundation.sol";
import "./interfaces/IcToken.sol";
import "./interfaces/IxToken.sol";
import "./interfaces/ILNDX.sol";
import "./interfaces/ITWAP.sol";
contract XToken is Context, ERC20Permit, ERC20Burnable, Ownable, ERC1155Holder, IxToken {
struct Stake {
uint256 amount;
uint256 startTime;
}
string public crop;
address public xBasketContract;
address public lndx;
address public usdc;
ILandXNFT public landXNFT;
IxTokenRouter public xTokenRouter;
IRentFoundation public rentFoundation;
IOraclePrices public oraclePrices;
IKeyProtocolVariables public keyProtocolValues;
ISwapRouter public uniswapRouter;
ITWAP public twap;
mapping(uint256 => address) public initialOwner;
mapping(address => uint256) public Claimed;
mapping(address => Stake) public Staked;
mapping(address => uint256) public Yield;
mapping(uint256 => uint256) public SecurityDepositedAmount;
Stake public TotalStaked;
uint256 public TotalYield;
Stake public NonStakedTokens;
uint256 public NonDistributedYield;
event Sharded(uint256 nftID, uint256 amount, string name);
event BuyOut(uint256 nftID, uint256 amount, string name);
event TokenStaked(address staker, uint256 amount);
event Unstaked(address staker, uint256 amount);
event YieldClaimed(address staker, uint256 amount);
constructor(
address _landXNFT,
address _lndx,
address _usdc,
address _rentFoundation,
address _xTokenRouter,
address _keyProtocolValues,
address _oraclePrices,
string memory _crop
) ERC20Permit(string(abi.encodePacked("x", _crop))) ERC20("LandX xToken", string(abi.encodePacked("x", _crop))) {
require(_landXNFT != address(0), "zero address is not allowed");
require(_lndx != address(0), "zero address is not allowed");
require(_usdc != address(0), "zero address is not allowed");
require(_rentFoundation != address(0), "zero address is not allowed");
require(_xTokenRouter != address(0), "zero address is not allowed");
require(_keyProtocolValues != address(0), "zero address is not allowed");
landXNFT = ILandXNFT(_landXNFT);
crop = _crop;
lndx = _lndx;
usdc = _usdc;
rentFoundation = IRentFoundation(_rentFoundation);
xTokenRouter = IxTokenRouter(_xTokenRouter);
keyProtocolValues = IKeyProtocolVariables(_keyProtocolValues);
oraclePrices = IOraclePrices(_oraclePrices);
twap = ITWAP(0x5eb612F924dAD205eAb02911b198520eFfE96e5C);
uniswapRouter = ISwapRouter(0xE592427A0AEce92De3Edee1F18E0157C05861564);
}
function getShards(uint256 _id) external {
require(
landXNFT.tillableArea(_id) > 0,
"this NFT has no land area set"
);
require(landXNFT.cropShare(_id) > 0, "this NFT has no crop share set");
require(
landXNFT.initialOwner(_id) == msg.sender,
"only initial owner can shard"
);
require(
keccak256(abi.encodePacked(landXNFT.crop(_id))) ==
keccak256(abi.encodePacked(crop)),
"wrong crop"
);
require(
xTokenRouter.getXToken(crop) == address(this),
"tokens are not set for this crop"
);
require(
landXNFT.balanceOf(msg.sender, _id) > 0,
"you must own this NFT"
);
require(
rentFoundation.initialRentApplied(_id) == false,
"rent was already applied"
);
initialOwner[_id] = msg.sender;
landXNFT.safeTransferFrom(msg.sender, address(this), _id, 1, "");
uint256 shards = landXNFT.tillableArea(_id) *
(landXNFT.cropShare(_id)) *
(1e6) / 10000;
_mint(address(this), shards);
uint256 fee = _calcFee(shards);
uint256 validatorFee = _validatorFee(_id, shards);
uint256 annualRent = getAnnualRentAmount(_id);
uint256 xTokensAnnualRent = ((annualRent * oraclePrices.prices(crop)) /
oraclePrices.getXTokenPrice(address(this))) * 1e3;
uint256 toSecurityDepositsAmount = (xTokensAnnualRent / 12) *
keyProtocolValues.securityDepositMonths();
if (keyProtocolValues.preLaunch()) {
_transfer(
address(this),
keyProtocolValues.landxOperationalWallet(),
xTokensAnnualRent
);
_transfer(
address(this),
keyProtocolValues.landxOperationalWallet(),
fee
);
} else {
uint256 usdcFee = _convertToUsdc(fee);
uint256 usdcAnnualRent = _convertToUsdc(xTokensAnnualRent);
uint256 toHedgeFund = (usdcAnnualRent *
keyProtocolValues.hedgeFundAllocation()) / 10000;
ERC20(usdc).transfer(
keyProtocolValues.hedgeFundWallet(),
toHedgeFund
);
ERC20(usdc).transfer(
address(rentFoundation),
usdcAnnualRent - toHedgeFund
);
_feeDistributor(usdcFee);
}
_transfer(
address(this),
keyProtocolValues.xTokensSecurityWallet(),
toSecurityDepositsAmount
);
if (landXNFT.validator(_id) != address(0)) {
_transfer(address(this), landXNFT.validator(_id), validatorFee);
}
_transfer(
address(this),
msg.sender,
shards - fee - xTokensAnnualRent - toSecurityDepositsAmount - validatorFee
);
SecurityDepositedAmount[_id] = toSecurityDepositsAmount;
rentFoundation.payInitialRent(_id, annualRent);
_calculateNonDistributedYield();
emit Sharded(_id, shards, symbol());
}
function getTheNFT(uint256 _id) external {
require(
initialOwner[_id] == msg.sender,
"only initial owner can redeem the NFT"
);
uint256 remainingRentUSDC;
remainingRentUSDC = rentFoundation.buyOut(_id);
uint256 securityDepositedAmount = SecurityDepositedAmount[_id];
if (rentFoundation.spentSecurityDeposit(_id)) {
securityDepositedAmount = 0;
}
uint256 xTokens = 0;
if (remainingRentUSDC > 0) {
xTokens = _convertToXToken(remainingRentUSDC);
}
uint256 shards = landXNFT.tillableArea(_id) *
landXNFT.cropShare(_id) *
1e6 / 10000;
if (securityDepositedAmount > 0) {
_burn(keyProtocolValues.xTokensSecurityWallet(), securityDepositedAmount);
}
_burn(address(this), xTokens);
burn(shards - securityDepositedAmount - xTokens);
_calculateNonDistributedYield();
landXNFT.safeTransferFrom(address(this), msg.sender, _id, 1, "");
emit BuyOut(_id, shards, symbol());
}
function getTheNFTPreview(uint256 _id) public view returns(uint256) {
bool allow;
uint256 remainingRentUSDC;
(allow, remainingRentUSDC) = rentFoundation.buyOutPreview(_id);
require(allow, "there is a debt");
uint256 securityDepositedAmount = SecurityDepositedAmount[_id];
if (rentFoundation.spentSecurityDeposit(_id)) {
securityDepositedAmount = 0;
}
uint256 xTokens = remainingRentUSDC * 1e6 / oraclePrices.getXTokenPrice(address(this));
uint256 shards = landXNFT.tillableArea(_id) *
landXNFT.cropShare(_id) *
1e6 / 10000;
return (shards - securityDepositedAmount - xTokens);
}
function stake(uint256 amount) public {
_transfer(msg.sender, address(this), amount);
uint256 yield = _calculateYield(Staked[msg.sender]);
TotalYield += _calculateTotalYield();
Yield[msg.sender] += yield;
Staked[msg.sender].startTime = block.timestamp;
TotalStaked.startTime = block.timestamp;
TotalStaked.amount += amount;
Staked[msg.sender].amount += amount;
_calculateNonDistributedYield();
emit TokenStaked(msg.sender, amount);
}
function unstake(uint256 amount) public {
require(Staked[msg.sender].amount >= amount);
_transfer(address(this), msg.sender, amount);
claim();
Staked[msg.sender].amount -= amount;
TotalStaked.amount -= amount;
_calculateNonDistributedYield();
emit Unstaked(msg.sender, amount);
}
function claim() public {
address cToken = xTokenRouter.getCToken(crop);
uint256 yield = _calculateYield(Staked[msg.sender]);
TotalYield =
TotalYield +
_calculateTotalYield() -
(Yield[msg.sender] + yield);
IcToken(cToken).mint(msg.sender, (Yield[msg.sender] + yield));
Claimed[msg.sender] += (Yield[msg.sender] + yield);
Staked[msg.sender].startTime = block.timestamp;
TotalStaked.startTime = block.timestamp;
Yield[msg.sender] = 0;
emit YieldClaimed(msg.sender, yield);
}
function _feeDistributor(uint256 _fee) internal {
uint256 lndxFee = (_fee * keyProtocolValues.lndxHoldersPercentage()) /
10000;
uint256 operationalFee = (_fee *
keyProtocolValues.landXOperationsPercentage()) / 10000;
ERC20(usdc).transfer(lndx, lndxFee);
ILNDX(lndx).feeToDistribute(lndxFee);
ERC20(usdc).transfer(
keyProtocolValues.landxOperationalWallet(),
operationalFee
);
ERC20(usdc).transfer(
keyProtocolValues.landxChoiceWallet(),
_fee - lndxFee - operationalFee
);
}
function availableToClaim(address account) public view returns (uint256) {
return Yield[account] + _calculateYield(Staked[account]);
}
function totalAvailableToClaim() public view returns (uint256) {
return TotalYield + _calculateTotalYield();
}
function _calculateYield(Stake storage s) internal view returns (uint256) {
uint256 elapsedSeconds = block.timestamp - s.startTime;
uint256 delimeter = 365 * 1 days;
return (s.amount * elapsedSeconds) / delimeter;
}
function _calculateTotalYield() internal view returns (uint256) {
uint256 elapsedSeconds = block.timestamp - TotalStaked.startTime;
uint256 delimeter = 365 * 1 days;
return (TotalStaked.amount * elapsedSeconds) / delimeter;
}
function xBasketTransfer(address _from, uint256 amount) external {
require(msg.sender == xBasketContract, "not authorized");
_transfer(_from, xBasketContract, amount);
}
function changeXBasketAddress(address _newAddress) public onlyOwner {
require(_newAddress != address(0), "zero address is not allowed");
xBasketContract = _newAddress;
}
function _calcFee(uint256 amount) internal view returns (uint256) {
uint256 fee = keyProtocolValues.xTokenMintFee();
return (amount * fee) / 10000;
}
function _validatorFee(uint256 tokenID, uint256 amount) internal view returns(uint256) {
if (landXNFT.validator(tokenID) == address(0)) {
return 0;
}
uint256 validatorFee = landXNFT.validatorFee(tokenID);
if (validatorFee == 0) {
return 0;
}
return (amount* validatorFee) / 10000;
}
function setXTokenRouter(address _router) public onlyOwner {
require(_router != address(0), "zero address is not allowed");
xTokenRouter = IxTokenRouter(_router);
}
function getAnnualRentAmount(uint256 tokenID)
public
view
returns (uint256)
{
uint256 rent = landXNFT.cropShare(tokenID);
uint256 area = landXNFT.tillableArea(tokenID);
return (rent * area) / 10000;
}
function quoteAmountOut(uint _amount) public view returns (uint) {
uint price = twap.getPrice(address(this), usdc);
uint256 amountOut = _amount * price / 1e6;
return amountOut;
}
function _convertToXToken(uint256 amount) internal returns (uint256) {
uint256 slippage = keyProtocolValues.buyXTokenSlippage();
uint price = twap.getPrice(usdc, address(this));
uint256 predictedAmountOut = amount * price / 10 ** decimals();
uint256 minAmountOut = predictedAmountOut * 10000 / (10000 + slippage);
TransferHelper.safeApprove(usdc, address(uniswapRouter), amount);
ISwapRouter.ExactInputSingleParams memory params = ISwapRouter
.ExactInputSingleParams(
usdc,
address(this),
3000,
address(this),
block.timestamp + 15,
amount,
minAmountOut,
0
);
return uniswapRouter.exactInputSingle(params);
}
function _convertToUsdc(uint256 amount) internal returns (uint256) {
uint256 slippage = keyProtocolValues.sellXTokenSlippage();
uint256 predictedAmountOut = quoteAmountOut(amount);
uint256 minAmountOut = predictedAmountOut * 10000 / (10000 + slippage);
TransferHelper.safeApprove(
address(this),
address(uniswapRouter),
amount
);
ISwapRouter.ExactInputSingleParams memory params = ISwapRouter
.ExactInputSingleParams(
address(this),
usdc,
3000,
address(this),
block.timestamp + 15,
amount,
minAmountOut,
0
);
return uniswapRouter.exactInputSingle(params);
}
function preview(uint256 id)
public
view
returns (
uint256,
uint256,
uint256,
uint256
)
{
require(landXNFT.tillableArea(id) > 0, "this NFT has no land area set");
require(landXNFT.cropShare(id) > 0, "this NFT has no crop share set");
require(
keccak256(abi.encodePacked(landXNFT.crop(id))) ==
keccak256(abi.encodePacked(crop)),
"wrong crop"
);
require(
xTokenRouter.getXToken(landXNFT.crop(id)) == address(this),
"Unable to shard this NFT"
);
uint256 shards = (landXNFT.tillableArea(id) *
landXNFT.cropShare(id) *
1e6) / 10000;
uint256 annualRent = getAnnualRentAmount(id);
uint256 xTokensAnnualRent = ((annualRent * oraclePrices.prices(crop)) /
oraclePrices.getXTokenPrice(xTokenRouter.getXToken(crop))) * 1e3;
uint256 toSecurityDepositsAmount = (xTokensAnnualRent / 12) *
keyProtocolValues.securityDepositMonths();
uint256 fee = _calcFee(shards);
uint256 validatorFee = _validatorFee(id, shards);
uint256 toBeReceived = shards -
fee -
xTokensAnnualRent -
toSecurityDepositsAmount - validatorFee;
return (
shards,
fee,
xTokensAnnualRent + toSecurityDepositsAmount,
toBeReceived
);
}
function _calculateNonDistributedYield() internal {
uint256 elapsedSeconds = block.timestamp - NonStakedTokens.startTime;
uint256 delimeter = 365 * 1 days;
NonDistributedYield += NonStakedTokens.amount * elapsedSeconds / delimeter;
NonStakedTokens.amount = totalSupply() - TotalStaked.amount;
NonStakedTokens.startTime = block.timestamp;
}
function previewNonDistributedYield() external view returns(uint256) {
uint256 elapsedSeconds = block.timestamp - NonStakedTokens.startTime;
uint256 delimeter = 365 * 1 days;
return NonDistributedYield + NonStakedTokens.amount * elapsedSeconds / delimeter;
}
function getNonDistributedYield() external returns(uint256) {
require(msg.sender == address(rentFoundation), "only rentFoundation can take it");
_calculateNonDistributedYield();
uint256 amount = NonDistributedYield;
NonDistributedYield = 0;
return amount;
}
function renounceOwnership() public view override onlyOwner {
revert ("can 't renounceOwnership here");
}
function updateUniswapContracts(address _twap, address _uniswapRouter) public onlyOwner {
twap = ITWAP(_twap);
uniswapRouter = ISwapRouter(_uniswapRouter);
}
function decimals() public pure override returns (uint8) {
return 6;
}
}{
"compilationTarget": {
"contracts/xToken.sol": "XToken"
},
"evmVersion": "london",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs",
"useLiteralContent": true
},
"optimizer": {
"enabled": true,
"runs": 2000
},
"remappings": []
}[{"inputs":[{"internalType":"address","name":"_landXNFT","type":"address"},{"internalType":"address","name":"_lndx","type":"address"},{"internalType":"address","name":"_usdc","type":"address"},{"internalType":"address","name":"_rentFoundation","type":"address"},{"internalType":"address","name":"_xTokenRouter","type":"address"},{"internalType":"address","name":"_keyProtocolValues","type":"address"},{"internalType":"address","name":"_oraclePrices","type":"address"},{"internalType":"string","name":"_crop","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"InvalidShortString","type":"error"},{"inputs":[{"internalType":"string","name":"str","type":"string"}],"name":"StringTooLong","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"nftID","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"string","name":"name","type":"string"}],"name":"BuyOut","type":"event"},{"anonymous":false,"inputs":[],"name":"EIP712DomainChanged","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":false,"internalType":"uint256","name":"nftID","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"string","name":"name","type":"string"}],"name":"Sharded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"staker","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokenStaked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"staker","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Unstaked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"staker","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"YieldClaimed","type":"event"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"Claimed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"NonDistributedYield","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"NonStakedTokens","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"startTime","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"SecurityDepositedAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"Staked","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"startTime","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TotalStaked","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"startTime","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TotalYield","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"Yield","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"availableToClaim","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newAddress","type":"address"}],"name":"changeXBasketAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"crop","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"eip712Domain","outputs":[{"internalType":"bytes1","name":"fields","type":"bytes1"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"version","type":"string"},{"internalType":"uint256","name":"chainId","type":"uint256"},{"internalType":"address","name":"verifyingContract","type":"address"},{"internalType":"bytes32","name":"salt","type":"bytes32"},{"internalType":"uint256[]","name":"extensions","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenID","type":"uint256"}],"name":"getAnnualRentAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getNonDistributedYield","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"}],"name":"getShards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"}],"name":"getTheNFT","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"}],"name":"getTheNFTPreview","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"initialOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"keyProtocolValues","outputs":[{"internalType":"contract IKeyProtocolVariables","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"landXNFT","outputs":[{"internalType":"contract ILandXNFT","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lndx","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155BatchReceived","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"oraclePrices","outputs":[{"internalType":"contract IOraclePrices","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"preview","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"previewNonDistributedYield","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"quoteAmountOut","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rentFoundation","outputs":[{"internalType":"contract IRentFoundation","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_router","type":"address"}],"name":"setXTokenRouter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"stake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAvailableToClaim","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"twap","outputs":[{"internalType":"contract ITWAP","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"uniswapRouter","outputs":[{"internalType":"contract ISwapRouter","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"unstake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_twap","type":"address"},{"internalType":"address","name":"_uniswapRouter","type":"address"}],"name":"updateUniswapContracts","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"usdc","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"xBasketContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"xBasketTransfer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"xTokenRouter","outputs":[{"internalType":"contract IxTokenRouter","name":"","type":"address"}],"stateMutability":"view","type":"function"}]
