文件 1 的 1：stableQiVault.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;
}
}
pragma solidity ^0.8.0;
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);
}
}
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);
}
pragma solidity ^0.8.0;
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
pragma solidity ^0.8.0;
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 {}
}
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);
}
pragma solidity ^0.8.1;
library Address {
function isContract(address account) internal view returns (bool) {
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
pragma solidity ^0.8.0;
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require(
(value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 oldAllowance = token.allowance(address(this), spender);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
}
}
function forceApprove(IERC20 token, address spender, uint256 value) internal {
bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);
if (!_callOptionalReturnBool(token, approvalCall)) {
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
_callOptionalReturn(token, approvalCall);
}
}
function safePermit(
IERC20Permit token,
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) internal {
uint256 nonceBefore = token.nonces(owner);
token.permit(owner, spender, value, deadline, v, r, s);
uint256 nonceAfter = token.nonces(owner);
require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
(bool success, bytes memory returndata) = address(token).call(data);
return
success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));
}
}
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity ^0.8.0;
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
function safeTransferFrom(address from, address to, uint256 tokenId) external;
function transferFrom(address from, address to, uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function setApprovalForAll(address operator, bool approved) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function isApprovedForAll(address owner, address operator) external view returns (bool);
}
pragma solidity ^0.8.0;
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
pragma solidity ^0.8.0;
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
pragma solidity ^0.8.0;
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
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);
}
}
}
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);
}
}
}
pragma solidity ^0.8.0;
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));
}
}
pragma solidity ^0.8.0;
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
mapping(uint256 => address) private _owners;
mapping(address => uint256) private _balances;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: address zero is not a valid owner");
return _balances[owner];
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _ownerOf(tokenId);
require(owner != address(0), "ERC721: invalid token ID");
return owner;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
_requireMinted(tokenId);
string memory baseURI = _baseURI();
return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
}
function _baseURI() internal view virtual returns (string memory) {
return "";
}
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not token owner or approved for all"
);
_approve(to, tokenId);
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
_requireMinted(tokenId);
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(address from, address to, uint256 tokenId) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
_transfer(from, to, tokenId);
}
function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
_safeTransfer(from, to, tokenId, data);
}
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
return _owners[tokenId];
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _ownerOf(tokenId) != address(0);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
address owner = ERC721.ownerOf(tokenId);
return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender);
}
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
function _safeMint(address to, uint256 tokenId, bytes memory data) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId, 1);
require(!_exists(tokenId), "ERC721: token already minted");
unchecked {
_balances[to] += 1;
}
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
_afterTokenTransfer(address(0), to, tokenId, 1);
}
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId, 1);
owner = ERC721.ownerOf(tokenId);
delete _tokenApprovals[tokenId];
unchecked {
_balances[owner] -= 1;
}
delete _owners[tokenId];
emit Transfer(owner, address(0), tokenId);
_afterTokenTransfer(owner, address(0), tokenId, 1);
}
function _transfer(address from, address to, uint256 tokenId) internal virtual {
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId, 1);
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
delete _tokenApprovals[tokenId];
unchecked {
_balances[from] -= 1;
_balances[to] += 1;
}
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
_afterTokenTransfer(from, to, tokenId, 1);
}
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
}
function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {
require(owner != operator, "ERC721: approve to caller");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
function _requireMinted(uint256 tokenId) internal view virtual {
require(_exists(tokenId), "ERC721: invalid token ID");
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
function _beforeTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual {}
function _afterTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual {}
function __unsafe_increaseBalance(address account, uint256 amount) internal {
_balances[account] += amount;
}
}
pragma solidity ^0.8.0;
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
function tokenByIndex(uint256 index) external view returns (uint256);
}
pragma solidity ^0.8.0;
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
mapping(uint256 => uint256) private _ownedTokensIndex;
uint256[] private _allTokens;
mapping(uint256 => uint256) private _allTokensIndex;
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
return interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId);
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
return _ownedTokens[owner][index];
}
function totalSupply() public view virtual override returns (uint256) {
return _allTokens.length;
}
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds");
return _allTokens[index];
}
function _beforeTokenTransfer(
address from,
address to,
uint256 firstTokenId,
uint256 batchSize
) internal virtual override {
super._beforeTokenTransfer(from, to, firstTokenId, batchSize);
if (batchSize > 1) {
revert("ERC721Enumerable: consecutive transfers not supported");
}
uint256 tokenId = firstTokenId;
if (from == address(0)) {
_addTokenToAllTokensEnumeration(tokenId);
} else if (from != to) {
_removeTokenFromOwnerEnumeration(from, tokenId);
}
if (to == address(0)) {
_removeTokenFromAllTokensEnumeration(tokenId);
} else if (to != from) {
_addTokenToOwnerEnumeration(to, tokenId);
}
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
uint256 length = ERC721.balanceOf(to);
_ownedTokens[to][length] = tokenId;
_ownedTokensIndex[tokenId] = length;
}
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
_allTokensIndex[tokenId] = _allTokens.length;
_allTokens.push(tokenId);
}
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
uint256 lastTokenIndex = ERC721.balanceOf(from) - 1;
uint256 tokenIndex = _ownedTokensIndex[tokenId];
if (tokenIndex != lastTokenIndex) {
uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];
_ownedTokens[from][tokenIndex] = lastTokenId;
_ownedTokensIndex[lastTokenId] = tokenIndex;
}
delete _ownedTokensIndex[tokenId];
delete _ownedTokens[from][lastTokenIndex];
}
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
uint256 lastTokenIndex = _allTokens.length - 1;
uint256 tokenIndex = _allTokensIndex[tokenId];
uint256 lastTokenId = _allTokens[lastTokenIndex];
_allTokens[tokenIndex] = lastTokenId;
_allTokensIndex[lastTokenId] = tokenIndex;
delete _allTokensIndex[tokenId];
_allTokens.pop();
}
}
pragma solidity ^0.8.0;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
}
function _nonReentrantAfter() private {
_status = _NOT_ENTERED;
}
function _reentrancyGuardEntered() internal view returns (bool) {
return _status == _ENTERED;
}
}
pragma solidity 0.8.11;
interface IPriceSource {
function latestRoundData() external view returns (uint256);
function latestAnswer() external view returns (uint256);
function decimals() external view returns (uint8);
}
pragma solidity 0.8.11;
contract VaultNFTv5 is ERC721, ERC721Enumerable {
bool public custom;
string internal baseURI;
function _beforeTokenTransfer(address from, address to, uint256 tokenId, uint256 batchSize) internal override(ERC721, ERC721Enumerable) {
super._beforeTokenTransfer(from, to, tokenId, batchSize);
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) {
return super.supportsInterface(interfaceId);
}
constructor(string memory name, string memory symbol, string memory _baseURI)
ERC721(name, symbol)
{
baseURI = _baseURI;
}
function _baseURI() internal view virtual override returns (string memory) {
return baseURI;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
_requireMinted(tokenId);
string memory baseURI = _baseURI();
if(custom){
return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, Strings.toString(tokenId))) : "";
} else{
return baseURI;
}
}
}
pragma solidity 0.8.11;
contract fixedVault is ReentrancyGuard, VaultNFTv5 {
using SafeERC20 for ERC20;
uint256 constant TEN_THOUSAND = 10000;
uint256 constant ONE_YEAR = 31556952;
uint256 constant THOUSAND = 1000;
IPriceSource public ethPriceSource;
uint256 public _minimumCollateralPercentage;
uint256 public vaultCount;
uint256 public closingFee;
uint256 public openingFee;
uint256 public minDebt;
uint256 public maxDebt;
uint256 constant public tokenPeg = 1e8;
uint256 public iR;
mapping(uint256 => uint256) public vaultCollateral;
mapping(uint256 => uint256) public accumulatedVaultDebt;
mapping(uint256 => uint256) public lastInterest;
mapping(uint256 => uint256) public promoter;
uint256 public adminFee;
uint256 public refFee;
uint256 public debtRatio;
uint256 public gainRatio;
ERC20 public collateral;
ERC20 public mai;
uint256 public decimalDifferenceRaisedToTen;
uint256 public priceSourceDecimals;
uint256 public totalBorrowed;
mapping(address => uint256) public maticDebt;
uint256 public maiDebt;
address public stabilityPool;
address public adm;
address public ref;
address public router;
uint8 public version = 8;
event CreateVault(uint256 vaultID, address creator);
event DestroyVault(uint256 vaultID);
event DepositCollateral(uint256 vaultID, uint256 amount);
event WithdrawCollateral(uint256 vaultID, uint256 amount);
event BorrowToken(uint256 vaultID, uint256 amount);
event PayBackToken(uint256 vaultID, uint256 amount, uint256 closingFee);
event LiquidateVault(
uint256 vaultID,
address owner,
address buyer,
uint256 debtRepaid,
uint256 collateralLiquidated,
uint256 closingFee
);
event BoughtRiskyDebtVault(uint256 riskyVault, uint256 newVault, address riskyVaultBuyer, uint256 amountPaidtoBuy);
constructor(
address ethPriceSourceAddress,
uint256 minimumCollateralPercentage,
string memory name,
string memory symbol,
address _mai,
address _collateral,
string memory baseURI
) VaultNFTv5(name, symbol, baseURI) {
require(ethPriceSourceAddress != address(0));
require(minimumCollateralPercentage != 0);
closingFee = 50;
openingFee = 0;
ethPriceSource = IPriceSource(ethPriceSourceAddress);
stabilityPool = address(0);
maxDebt = 500000 ether;
debtRatio = 2;
gainRatio = 1100;
_minimumCollateralPercentage = minimumCollateralPercentage;
collateral = ERC20(_collateral);
mai = ERC20(_mai);
priceSourceDecimals = 8;
decimalDifferenceRaisedToTen =
10**(mai.decimals() - collateral.decimals());
adm = msg.sender;
ref = msg.sender;
}
modifier onlyVaultOwner(uint256 vaultID) {
require(_exists(vaultID), "Vault does not exist");
require(ownerOf(vaultID) == msg.sender, "Vault is not owned by you");
_;
}
modifier onlyRouter() {
require(
router == address(0) || msg.sender == router,
"must use router"
);
_;
}
modifier vaultExists(uint256 vaultID) {
require(_exists(vaultID), "Vault does not exist");
_;
}
modifier frontExists(uint256 vaultID) {
require(_exists(vaultID), "front end vault does not exist");
require(promoter[vaultID] <= TEN_THOUSAND && promoter[vaultID] > 0, "Front end not added");
_;
}
function getDebtCeiling() public view returns (uint256) {
return mai.balanceOf(address(this));
}
function exists(uint256 vaultID) external view returns (bool) {
return _exists(vaultID);
}
function getTotalValueLocked() external view returns (uint256) {
return ( getEthPriceSource() * decimalDifferenceRaisedToTen * collateral.balanceOf(address(this)) ) ;
}
function getClosingFee() external view returns (uint256) {
return closingFee;
}
function getTokenPriceSource() public view returns (uint256) {
return tokenPeg;
}
function getEthPriceSource() public view returns (uint256) {
return ethPriceSource.latestAnswer();
}
function _vaultDebtAndFee(uint256 vaultID)
internal
view
returns (uint256, uint256)
{
uint256 currentTime = block.timestamp;
uint256 debt = accumulatedVaultDebt[vaultID];
uint256 fee = 0;
if (lastInterest[vaultID] != 0 && iR > 0) {
uint256 timeDelta = currentTime - lastInterest[vaultID];
uint256 feeAccrued = (((iR * debt) * timeDelta) / ONE_YEAR) / TEN_THOUSAND;
fee = feeAccrued;
debt = feeAccrued + debt;
}
return (fee, debt);
}
function vaultDebt(uint256 vaultID) public view returns (uint256) {
(, uint256 debt) = _vaultDebtAndFee(vaultID);
return debt;
}
function updateVaultDebt(uint256 vaultID) public returns (uint256) {
(uint256 fee, uint256 debt) = _vaultDebtAndFee(vaultID);
maiDebt = maiDebt + fee;
totalBorrowed = totalBorrowed + fee;
if(iR > 0) {
lastInterest[vaultID] = block.timestamp;
}
accumulatedVaultDebt[vaultID] = debt;
return debt;
}
function calculateCollateralProperties(uint256 _collateral, uint256 _debt)
private
view
returns (uint256, uint256)
{
require(getEthPriceSource() != 0);
require(getTokenPriceSource() != 0);
uint256 collateralValue = _collateral *
getEthPriceSource() *
decimalDifferenceRaisedToTen;
require(collateralValue >= _collateral);
uint256 debtValue = _debt * getTokenPriceSource();
require(debtValue >= _debt);
uint256 collateralValueTimes100 = collateralValue * 100;
require(collateralValueTimes100 > collateralValue);
return (collateralValueTimes100, debtValue);
}
function isValidCollateral(uint256 _collateral, uint256 debt)
public
view
returns (bool)
{
(
uint256 collateralValueTimes100,
uint256 debtValue
) = calculateCollateralProperties(_collateral, debt);
uint256 collateralPercentage = collateralValueTimes100 / debtValue;
return collateralPercentage >= _minimumCollateralPercentage;
}
function calculateFee(
uint256 fee,
uint256 amount,
uint256 promoFee
) public view returns (uint256) {
uint256 _fee;
if (promoFee>0) {
_fee = ((amount * fee * getTokenPriceSource() * promoFee) /
(getEthPriceSource() * TEN_THOUSAND * TEN_THOUSAND));
} else {
_fee = (amount * fee * getTokenPriceSource()) /
(getEthPriceSource() * TEN_THOUSAND);
}
return _fee / decimalDifferenceRaisedToTen;
}
function createVault() public returns (uint256) {
uint256 id = vaultCount;
vaultCount = vaultCount + 1;
require(vaultCount >= id);
_mint(msg.sender, id);
emit CreateVault(id, msg.sender);
return id;
}
function destroyVault(uint256 vaultID)
external
onlyVaultOwner(vaultID)
nonReentrant
{
require(vaultDebt(vaultID) == 0, "Vault has outstanding debt");
if (vaultCollateral[vaultID] != 0) {
collateral.safeTransfer(ownerOf(vaultID), vaultCollateral[vaultID]);
}
_burn(vaultID);
delete vaultCollateral[vaultID];
delete accumulatedVaultDebt[vaultID];
delete lastInterest[vaultID];
emit DestroyVault(vaultID);
}
function depositCollateral(uint256 vaultID, uint256 amount)
external
vaultExists(vaultID)
onlyRouter
{
uint256 newCollateral = vaultCollateral[vaultID] + (amount);
require(newCollateral >= vaultCollateral[vaultID]);
vaultCollateral[vaultID] = newCollateral;
collateral.safeTransferFrom(msg.sender, address(this), amount);
emit DepositCollateral(vaultID, amount);
}
function withdrawCollateral(uint256 vaultID, uint256 amount)
external
onlyVaultOwner(vaultID)
nonReentrant
{
require(
vaultCollateral[vaultID] >= amount,
"Vault does not have enough collateral"
);
uint256 newCollateral = vaultCollateral[vaultID] - amount;
uint256 debt = updateVaultDebt(vaultID);
if (debt != 0) {
require(
isValidCollateral(newCollateral, debt),
"Withdrawal would put vault below minimum collateral percentage"
);
}
vaultCollateral[vaultID] = newCollateral;
collateral.safeTransfer(msg.sender, amount);
emit WithdrawCollateral(vaultID, amount);
}
function borrowToken(
uint256 vaultID,
uint256 amount,
uint256 _front
) external
frontExists(_front)
onlyVaultOwner(vaultID)
nonReentrant
{
require(amount > 0, "Must borrow non-zero amount");
require(
amount <= getDebtCeiling(),
"borrowToken: Cannot mint over available supply."
);
uint256 newDebt = updateVaultDebt(vaultID) + amount;
require(newDebt<=maxDebt, "borrowToken: max loan cap reached.");
require(newDebt > vaultDebt(vaultID));
require(
isValidCollateral(vaultCollateral[vaultID], newDebt),
"Borrow would put vault below minimum collateral percentage"
);
require(
((vaultDebt(vaultID)) + amount) >= minDebt,
"Vault debt can't be under minDebt"
);
accumulatedVaultDebt[vaultID] = newDebt;
uint256 _openingFee = calculateFee(openingFee, newDebt, promoter[_front]);
vaultCollateral[vaultID] = vaultCollateral[vaultID] - (_openingFee);
vaultCollateral[_front] = vaultCollateral[_front] + (_openingFee);
mai.safeTransfer(msg.sender, amount);
totalBorrowed = totalBorrowed + (amount);
emit BorrowToken(vaultID, amount);
}
function paybackTokenAll(
uint256 vaultID,
uint256 deadline,
uint256 _front
) external frontExists(_front) vaultExists(vaultID) onlyRouter {
require(
deadline >= block.timestamp,
"paybackTokenAll: deadline expired."
);
uint256 _amount = updateVaultDebt(vaultID);
payBackToken(vaultID, _amount, _front);
}
function payBackToken(
uint256 vaultID,
uint256 amount,
uint256 _front
) public frontExists(_front) vaultExists(vaultID) onlyRouter {
require(mai.balanceOf(msg.sender) >= amount, "Token balance too low");
uint256 vaultDebtNow = updateVaultDebt(vaultID);
require(
vaultDebtNow >= amount,
"Vault debt less than amount to pay back"
);
require(
((vaultDebtNow) - amount) >= minDebt || amount == (vaultDebtNow),
"Vault debt can't be under minDebt"
);
uint256 _closingFee = calculateFee(
closingFee,
amount,
promoter[_front]
);
accumulatedVaultDebt[vaultID] = vaultDebtNow - amount;
vaultCollateral[vaultID] = vaultCollateral[vaultID] - _closingFee;
vaultCollateral[_front] = vaultCollateral[_front] + _closingFee;
totalBorrowed = totalBorrowed - amount;
mai.safeTransferFrom(msg.sender, address(this), amount);
emit PayBackToken(vaultID, amount, _closingFee);
}
function getPaid() external nonReentrant {
require(maticDebt[msg.sender] != 0, "Don't have anything for you.");
uint256 amount = maticDebt[msg.sender];
maticDebt[msg.sender] = 0;
collateral.safeTransfer(msg.sender, amount);
}
function getPaid(address pay) external nonReentrant {
require(maticDebt[pay] != 0, "Don't have anything for you.");
uint256 amount = maticDebt[pay];
maticDebt[pay] = 0;
collateral.safeTransfer(pay, amount);
}
function checkCost(uint256 vaultID) public view returns (uint256) {
uint256 vaultDebtNow = vaultDebt(vaultID);
if (
vaultCollateral[vaultID] == 0 ||
vaultDebtNow == 0 ||
!checkLiquidation(vaultID)
) {
return 0;
}
(,
uint256 debtValue
) = calculateCollateralProperties(
vaultCollateral[vaultID],
vaultDebtNow
);
if (debtValue == 0) {
return 0;
}
debtValue = debtValue / (10**priceSourceDecimals);
uint256 halfDebt = debtValue / debtRatio;
if (halfDebt <= minDebt) {
halfDebt = debtValue;
}
return (halfDebt);
}
function checkExtract(uint256 vaultID) public view returns (uint256) {
if (vaultCollateral[vaultID] == 0 || !checkLiquidation(vaultID)) {
return 0;
}
uint256 vaultDebtNow = vaultDebt(vaultID);
(, uint256 debtValue) = calculateCollateralProperties(
vaultCollateral[vaultID],
vaultDebtNow
);
uint256 halfDebt = debtValue / debtRatio;
if (halfDebt == 0) {
return 0;
}
if ((halfDebt) / (10**priceSourceDecimals) <= minDebt) {
return (debtValue * ( gainRatio)) / (THOUSAND) / (getEthPriceSource()) / decimalDifferenceRaisedToTen;
} else {
return (halfDebt * (gainRatio)) / THOUSAND / (getEthPriceSource()) / decimalDifferenceRaisedToTen;
}
}
function checkCollateralPercentage(uint256 vaultID)
public
view
vaultExists(vaultID)
returns (uint256)
{
uint256 vaultDebtNow = vaultDebt(vaultID);
if (vaultCollateral[vaultID] == 0 || vaultDebtNow == 0) {
return 0;
}
(
uint256 collateralValueTimes100,
uint256 debtValue
) = calculateCollateralProperties(
vaultCollateral[vaultID],
vaultDebtNow
);
return collateralValueTimes100 / (debtValue);
}
function checkLiquidation(uint256 vaultID)
public
view
vaultExists(vaultID)
returns (bool)
{
uint256 vaultDebtNow = vaultDebt(vaultID);
if (vaultCollateral[vaultID] == 0 || vaultDebtNow == 0) {
return false;
}
(
uint256 collateralValueTimes100,
uint256 debtValue
) = calculateCollateralProperties(
vaultCollateral[vaultID],
vaultDebtNow
);
uint256 collateralPercentage = collateralValueTimes100 / (debtValue);
if (collateralPercentage < _minimumCollateralPercentage) {
return true;
} else {
return false;
}
}
function checkRiskyVault(uint256 vaultID) public view vaultExists(vaultID) returns (bool) {
uint256 vaultDebtNow = vaultDebt(vaultID);
if (vaultCollateral[vaultID] == 0 || vaultDebtNow == 0) {
return false;
}
(
uint256 collateralValueTimes100,
uint256 debtValue
) = calculateCollateralProperties(
vaultCollateral[vaultID],
vaultDebtNow
);
uint256 collateralPercentage = collateralValueTimes100 / (debtValue);
if ((collateralPercentage*10) <= gainRatio) {
return true;
} else {
return false;
}
}
function liquidateVault(uint256 vaultID, uint256 _front)
external
frontExists(_front)
vaultExists(vaultID)
{
require(
stabilityPool == address(0) || msg.sender == stabilityPool,
"liquidation is disabled for public"
);
uint256 vaultDebtNow = updateVaultDebt(vaultID);
(
uint256 collateralValueTimes100,
uint256 debtValue
) = calculateCollateralProperties(
vaultCollateral[vaultID],
vaultDebtNow
);
require(vaultDebtNow != 0, "Vault debt is 0");
uint256 collateralPercentage = collateralValueTimes100 / (debtValue);
require(
collateralPercentage < _minimumCollateralPercentage,
"Vault is not below minimum collateral percentage"
);
require(collateralPercentage * 10 > gainRatio , "Vault is not above gain ratio");
debtValue = debtValue / (10**priceSourceDecimals);
uint256 halfDebt = debtValue / (debtRatio);
if (halfDebt <= minDebt) {
halfDebt = debtValue;
}
require(
mai.balanceOf(msg.sender) >= halfDebt,
"Token balance too low to pay off outstanding debt"
);
totalBorrowed = totalBorrowed - (halfDebt);
uint256 maticExtract = checkExtract(vaultID);
accumulatedVaultDebt[vaultID] = vaultDebtNow - (halfDebt);
uint256 _closingFee = calculateFee(closingFee, halfDebt, promoter[_front]);
vaultCollateral[vaultID] = vaultCollateral[vaultID] - (_closingFee);
vaultCollateral[_front] = vaultCollateral[_front] + (_closingFee);
vaultCollateral[vaultID] = vaultCollateral[vaultID] - (maticExtract);
maticDebt[msg.sender] = maticDebt[msg.sender] + (maticExtract);
mai.safeTransferFrom(msg.sender, address(this), halfDebt);
emit LiquidateVault(
vaultID,
ownerOf(vaultID),
msg.sender,
halfDebt,
maticExtract,
_closingFee
);
}
function buyRiskDebtVault(uint256 vaultID) external vaultExists(vaultID) nonReentrant returns(uint256) {
require(
stabilityPool == address(0) || msg.sender == stabilityPool,
"buy risky is disabled for public"
);
uint256 vaultDebtNow = updateVaultDebt(vaultID);
require(vaultDebtNow != 0, "Vault debt is 0");
(
uint256 collateralValueTimes100,
uint256 debtValue
) = calculateCollateralProperties(
vaultCollateral[vaultID],
vaultDebtNow
);
uint256 collateralPercentage = collateralValueTimes100 / (debtValue);
require(
(collateralPercentage*10) <= gainRatio,
"Vault is not below risky collateral percentage"
);
uint256 maiDebtTobePaid = (debtValue / (10**priceSourceDecimals)) -
(collateralValueTimes100 /
( _minimumCollateralPercentage * (10**priceSourceDecimals)));
require(mai.balanceOf(msg.sender) >= maiDebtTobePaid, "Not enough mai to buy the risky vault");
mai.safeTransferFrom(msg.sender, address(this), maiDebtTobePaid);
totalBorrowed = totalBorrowed - (maiDebtTobePaid);
uint256 newVault = createVault();
vaultCollateral[newVault] = vaultCollateral[vaultID];
accumulatedVaultDebt[newVault] = vaultDebtNow - maiDebtTobePaid;
lastInterest[newVault] = block.timestamp;
delete vaultCollateral[vaultID];
delete accumulatedVaultDebt[vaultID];
emit BoughtRiskyDebtVault(vaultID, newVault, msg.sender, maiDebtTobePaid);
return newVault;
}
}
pragma solidity 0.8.11;
contract stableQiVault is fixedVault, Ownable {
uint256 constant FEE_MAX = 500;
string private oracleType;
constructor(
address ethPriceSourceAddress,
uint256 minimumCollateralPercentage,
string memory name,
string memory symbol,
address _mai,
address _collateral,
string memory baseURI
)
fixedVault(
ethPriceSourceAddress,
minimumCollateralPercentage,
name,
symbol,
_mai,
_collateral,
baseURI
)
{
createVault();
addFrontEnd(0);
}
event UpdatedClosingFee(uint256 newFee);
event UpdatedOpeningFee(uint256 newFee);
event WithdrawInterest(uint256 earned);
event UpdatedMinDebt(uint256 newMinDebt);
event UpdatedMaxDebt(uint256 newMaxDebt);
event UpdatedDebtRatio(uint256 _debtRatio);
event UpdatedGainRatio(uint256 _gainRatio);
event UpdatedEthPriceSource(address _ethPriceSourceAddress);
event AddedFrontEnd(uint256 promoter);
event RemovedFrontEnd(uint256 promoter);
event UpdatedFrontEnd(uint256 promoter, uint256 newFee);
event UpdatedFees(uint256 _adminFee, uint256 _refFee);
event UpdatedMinCollateralRatio(uint256 newMinCollateralRatio);
event UpdatedStabilityPool(address pool);
event UpdatedInterestRate(uint256 interestRate);
event BurnedToken(uint256 amount);
event UpdatedTokenURI(string uri);
event UpdatedAdmin(address newAdmin);
event UpdatedRef(address newRef);
event UpdatedOracleName(string oracle);
event UpdatedRouter(address router);
event UpdatedCustomURI(bool custom);
modifier onlyOperators() {
require(ref == msg.sender || adm == msg.sender || owner() == msg.sender, "Needs to be called by operators");
_;
}
modifier onlyAdmin() {
require(adm == msg.sender, "Needs to be called by admin");
_;
}
function updateOracleName(string memory _oracle) external onlyOwner {
oracleType = _oracle;
emit UpdatedOracleName(_oracle);
}
function setGainRatio(uint256 _gainRatio) external onlyOwner {
require(_gainRatio >= 1000, "gainRatio cannot be less than or equal to 1000");
gainRatio = _gainRatio;
emit UpdatedGainRatio(gainRatio);
}
function setDebtRatio(uint256 _debtRatio) external onlyOwner {
require(_debtRatio != 0, "Debt Ratio cannot be 0");
debtRatio = _debtRatio;
emit UpdatedDebtRatio(debtRatio);
}
function changeEthPriceSource(address ethPriceSourceAddress)
external
onlyOwner
{
require(ethPriceSourceAddress != address(0), "Ethpricesource cannot be zero address" );
ethPriceSource = IPriceSource(ethPriceSourceAddress);
emit UpdatedEthPriceSource(ethPriceSourceAddress);
}
function setStabilityPool(address _pool) external onlyOwner {
require(_pool != address(0), "StabilityPool cannot be zero address" );
stabilityPool = _pool;
emit UpdatedStabilityPool(stabilityPool);
}
function setFees(uint256 _admin, uint256 _ref) external onlyOwner {
require((_admin+_ref)==TEN_THOUSAND, "setFees: must equal 10000.");
adminFee=_admin;
refFee=_ref;
emit UpdatedFees(adminFee, refFee);
}
function setMinCollateralRatio(uint256 minimumCollateralPercentage)
external
onlyOwner
{
_minimumCollateralPercentage = minimumCollateralPercentage;
emit UpdatedMinCollateralRatio(_minimumCollateralPercentage);
}
function setMinDebt(uint256 _minDebt)
external
onlyOwner
{
require(_minDebt >=0, "setMinDebt: must be over 0.");
minDebt = _minDebt;
emit UpdatedMinDebt(minDebt);
}
function setMaxDebt(uint256 _maxDebt)
external
onlyOwner
{
require(_maxDebt >=0, "setMaxDebt: must be over 0.");
maxDebt = _maxDebt;
emit UpdatedMaxDebt(maxDebt);
}
function setRef(address _ref) external onlyOwner {
require(_ref != address(0), "Reference Address cannot be zero");
ref = _ref;
emit UpdatedRef(ref);
}
function setAdmin(address _adm) external onlyOwner {
require(_adm != address(0), "Admin Address cannot be zero");
adm = _adm;
emit UpdatedAdmin(adm);
}
function setOpeningFee(uint256 _openingFee) external onlyOwner {
require(_openingFee >= 0 && _openingFee <= FEE_MAX, "setOpeningFee: cannot be more than 5%");
openingFee = _openingFee;
emit UpdatedOpeningFee(openingFee);
}
function setClosingFee(uint256 _closingFee) external onlyOwner {
require(_closingFee >= 0 && _closingFee <= FEE_MAX, "setClosingFee: cannot be more than 5%");
closingFee = _closingFee;
emit UpdatedClosingFee(closingFee);
}
function addFrontEnd(uint256 _promoter) public onlyOwner {
require(_exists(_promoter), "addFrontEnd: Vault does not exist");
require(promoter[_promoter] == 0, "addFrontEnd: already added");
promoter[_promoter] = TEN_THOUSAND;
emit AddedFrontEnd(_promoter);
}
function updateFrontEnd(uint256 _promoter, uint256 cashback) external frontExists(_promoter) onlyVaultOwner(_promoter) {
require(cashback > 0 && cashback <= TEN_THOUSAND, "updateFrontEnd: cannot be 0");
promoter[_promoter] = cashback;
emit UpdatedFrontEnd(_promoter, cashback);
}
function removeFrontEnd(uint256 _promoter) external frontExists(_promoter) onlyOwner {
require(_exists(_promoter), "removeFrontEnd: Vault does not exist");
require(promoter[_promoter] > 0, "removeFrontEnd: not a front end");
promoter[_promoter] = 0;
emit RemovedFrontEnd(_promoter);
}
function withdrawInterest() external onlyOperators nonReentrant {
uint256 adm_fee = maiDebt*adminFee / TEN_THOUSAND;
mai.transfer(ref, (maiDebt-adm_fee) );
mai.transfer(adm, adm_fee);
emit WithdrawInterest(maiDebt);
maiDebt = 0;
}
function setInterestRate(uint256 _iR) external onlyOwner {
iR = _iR;
emit UpdatedInterestRate(iR);
}
function burn(uint256 amountToken) external onlyAdmin {
require(amountToken <= mai.balanceOf(address(this)), "burn: Balance not enough");
mai.transfer(ref, amountToken);
emit BurnedToken(amountToken);
}
function setTokenURI(string calldata _baseURI) external onlyOwner {
baseURI = _baseURI;
emit UpdatedTokenURI(baseURI);
}
function setRouter(address _router) external onlyOwner {
router=_router;
emit UpdatedRouter(router);
}
function setCustomURI(bool _custom) external onlyOwner {
custom=_custom;
emit UpdatedCustomURI(custom);
}
}
