编译器
0.8.15+commit.e14f2714
文件 1 的 54：Address.sol
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 functionCall(target, data, "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");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(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) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(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) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
文件 2 的 54：AddressUpgradeable.sol
pragma solidity ^0.8.1;
library AddressUpgradeable {
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 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);
}
}
}
文件 3 的 54：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;
}
}
文件 4 的 54：ContextUpgradeable.sol
pragma solidity ^0.8.0;
import "../proxy/utils/Initializable.sol";
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal onlyInitializing {
}
function __Context_init_unchained() internal onlyInitializing {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
uint256[50] private __gap;
}
文件 5 的 54：Create2Upgradeable.sol
pragma solidity ^0.8.0;
library Create2Upgradeable {
function deploy(
uint256 amount,
bytes32 salt,
bytes memory bytecode
) internal returns (address addr) {
require(address(this).balance >= amount, "Create2: insufficient balance");
require(bytecode.length != 0, "Create2: bytecode length is zero");
assembly {
addr := create2(amount, add(bytecode, 0x20), mload(bytecode), salt)
}
require(addr != address(0), "Create2: Failed on deploy");
}
function computeAddress(bytes32 salt, bytes32 bytecodeHash) internal view returns (address) {
return computeAddress(salt, bytecodeHash, address(this));
}
function computeAddress(
bytes32 salt,
bytes32 bytecodeHash,
address deployer
) internal pure returns (address addr) {
assembly {
let ptr := mload(0x40)
mstore(add(ptr, 0x40), bytecodeHash)
mstore(add(ptr, 0x20), salt)
mstore(ptr, deployer)
let start := add(ptr, 0x0b)
mstore8(start, 0xff)
addr := keccak256(start, 85)
}
}
}
文件 6 的 54：ERC165Upgradeable.sol
pragma solidity ^0.8.0;
import "./IERC165Upgradeable.sol";
import "../../proxy/utils/Initializable.sol";
abstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {
function __ERC165_init() internal onlyInitializing {
}
function __ERC165_init_unchained() internal onlyInitializing {
}
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165Upgradeable).interfaceId;
}
uint256[50] private __gap;
}
文件 7 的 54：ERC20FlashMintUpgradeable.sol
pragma solidity ^0.8.0;
import {Initializable} from "@openzeppelin-upgradeable/contracts/proxy/utils/Initializable.sol";
import {ERC20Upgradeable} from "@src/custom/tokens/ERC20/ERC20Upgradeable.sol";
import {IERC3156FlashLenderUpgradeable} from "@openzeppelin-upgradeable/contracts/interfaces/IERC3156FlashLenderUpgradeable.sol";
import {IERC3156FlashBorrowerUpgradeable} from "@openzeppelin-upgradeable/contracts/interfaces/IERC3156FlashBorrowerUpgradeable.sol";
abstract contract ERC20FlashMintUpgradeable is
Initializable,
ERC20Upgradeable,
IERC3156FlashLenderUpgradeable
{
error WrongToken();
error AmountExceedsMaxFlashLoan();
error InvalidReturnValue();
function __ERC20FlashMint_init() internal onlyInitializing {}
function __ERC20FlashMint_init_unchained() internal onlyInitializing {}
bytes32 private constant _RETURN_VALUE =
keccak256("ERC3156FlashBorrower.onFlashLoan");
function maxFlashLoan(
address token
) public view virtual override returns (uint256) {
return
token == address(this)
? type(uint256).max - ERC20Upgradeable.totalSupply()
: 0;
}
function flashFee(
address token,
uint256 amount
) public view virtual override returns (uint256) {
if (token != address(this)) revert WrongToken();
return _flashFee(token, amount);
}
function _flashFee(
address token,
uint256 amount
) internal view virtual returns (uint256) {
token;
amount;
return 0;
}
function _flashFeeReceiver() internal view virtual returns (address) {
return address(0);
}
function flashLoan(
IERC3156FlashBorrowerUpgradeable receiver,
address token,
uint256 amount,
bytes calldata data
) public virtual override returns (bool) {
if (amount > maxFlashLoan(token)) revert AmountExceedsMaxFlashLoan();
uint256 fee = flashFee(token, amount);
_mint(address(receiver), amount);
if (
receiver.onFlashLoan(msg.sender, token, amount, fee, data) !=
_RETURN_VALUE
) revert InvalidReturnValue();
address flashFeeReceiver = _flashFeeReceiver();
_spendAllowance(address(receiver), address(this), amount + fee);
if (fee == 0 || flashFeeReceiver == address(0)) {
_burn(address(receiver), amount + fee);
} else {
_burn(address(receiver), amount);
_transfer(address(receiver), flashFeeReceiver, fee);
}
return true;
}
uint256[50] private __gap;
}
文件 8 的 54：ERC20Upgradeable.sol
pragma solidity ^0.8.0;
import {Initializable} from "@openzeppelin-upgradeable/contracts/proxy/utils/Initializable.sol";
import {IERC20Upgradeable} from "@openzeppelin-upgradeable/contracts/token/ERC20/IERC20Upgradeable.sol";
import {ContextUpgradeable} from "@openzeppelin-upgradeable/contracts/utils/ContextUpgradeable.sol";
import {IERC20MetadataUpgradeable} from "@openzeppelin-upgradeable/contracts/token/ERC20/extensions/IERC20MetadataUpgradeable.sol";
contract ERC20Upgradeable is
Initializable,
ContextUpgradeable,
IERC20Upgradeable,
IERC20MetadataUpgradeable
{
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
event MetadataUpdated(string name, string symbol);
error DecreasedAllowanceBelowZero();
error TransferFromZeroAddress();
error TransferToZeroAddress();
error TransferAmountExceedsBalance();
error MintToZeroAddress();
error BurnFromZeroAddress();
error BurnAmountExceedsBalance();
error ApproveFromZeroAddress();
error ApproveToZeroAddress();
error InsufficientAllowance();
function __ERC20_init(
string memory name_,
string memory symbol_
) internal onlyInitializing {
__ERC20_init_unchained(name_, symbol_);
}
function __ERC20_init_unchained(
string memory name_,
string memory symbol_
) internal onlyInitializing {
_name = name_;
_symbol = symbol_;
}
function _setMetadata(string memory name_, string memory symbol_) internal {
_name = name_;
_symbol = symbol_;
emit MetadataUpdated(name_, 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);
if (currentAllowance < subtractedValue)
revert DecreasedAllowanceBelowZero();
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
if (from == address(0)) revert TransferFromZeroAddress();
if (to == address(0)) revert TransferToZeroAddress();
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
if (fromBalance < amount) revert TransferAmountExceedsBalance();
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 {
if (account == address(0)) revert MintToZeroAddress();
_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 {
if (account == address(0)) revert BurnFromZeroAddress();
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
if (accountBalance < amount) revert BurnAmountExceedsBalance();
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 {
if (owner == address(0)) revert ApproveFromZeroAddress();
if (spender == address(0)) revert ApproveToZeroAddress();
_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) {
if (currentAllowance < amount) revert InsufficientAllowance();
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 {}
uint256[45] private __gap;
}
文件 9 的 54：ERC721Upgradeable.sol
pragma solidity ^0.8.0;
import "./IERC721Upgradeable.sol";
import "./IERC721ReceiverUpgradeable.sol";
import "./extensions/IERC721MetadataUpgradeable.sol";
import "../../utils/AddressUpgradeable.sol";
import "../../utils/ContextUpgradeable.sol";
import "../../utils/StringsUpgradeable.sol";
import "../../utils/introspection/ERC165Upgradeable.sol";
import "../../proxy/utils/Initializable.sol";
contract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {
using AddressUpgradeable for address;
using StringsUpgradeable 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;
function __ERC721_init(string memory name_, string memory symbol_) internal onlyInitializing {
__ERC721_init_unchained(name_, symbol_);
}
function __ERC721_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {
_name = name_;
_symbol = symbol_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {
return
interfaceId == type(IERC721Upgradeable).interfaceId ||
interfaceId == type(IERC721MetadataUpgradeable).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 = ERC721Upgradeable.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 = ERC721Upgradeable.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 = ERC721Upgradeable.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId, 1);
owner = ERC721Upgradeable.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(ERC721Upgradeable.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId, 1);
require(ERC721Upgradeable.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(ERC721Upgradeable.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 IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
return retval == IERC721ReceiverUpgradeable.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,
uint256 batchSize
) internal virtual {
if (batchSize > 1) {
if (from != address(0)) {
_balances[from] -= batchSize;
}
if (to != address(0)) {
_balances[to] += batchSize;
}
}
}
function _afterTokenTransfer(
address from,
address to,
uint256 firstTokenId,
uint256 batchSize
) internal virtual {}
uint256[44] private __gap;
}
文件 10 的 54：HexStrings.sol
pragma solidity ^0.8.0;
library HexStrings {
bytes16 internal constant ALPHABET = '0123456789abcdef';
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] = ALPHABET[value & 0xf];
value >>= 4;
}
require(value == 0, 'Strings: hex length insufficient');
return string(buffer);
}
function toHexStringNoPrefix(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length);
for (uint256 i = buffer.length; i > 0; i--) {
buffer[i - 1] = ALPHABET[value & 0xf];
value >>= 4;
}
return string(buffer);
}
}
文件 11 的 54：IBeacon.sol
pragma solidity ^0.8.0;
interface IBeacon {
function implementation() external view returns (address);
function upgradeBeaconTo(address newImplementation) external;
}
文件 12 的 54：IERC1155.sol
pragma solidity ^0.8.0;
import "../../utils/introspection/IERC165.sol";
interface IERC1155 is IERC165 {
event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
event TransferBatch(
address indexed operator,
address indexed from,
address indexed to,
uint256[] ids,
uint256[] values
);
event ApprovalForAll(address indexed account, address indexed operator, bool approved);
event URI(string value, uint256 indexed id);
function balanceOf(address account, uint256 id) external view returns (uint256);
function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
external
view
returns (uint256[] memory);
function setApprovalForAll(address operator, bool approved) external;
function isApprovedForAll(address account, address operator) external view returns (bool);
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
function safeBatchTransferFrom(
address from,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data
) external;
}
文件 13 的 54：IERC1155Upgradeable.sol
pragma solidity ^0.8.0;
import "../../utils/introspection/IERC165Upgradeable.sol";
interface IERC1155Upgradeable is IERC165Upgradeable {
event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
event TransferBatch(
address indexed operator,
address indexed from,
address indexed to,
uint256[] ids,
uint256[] values
);
event ApprovalForAll(address indexed account, address indexed operator, bool approved);
event URI(string value, uint256 indexed id);
function balanceOf(address account, uint256 id) external view returns (uint256);
function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
external
view
returns (uint256[] memory);
function setApprovalForAll(address operator, bool approved) external;
function isApprovedForAll(address account, address operator) external view returns (bool);
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
function safeBatchTransferFrom(
address from,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data
) external;
}
文件 14 的 54：IERC165.sol
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
文件 15 的 54：IERC165Upgradeable.sol
pragma solidity ^0.8.0;
interface IERC165Upgradeable {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
文件 16 的 54：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);
}
文件 17 的 54：IERC20MetadataUpgradeable.sol
pragma solidity ^0.8.0;
import "../IERC20Upgradeable.sol";
interface IERC20MetadataUpgradeable is IERC20Upgradeable {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
文件 18 的 54：IERC20Upgradeable.sol
pragma solidity ^0.8.0;
interface IERC20Upgradeable {
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);
}
文件 19 的 54：IERC3156FlashBorrowerUpgradeable.sol
pragma solidity ^0.8.0;
interface IERC3156FlashBorrowerUpgradeable {
function onFlashLoan(
address initiator,
address token,
uint256 amount,
uint256 fee,
bytes calldata data
) external returns (bytes32);
}
文件 20 的 54：IERC3156FlashLenderUpgradeable.sol
pragma solidity ^0.8.0;
import "./IERC3156FlashBorrowerUpgradeable.sol";
interface IERC3156FlashLenderUpgradeable {
function maxFlashLoan(address token) external view returns (uint256);
function flashFee(address token, uint256 amount) external view returns (uint256);
function flashLoan(
IERC3156FlashBorrowerUpgradeable receiver,
address token,
uint256 amount,
bytes calldata data
) external returns (bool);
}
文件 21 的 54：IERC721.sol
pragma solidity ^0.8.0;
import "../../utils/introspection/IERC165.sol";
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);
}
文件 22 的 54：IERC721Enumerable.sol
pragma solidity ^0.8.0;
import "../IERC721.sol";
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);
}
文件 23 的 54：IERC721Metadata.sol
pragma solidity ^0.8.0;
import "../IERC721.sol";
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);
}
文件 24 的 54：IERC721MetadataUpgradeable.sol
pragma solidity ^0.8.0;
import "../IERC721Upgradeable.sol";
interface IERC721MetadataUpgradeable is IERC721Upgradeable {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
文件 25 的 54：IERC721Permit.sol
pragma solidity >=0.7.5;
import '@openzeppelin/contracts/token/ERC721/IERC721.sol';
interface IERC721Permit is IERC721 {
function PERMIT_TYPEHASH() external pure returns (bytes32);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function permit(
address spender,
uint256 tokenId,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external payable;
}
文件 26 的 54：IERC721ReceiverUpgradeable.sol
pragma solidity ^0.8.0;
interface IERC721ReceiverUpgradeable {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
文件 27 的 54：IERC721Upgradeable.sol
pragma solidity ^0.8.0;
import "../../utils/introspection/IERC165Upgradeable.sol";
interface IERC721Upgradeable is IERC165Upgradeable {
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);
}
文件 28 的 54：INFTXEligibility.sol
pragma solidity ^0.8.0;
interface INFTXEligibility {
function name() external pure returns (string memory);
function finalized() external view returns (bool);
function targetAsset() external pure returns (address);
function checkAllEligible(uint256[] calldata tokenIds)
external
view
returns (bool);
function checkEligible(uint256[] calldata tokenIds)
external
view
returns (bool[] memory);
function checkAllIneligible(uint256[] calldata tokenIds)
external
view
returns (bool);
function checkIsEligible(uint256 tokenId) external view returns (bool);
function __NFTXEligibility_init_bytes(bytes calldata configData) external;
function beforeMintHook(uint256[] calldata tokenIds) external;
function afterMintHook(uint256[] calldata tokenIds) external;
function beforeRedeemHook(uint256[] calldata tokenIds) external;
function afterRedeemHook(uint256[] calldata tokenIds) external;
}
文件 29 的 54：INFTXInventoryStakingV2.sol
pragma solidity ^0.8.0;
interface INFTXInventoryStakingV2 {
function nftxVaultFactory() external view returns (address);
function vaultXToken(uint256 vaultId) external view returns (address);
function xTokenAddr(address baseToken) external view returns (address);
function xTokenShareValue(uint256 vaultId) external view returns (uint256);
function __NFTXInventoryStaking_init(address nftxFactory) external;
function deployXTokenForVault(uint256 vaultId) external;
function receiveRewards(
uint256 vaultId,
uint256 amount
) external returns (bool);
function timelockMintFor(
uint256 vaultId,
uint256 amount,
address to,
uint256 timelockLength
) external returns (uint256);
function deposit(uint256 vaultId, uint256 _amount) external;
function withdraw(uint256 vaultId, uint256 _share) external;
function timelockUntil(
uint256 vaultId,
address who
) external view returns (uint256);
}
文件 30 的 54：INFTXInventoryStakingV3.sol
pragma solidity =0.8.15;
import {IWETH9} from "@uni-periphery/interfaces/external/IWETH9.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {IERC721Upgradeable} from "@openzeppelin-upgradeable/contracts/token/ERC721/ERC721Upgradeable.sol";
import {INFTXVaultFactoryV3} from "@src/interfaces/INFTXVaultFactoryV3.sol";
import {ITimelockExcludeList} from "@src/interfaces/ITimelockExcludeList.sol";
import {IPermitAllowanceTransfer} from "@src/interfaces/external/IPermitAllowanceTransfer.sol";
import {InventoryStakingDescriptor} from "@src/custom/InventoryStakingDescriptor.sol";
interface INFTXInventoryStakingV3 is IERC721Upgradeable {
struct Position {
uint256 nonce;
uint256 vaultId;
uint256 timelockedUntil;
uint256 timelock;
uint256 vTokenTimelockedUntil;
uint256 vTokenShareBalance;
uint256 wethFeesPerVTokenShareSnapshotX128;
uint256 wethOwed;
}
struct VaultGlobal {
uint256 totalVTokenShares;
uint256 globalWethFeesPerVTokenShareX128;
}
function MINIMUM_LIQUIDITY() external view returns (uint256);
function nftxVaultFactory() external view returns (INFTXVaultFactoryV3);
function timelockExcludeList() external view returns (ITimelockExcludeList);
function WETH() external view returns (IWETH9);
function PERMIT2() external returns (IPermitAllowanceTransfer);
function timelock() external view returns (uint256);
function earlyWithdrawPenaltyInWei() external view returns (uint256);
function positions(
uint256 positionId
)
external
view
returns (
uint256 nonce,
uint256 vaultId,
uint256 timelockedUntil,
uint256 timelock,
uint256 vTokenTimelockedUntil,
uint256 vTokenShareBalance,
uint256 wethFeesPerVTokenShareSnapshotX128,
uint256 wethOwed
);
function vaultGlobal(
uint256 vaultId
)
external
view
returns (
uint256 totalVTokenShares,
uint256 globalWethFeesPerVTokenShareX128
);
function descriptor() external view returns (InventoryStakingDescriptor);
event Deposit(
uint256 indexed vaultId,
uint256 indexed positionId,
uint256 amount,
bool forceTimelock
);
event DepositWithNFT(
uint256 indexed vaultId,
uint256 indexed positionId,
uint256[] tokenIds,
uint256[] amounts
);
event IncreasePosition(
uint256 indexed vaultId,
uint256 indexed positionId,
uint256 amount
);
event CombinePositions(
uint256 parentPositionId,
uint256[] childPositionIds
);
event CollectWethFees(uint256 indexed positionId, uint256 wethAmount);
event Withdraw(
uint256 indexed positionId,
uint256 vTokenShares,
uint256 vTokenAmount,
uint256 wethAmount
);
event UpdateTimelock(uint256 newTimelock);
event UpdateEarlyWithdrawPenalty(uint256 newEarlyWithdrawPenaltyInWei);
error TimelockTooLong();
error InvalidEarlyWithdrawPenalty();
error NotPositionOwner();
error Timelocked();
error VaultIdMismatch();
error ParentChildSame();
error InsufficientVTokens();
error LiquidityBelowMinimum();
error ZeroAddress();
error InsufficientVTokenShares();
error SenderNotFeeDistributor();
error PositionNotCreatedWithVTokens();
error ZeroVTokenShares();
function __NFTXInventoryStaking_init(
uint256 timelock_,
uint256 earlyWithdrawPenaltyInWei_,
ITimelockExcludeList timelockExcludeList_,
InventoryStakingDescriptor descriptor_
) external;
function deposit(
uint256 vaultId,
uint256 amount,
address recipient,
bytes calldata encodedPermit2,
bool viaPermit2,
bool forceTimelock
) external returns (uint256 positionId);
function depositWithNFT(
uint256 vaultId,
uint256[] calldata tokenIds,
uint256[] calldata amounts,
address recipient
) external returns (uint256 positionId);
function increasePosition(
uint256 positionId,
uint256 amount,
bytes calldata encodedPermit2,
bool viaPermit2,
bool forceTimelock
) external;
function withdraw(
uint256 positionId,
uint256 vTokenShares,
uint256[] calldata nftIds,
uint256 vTokenPremiumLimit
) external payable;
function combinePositions(
uint256 parentPositionId,
uint256[] calldata childPositionIds
) external;
function collectWethFees(uint256[] calldata positionIds) external;
function receiveWethRewards(
uint256 vaultId,
uint256 wethAmount
) external returns (bool rewardsDistributed);
function setTimelock(uint256 timelock_) external;
function setEarlyWithdrawPenalty(
uint256 earlyWithdrawPenaltyInWei_
) external;
function setDescriptor(InventoryStakingDescriptor descriptor_) external;
function pricePerShareVToken(
uint256 vaultId
) external view returns (uint256);
function wethBalance(uint256 positionId) external view returns (uint256);
}
文件 31 的 54：INFTXVaultFactoryV2.sol
pragma solidity ^0.8.0;
interface INFTXVaultFactoryV2 {
function owner() external view returns (address);
function numVaults() external view returns (uint256);
function zapContract() external view returns (address);
function zapContracts(address addr) external view returns (bool);
function feeDistributor() external view returns (address);
function eligibilityManager() external view returns (address);
function vault(uint256 vaultId) external view returns (address);
function allVaults() external view returns (address[] memory);
function vaultsForAsset(
address asset
) external view returns (address[] memory);
function isLocked(uint256 id) external view returns (bool);
function excludedFromFees(address addr) external view returns (bool);
function factoryMintFee() external view returns (uint64);
function factoryRandomRedeemFee() external view returns (uint64);
function factoryTargetRedeemFee() external view returns (uint64);
function factoryRandomSwapFee() external view returns (uint64);
function factoryTargetSwapFee() external view returns (uint64);
function vaultFees(
uint256 vaultId
) external view returns (uint256, uint256, uint256, uint256, uint256);
event NewFeeDistributor(address oldDistributor, address newDistributor);
event NewZapContract(address oldZap, address newZap);
event UpdatedZapContract(address zap, bool excluded);
event FeeExclusion(address feeExcluded, bool excluded);
event NewEligibilityManager(address oldEligManager, address newEligManager);
event NewVault(
uint256 indexed vaultId,
address vaultAddress,
address assetAddress
);
event UpdateVaultFees(
uint256 vaultId,
uint256 mintFee,
uint256 randomRedeemFee,
uint256 targetRedeemFee,
uint256 randomSwapFee,
uint256 targetSwapFee
);
event DisableVaultFees(uint256 vaultId);
event UpdateFactoryFees(
uint256 mintFee,
uint256 randomRedeemFee,
uint256 targetRedeemFee,
uint256 randomSwapFee,
uint256 targetSwapFee
);
function __NFTXVaultFactory_init(
address _vaultImpl,
address _feeDistributor
) external;
function createVault(
string calldata name,
string calldata symbol,
address _assetAddress,
bool is1155,
bool allowAllItems
) external returns (uint256);
function setFeeDistributor(address _feeDistributor) external;
function setEligibilityManager(address _eligibilityManager) external;
function setZapContract(address _zapContract, bool _excluded) external;
function setFeeExclusion(address _excludedAddr, bool excluded) external;
function setFactoryFees(
uint256 mintFee,
uint256 randomRedeemFee,
uint256 targetRedeemFee,
uint256 randomSwapFee,
uint256 targetSwapFee
) external;
function setVaultFees(
uint256 vaultId,
uint256 mintFee,
uint256 randomRedeemFee,
uint256 targetRedeemFee,
uint256 randomSwapFee,
uint256 targetSwapFee
) external;
function disableVaultFees(uint256 vaultId) external;
}
文件 32 的 54：INFTXVaultFactoryV3.sol
pragma solidity ^0.8.0;
import {IBeacon} from "@src/custom/proxy/IBeacon.sol";
interface INFTXVaultFactoryV3 is IBeacon {
struct VaultFees {
bool active;
uint64 mintFee;
uint64 redeemFee;
uint64 swapFee;
}
function feeDistributor() external view returns (address);
function eligibilityManager() external view returns (address);
function excludedFromFees(address addr) external view returns (bool);
function factoryMintFee() external view returns (uint64);
function factoryRedeemFee() external view returns (uint64);
function factorySwapFee() external view returns (uint64);
function twapInterval() external view returns (uint32);
function premiumDuration() external view returns (uint256);
function premiumMax() external view returns (uint256);
function depositorPremiumShare() external view returns (uint256);
event NewFeeDistributor(address oldDistributor, address newDistributor);
event FeeExclusion(address feeExcluded, bool excluded);
event NewEligibilityManager(address oldEligManager, address newEligManager);
event NewVault(
uint256 indexed vaultId,
address vaultAddress,
address assetAddress,
string name,
string symbol
);
event UpdateVaultFees(
uint256 vaultId,
uint256 mintFee,
uint256 redeemFee,
uint256 swapFee
);
event DisableVaultFees(uint256 vaultId);
event UpdateFactoryFees(
uint256 mintFee,
uint256 redeemFee,
uint256 swapFee
);
event NewPremiumMax(uint256 premiumMax);
event NewPremiumDuration(uint256 premiumDuration);
event NewDepositorPremiumShare(uint256 depositorPremiumShare);
event NewTwapInterval(uint32 twapInterval);
error FeeDistributorNotSet();
error VaultImplementationNotSet();
error FeeExceedsLimit();
error CallerIsNotVault();
error ZeroTwapInterval();
error DepositorPremiumShareExceedsLimit();
error ZeroAddress();
error ZeroAmountRequested();
error NFTInventoryExceeded();
function __NFTXVaultFactory_init(
address vaultImpl,
uint32 twapInterval_,
uint256 premiumDuration_,
uint256 premiumMax_,
uint256 depositorPremiumShare_
) external;
function setFactoryFees(
uint256 mintFee,
uint256 redeemFee,
uint256 swapFee
) external;
function setVaultFees(
uint256 vaultId,
uint256 mintFee,
uint256 redeemFee,
uint256 swapFee
) external;
function disableVaultFees(uint256 vaultId) external;
function setFeeDistributor(address feeDistributor_) external;
function setFeeExclusion(address excludedAddr, bool excluded) external;
function setEligibilityManager(address eligibilityManager_) external;
function setTwapInterval(uint32 twapInterval_) external;
function setPremiumDuration(uint256 premiumDuration_) external;
function setPremiumMax(uint256 premiumMax_) external;
function setDepositorPremiumShare(uint256 depositorPremiumShare_) external;
function createVault(
string calldata name,
string calldata symbol,
address assetAddress,
bool is1155,
bool allowAllItems
) external returns (uint256 vaultId);
function vaultFees(
uint256 vaultId
)
external
view
returns (uint256 mintFee, uint256 redeemFee, uint256 swapFee);
function isLocked(uint256 id) external view returns (bool);
function vaultsForAsset(
address asset
) external view returns (address[] memory);
function allVaults() external view returns (address[] memory);
function numVaults() external view returns (uint256);
function vault(uint256 vaultId) external view returns (address);
function computeVaultAddress(
address assetAddress,
string memory name,
string memory symbol
) external view returns (address);
function getTwapX96(address pool) external view returns (uint256 priceX96);
function getVTokenPremium721(
uint256 vaultId,
uint256 tokenId
) external view returns (uint256 premium, address depositor);
function getVTokenPremium1155(
uint256 vaultId,
uint256 tokenId,
uint256 amount
)
external
view
returns (
uint256 totalPremium,
uint256[] memory premiums,
address[] memory depositors
);
}
文件 33 的 54：INFTXVaultV2.sol
pragma solidity ^0.8.0;
interface INFTXVaultV2 {
function manager() external view returns (address);
function assetAddress() external view returns (address);
function vaultFactory() external view returns (address);
function eligibilityStorage() external view returns (address);
function is1155() external view returns (bool);
function allowAllItems() external view returns (bool);
function enableMint() external view returns (bool);
function enableRandomRedeem() external view returns (bool);
function enableTargetRedeem() external view returns (bool);
function enableRandomSwap() external view returns (bool);
function enableTargetSwap() external view returns (bool);
function vaultId() external view returns (uint256);
function nftIdAt(uint256 holdingsIndex) external view returns (uint256);
function allHoldings() external view returns (uint256[] memory);
function totalHoldings() external view returns (uint256);
function mintFee() external view returns (uint256);
function randomRedeemFee() external view returns (uint256);
function targetRedeemFee() external view returns (uint256);
function randomSwapFee() external view returns (uint256);
function targetSwapFee() external view returns (uint256);
function vaultFees()
external
view
returns (uint256, uint256, uint256, uint256, uint256);
event VaultInit(
uint256 indexed vaultId,
address assetAddress,
bool is1155,
bool allowAllItems
);
event ManagerSet(address manager);
event EligibilityDeployed(uint256 moduleIndex, address eligibilityAddr);
event EnableMintUpdated(bool enabled);
event EnableRandomRedeemUpdated(bool enabled);
event EnableTargetRedeemUpdated(bool enabled);
event EnableRandomSwapUpdated(bool enabled);
event EnableTargetSwapUpdated(bool enabled);
event Minted(uint256[] nftIds, uint256[] amounts, address to);
event Redeemed(uint256[] nftIds, uint256[] specificIds, address to);
event Swapped(
uint256[] nftIds,
uint256[] amounts,
uint256[] specificIds,
uint256[] redeemedIds,
address to
);
function __NFTXVault_init(
string calldata _name,
string calldata _symbol,
address _assetAddress,
bool _is1155,
bool _allowAllItems
) external;
function finalizeVault() external;
function setVaultMetadata(
string memory name_,
string memory symbol_
) external;
function setVaultFeatures(
bool _enableMint,
bool _enableRandomRedeem,
bool _enableTargetRedeem,
bool _enableRandomSwap,
bool _enableTargetSwap
) external;
function setFees(
uint256 _mintFee,
uint256 _randomRedeemFee,
uint256 _targetRedeemFee,
uint256 _randomSwapFee,
uint256 _targetSwapFee
) external;
function disableVaultFees() external;
function deployEligibilityStorage(
uint256 moduleIndex,
bytes calldata initData
) external returns (address);
function setManager(address _manager) external;
function mint(
uint256[] calldata tokenIds,
uint256[] calldata amounts
) external returns (uint256);
function mintTo(
uint256[] calldata tokenIds,
uint256[] calldata amounts ,
address to
) external returns (uint256);
function redeem(
uint256 nftCount,
uint256[] calldata specificIds
) external returns (uint256[] calldata);
function redeemTo(
uint256 nftCount,
uint256[] calldata specificIds,
address to
) external returns (uint256[] calldata);
function swap(
uint256[] calldata tokenIds,
uint256[] calldata amounts ,
uint256[] calldata specificIds
) external returns (uint256[] calldata);
function swapTo(
uint256[] calldata tokenIds,
uint256[] calldata amounts ,
uint256[] calldata specificIds,
address to
) external returns (uint256[] calldata);
function allValidNFTs(
uint256[] calldata tokenIds
) external view returns (bool);
}
文件 34 的 54：INFTXVaultV3.sol
pragma solidity ^0.8.0;
import {IWETH9} from "@uni-periphery/interfaces/external/IWETH9.sol";
import {INFTXEligibility} from "@src/interfaces/INFTXEligibility.sol";
import {IERC20Upgradeable} from "@openzeppelin-upgradeable/contracts/token/ERC20/IERC20Upgradeable.sol";
import {IERC721Upgradeable} from "@openzeppelin-upgradeable/contracts/token/ERC721/IERC721Upgradeable.sol";
import {INFTXVaultFactoryV3} from "@src/interfaces/INFTXVaultFactoryV3.sol";
import {IERC1155Upgradeable} from "@openzeppelin-upgradeable/contracts/token/ERC1155/IERC1155Upgradeable.sol";
import {IERC3156FlashBorrowerUpgradeable} from "@src/custom/tokens/ERC20/ERC20FlashMintUpgradeable.sol";
interface INFTXVaultV3 is IERC20Upgradeable {
struct TokenDepositInfo {
uint48 timestamp;
address depositor;
}
struct DepositInfo1155 {
uint256 qty;
address depositor;
uint48 timestamp;
}
enum TokenType {
ERC20,
ERC721,
ERC1155
}
function WETH() external view returns (IWETH9);
function assetAddress() external view returns (address);
function vaultFactory() external view returns (INFTXVaultFactoryV3);
function vaultId() external view returns (uint256);
function is1155() external view returns (bool);
function manager() external view returns (address);
function eligibilityStorage() external view returns (INFTXEligibility);
function allowAllItems() external view returns (bool);
function enableMint() external view returns (bool);
function enableRedeem() external view returns (bool);
function enableSwap() external view returns (bool);
function tokenDepositInfo(
uint256 tokenId
) external view returns (uint48 timestamp, address depositor);
function depositInfo1155(
uint256 tokenId,
uint256 index
) external view returns (uint256 qty, address depositor, uint48 timestamp);
function pointerIndex1155(uint256 tokenId) external view returns (uint256);
event VaultInit(
uint256 indexed vaultId,
address assetAddress,
bool is1155,
bool allowAllItems
);
event ManagerSet(address manager);
event EligibilityDeployed(uint256 moduleIndex, address eligibilityAddr);
event EnableMintUpdated(bool enabled);
event EnableRedeemUpdated(bool enabled);
event EnableSwapUpdated(bool enabled);
event Minted(
uint256[] nftIds,
uint256[] amounts,
address to,
address depositor
);
event Redeemed(uint256[] specificIds, address to);
event Swapped(
uint256[] nftIds,
uint256[] amounts,
uint256[] specificIds,
address to,
address depositor
);
event PremiumShared(address depositor, uint256 wethPremium);
event FeesDistributed(uint256 wethFees);
event VaultShutdown(
address assetAddress,
uint256 numItems,
address recipient
);
error ZeroAddress();
error MintingDisabled();
error RedeemDisabled();
error SwapDisabled();
error InsufficientETHSent();
error TransferAmountIsZero();
error TokenLengthMismatch();
error EligibilityAlreadySet();
error NotEligible();
error NotNFTOwner();
error NFTAlreadyOwned();
error NotOwner();
error NotManager();
error Paused();
error TooManyItems();
error IdNotFound();
error HoldingsUpdationFailed();
error InvalidToken();
error PremiumLimitExceeded();
error ETHSent();
error CantRescueAssetToken();
function __NFTXVault_init(
string calldata name_,
string calldata symbol_,
address assetAddress_,
bool is1155_,
bool allowAllItems_
) external;
function finalizeVault() external;
function setVaultMetadata(
string memory name_,
string memory symbol_
) external;
function setVaultFeatures(
bool enableMint_,
bool enableRedeem_,
bool enableSwap_
) external;
function setFees(
uint256 mintFee_,
uint256 redeemFee_,
uint256 swapFee_
) external;
function disableVaultFees() external;
function deployEligibilityStorage(
uint256 moduleIndex,
bytes calldata initData
) external returns (address);
function setManager(address _manager) external;
function updateDelegate() external;
function rescueTokens(
TokenType tt,
address token,
uint256[] calldata ids,
uint256[] calldata amounts
) external;
function shutdown(address recipient, uint256[] calldata tokenIds) external;
function mint(
uint256[] calldata tokenIds,
uint256[] calldata amounts,
address depositor,
address to
) external payable returns (uint256 vTokensMinted);
function redeem(
uint256[] calldata idsOut,
address to,
uint256 wethAmount,
uint256 vTokenPremiumLimit,
bool forceFees
) external payable returns (uint256 ethFees);
function swap(
uint256[] calldata idsIn,
uint256[] calldata amounts,
uint256[] calldata idsOut,
address depositor,
address to,
uint256 vTokenPremiumLimit,
bool forceFees
) external payable returns (uint256 ethFees);
function flashLoan(
IERC3156FlashBorrowerUpgradeable receiver,
address token,
uint256 amount,
bytes calldata data
) external returns (bool);
function nftIdAt(uint256 holdingsIndex) external view returns (uint256);
function allHoldings() external view returns (uint256[] memory);
function totalHoldings() external view returns (uint256);
function holdingsContains(uint256 tokenId) external view returns (bool);
function vaultFees()
external
view
returns (uint256 mintFee, uint256 redeemFee, uint256 swapFee);
function allValidNFTs(
uint256[] calldata tokenIds
) external view returns (bool);
function vTokenToETH(uint256 vTokenAmount) external view returns (uint256);
function depositInfo1155Length(
uint256 tokenId
) external view returns (uint256);
function version() external pure returns (string memory);
}
文件 35 的 54：INonfungiblePositionManager.sol
pragma solidity >=0.7.5;
pragma abicoder v2;
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
import "./IPoolInitializer.sol";
import "./IERC721Permit.sol";
import "./IPeripheryPayments.sol";
import "./IPeripheryImmutableState.sol";
import "../libraries/PoolAddress.sol";
interface INonfungiblePositionManager is
IPoolInitializer,
IPeripheryPayments,
IPeripheryImmutableState,
IERC721Metadata,
IERC721Enumerable,
IERC721Permit
{
event IncreaseLiquidity(
uint256 indexed tokenId,
uint128 liquidity,
uint256 amount0,
uint256 amount1
);
event DecreaseLiquidity(
uint256 indexed tokenId,
uint128 liquidity,
uint256 amount0,
uint256 amount1
);
event Collect(
uint256 indexed tokenId,
address recipient,
uint256 amount0,
uint256 amount1
);
function lockedUntil(uint256 tokenId) external view returns (uint256);
function timelock(uint256 tokenId) external view returns (uint256);
function timelockExcluded(address addr) external view returns (bool);
function setLockedUntil(
uint256 tokenId,
uint256 lockedUntil,
uint256 timelock
) external;
function setTimelockExcluded(address addr, bool isExcluded) external;
function positions(
uint256 tokenId
)
external
view
returns (
uint96 nonce,
address operator,
address token0,
address token1,
uint24 fee,
int24 tickLower,
int24 tickUpper,
uint128 liquidity,
uint256 feeGrowthInside0LastX128,
uint256 feeGrowthInside1LastX128,
uint128 tokensOwed0,
uint128 tokensOwed1
);
struct MintParams {
address token0;
address token1;
uint24 fee;
int24 tickLower;
int24 tickUpper;
uint256 amount0Desired;
uint256 amount1Desired;
uint256 amount0Min;
uint256 amount1Min;
address recipient;
uint256 deadline;
}
function mint(
MintParams calldata params
)
external
payable
returns (
uint256 tokenId,
uint128 liquidity,
uint256 amount0,
uint256 amount1
);
struct IncreaseLiquidityParams {
uint256 tokenId;
uint256 amount0Desired;
uint256 amount1Desired;
uint256 amount0Min;
uint256 amount1Min;
uint256 deadline;
}
function increaseLiquidity(
IncreaseLiquidityParams calldata params
)
external
payable
returns (uint128 liquidity, uint256 amount0, uint256 amount1);
struct DecreaseLiquidityParams {
uint256 tokenId;
uint128 liquidity;
uint256 amount0Min;
uint256 amount1Min;
uint256 deadline;
}
function decreaseLiquidity(
DecreaseLiquidityParams calldata params
) external payable returns (uint256 amount0, uint256 amount1);
struct CollectParams {
uint256 tokenId;
address recipient;
uint128 amount0Max;
uint128 amount1Max;
}
function collect(
CollectParams calldata params
) external payable returns (uint256 amount0, uint256 amount1);
function burn(uint256 tokenId) external payable;
}
文件 36 的 54：IPeripheryImmutableState.sol
pragma solidity >=0.5.0;
interface IPeripheryImmutableState {
function factory() external view returns (address);
function WETH9() external view returns (address);
}
文件 37 的 54：IPeripheryPayments.sol
pragma solidity >=0.7.5;
interface IPeripheryPayments {
function unwrapWETH9(uint256 amountMinimum, address recipient) external payable;
function refundETH() external payable;
function refundETH(address receiver) external payable;
function sweepToken(
address token,
uint256 amountMinimum,
address recipient
) external payable;
}
文件 38 的 54：IPermitAllowanceTransfer.sol
pragma solidity =0.8.15;
interface IPermitAllowanceTransfer {
error AllowanceExpired(uint256 deadline);
error InsufficientAllowance(uint256 amount);
error ExcessiveInvalidation();
event NonceInvalidation(
address indexed owner,
address indexed token,
address indexed spender,
uint48 newNonce,
uint48 oldNonce
);
event Approval(
address indexed owner,
address indexed token,
address indexed spender,
uint160 amount,
uint48 expiration
);
event Permit(
address indexed owner,
address indexed token,
address indexed spender,
uint160 amount,
uint48 expiration,
uint48 nonce
);
event Lockdown(address indexed owner, address token, address spender);
struct PermitDetails {
address token;
uint160 amount;
uint48 expiration;
uint48 nonce;
}
struct PermitSingle {
PermitDetails details;
address spender;
uint256 sigDeadline;
}
struct PermitBatch {
PermitDetails[] details;
address spender;
uint256 sigDeadline;
}
struct PackedAllowance {
uint160 amount;
uint48 expiration;
uint48 nonce;
}
struct TokenSpenderPair {
address token;
address spender;
}
struct AllowanceTransferDetails {
address from;
address to;
uint160 amount;
address token;
}
function allowance(
address,
address,
address
) external view returns (uint160, uint48, uint48);
function approve(
address token,
address spender,
uint160 amount,
uint48 expiration
) external;
function permit(
address owner,
PermitSingle memory permitSingle,
bytes calldata signature
) external;
function permit(
address owner,
PermitBatch memory permitBatch,
bytes calldata signature
) external;
function transferFrom(
address from,
address to,
uint160 amount,
address token
) external;
function transferFrom(
AllowanceTransferDetails[] calldata transferDetails
) external;
function lockdown(TokenSpenderPair[] calldata approvals) external;
function invalidateNonces(
address token,
address spender,
uint48 newNonce
) external;
}
文件 39 的 54：IPoolInitializer.sol
pragma solidity >=0.7.5;
pragma abicoder v2;
interface IPoolInitializer {
function createAndInitializePoolIfNecessary(
address token0,
address token1,
uint24 fee,
uint160 sqrtPriceX96
) external payable returns (address pool);
}
文件 40 的 54：ITimelockExcludeList.sol
pragma solidity ^0.8.0;
interface ITimelockExcludeList {
function isExcluded(
address addr,
uint256 vaultId
) external view returns (bool);
}
文件 41 的 54：IUniswapV2Pair.sol
pragma solidity >=0.5.0;
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
文件 42 的 54：IUniswapV2Router02.sol
pragma solidity =0.8.15;
interface IUniswapV2Router02 {
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapETHForExactTokens(
uint256 amountOut,
address[] calldata path,
address to,
uint256 deadline
) external payable returns (uint256[] memory amounts);
}
文件 43 的 54：IWETH9.sol
pragma solidity =0.8.15;
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
interface IWETH9 is IERC20 {
function deposit() external payable;
function withdraw(uint256) external;
}
文件 44 的 54：Initializable.sol
pragma solidity ^0.8.2;
import "../../utils/AddressUpgradeable.sol";
abstract contract Initializable {
uint8 private _initialized;
bool private _initializing;
event Initialized(uint8 version);
modifier initializer() {
bool isTopLevelCall = !_initializing;
require(
(isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
"Initializable: contract is already initialized"
);
_initialized = 1;
if (isTopLevelCall) {
_initializing = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
emit Initialized(1);
}
}
modifier reinitializer(uint8 version) {
require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
_initialized = version;
_initializing = true;
_;
_initializing = false;
emit Initialized(version);
}
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
function _disableInitializers() internal virtual {
require(!_initializing, "Initializable: contract is initializing");
if (_initialized < type(uint8).max) {
_initialized = type(uint8).max;
emit Initialized(type(uint8).max);
}
}
function _getInitializedVersion() internal view returns (uint8) {
return _initialized;
}
function _isInitializing() internal view returns (bool) {
return _initializing;
}
}
文件 45 的 54：InventoryStakingDescriptor.sol
pragma solidity =0.8.15;
import {Base64} from "base64-sol/base64.sol";
import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
import {HexStrings} from "@uni-periphery/libraries/HexStrings.sol";
contract InventoryStakingDescriptor {
using Strings for uint256;
using HexStrings for uint256;
string internal constant PREFIX = "x";
function renderSVG(
uint256 tokenId,
uint256 vaultId,
address vToken,
string calldata vTokenSymbol,
uint256 vTokenBalance,
uint256 wethBalance,
uint256 timelockLeft
) public pure returns (string memory) {
return
string.concat(
'<svg width="290" height="500" viewBox="0 0 290 500" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">',
getDefs(
tokenToColorHex(uint256(uint160(vToken)), 136),
tokenToColorHex(uint256(uint160(vToken)), 100)
),
'<g mask="url(#fade-symbol)">',
text("32", "70", "200", "32"),
PREFIX,
vTokenSymbol,
"</text>",
underlyingBalances(vTokenSymbol, vTokenBalance, wethBalance),
'<rect x="16" y="16" width="258" height="468" rx="26" ry="26" fill="rgba(0,0,0,0)" stroke="rgba(255,255,255,0.2)"/>',
infoTags(tokenId, vaultId, timelockLeft),
"</svg>"
);
}
function tokenURI(
uint256 tokenId,
uint256 vaultId,
address vToken,
string calldata vTokenSymbol,
uint256 vTokenBalance,
uint256 wethBalance,
uint256 timelockedUntil
) external view returns (string memory) {
string memory image = Base64.encode(
bytes(
renderSVG(
tokenId,
vaultId,
vToken,
vTokenSymbol,
vTokenBalance,
wethBalance,
block.timestamp > timelockedUntil
? 0
: timelockedUntil - block.timestamp
)
)
);
return
string.concat(
"data:application/json;base64,",
Base64.encode(
bytes(
string.concat(
'{"name":"',
string.concat(
"x",
vTokenSymbol,
" #",
tokenId.toString()
),
'", "description":"',
"xNFT representing inventory staking position on NFTX",
'", "image": "',
"data:image/svg+xml;base64,",
image,
'", "attributes": [{"trait_type": "VaultId", "value": "',
vaultId.toString(),
'"}]}'
)
)
)
);
}
function getDefs(
string memory color2,
string memory color3
) private pure returns (string memory) {
return
string.concat(
"<defs>",
'<filter id="f1"><feImage result="p2" xlink:href="data:image/svg+xml;base64,',
Base64.encode(
bytes(
string.concat(
"<svg width='290' height='500' viewBox='0 0 290 500' xmlns='http://www.w3.org/2000/svg'><circle cx='16' cy='232' r='120px' fill='#",
color2,
"'/></svg>"
)
)
),
'"/><feImage result="p3" xlink:href="data:image/svg+xml;base64,',
Base64.encode(
bytes(
string.concat(
"<svg width='290' height='500' viewBox='0 0 290 500' xmlns='http://www.w3.org/2000/svg'><circle cx='20' cy='100' r='130px' fill='#",
color3,
"'/></svg>"
)
)
),
'"/><feBlend mode="exclusion" in2="p2"/><feBlend mode="overlay" in2="p3" result="blendOut"/><feGaussianBlur in="blendOut" stdDeviation="42"/></filter><clipPath id="corners"><rect width="290" height="500" rx="42" ry="42"/></clipPath><filter id="top-region-blur"><feGaussianBlur in="SourceGraphic" stdDeviation="24"/></filter><linearGradient id="grad-symbol"><stop offset="0.7" stop-color="white" stop-opacity="1"/><stop offset=".95" stop-color="white" stop-opacity="0"/></linearGradient><mask id="fade-symbol" maskContentUnits="userSpaceOnUse"><rect width="290px" height="200px" fill="url(#grad-symbol)"/></mask></defs>',
'<g clip-path="url(#corners)"><rect fill="2c9715" x="0px" y="0px" width="290px" height="500px"/><rect style="filter: url(#f1)" x="0px" y="0px" width="290px" height="500px"/><g style="filter:url(#top-region-blur); transform:scale(1.5); transform-origin:center top;"><rect fill="none" x="0px" y="0px" width="290px" height="500px"/><ellipse cx="50%" cy="0px" rx="180px" ry="120px" fill="#000" opacity="0.85"/></g><rect x="0" y="0" width="290" height="500" rx="42" ry="42" fill="rgba(0,0,0,0)" stroke="rgba(255,255,255,0.2)"/></g>'
);
}
function text(
string memory x,
string memory y,
string memory fontWeight,
string memory fontSize
) private pure returns (string memory) {
return text(x, y, fontWeight, fontSize, false);
}
function text(
string memory x,
string memory y,
string memory fontWeight,
string memory fontSize,
bool onlyMonospace
) private pure returns (string memory) {
return
string.concat(
'<text y="',
y,
'px" x="',
x,
'px" fill="white" font-family="',
!onlyMonospace ? "'Courier New', " : "",
'monospace" font-weight="',
fontWeight,
'" font-size="',
fontSize,
'px">'
);
}
function tokenToColorHex(
uint256 token,
uint256 offset
) private pure returns (string memory str) {
return string((token >> offset).toHexStringNoPrefix(3));
}
function balanceTag(
string memory y,
uint256 tokenBalance,
string memory tokenSymbol
) private pure returns (string memory) {
uint256 beforeDecimal = tokenBalance / 1 ether;
string memory afterDecimals = getAfterDecimals(tokenBalance);
uint256 leftPadding = 12;
uint256 beforeDecimalFontSize = 20;
uint256 afterDecimalFontSize = 16;
uint256 width = leftPadding +
((getDigitsCount(beforeDecimal) + 1) * beforeDecimalFontSize) /
2 +
(bytes(afterDecimals).length * afterDecimalFontSize * 100) /
100;
return
string.concat(
'<g style="transform:translate(29px, ',
y,
'px)"><rect width="',
width.toString(),
'px" height="30px" rx="8px" ry="8px" fill="rgba(0,0,0,0.6)"/>',
text(
leftPadding.toString(),
"21",
"100",
beforeDecimalFontSize.toString(),
true
),
beforeDecimal.toString(),
'.<tspan font-size="',
afterDecimalFontSize.toString(),
'px">',
afterDecimals,
'</tspan> <tspan fill="rgba(255,255,255,0.8)">',
tokenSymbol,
"</tspan></text></g>"
);
}
function infoTag(
string memory y,
string memory label,
string memory value
) private pure returns (string memory) {
return
string.concat(
'<g style="transform:translate(29px, ',
y,
'px)"><rect width="98px" height="26px" rx="8px" ry="8px" fill="rgba(0,0,0,0.6)"/>',
text("12", "17", "100", "12"),
'<tspan fill="rgba(255,255,255,0.6)">',
label,
": </tspan>",
value,
"</text></g>"
);
}
function underlyingBalances(
string memory vTokenSymbol,
uint256 vTokenBalance,
uint256 wethBalance
) private pure returns (string memory) {
return
string.concat(
text("32", "160", "200", "16"),
"Underlying Balance</text></g>",
balanceTag("180", vTokenBalance, vTokenSymbol),
balanceTag("220", wethBalance, "WETH")
);
}
function infoTags(
uint256 tokenId,
uint256 vaultId,
uint256 timelockLeft
) private pure returns (string memory) {
return
string.concat(
infoTag("384", "ID", tokenId.toString()),
infoTag("414", "VaultId", vaultId.toString()),
infoTag(
"444",
"Timelock",
timelockLeft > 0
? string.concat(timelockLeft.toString(), "s left")
: "Unlocked"
)
);
}
function getDigitsCount(uint256 num) private pure returns (uint256 count) {
if (num == 0) return 1;
while (num > 0) {
++count;
num /= 10;
}
}
function getAfterDecimals(
uint256 tokenBalance
) private pure returns (string memory afterDecimals) {
uint256 afterDecimal = (tokenBalance % 1 ether) / 10 ** (18 - 10);
uint256 leadingZeroes;
if (afterDecimal == 0) {
leadingZeroes = 0;
} else {
leadingZeroes = 10 - getDigitsCount(afterDecimal);
}
afterDecimals = afterDecimal.toString();
for (uint256 i; i < leadingZeroes; ) {
afterDecimals = string.concat("0", afterDecimals);
unchecked {
++i;
}
}
}
}
文件 46 的 54：MathUpgradeable.sol
pragma solidity ^0.8.0;
library MathUpgradeable {
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);
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 * 8) < value ? 1 : 0);
}
}
}
文件 47 的 54：MigratorZap.sol
pragma solidity =0.8.15;
import {TransferLib} from "@src/lib/TransferLib.sol";
import {IERC20, SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {IWETH9} from "@uni-periphery/interfaces/external/IWETH9.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {IERC1155} from "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import {INFTXVaultV2} from "@src/v2/interfaces/INFTXVaultV2.sol";
import {INFTXVaultV3} from "@src/interfaces/INFTXVaultV3.sol";
import {IUniswapV2Pair} from "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol";
import {IUniswapV2Router02} from "@src/interfaces/external/IUniswapV2Router02.sol";
import {INFTXVaultFactoryV3} from "@src/interfaces/INFTXVaultFactoryV3.sol";
import {INFTXVaultFactoryV2} from "@src/v2/interfaces/INFTXVaultFactoryV2.sol";
import {INFTXInventoryStakingV2} from "@src/v2/interfaces/INFTXInventoryStakingV2.sol";
import {INFTXInventoryStakingV3} from "@src/interfaces/INFTXInventoryStakingV3.sol";
import {INonfungiblePositionManager} from "@uni-periphery/interfaces/INonfungiblePositionManager.sol";
contract MigratorZap is Ownable {
using SafeERC20 for IERC20;
struct SushiToNFTXAMMParams {
address sushiPair;
uint256 lpAmount;
address vTokenV2;
bool is1155;
bytes permitSig;
uint256 vaultIdV3;
int24 tickLower;
int24 tickUpper;
uint24 fee;
uint160 sqrtPriceX96;
uint256 amount0Min;
uint256 amount1Min;
uint256 deadline;
}
uint256 private constant DEADLINE =
0xf000000000000000000000000000000000000000000000000000000000000000;
uint256 private constant DUST_THRESHOLD = 0.005 ether;
uint256 private constant V2_VTOKEN_DUST = 100;
IWETH9 public immutable WETH;
INFTXVaultFactoryV2 public immutable v2NFTXFactory;
INFTXInventoryStakingV2 public immutable v2Inventory;
IUniswapV2Router02 public immutable sushiRouter;
INonfungiblePositionManager public immutable positionManager;
INFTXVaultFactoryV3 public immutable v3NFTXFactory;
INFTXInventoryStakingV3 public immutable v3Inventory;
error InvalidSignatureLength();
constructor(
IWETH9 WETH_,
INFTXVaultFactoryV2 v2NFTXFactory_,
INFTXInventoryStakingV2 v2Inventory_,
IUniswapV2Router02 sushiRouter_,
INonfungiblePositionManager positionManager_,
INFTXVaultFactoryV3 v3NFTXFactory_,
INFTXInventoryStakingV3 v3Inventory_
) {
WETH = WETH_;
v2NFTXFactory = v2NFTXFactory_;
v2Inventory = v2Inventory_;
sushiRouter = sushiRouter_;
positionManager = positionManager_;
v3NFTXFactory = v3NFTXFactory_;
v3Inventory = v3Inventory_;
WETH_.approve(address(positionManager_), type(uint256).max);
}
function sushiToNFTXAMM(
SushiToNFTXAMMParams calldata params
) external returns (uint256 positionId) {
if (params.permitSig.length > 0) {
_permit(params.sushiPair, params.lpAmount, params.permitSig);
}
uint256 wethBalance;
address vTokenV3;
uint256 vTokenV3Balance;
{
uint256 vTokenV2Balance;
(vTokenV2Balance, wethBalance) = _withdrawFromSushi(
params.sushiPair,
params.lpAmount,
params.vTokenV2
);
uint256 wethReceived;
(vTokenV3, vTokenV3Balance, wethReceived) = _v2ToV3Vault(
params.vTokenV2,
vTokenV2Balance,
params.vaultIdV3,
params.is1155,
0
);
wethBalance += wethReceived;
}
bool isVTokenV30 = vTokenV3 < address(WETH);
(
address token0,
address token1,
uint256 amount0,
uint256 amount1
) = isVTokenV30
? (vTokenV3, address(WETH), vTokenV3Balance, wethBalance)
: (address(WETH), vTokenV3, wethBalance, vTokenV3Balance);
positionManager.createAndInitializePoolIfNecessary(
token0,
token1,
params.fee,
params.sqrtPriceX96
);
TransferLib.unSafeMaxApprove(
vTokenV3,
address(positionManager),
vTokenV3Balance
);
uint256 newAmount0;
uint256 newAmount1;
(positionId, , newAmount0, newAmount1) = positionManager.mint(
INonfungiblePositionManager.MintParams({
token0: token0,
token1: token1,
fee: params.fee,
tickLower: params.tickLower,
tickUpper: params.tickUpper,
amount0Desired: amount0,
amount1Desired: amount1,
amount0Min: params.amount0Min,
amount1Min: params.amount1Min,
recipient: msg.sender,
deadline: params.deadline
})
);
if (newAmount0 < amount0) {
IERC20(token0).transfer(msg.sender, amount0 - newAmount0);
}
if (newAmount1 < amount1) {
IERC20(token1).transfer(msg.sender, amount1 - newAmount1);
}
}
function v2InventoryToXNFT(
uint256 vaultIdV2,
uint256 shares,
bool is1155,
uint256 vaultIdV3,
uint256 minWethToReceive
) external returns (uint256 xNFTId) {
address xToken = v2Inventory.vaultXToken(vaultIdV2);
IERC20(xToken).transferFrom(msg.sender, address(this), shares);
v2Inventory.withdraw(vaultIdV2, shares);
address vTokenV2 = v2NFTXFactory.vault(vaultIdV2);
uint256 vTokenV2Balance = IERC20(vTokenV2).balanceOf(address(this));
uint256 numNftsRedeemable = vTokenV2Balance / 1 ether;
uint256 numNftsRedeemableAfterDust = (vTokenV2Balance +
V2_VTOKEN_DUST) / 1 ether;
if (numNftsRedeemableAfterDust > numNftsRedeemable) {
uint256 vTokensToBuy = numNftsRedeemableAfterDust *
1 ether -
vTokenV2Balance;
address[] memory path = new address[](2);
path[0] = address(WETH);
path[1] = vTokenV2;
sushiRouter.swapETHForExactTokens{value: 1_000_000_000}(
vTokensToBuy,
path,
address(this),
block.timestamp
);
vTokenV2Balance = IERC20(vTokenV2).balanceOf(address(this));
}
(
address vTokenV3,
uint256 vTokenV3Balance,
uint256 wethReceived
) = _v2ToV3Vault(
vTokenV2,
vTokenV2Balance,
vaultIdV3,
is1155,
minWethToReceive
);
if (wethReceived > 0) {
WETH.transfer(msg.sender, wethReceived);
}
TransferLib.unSafeMaxApprove(
vTokenV3,
address(v3Inventory),
vTokenV3Balance
);
xNFTId = v3Inventory.deposit(
vaultIdV3,
vTokenV3Balance,
msg.sender,
"",
false,
false
);
}
function v2VaultToXNFT(
address vTokenV2,
uint256 vTokenV2Balance,
bool is1155,
uint256 vaultIdV3,
uint256 minWethToReceive
) external returns (uint256 xNFTId) {
IERC20(vTokenV2).transferFrom(
msg.sender,
address(this),
vTokenV2Balance
);
(
address vTokenV3,
uint256 vTokenV3Balance,
uint256 wethReceived
) = _v2ToV3Vault(
vTokenV2,
vTokenV2Balance,
vaultIdV3,
is1155,
minWethToReceive
);
if (wethReceived > 0) {
WETH.transfer(msg.sender, wethReceived);
}
TransferLib.unSafeMaxApprove(
vTokenV3,
address(v3Inventory),
vTokenV3Balance
);
xNFTId = v3Inventory.deposit(
vaultIdV3,
vTokenV3Balance,
msg.sender,
"",
false,
false
);
}
function rescueTokens(address token) external onlyOwner {
if (token != address(0)) {
uint256 balance = IERC20(token).balanceOf(address(this));
IERC20(token).safeTransfer(msg.sender, balance);
} else {
uint256 balance = address(this).balance;
TransferLib.transferETH(msg.sender, balance);
}
}
function _permit(
address sushiPair,
uint256 lpAmount,
bytes memory permitSig
) internal {
if (permitSig.length != 65) revert InvalidSignatureLength();
bytes32 r;
bytes32 s;
uint8 v;
assembly {
r := mload(add(permitSig, 32))
s := mload(add(permitSig, 64))
v := byte(0, mload(add(permitSig, 96)))
}
IUniswapV2Pair(sushiPair).permit(
msg.sender,
address(this),
lpAmount,
DEADLINE,
v,
r,
s
);
}
function _withdrawFromSushi(
address sushiPair,
uint256 lpAmount,
address vTokenV2
) internal returns (uint256 vTokenV2Balance, uint256 wethBalance) {
IUniswapV2Pair(sushiPair).transferFrom(msg.sender, sushiPair, lpAmount);
(uint256 amount0, uint256 amount1) = IUniswapV2Pair(sushiPair).burn(
address(this)
);
bool isVTokenV20 = vTokenV2 < address(WETH);
(vTokenV2Balance, wethBalance) = isVTokenV20
? (amount0, amount1)
: (amount1, amount0);
}
function _v2ToV3Vault(
address vTokenV2,
uint256 vTokenV2Balance,
uint256 vaultIdV3,
bool is1155,
uint256 minWethToReceive
)
internal
returns (
address vTokenV3,
uint256 vTokenV3Balance,
uint256 wethReceived
)
{
vTokenV3 = v3NFTXFactory.vault(vaultIdV3);
uint256[] memory idsToRedeem;
uint256[] memory idsRedeemed = INFTXVaultV2(vTokenV2).redeemTo(
vTokenV2Balance / 1 ether,
idsToRedeem,
is1155 ? address(this) : vTokenV3
);
if (is1155) {
IERC1155(INFTXVaultV3(vTokenV3).assetAddress()).setApprovalForAll(
vTokenV3,
true
);
}
vTokenV2Balance = vTokenV2Balance % 1 ether;
if (vTokenV2Balance > DUST_THRESHOLD) {
address[] memory path = new address[](2);
path[0] = vTokenV2;
path[1] = address(WETH);
TransferLib.unSafeMaxApprove(
vTokenV2,
address(sushiRouter),
vTokenV2Balance
);
wethReceived = sushiRouter.swapExactTokensForTokens(
vTokenV2Balance,
minWethToReceive,
path,
address(this),
block.timestamp
)[path.length - 1];
} else if (vTokenV2Balance > 0) {
IERC20(vTokenV2).transfer(msg.sender, vTokenV2Balance);
}
uint256[] memory amounts;
if (is1155) {
amounts = new uint256[](idsRedeemed.length);
for (uint256 i; i < idsRedeemed.length; ) {
amounts[i] = 1;
unchecked {
++i;
}
}
}
vTokenV3Balance = INFTXVaultV3(vTokenV3).mint(
idsRedeemed,
amounts,
msg.sender,
address(this)
);
}
receive() external payable {}
}
文件 48 的 54：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());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
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);
}
}
文件 49 的 54：PoolAddress.sol
pragma solidity >=0.5.0;
import {Create2Upgradeable} from "@openzeppelin-upgradeable/contracts/utils/Create2Upgradeable.sol";
library PoolAddress {
bytes32 internal constant BEACON_CODE_HASH =
0x7700ec83d0dc69c0a1e228138168ca93778a8d2f0fe9a0afb44901e1d5142d48;
struct PoolKey {
address token0;
address token1;
uint24 fee;
}
function getPoolKey(
address tokenA,
address tokenB,
uint24 fee
) internal pure returns (PoolKey memory) {
if (tokenA > tokenB) (tokenA, tokenB) = (tokenB, tokenA);
return PoolKey({token0: tokenA, token1: tokenB, fee: fee});
}
function computeAddress(
address factory,
PoolKey memory key
) internal pure returns (address pool) {
require(key.token0 < key.token1);
pool = Create2Upgradeable.computeAddress(
keccak256(abi.encode(key.token0, key.token1, key.fee)),
BEACON_CODE_HASH,
factory
);
}
}
文件 50 的 54：SafeERC20.sol
pragma solidity ^0.8.0;
import "../IERC20.sol";
import "../../../utils/Address.sol";
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 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
文件 51 的 54：Strings.sol
pragma solidity ^0.8.0;
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
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] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}
文件 52 的 54：StringsUpgradeable.sol
pragma solidity ^0.8.0;
import "./math/MathUpgradeable.sol";
library StringsUpgradeable {
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = MathUpgradeable.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 toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, MathUpgradeable.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);
}
}
文件 53 的 54：TransferLib.sol
pragma solidity ^0.8.0;
import {SafeERC20, IERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
library TransferLib {
using SafeERC20 for IERC20;
address internal constant CRYPTO_PUNKS =
0xb47e3cd837dDF8e4c57F05d70Ab865de6e193BBB;
address internal constant CRYPTO_KITTIES =
0x06012c8cf97BEaD5deAe237070F9587f8E7A266d;
error UnableToSendETH();
error NotNFTOwner();
function transferFromERC721(
address assetAddress,
address to,
uint256[] memory nftIds
) internal {
for (uint256 i; i < nftIds.length; ) {
_transferFromERC721(assetAddress, nftIds[i], to);
if (assetAddress == CRYPTO_PUNKS) {
_approveCryptoPunkERC721(nftIds[i], to);
}
unchecked {
++i;
}
}
}
function maxApprove(
address token,
address spender,
uint256 amount
) internal {
uint256 allowance = IERC20(token).allowance(address(this), spender);
if (amount > allowance) {
IERC20(token).safeApprove(spender, type(uint256).max);
}
}
function unSafeMaxApprove(
address token,
address spender,
uint256 amount
) internal {
uint256 allowance = IERC20(token).allowance(address(this), spender);
if (amount > allowance) {
IERC20(token).approve(spender, type(uint256).max);
}
}
function transferETH(address to, uint256 amount) internal {
(bool success, ) = payable(to).call{value: amount}("");
if (!success) revert UnableToSendETH();
}
function _transferFromERC721(
address assetAddr,
uint256 tokenId,
address to
) private {
bytes memory data;
if (assetAddr != CRYPTO_PUNKS && assetAddr != CRYPTO_KITTIES) {
data = abi.encodeWithSignature(
"safeTransferFrom(address,address,uint256)",
msg.sender,
to,
tokenId
);
} else if (assetAddr == CRYPTO_PUNKS) {
bytes memory punkIndexToAddress = abi.encodeWithSignature(
"punkIndexToAddress(uint256)",
tokenId
);
(bool checkSuccess, bytes memory result) = CRYPTO_PUNKS.staticcall(
punkIndexToAddress
);
address nftOwner = abi.decode(result, (address));
if (!checkSuccess || nftOwner != msg.sender) revert NotNFTOwner();
data = abi.encodeWithSignature("buyPunk(uint256)", tokenId);
} else {
data = abi.encodeWithSignature(
"transferFrom(address,address,uint256)",
msg.sender,
address(this),
tokenId
);
}
(bool success, bytes memory resultData) = address(assetAddr).call(data);
require(success, string(resultData));
}
function _approveCryptoPunkERC721(uint256 tokenId, address to) private {
bytes memory data = abi.encodeWithSignature(
"offerPunkForSaleToAddress(uint256,uint256,address)",
tokenId,
0,
to
);
(bool success, bytes memory resultData) = CRYPTO_PUNKS.call(data);
require(success, string(resultData));
}
}
文件 54 的 54：base64.sol
pragma solidity >=0.6.0;
library Base64 {
string internal constant TABLE_ENCODE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
bytes internal constant TABLE_DECODE = hex"0000000000000000000000000000000000000000000000000000000000000000"
hex"00000000000000000000003e0000003f3435363738393a3b3c3d000000000000"
hex"00000102030405060708090a0b0c0d0e0f101112131415161718190000000000"
hex"001a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132330000000000";
function encode(bytes memory data) internal pure returns (string memory) {
if (data.length == 0) return '';
string memory table = TABLE_ENCODE;
uint256 encodedLen = 4 * ((data.length + 2) / 3);
string memory result = new string(encodedLen + 32);
assembly {
mstore(result, encodedLen)
let tablePtr := add(table, 1)
let dataPtr := data
let endPtr := add(dataPtr, mload(data))
let resultPtr := add(result, 32)
for {} lt(dataPtr, endPtr) {}
{
dataPtr := add(dataPtr, 3)
let input := mload(dataPtr)
mstore8(resultPtr, mload(add(tablePtr, and(shr(18, input), 0x3F))))
resultPtr := add(resultPtr, 1)
mstore8(resultPtr, mload(add(tablePtr, and(shr(12, input), 0x3F))))
resultPtr := add(resultPtr, 1)
mstore8(resultPtr, mload(add(tablePtr, and(shr( 6, input), 0x3F))))
resultPtr := add(resultPtr, 1)
mstore8(resultPtr, mload(add(tablePtr, and( input, 0x3F))))
resultPtr := add(resultPtr, 1)
}
switch mod(mload(data), 3)
case 1 { mstore(sub(resultPtr, 2), shl(240, 0x3d3d)) }
case 2 { mstore(sub(resultPtr, 1), shl(248, 0x3d)) }
}
return result;
}
function decode(string memory _data) internal pure returns (bytes memory) {
bytes memory data = bytes(_data);
if (data.length == 0) return new bytes(0);
require(data.length % 4 == 0, "invalid base64 decoder input");
bytes memory table = TABLE_DECODE;
uint256 decodedLen = (data.length / 4) * 3;
bytes memory result = new bytes(decodedLen + 32);
assembly {
let lastBytes := mload(add(data, mload(data)))
if eq(and(lastBytes, 0xFF), 0x3d) {
decodedLen := sub(decodedLen, 1)
if eq(and(lastBytes, 0xFFFF), 0x3d3d) {
decodedLen := sub(decodedLen, 1)
}
}
mstore(result, decodedLen)
let tablePtr := add(table, 1)
let dataPtr := data
let endPtr := add(dataPtr, mload(data))
let resultPtr := add(result, 32)
for {} lt(dataPtr, endPtr) {}
{
dataPtr := add(dataPtr, 4)
let input := mload(dataPtr)
let output := add(
add(
shl(18, and(mload(add(tablePtr, and(shr(24, input), 0xFF))), 0xFF)),
shl(12, and(mload(add(tablePtr, and(shr(16, input), 0xFF))), 0xFF))),
add(
shl( 6, and(mload(add(tablePtr, and(shr( 8, input), 0xFF))), 0xFF)),
and(mload(add(tablePtr, and( input , 0xFF))), 0xFF)
)
)
mstore(resultPtr, shl(232, output))
resultPtr := add(resultPtr, 3)
}
}
return result;
}
}{
"compilationTarget": {
"src/zaps/MigratorZap.sol": "MigratorZap"
},
"evmVersion": "london",
"libraries": {},
"metadata": {
"bytecodeHash": "none",
"useLiteralContent": true
},
"optimizer": {
"enabled": true,
"runs": 800
},
"remappings": [
":@mocks/=src/mocks/",
":@openzeppelin-upgradeable/=lib/openzeppelin-contracts-upgradeable/",
":@openzeppelin/=lib/openzeppelin-contracts/",
":@permit2/=lib/permit2/src/",
":@src/=src/",
":@test/=test/",
":@uni-core/=src/uniswap/v3-core/",
":@uni-periphery/=src/uniswap/v3-periphery/",
":@uniswap/lib/=lib/solidity-lib/",
":@uniswap/v2-core/=lib/v2-core/",
":@uniswap/v3-core/contracts/=src/uniswap/v3-core/",
":base64-sol/=src/uniswap/v3-periphery/libraries/",
":ds-test/=lib/forge-std/lib/ds-test/src/",
":forge-gas-snapshot/=lib/permit2/lib/forge-gas-snapshot/src/",
":forge-std/=lib/forge-std/src/",
":openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/",
":openzeppelin-contracts/=lib/openzeppelin-contracts/",
":permit2/=lib/permit2/",
":solidity-lib/=lib/solidity-lib/contracts/",
":solmate/=lib/permit2/lib/solmate/",
":v2-core/=lib/v2-core/contracts/"
]
}[{"inputs":[{"internalType":"contract IWETH9","name":"WETH_","type":"address"},{"internalType":"contract INFTXVaultFactoryV2","name":"v2NFTXFactory_","type":"address"},{"internalType":"contract INFTXInventoryStakingV2","name":"v2Inventory_","type":"address"},{"internalType":"contract IUniswapV2Router02","name":"sushiRouter_","type":"address"},{"internalType":"contract INonfungiblePositionManager","name":"positionManager_","type":"address"},{"internalType":"contract INFTXVaultFactoryV3","name":"v3NFTXFactory_","type":"address"},{"internalType":"contract INFTXInventoryStakingV3","name":"v3Inventory_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"InvalidSignatureLength","type":"error"},{"inputs":[],"name":"UnableToSendETH","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[],"name":"WETH","outputs":[{"internalType":"contract IWETH9","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"positionManager","outputs":[{"internalType":"contract INonfungiblePositionManager","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"rescueTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"sushiRouter","outputs":[{"internalType":"contract IUniswapV2Router02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"sushiPair","type":"address"},{"internalType":"uint256","name":"lpAmount","type":"uint256"},{"internalType":"address","name":"vTokenV2","type":"address"},{"internalType":"bool","name":"is1155","type":"bool"},{"internalType":"bytes","name":"permitSig","type":"bytes"},{"internalType":"uint256","name":"vaultIdV3","type":"uint256"},{"internalType":"int24","name":"tickLower","type":"int24"},{"internalType":"int24","name":"tickUpper","type":"int24"},{"internalType":"uint24","name":"fee","type":"uint24"},{"internalType":"uint160","name":"sqrtPriceX96","type":"uint160"},{"internalType":"uint256","name":"amount0Min","type":"uint256"},{"internalType":"uint256","name":"amount1Min","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"internalType":"struct MigratorZap.SushiToNFTXAMMParams","name":"params","type":"tuple"}],"name":"sushiToNFTXAMM","outputs":[{"internalType":"uint256","name":"positionId","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"v2Inventory","outputs":[{"internalType":"contract INFTXInventoryStakingV2","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"vaultIdV2","type":"uint256"},{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"bool","name":"is1155","type":"bool"},{"internalType":"uint256","name":"vaultIdV3","type":"uint256"},{"internalType":"uint256","name":"minWethToReceive","type":"uint256"}],"name":"v2InventoryToXNFT","outputs":[{"internalType":"uint256","name":"xNFTId","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"v2NFTXFactory","outputs":[{"internalType":"contract INFTXVaultFactoryV2","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"vTokenV2","type":"address"},{"internalType":"uint256","name":"vTokenV2Balance","type":"uint256"},{"internalType":"bool","name":"is1155","type":"bool"},{"internalType":"uint256","name":"vaultIdV3","type":"uint256"},{"internalType":"uint256","name":"minWethToReceive","type":"uint256"}],"name":"v2VaultToXNFT","outputs":[{"internalType":"uint256","name":"xNFTId","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"v3Inventory","outputs":[{"internalType":"contract INFTXInventoryStakingV3","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"v3NFTXFactory","outputs":[{"internalType":"contract INFTXVaultFactoryV3","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]
