编译器
0.8.20+commit.a1b79de6
文件 1 的 44：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 functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
文件 2 的 44：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 的 44：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;
}
文件 4 的 44：CurveErrorCodes.sol
pragma solidity ^0.8.0;
contract CurveErrorCodes {
enum Error {
OK,
INVALID_NUMITEMS,
SPOT_PRICE_OVERFLOW,
DELTA_OVERFLOW,
SPOT_PRICE_UNDERFLOW
}
}
文件 5 的 44：ERC1155Holder.sol
pragma solidity ^0.8.0;
import "./ERC1155Receiver.sol";
contract ERC1155Holder is ERC1155Receiver {
function onERC1155Received(
address,
address,
uint256,
uint256,
bytes memory
) public virtual override returns (bytes4) {
return this.onERC1155Received.selector;
}
function onERC1155BatchReceived(
address,
address,
uint256[] memory,
uint256[] memory,
bytes memory
) public virtual override returns (bytes4) {
return this.onERC1155BatchReceived.selector;
}
}
文件 6 的 44：ERC1155Receiver.sol
pragma solidity ^0.8.0;
import "../IERC1155Receiver.sol";
import "../../../utils/introspection/ERC165.sol";
abstract contract ERC1155Receiver is ERC165, IERC1155Receiver {
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return interfaceId == type(IERC1155Receiver).interfaceId || super.supportsInterface(interfaceId);
}
}
文件 7 的 44：ERC165.sol
pragma solidity ^0.8.0;
import "./IERC165.sol";
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
文件 8 的 44：ERC165Checker.sol
pragma solidity ^0.8.0;
import "./IERC165.sol";
library ERC165Checker {
bytes4 private constant _INTERFACE_ID_INVALID = 0xffffffff;
function supportsERC165(address account) internal view returns (bool) {
return
supportsERC165InterfaceUnchecked(account, type(IERC165).interfaceId) &&
!supportsERC165InterfaceUnchecked(account, _INTERFACE_ID_INVALID);
}
function supportsInterface(address account, bytes4 interfaceId) internal view returns (bool) {
return supportsERC165(account) && supportsERC165InterfaceUnchecked(account, interfaceId);
}
function getSupportedInterfaces(
address account,
bytes4[] memory interfaceIds
) internal view returns (bool[] memory) {
bool[] memory interfaceIdsSupported = new bool[](interfaceIds.length);
if (supportsERC165(account)) {
for (uint256 i = 0; i < interfaceIds.length; i++) {
interfaceIdsSupported[i] = supportsERC165InterfaceUnchecked(account, interfaceIds[i]);
}
}
return interfaceIdsSupported;
}
function supportsAllInterfaces(address account, bytes4[] memory interfaceIds) internal view returns (bool) {
if (!supportsERC165(account)) {
return false;
}
for (uint256 i = 0; i < interfaceIds.length; i++) {
if (!supportsERC165InterfaceUnchecked(account, interfaceIds[i])) {
return false;
}
}
return true;
}
function supportsERC165InterfaceUnchecked(address account, bytes4 interfaceId) internal view returns (bool) {
bytes memory encodedParams = abi.encodeWithSelector(IERC165.supportsInterface.selector, interfaceId);
bool success;
uint256 returnSize;
uint256 returnValue;
assembly {
success := staticcall(30000, account, add(encodedParams, 0x20), mload(encodedParams), 0x00, 0x20)
returnSize := returndatasize()
returnValue := mload(0x00)
}
return success && returnSize >= 0x20 && returnValue > 0;
}
}
文件 9 的 44：ERC20.sol
pragma solidity >=0.8.0;
abstract contract ERC20 {
event Transfer(address indexed from, address indexed to, uint256 amount);
event Approval(address indexed owner, address indexed spender, uint256 amount);
string public name;
string public symbol;
uint8 public immutable decimals;
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
uint256 internal immutable INITIAL_CHAIN_ID;
bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR;
mapping(address => uint256) public nonces;
constructor(
string memory _name,
string memory _symbol,
uint8 _decimals
) {
name = _name;
symbol = _symbol;
decimals = _decimals;
INITIAL_CHAIN_ID = block.chainid;
INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator();
}
function approve(address spender, uint256 amount) public virtual returns (bool) {
allowance[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function transfer(address to, uint256 amount) public virtual returns (bool) {
balanceOf[msg.sender] -= amount;
unchecked {
balanceOf[to] += amount;
}
emit Transfer(msg.sender, to, amount);
return true;
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual returns (bool) {
uint256 allowed = allowance[from][msg.sender];
if (allowed != type(uint256).max) allowance[from][msg.sender] = allowed - amount;
balanceOf[from] -= amount;
unchecked {
balanceOf[to] += amount;
}
emit Transfer(from, to, amount);
return true;
}
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public virtual {
require(deadline >= block.timestamp, "PERMIT_DEADLINE_EXPIRED");
unchecked {
address recoveredAddress = ecrecover(
keccak256(
abi.encodePacked(
"\x19\x01",
DOMAIN_SEPARATOR(),
keccak256(
abi.encode(
keccak256(
"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"
),
owner,
spender,
value,
nonces[owner]++,
deadline
)
)
)
),
v,
r,
s
);
require(recoveredAddress != address(0) && recoveredAddress == owner, "INVALID_SIGNER");
allowance[recoveredAddress][spender] = value;
}
emit Approval(owner, spender, value);
}
function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {
return block.chainid == INITIAL_CHAIN_ID ? INITIAL_DOMAIN_SEPARATOR : computeDomainSeparator();
}
function computeDomainSeparator() internal view virtual returns (bytes32) {
return
keccak256(
abi.encode(
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(name)),
keccak256("1"),
block.chainid,
address(this)
)
);
}
function _mint(address to, uint256 amount) internal virtual {
totalSupply += amount;
unchecked {
balanceOf[to] += amount;
}
emit Transfer(address(0), to, amount);
}
function _burn(address from, uint256 amount) internal virtual {
balanceOf[from] -= amount;
unchecked {
totalSupply -= amount;
}
emit Transfer(from, address(0), amount);
}
}
文件 10 的 44：ERC721Holder.sol
pragma solidity ^0.8.0;
import "../IERC721Receiver.sol";
contract ERC721Holder is IERC721Receiver {
function onERC721Received(address, address, uint256, bytes memory) public virtual override returns (bytes4) {
return this.onERC721Received.selector;
}
}
文件 11 的 44：IAccessControlUpgradeable.sol
pragma solidity ^0.8.0;
interface IAccessControlUpgradeable {
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
function hasRole(bytes32 role, address account) external view returns (bool);
function getRoleAdmin(bytes32 role) external view returns (bytes32);
function grantRole(bytes32 role, address account) external;
function revokeRole(bytes32 role, address account) external;
function renounceRole(bytes32 role, address account) external;
}
文件 12 的 44：IAdminControl.sol
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
interface IAdminControl is IERC165 {
event AdminApproved(address indexed account, address indexed sender);
event AdminRevoked(address indexed account, address indexed sender);
function getAdmins() external view returns (address[] memory);
function approveAdmin(address admin) external;
function revokeAdmin(address admin) external;
function isAdmin(address admin) external view returns (bool);
}文件 13 的 44：IArtBlocks.sol
pragma solidity ^0.8.0;
interface IArtBlocks {
function admin() external view returns (address);
}
文件 14 的 44：ICurve.sol
pragma solidity ^0.8.0;
import {CurveErrorCodes} from "./CurveErrorCodes.sol";
interface ICurve {
function validateDelta(uint128 delta) external pure returns (bool valid);
function validateSpotPrice(uint128 newSpotPrice) external view returns (bool valid);
function getBuyInfo(
uint128 spotPrice,
uint128 delta,
uint256 numItems,
uint256 feeMultiplier,
uint256 protocolFeeMultiplier
)
external
view
returns (
CurveErrorCodes.Error error,
uint128 newSpotPrice,
uint128 newDelta,
uint256 inputValue,
uint256 tradeFee,
uint256 protocolFee
);
function getSellInfo(
uint128 spotPrice,
uint128 delta,
uint256 numItems,
uint256 feeMultiplier,
uint256 protocolFeeMultiplier
)
external
view
returns (
CurveErrorCodes.Error error,
uint128 newSpotPrice,
uint128 newDelta,
uint256 outputValue,
uint256 tradeFee,
uint256 protocolFee
);
}
文件 15 的 44：IDigitalax.sol
pragma solidity ^0.8.0;
interface IDigitalax {
function accessControls() external view returns (address);
}
interface IDigitalaxAccessControls {
function hasAdminRole(address _account) external view returns (bool);
}
文件 16 的 44：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;
}
文件 17 的 44：IERC1155Receiver.sol
pragma solidity ^0.8.0;
import "../../utils/introspection/IERC165.sol";
interface IERC1155Receiver is IERC165 {
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external returns (bytes4);
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external returns (bytes4);
}
文件 18 的 44：IERC165.sol
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
文件 19 的 44：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);
}
文件 20 的 44：IERC721Receiver.sol
pragma solidity ^0.8.0;
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
文件 21 的 44：IFoundation.sol
pragma solidity ^0.8.0;
interface IFoundation {
function getFees(uint256 tokenId) external view returns (address payable[] memory, uint256[] memory);
}
interface IFoundationTreasuryNode {
function getFoundationTreasury() external view returns (address payable);
}
interface IFoundationTreasury {
function isAdmin(address account) external view returns (bool);
}
文件 22 的 44：ILSSVMPairFactoryLike.sol
pragma solidity ^0.8.0;
import {LSSVMRouter} from "./LSSVMRouter.sol";
interface ILSSVMPairFactoryLike {
struct Settings {
uint96 bps;
address pairAddress;
}
enum PairNFTType {
ERC721,
ERC1155
}
enum PairTokenType {
ETH,
ERC20
}
enum PairVariant {
ERC721_ETH,
ERC721_ERC20,
ERC1155_ETH,
ERC1155_ERC20
}
function protocolFeeMultiplier() external view returns (uint256);
function protocolFeeRecipient() external view returns (address payable);
function callAllowed(address target) external view returns (bool);
function authAllowedForToken(address tokenAddress, address proposedAuthAddress) external view returns (bool);
function getSettingsForPair(address pairAddress) external view returns (bool settingsEnabled, uint96 bps);
function enableSettingsForPair(address settings, address pairAddress) external;
function disableSettingsForPair(address settings, address pairAddress) external;
function routerStatus(LSSVMRouter router) external view returns (bool allowed, bool wasEverTouched);
function isValidPair(address pairAddress) external view returns (bool);
function getPairNFTType(address pairAddress) external pure returns (PairNFTType);
function getPairTokenType(address pairAddress) external pure returns (PairTokenType);
function openLock() external;
function closeLock() external;
}
文件 23 的 44：INiftyGateway.sol
pragma solidity ^0.8.0;
interface INiftyBuilderInstance {
function niftyRegistryContract() external view returns (address);
}
interface INiftyRegistry {
function isValidNiftySender(address sending_key) external view returns (bool);
}
文件 24 的 44：IOwnershipTransferReceiver.sol
pragma solidity ^0.8.4;
interface IOwnershipTransferReceiver {
function onOwnershipTransferred(address oldOwner, bytes memory data) external payable;
}
文件 25 的 44：IPropertyChecker.sol
pragma solidity ^0.8.0;
interface IPropertyChecker {
function hasProperties(uint256[] calldata ids, bytes calldata params) external returns (bool);
}
文件 26 的 44：IRoyaltyEngineV1.sol
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
interface IRoyaltyEngineV1 is IERC165 {
function getRoyalty(address tokenAddress, uint256 tokenId, uint256 value)
external
returns (address payable[] memory recipients, uint256[] memory amounts);
function getRoyaltyView(address tokenAddress, uint256 tokenId, uint256 value)
external
view
returns (address payable[] memory recipients, uint256[] memory amounts);
}
文件 27 的 44：ISettings.sol
pragma solidity ^0.8.0;
interface ISettings {
struct PairInfo {
address prevOwner;
uint96 unlockTime;
address prevFeeRecipient;
}
function getFeeSplitBps() external pure returns (uint64);
function getRoyaltyInfo(address pairAddress) external view returns (bool, uint96);
function settingsFeeRecipient() external returns (address payable);
function getPrevFeeRecipientForPair(address pairAddress) external returns (address);
}
文件 28 的 44：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;
}
}
文件 29 的 44：LSSVMPair.sol
pragma solidity ^0.8.0;
import {IRoyaltyEngineV1} from "manifoldxyz/IRoyaltyEngineV1.sol";
import {ERC20} from "solmate/tokens/ERC20.sol";
import {Address} from "@openzeppelin/contracts/utils/Address.sol";
import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import {IERC1155} from "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import {ERC721Holder} from "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol";
import {ERC1155Holder} from "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol";
import {LSSVMRouter} from "./LSSVMRouter.sol";
import {ICurve} from "./bonding-curves/ICurve.sol";
import {ILSSVMPairFactoryLike} from "./ILSSVMPairFactoryLike.sol";
import {CurveErrorCodes} from "./bonding-curves/CurveErrorCodes.sol";
import {IOwnershipTransferReceiver} from "./lib/IOwnershipTransferReceiver.sol";
import {OwnableWithTransferCallback} from "./lib/OwnableWithTransferCallback.sol";
abstract contract LSSVMPair is OwnableWithTransferCallback, ERC721Holder, ERC1155Holder {
using Address for address;
enum PoolType {
TOKEN,
NFT,
TRADE
}
uint256 internal constant MAX_TRADE_FEE = 0.5e18;
IRoyaltyEngineV1 public immutable ROYALTY_ENGINE;
uint128 public spotPrice;
uint128 public delta;
uint96 public fee;
address payable internal assetRecipient;
event SwapNFTInPair(uint256 amountOut, uint256[] ids);
event SwapNFTInPair(uint256 amountOut, uint256 numNFTs);
event SwapNFTOutPair(uint256 amountIn, uint256[] ids);
event SwapNFTOutPair(uint256 amountIn, uint256 numNFTs);
event SpotPriceUpdate(uint128 newSpotPrice);
event TokenDeposit(uint256 amount);
event TokenWithdrawal(uint256 amount);
event NFTWithdrawal(uint256[] ids);
event NFTWithdrawal(uint256 numNFTs);
event DeltaUpdate(uint128 newDelta);
event FeeUpdate(uint96 newFee);
event AssetRecipientChange(address indexed a);
error LSSVMPair__NotRouter();
error LSSVMPair__CallFailed();
error LSSVMPair__InvalidDelta();
error LSSVMPair__WrongPoolType();
error LSSVMPair__OutputTooSmall();
error LSSVMPair__ZeroSwapAmount();
error LSSVMPair__RoyaltyTooLarge();
error LSSVMPair__TradeFeeTooLarge();
error LSSVMPair__InvalidSpotPrice();
error LSSVMPair__TargetNotAllowed();
error LSSVMPair__NftNotTransferred();
error LSSVMPair__AlreadyInitialized();
error LSSVMPair__FunctionNotAllowed();
error LSSVMPair__DemandedInputTooLarge();
error LSSVMPair__NonTradePoolWithTradeFee();
error LSSVMPair__BondingCurveError(CurveErrorCodes.Error error);
constructor(IRoyaltyEngineV1 royaltyEngine) {
ROYALTY_ENGINE = royaltyEngine;
}
function initialize(
address _owner,
address payable _assetRecipient,
uint128 _delta,
uint96 _fee,
uint128 _spotPrice
) external {
if (owner() != address(0)) revert LSSVMPair__AlreadyInitialized();
__Ownable_init(_owner);
ICurve _bondingCurve = bondingCurve();
PoolType _poolType = poolType();
if (_poolType != PoolType.TRADE) {
if (_fee != 0) revert LSSVMPair__NonTradePoolWithTradeFee();
} else {
if (_fee > MAX_TRADE_FEE) revert LSSVMPair__TradeFeeTooLarge();
fee = _fee;
}
assetRecipient = _assetRecipient;
if (!_bondingCurve.validateDelta(_delta)) revert LSSVMPair__InvalidDelta();
if (!_bondingCurve.validateSpotPrice(_spotPrice)) revert LSSVMPair__InvalidSpotPrice();
delta = _delta;
spotPrice = _spotPrice;
}
function swapTokenForSpecificNFTs(
uint256[] calldata nftIds,
uint256 maxExpectedTokenInput,
address nftRecipient,
bool isRouter,
address routerCaller
) external payable virtual returns (uint256);
function swapNFTsForToken(
uint256[] calldata nftIds,
uint256 minExpectedTokenOutput,
address payable tokenRecipient,
bool isRouter,
address routerCaller
) external virtual returns (uint256 outputAmount);
function getBuyNFTQuote(uint256 assetId, uint256 numNFTs)
external
view
returns (
CurveErrorCodes.Error error,
uint256 newSpotPrice,
uint256 newDelta,
uint256 inputAmount,
uint256 protocolFee,
uint256 royaltyAmount
)
{
uint256 tradeFee;
(error, newSpotPrice, newDelta, inputAmount, tradeFee, protocolFee) =
bondingCurve().getBuyInfo(spotPrice, delta, numNFTs, fee, factory().protocolFeeMultiplier());
if (numNFTs != 0) {
uint256 inputAmountMinusFees = inputAmount - tradeFee - protocolFee;
(,, royaltyAmount) = calculateRoyaltiesView(assetId, inputAmountMinusFees);
inputAmount += royaltyAmount;
}
}
function getSellNFTQuote(uint256 assetId, uint256 numNFTs)
external
view
returns (
CurveErrorCodes.Error error,
uint256 newSpotPrice,
uint256 newDelta,
uint256 outputAmount,
uint256 protocolFee,
uint256 royaltyAmount
)
{
(error, newSpotPrice, newDelta, outputAmount, , protocolFee) =
bondingCurve().getSellInfo(spotPrice, delta, numNFTs, fee, factory().protocolFeeMultiplier());
if (numNFTs != 0) {
(,, royaltyAmount) = calculateRoyaltiesView(assetId, outputAmount);
unchecked {
outputAmount -= royaltyAmount;
}
}
}
function pairVariant() public pure virtual returns (ILSSVMPairFactoryLike.PairVariant);
function factory() public pure returns (ILSSVMPairFactoryLike _factory) {
uint256 paramsLength = _immutableParamsLength();
assembly {
_factory := shr(0x60, calldataload(sub(calldatasize(), paramsLength)))
}
}
function bondingCurve() public pure returns (ICurve _bondingCurve) {
uint256 paramsLength = _immutableParamsLength();
assembly {
_bondingCurve := shr(0x60, calldataload(add(sub(calldatasize(), paramsLength), 20)))
}
}
function nft() public pure returns (address _nft) {
uint256 paramsLength = _immutableParamsLength();
assembly {
_nft := shr(0x60, calldataload(add(sub(calldatasize(), paramsLength), 40)))
}
}
function poolType() public pure returns (PoolType _poolType) {
uint256 paramsLength = _immutableParamsLength();
assembly {
_poolType := shr(0xf8, calldataload(add(sub(calldatasize(), paramsLength), 60)))
}
}
function getAssetRecipient() public view returns (address payable) {
if (poolType() == PoolType.TRADE) {
return payable(address(this));
}
address payable _assetRecipient = assetRecipient;
if (_assetRecipient == address(0)) {
return payable(owner());
}
return _assetRecipient;
}
function getFeeRecipient() public view returns (address payable _feeRecipient) {
_feeRecipient = assetRecipient;
if (_feeRecipient == address(0)) {
_feeRecipient = payable(address(this));
}
}
function _calculateBuyInfoAndUpdatePoolParams(uint256 numNFTs, ICurve _bondingCurve, ILSSVMPairFactoryLike _factory)
internal
returns (uint256 tradeFee, uint256 protocolFee, uint256 inputAmount)
{
CurveErrorCodes.Error error;
uint128 currentSpotPrice = spotPrice;
uint128 currentDelta = delta;
uint128 newDelta;
uint128 newSpotPrice;
(error, newSpotPrice, newDelta, inputAmount, tradeFee, protocolFee) =
_bondingCurve.getBuyInfo(currentSpotPrice, currentDelta, numNFTs, fee, _factory.protocolFeeMultiplier());
if (error != CurveErrorCodes.Error.OK) {
revert LSSVMPair__BondingCurveError(error);
}
if (currentSpotPrice != newSpotPrice || currentDelta != newDelta) {
spotPrice = newSpotPrice;
delta = newDelta;
}
if (currentSpotPrice != newSpotPrice) {
emit SpotPriceUpdate(newSpotPrice);
}
if (currentDelta != newDelta) {
emit DeltaUpdate(newDelta);
}
}
function _calculateSellInfoAndUpdatePoolParams(
uint256 numNFTs,
ICurve _bondingCurve,
ILSSVMPairFactoryLike _factory
) internal returns (uint256 protocolFee, uint256 outputAmount) {
CurveErrorCodes.Error error;
uint128 currentSpotPrice = spotPrice;
uint128 currentDelta = delta;
uint128 newSpotPrice;
uint128 newDelta;
(error, newSpotPrice, newDelta, outputAmount, , protocolFee) =
_bondingCurve.getSellInfo(currentSpotPrice, currentDelta, numNFTs, fee, _factory.protocolFeeMultiplier());
if (error != CurveErrorCodes.Error.OK) {
revert LSSVMPair__BondingCurveError(error);
}
if (currentSpotPrice != newSpotPrice || currentDelta != newDelta) {
spotPrice = newSpotPrice;
delta = newDelta;
}
if (currentSpotPrice != newSpotPrice) {
emit SpotPriceUpdate(newSpotPrice);
}
if (currentDelta != newDelta) {
emit DeltaUpdate(newDelta);
}
}
function _pullTokenInputs(
uint256 inputAmountExcludingRoyalty,
uint256[] memory royaltyAmounts,
address payable[] memory royaltyRecipients,
uint256 royaltyTotal,
uint256 tradeFeeAmount,
bool isRouter,
address routerCaller,
uint256 protocolFee
) internal virtual;
function _refundTokenToSender(uint256 inputAmount) internal virtual;
function _sendTokenOutput(address payable tokenRecipient, uint256 outputAmount) internal virtual;
function _immutableParamsLength() internal pure virtual returns (uint256);
function _calculateRoyalties(uint256 assetId, uint256 saleAmount)
internal
returns (address payable[] memory royaltyRecipients, uint256[] memory royaltyAmounts, uint256 royaltyTotal)
{
(address payable[] memory recipients, uint256[] memory amounts) =
ROYALTY_ENGINE.getRoyalty(nft(), assetId, saleAmount);
return _calculateRoyaltiesLogic(recipients, amounts, saleAmount);
}
function calculateRoyaltiesView(uint256 assetId, uint256 saleAmount)
public
view
returns (address payable[] memory royaltyRecipients, uint256[] memory royaltyAmounts, uint256 royaltyTotal)
{
(address payable[] memory recipients, uint256[] memory amounts) =
ROYALTY_ENGINE.getRoyaltyView(nft(), assetId, saleAmount);
return _calculateRoyaltiesLogic(recipients, amounts, saleAmount);
}
function _calculateRoyaltiesLogic(address payable[] memory recipients, uint256[] memory amounts, uint256 saleAmount)
internal
view
returns (address payable[] memory royaltyRecipients, uint256[] memory royaltyAmounts, uint256 royaltyTotal)
{
uint256 numRecipients = recipients.length;
if (numRecipients != 0) {
try factory().getSettingsForPair(address(this)) returns (bool settingsEnabled, uint96 bps) {
if (settingsEnabled) {
royaltyRecipients = new address payable[](1);
royaltyRecipients[0] = recipients[0];
royaltyAmounts = new uint256[](1);
royaltyAmounts[0] = (saleAmount * bps) / 10000;
numRecipients = 1;
} else {
royaltyRecipients = recipients;
royaltyAmounts = amounts;
}
} catch {
royaltyRecipients = recipients;
royaltyAmounts = amounts;
}
}
for (uint256 i; i < numRecipients;) {
royaltyTotal += royaltyAmounts[i];
unchecked {
++i;
}
}
if (royaltyTotal > saleAmount >> 2) {
revert LSSVMPair__RoyaltyTooLarge();
}
}
function withdrawERC721(IERC721 a, uint256[] calldata nftIds) external virtual;
function withdrawERC20(ERC20 a, uint256 amount) external virtual;
function withdrawERC1155(IERC1155 a, uint256[] calldata ids, uint256[] calldata amounts) external virtual;
function changeSpotPrice(uint128 newSpotPrice) external onlyOwner {
ICurve _bondingCurve = bondingCurve();
if (!_bondingCurve.validateSpotPrice(newSpotPrice)) revert LSSVMPair__InvalidSpotPrice();
if (spotPrice != newSpotPrice) {
spotPrice = newSpotPrice;
emit SpotPriceUpdate(newSpotPrice);
}
}
function changeDelta(uint128 newDelta) external onlyOwner {
ICurve _bondingCurve = bondingCurve();
if (!_bondingCurve.validateDelta(newDelta)) revert LSSVMPair__InvalidDelta();
if (delta != newDelta) {
delta = newDelta;
emit DeltaUpdate(newDelta);
}
}
function changeFee(uint96 newFee) external onlyOwner {
PoolType _poolType = poolType();
if (_poolType != PoolType.TRADE) revert LSSVMPair__NonTradePoolWithTradeFee();
if (newFee > MAX_TRADE_FEE) revert LSSVMPair__TradeFeeTooLarge();
if (fee != newFee) {
fee = newFee;
emit FeeUpdate(newFee);
}
}
function changeAssetRecipient(address payable newRecipient) external onlyOwner {
if (assetRecipient != newRecipient) {
assetRecipient = newRecipient;
emit AssetRecipientChange(newRecipient);
}
}
function _preCallCheck(address target) internal virtual;
function call(address payable target, bytes calldata data) external onlyOwner {
ILSSVMPairFactoryLike _factory = factory();
if (!_factory.callAllowed(target)) revert LSSVMPair__TargetNotAllowed();
bytes4 sig = bytes4(data[:4]);
if (
sig == IOwnershipTransferReceiver.onOwnershipTransferred.selector
|| sig == LSSVMRouter.pairTransferERC20From.selector || sig == LSSVMRouter.pairTransferNFTFrom.selector
|| sig == LSSVMRouter.pairTransferERC1155From.selector || sig == ILSSVMPairFactoryLike.openLock.selector
|| sig == ILSSVMPairFactoryLike.closeLock.selector
) {
revert LSSVMPair__FunctionNotAllowed();
}
if (target == nft()) revert LSSVMPair__TargetNotAllowed();
_preCallCheck(target);
(bool success,) = target.call{value: 0}(data);
if (!success) revert LSSVMPair__CallFailed();
}
function multicall(bytes[] calldata calls, bool revertOnFail) external onlyOwner {
for (uint256 i; i < calls.length;) {
bytes4 sig = bytes4(calls[i][:4]);
if (sig == transferOwnership.selector) revert LSSVMPair__FunctionNotAllowed();
(bool success, bytes memory result) = address(this).delegatecall(calls[i]);
if (!success && revertOnFail) {
assembly {
revert(add(0x20, result), mload(result))
}
}
unchecked {
++i;
}
}
}
}
文件 30 的 44：LSSVMPairCloner.sol
pragma solidity ^0.8.0;
import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import {IERC1155} from "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import {ERC20} from "solmate/tokens/ERC20.sol";
import {ICurve} from "../bonding-curves/ICurve.sol";
import {ILSSVMPairFactoryLike} from "../ILSSVMPairFactoryLike.sol";
library LSSVMPairCloner {
function cloneERC721ETHPair(
address implementation,
ILSSVMPairFactoryLike factory,
ICurve bondingCurve,
IERC721 nft,
uint8 poolType,
address propertyChecker
) internal returns (address instance) {
assembly {
let ptr := mload(0x40)
mstore(ptr, hex"60863d8160093d39f33d3d3d3d363d3d37605160353639366051013d73000000")
mstore(add(ptr, 0x1d), shl(0x60, implementation))
mstore(add(ptr, 0x31), hex"5af43d3d93803e603357fd5bf300000000000000000000000000000000000000")
mstore(add(ptr, 0x3e), shl(0x60, factory))
mstore(add(ptr, 0x52), shl(0x60, bondingCurve))
mstore(add(ptr, 0x66), shl(0x60, nft))
mstore8(add(ptr, 0x7a), poolType)
mstore(add(ptr, 0x7b), shl(0x60, propertyChecker))
instance := create(0, ptr, 0x8f)
}
}
function cloneERC721ERC20Pair(
address implementation,
ILSSVMPairFactoryLike factory,
ICurve bondingCurve,
IERC721 nft,
uint8 poolType,
address propertyChecker,
ERC20 token
) internal returns (address instance) {
assembly {
let ptr := mload(0x40)
mstore(ptr, hex"609a3d8160093d39f33d3d3d3d363d3d37606560353639366065013d73000000")
mstore(add(ptr, 0x1d), shl(0x60, implementation))
mstore(add(ptr, 0x31), hex"5af43d3d93803e603357fd5bf300000000000000000000000000000000000000")
mstore(add(ptr, 0x3e), shl(0x60, factory))
mstore(add(ptr, 0x52), shl(0x60, bondingCurve))
mstore(add(ptr, 0x66), shl(0x60, nft))
mstore8(add(ptr, 0x7a), poolType)
mstore(add(ptr, 0x7b), shl(0x60, propertyChecker))
mstore(add(ptr, 0x8f), shl(0x60, token))
instance := create(0, ptr, 0xa3)
}
}
function isERC721ETHPairClone(address factory, address implementation, address query)
internal
view
returns (bool result)
{
assembly {
let ptr := mload(0x40)
mstore(ptr, hex"3d3d3d3d363d3d37605160353639366051013d73000000000000000000000000")
mstore(add(ptr, 0x14), shl(0x60, implementation))
mstore(add(ptr, 0x28), hex"5af43d3d93803e603357fd5bf300000000000000000000000000000000000000")
mstore(add(ptr, 0x35), shl(0x60, factory))
let other := add(ptr, 0x49)
extcodecopy(query, other, 0, 0x49)
result :=
and(
eq(mload(ptr), mload(other)),
and(
eq(mload(add(ptr, 0x20)), mload(add(other, 0x20))),
eq(mload(add(ptr, 0x29)), mload(add(other, 0x29)))
)
)
}
}
function isERC721ERC20PairClone(address factory, address implementation, address query)
internal
view
returns (bool result)
{
assembly {
let ptr := mload(0x40)
mstore(ptr, hex"3d3d3d3d363d3d37606560353639366065013d73000000000000000000000000")
mstore(add(ptr, 0x14), shl(0x60, implementation))
mstore(add(ptr, 0x28), hex"5af43d3d93803e603357fd5bf300000000000000000000000000000000000000")
mstore(add(ptr, 0x35), shl(0x60, factory))
let other := add(ptr, 0x49)
extcodecopy(query, other, 0, 0x49)
result :=
and(
eq(mload(ptr), mload(other)),
and(
eq(mload(add(ptr, 0x20)), mload(add(other, 0x20))),
eq(mload(add(ptr, 0x29)), mload(add(other, 0x29)))
)
)
}
}
function cloneERC1155ETHPair(
address implementation,
ILSSVMPairFactoryLike factory,
ICurve bondingCurve,
IERC1155 nft,
uint8 poolType,
uint256 nftId
) internal returns (address instance) {
assembly {
let ptr := mload(0x40)
mstore(ptr, hex"60923d8160093d39f33d3d3d3d363d3d37605d6035363936605d013d73000000")
mstore(add(ptr, 0x1d), shl(0x60, implementation))
mstore(add(ptr, 0x31), hex"5af43d3d93803e603357fd5bf300000000000000000000000000000000000000")
mstore(add(ptr, 0x3e), shl(0x60, factory))
mstore(add(ptr, 0x52), shl(0x60, bondingCurve))
mstore(add(ptr, 0x66), shl(0x60, nft))
mstore8(add(ptr, 0x7a), poolType)
mstore(add(ptr, 0x7b), nftId)
instance := create(0, ptr, 0x9b)
}
}
function cloneERC1155ERC20Pair(
address implementation,
ILSSVMPairFactoryLike factory,
ICurve bondingCurve,
IERC1155 nft,
uint8 poolType,
uint256 nftId,
ERC20 token
) internal returns (address instance) {
assembly {
let ptr := mload(0x40)
mstore(ptr, hex"60a63d8160093d39f33d3d3d3d363d3d37607160353639366071013d73000000")
mstore(add(ptr, 0x1d), shl(0x60, implementation))
mstore(add(ptr, 0x31), hex"5af43d3d93803e603357fd5bf300000000000000000000000000000000000000")
mstore(add(ptr, 0x3e), shl(0x60, factory))
mstore(add(ptr, 0x52), shl(0x60, bondingCurve))
mstore(add(ptr, 0x66), shl(0x60, nft))
mstore8(add(ptr, 0x7a), poolType)
mstore(add(ptr, 0x7b), nftId)
mstore(add(ptr, 0x9b), shl(0x60, token))
instance := create(0, ptr, 0xaf)
}
}
function isERC1155ETHPairClone(address factory, address implementation, address query)
internal
view
returns (bool result)
{
assembly {
let ptr := mload(0x40)
mstore(ptr, hex"3d3d3d3d363d3d37605d6035363936605d013d73000000000000000000000000")
mstore(add(ptr, 0x14), shl(0x60, implementation))
mstore(add(ptr, 0x28), hex"5af43d3d93803e603357fd5bf300000000000000000000000000000000000000")
mstore(add(ptr, 0x35), shl(0x60, factory))
let other := add(ptr, 0x49)
extcodecopy(query, other, 0, 0x49)
result :=
and(
eq(mload(ptr), mload(other)),
and(
eq(mload(add(ptr, 0x20)), mload(add(other, 0x20))),
eq(mload(add(ptr, 0x29)), mload(add(other, 0x29)))
)
)
}
}
function isERC1155ERC20PairClone(address factory, address implementation, address query)
internal
view
returns (bool result)
{
assembly {
let ptr := mload(0x40)
mstore(ptr, hex"3d3d3d3d363d3d37607160353639366071013d73000000000000000000000000")
mstore(add(ptr, 0x14), shl(0x60, implementation))
mstore(add(ptr, 0x28), hex"5af43d3d93803e603357fd5bf300000000000000000000000000000000000000")
mstore(add(ptr, 0x35), shl(0x60, factory))
let other := add(ptr, 0x49)
extcodecopy(query, other, 0, 0x49)
result :=
and(
eq(mload(ptr), mload(other)),
and(
eq(mload(add(ptr, 0x20)), mload(add(other, 0x20))),
eq(mload(add(ptr, 0x29)), mload(add(other, 0x29)))
)
)
}
}
}
文件 31 的 44：LSSVMPairERC1155.sol
pragma solidity ^0.8.0;
import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import {IERC1155} from "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import {ERC20} from "solmate/tokens/ERC20.sol";
import {LSSVMPair} from "../LSSVMPair.sol";
import {LSSVMRouter} from "../LSSVMRouter.sol";
import {ICurve} from "../bonding-curves/ICurve.sol";
import {ILSSVMPairFactoryLike} from "../ILSSVMPairFactoryLike.sol";
abstract contract LSSVMPairERC1155 is LSSVMPair {
function swapTokenForSpecificNFTs(
uint256[] calldata numNFTs,
uint256 maxExpectedTokenInput,
address nftRecipient,
bool isRouter,
address routerCaller
) external payable virtual override returns (uint256) {
factory().openLock();
{
if (poolType() == PoolType.TOKEN) revert LSSVMPair__WrongPoolType();
if (numNFTs.length != 1 || numNFTs[0] == 0) revert LSSVMPair__ZeroSwapAmount();
}
uint256 tradeFee;
uint256 protocolFee;
uint256 inputAmountExcludingRoyalty;
(tradeFee, protocolFee, inputAmountExcludingRoyalty) =
_calculateBuyInfoAndUpdatePoolParams(numNFTs[0], bondingCurve(), factory());
(address payable[] memory royaltyRecipients, uint256[] memory royaltyAmounts, uint256 royaltyTotal) =
_calculateRoyalties(nftId(), inputAmountExcludingRoyalty - protocolFee - tradeFee);
if (royaltyTotal + inputAmountExcludingRoyalty > maxExpectedTokenInput) {
revert LSSVMPair__DemandedInputTooLarge();
}
_pullTokenInputs({
inputAmountExcludingRoyalty: inputAmountExcludingRoyalty,
royaltyRecipients: royaltyRecipients,
royaltyAmounts: royaltyAmounts,
royaltyTotal: royaltyTotal,
tradeFeeAmount: 2 * tradeFee,
isRouter: isRouter,
routerCaller: routerCaller,
protocolFee: protocolFee
});
_sendAnyNFTsToRecipient(IERC1155(nft()), nftRecipient, numNFTs[0]);
_refundTokenToSender(royaltyTotal + inputAmountExcludingRoyalty);
factory().closeLock();
emit SwapNFTOutPair(royaltyTotal + inputAmountExcludingRoyalty, numNFTs[0]);
return (royaltyTotal + inputAmountExcludingRoyalty);
}
function swapNFTsForToken(
uint256[] calldata numNFTs,
uint256 minExpectedTokenOutput,
address payable tokenRecipient,
bool isRouter,
address routerCaller
) external virtual override returns (uint256 outputAmount) {
ILSSVMPairFactoryLike _factory = factory();
_factory.openLock();
ICurve _bondingCurve = bondingCurve();
{
if (poolType() == PoolType.NFT) revert LSSVMPair__WrongPoolType();
if (numNFTs.length != 1 || numNFTs[0] == 0) revert LSSVMPair__ZeroSwapAmount();
}
uint256 protocolFee;
(protocolFee, outputAmount) = _calculateSellInfoAndUpdatePoolParams(numNFTs[0], _bondingCurve, _factory);
(address payable[] memory royaltyRecipients, uint256[] memory royaltyAmounts, uint256 royaltyTotal) =
_calculateRoyalties(nftId(), outputAmount);
unchecked {
outputAmount -= royaltyTotal;
}
if (outputAmount < minExpectedTokenOutput) revert LSSVMPair__OutputTooSmall();
_takeNFTsFromSender(IERC1155(nft()), numNFTs[0], _factory, isRouter, routerCaller);
_sendTokenOutput(tokenRecipient, outputAmount);
for (uint256 i; i < royaltyRecipients.length;) {
_sendTokenOutput(royaltyRecipients[i], royaltyAmounts[i]);
unchecked {
++i;
}
}
_sendTokenOutput(payable(address(_factory)), protocolFee);
_factory.closeLock();
emit SwapNFTInPair(outputAmount, numNFTs[0]);
}
function nftId() public pure returns (uint256 id) {
uint256 paramsLength = _immutableParamsLength();
assembly {
id := calldataload(add(sub(calldatasize(), paramsLength), 61))
}
}
function _sendAnyNFTsToRecipient(IERC1155 _nft, address nftRecipient, uint256 numNFTs) internal virtual {
_nft.safeTransferFrom(address(this), nftRecipient, nftId(), numNFTs, bytes(""));
}
function _takeNFTsFromSender(
IERC1155 _nft,
uint256 numNFTs,
ILSSVMPairFactoryLike factory,
bool isRouter,
address routerCaller
) internal virtual {
address _assetRecipient = getAssetRecipient();
if (isRouter) {
LSSVMRouter router = LSSVMRouter(payable(msg.sender));
(bool routerAllowed,) = factory.routerStatus(router);
if (!routerAllowed) revert LSSVMPair__NotRouter();
uint256 _nftId = nftId();
uint256 beforeBalance = _nft.balanceOf(_assetRecipient, _nftId);
uint256[] memory ids = new uint256[](1);
ids[0] = _nftId;
uint256[] memory amounts = new uint256[](1);
amounts[0] = numNFTs;
router.pairTransferERC1155From(_nft, routerCaller, _assetRecipient, ids, amounts);
if (_nft.balanceOf(_assetRecipient, _nftId) - beforeBalance != numNFTs) {
revert LSSVMPair__NftNotTransferred();
}
} else {
_nft.safeTransferFrom(msg.sender, _assetRecipient, nftId(), numNFTs, bytes(""));
}
}
function withdrawERC721(IERC721 a, uint256[] calldata nftIds) external virtual override onlyOwner {
uint256 numNFTs = nftIds.length;
for (uint256 i; i < numNFTs;) {
a.safeTransferFrom(address(this), msg.sender, nftIds[i]);
unchecked {
++i;
}
}
}
function withdrawERC1155(IERC1155 a, uint256[] calldata ids, uint256[] calldata amounts)
external
virtual
override
onlyOwner
{
if (a == IERC1155(nft())) {
uint256 _nftId = nftId();
uint256 numNFTs = ids.length;
uint256 numPairNFTsWithdrawn;
for (uint256 i; i < numNFTs;) {
if (ids[i] == _nftId) {
numPairNFTsWithdrawn += amounts[i];
}
unchecked {
++i;
}
}
if (numPairNFTsWithdrawn != 0) {
emit NFTWithdrawal(numPairNFTsWithdrawn);
}
}
a.safeBatchTransferFrom(address(this), msg.sender, ids, amounts, bytes(""));
}
}
文件 32 的 44：LSSVMPairERC1155ERC20.sol
pragma solidity ^0.8.0;
import {IRoyaltyEngineV1} from "manifoldxyz/IRoyaltyEngineV1.sol";
import {LSSVMPair} from "../LSSVMPair.sol";
import {LSSVMPairERC20} from "../LSSVMPairERC20.sol";
import {LSSVMPairERC1155} from "./LSSVMPairERC1155.sol";
import {ILSSVMPairFactoryLike} from "../ILSSVMPairFactoryLike.sol";
contract LSSVMPairERC1155ERC20 is LSSVMPairERC1155, LSSVMPairERC20 {
uint256 internal constant IMMUTABLE_PARAMS_LENGTH = 113;
constructor(IRoyaltyEngineV1 royaltyEngine) LSSVMPair(royaltyEngine) {}
function pairVariant() public pure virtual override returns (ILSSVMPairFactoryLike.PairVariant) {
return ILSSVMPairFactoryLike.PairVariant.ERC1155_ERC20;
}
function _immutableParamsLength() internal pure override returns (uint256) {
return IMMUTABLE_PARAMS_LENGTH;
}
}
文件 33 的 44：LSSVMPairERC1155ETH.sol
pragma solidity ^0.8.0;
import {IRoyaltyEngineV1} from "manifoldxyz/IRoyaltyEngineV1.sol";
import {LSSVMPair} from "../LSSVMPair.sol";
import {LSSVMPairETH} from "../LSSVMPairETH.sol";
import {LSSVMPairERC1155} from "./LSSVMPairERC1155.sol";
import {ILSSVMPairFactoryLike} from "../ILSSVMPairFactoryLike.sol";
contract LSSVMPairERC1155ETH is LSSVMPairERC1155, LSSVMPairETH {
uint256 internal constant IMMUTABLE_PARAMS_LENGTH = 93;
constructor(IRoyaltyEngineV1 royaltyEngine) LSSVMPair(royaltyEngine) {}
function pairVariant() public pure virtual override returns (ILSSVMPairFactoryLike.PairVariant) {
return ILSSVMPairFactoryLike.PairVariant.ERC1155_ETH;
}
function _immutableParamsLength() internal pure override returns (uint256) {
return IMMUTABLE_PARAMS_LENGTH;
}
}
文件 34 的 44：LSSVMPairERC20.sol
pragma solidity ^0.8.0;
import {ERC20} from "solmate/tokens/ERC20.sol";
import {SafeTransferLib} from "solmate/utils/SafeTransferLib.sol";
import {LSSVMPair} from "./LSSVMPair.sol";
import {LSSVMRouter} from "./LSSVMRouter.sol";
import {ILSSVMPairFactoryLike} from "./ILSSVMPairFactoryLike.sol";
abstract contract LSSVMPairERC20 is LSSVMPair {
using SafeTransferLib for ERC20;
error LSSVMPairERC20__RoyaltyNotPaid();
error LSSVMPairERC20__MsgValueNotZero();
error LSSVMPairERC20__AssetRecipientNotPaid();
function token() public pure returns (ERC20 _token) {
assembly {
_token := shr(0x60, calldataload(sub(calldatasize(), 20)))
}
}
function _pullTokenInputs(
uint256 inputAmountExcludingRoyalty,
uint256[] memory royaltyAmounts,
address payable[] memory royaltyRecipients,
uint256,
uint256 tradeFeeAmount,
bool isRouter,
address routerCaller,
uint256 protocolFee
) internal override {
address _assetRecipient = getAssetRecipient();
if (isRouter) {
{
(bool routerAllowed,) = factory().routerStatus(LSSVMRouter(payable(msg.sender)));
if (!routerAllowed) revert LSSVMPair__NotRouter();
}
uint256 beforeBalance = token().balanceOf(_assetRecipient);
LSSVMRouter(payable(msg.sender)).pairTransferERC20From(
token(), routerCaller, _assetRecipient, inputAmountExcludingRoyalty - protocolFee
);
ERC20 token_ = token();
if (token_.balanceOf(_assetRecipient) - beforeBalance != (inputAmountExcludingRoyalty - protocolFee)) {
revert LSSVMPairERC20__AssetRecipientNotPaid();
}
for (uint256 i; i < royaltyRecipients.length;) {
beforeBalance = token_.balanceOf(royaltyRecipients[i]);
LSSVMRouter(payable(msg.sender)).pairTransferERC20From(
token_, routerCaller, royaltyRecipients[i], royaltyAmounts[i]
);
if (token_.balanceOf(royaltyRecipients[i]) - beforeBalance != royaltyAmounts[i]) {
revert LSSVMPairERC20__RoyaltyNotPaid();
}
unchecked {
++i;
}
}
if (protocolFee != 0) {
LSSVMRouter(payable(msg.sender)).pairTransferERC20From(
token_, routerCaller, address(factory()), protocolFee
);
}
} else {
ERC20 token_ = token();
token_.safeTransferFrom(msg.sender, _assetRecipient, inputAmountExcludingRoyalty - protocolFee);
for (uint256 i; i < royaltyRecipients.length;) {
token_.safeTransferFrom(msg.sender, royaltyRecipients[i], royaltyAmounts[i]);
unchecked {
++i;
}
}
if (protocolFee != 0) {
token_.safeTransferFrom(msg.sender, address(factory()), protocolFee);
}
}
if (poolType() == PoolType.TRADE && tradeFeeAmount != 0) {
address payable _feeRecipient = getFeeRecipient();
if (_feeRecipient != _assetRecipient) {
token().safeTransfer(_feeRecipient, tradeFeeAmount);
}
}
}
function _refundTokenToSender(uint256 inputAmount) internal override {
}
function _sendTokenOutput(address payable tokenRecipient, uint256 outputAmount) internal override {
if (outputAmount != 0) {
token().safeTransfer(tokenRecipient, outputAmount);
}
}
function withdrawERC20(ERC20 a, uint256 amount) external override onlyOwner {
a.safeTransfer(msg.sender, amount);
if (a == token()) {
emit TokenWithdrawal(amount);
}
}
function _preCallCheck(address target) internal pure override {
if (target == address(token())) revert LSSVMPair__TargetNotAllowed();
}
}
文件 35 的 44：LSSVMPairERC721.sol
pragma solidity ^0.8.0;
import {ERC20} from "solmate/tokens/ERC20.sol";
import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import {IERC1155} from "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import {ERC721Holder} from "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol";
import {LSSVMPair} from "../LSSVMPair.sol";
import {LSSVMRouter} from "../LSSVMRouter.sol";
import {ICurve} from "../bonding-curves/ICurve.sol";
import {ILSSVMPairFactoryLike} from "../ILSSVMPairFactoryLike.sol";
import {IPropertyChecker} from "../property-checking/IPropertyChecker.sol";
abstract contract LSSVMPairERC721 is LSSVMPair {
error LSSVMPairERC721__PropertyCheckFailed();
error LSSVMPairERC721__NeedPropertyChecking();
function swapTokenForSpecificNFTs(
uint256[] calldata nftIds,
uint256 maxExpectedTokenInput,
address nftRecipient,
bool isRouter,
address routerCaller
) external payable virtual override returns (uint256) {
factory().openLock();
{
PoolType _poolType = poolType();
if (_poolType == PoolType.TOKEN) revert LSSVMPair__WrongPoolType();
if (nftIds.length == 0) revert LSSVMPair__ZeroSwapAmount();
}
uint256 protocolFee;
uint256 tradeFee;
uint256 inputAmountExcludingRoyalty;
(tradeFee, protocolFee, inputAmountExcludingRoyalty) =
_calculateBuyInfoAndUpdatePoolParams(nftIds.length, bondingCurve(), factory());
(address payable[] memory royaltyRecipients, uint256[] memory royaltyAmounts, uint256 royaltyTotal) =
_calculateRoyalties(nftIds[0], inputAmountExcludingRoyalty - protocolFee - tradeFee);
if (royaltyTotal + inputAmountExcludingRoyalty > maxExpectedTokenInput) {
revert LSSVMPair__DemandedInputTooLarge();
}
_pullTokenInputs({
inputAmountExcludingRoyalty: inputAmountExcludingRoyalty,
royaltyAmounts: royaltyAmounts,
royaltyRecipients: royaltyRecipients,
royaltyTotal: royaltyTotal,
tradeFeeAmount: 2 * tradeFee,
isRouter: isRouter,
routerCaller: routerCaller,
protocolFee: protocolFee
});
{
_sendSpecificNFTsToRecipient(IERC721(nft()), nftRecipient, nftIds);
}
_refundTokenToSender(royaltyTotal + inputAmountExcludingRoyalty);
factory().closeLock();
emit SwapNFTOutPair(royaltyTotal + inputAmountExcludingRoyalty, nftIds);
return (royaltyTotal + inputAmountExcludingRoyalty);
}
function swapNFTsForToken(
uint256[] calldata nftIds,
uint256 minExpectedTokenOutput,
address payable tokenRecipient,
bool isRouter,
address routerCaller
) external virtual override returns (uint256 outputAmount) {
if (propertyChecker() != address(0)) revert LSSVMPairERC721__NeedPropertyChecking();
return _swapNFTsForToken(nftIds, minExpectedTokenOutput, tokenRecipient, isRouter, routerCaller);
}
function swapNFTsForToken(
uint256[] calldata nftIds,
uint256 minExpectedTokenOutput,
address payable tokenRecipient,
bool isRouter,
address routerCaller,
bytes calldata propertyCheckerParams
) external virtual returns (uint256 outputAmount) {
if (!IPropertyChecker(propertyChecker()).hasProperties(nftIds, propertyCheckerParams)) {
revert LSSVMPairERC721__PropertyCheckFailed();
}
return _swapNFTsForToken(nftIds, minExpectedTokenOutput, tokenRecipient, isRouter, routerCaller);
}
function propertyChecker() public pure returns (address _propertyChecker) {
uint256 paramsLength = _immutableParamsLength();
assembly {
_propertyChecker := shr(0x60, calldataload(add(sub(calldatasize(), paramsLength), 61)))
}
}
function _swapNFTsForToken(
uint256[] calldata nftIds,
uint256 minExpectedTokenOutput,
address payable tokenRecipient,
bool isRouter,
address routerCaller
) internal virtual returns (uint256 outputAmount) {
ILSSVMPairFactoryLike _factory = factory();
_factory.openLock();
{
PoolType _poolType = poolType();
if (_poolType == PoolType.NFT) revert LSSVMPair__WrongPoolType();
if (nftIds.length == 0) revert LSSVMPair__ZeroSwapAmount();
}
uint256 protocolFee;
(protocolFee, outputAmount) = _calculateSellInfoAndUpdatePoolParams(nftIds.length, bondingCurve(), _factory);
(address payable[] memory royaltyRecipients, uint256[] memory royaltyAmounts, uint256 royaltyTotal) =
_calculateRoyalties(nftIds[0], outputAmount);
unchecked {
outputAmount -= royaltyTotal;
}
if (outputAmount < minExpectedTokenOutput) revert LSSVMPair__OutputTooSmall();
_takeNFTsFromSender(IERC721(nft()), nftIds, _factory, isRouter, routerCaller);
_sendTokenOutput(tokenRecipient, outputAmount);
for (uint256 i; i < royaltyRecipients.length;) {
_sendTokenOutput(royaltyRecipients[i], royaltyAmounts[i]);
unchecked {
++i;
}
}
_sendTokenOutput(payable(address(_factory)), protocolFee);
_factory.closeLock();
emit SwapNFTInPair(outputAmount, nftIds);
}
function _sendSpecificNFTsToRecipient(IERC721 _nft, address nftRecipient, uint256[] calldata nftIds)
internal
virtual
{
uint256 numNFTs = nftIds.length;
for (uint256 i; i < numNFTs;) {
_nft.transferFrom(address(this), nftRecipient, nftIds[i]);
unchecked {
++i;
}
}
}
function _takeNFTsFromSender(
IERC721 _nft,
uint256[] calldata nftIds,
ILSSVMPairFactoryLike _factory,
bool isRouter,
address routerCaller
) internal virtual {
{
address _assetRecipient = getAssetRecipient();
uint256 numNFTs = nftIds.length;
if (isRouter) {
LSSVMRouter router = LSSVMRouter(payable(msg.sender));
(bool routerAllowed,) = _factory.routerStatus(router);
if (!routerAllowed) revert LSSVMPair__NotRouter();
if ((numNFTs > 1) && (propertyChecker() == address(0))) {
uint256 beforeBalance = _nft.balanceOf(_assetRecipient);
for (uint256 i; i < numNFTs;) {
router.pairTransferNFTFrom(_nft, routerCaller, _assetRecipient, nftIds[i]);
unchecked {
++i;
}
}
if (_nft.balanceOf(_assetRecipient) - beforeBalance != numNFTs) {
revert LSSVMPair__NftNotTransferred();
}
}
else {
for (uint256 i; i < numNFTs;) {
router.pairTransferNFTFrom(_nft, routerCaller, _assetRecipient, nftIds[i]);
if (_nft.ownerOf(nftIds[i]) != _assetRecipient) revert LSSVMPair__NftNotTransferred();
unchecked {
++i;
}
}
}
} else {
for (uint256 i; i < numNFTs;) {
_nft.transferFrom(msg.sender, _assetRecipient, nftIds[i]);
unchecked {
++i;
}
}
}
}
}
function withdrawERC721(IERC721 a, uint256[] calldata nftIds) external virtual override onlyOwner {
uint256 numNFTs = nftIds.length;
for (uint256 i; i < numNFTs;) {
a.safeTransferFrom(address(this), msg.sender, nftIds[i]);
unchecked {
++i;
}
}
if (a == IERC721(nft())) {
emit NFTWithdrawal(nftIds);
}
}
function withdrawERC1155(IERC1155 a, uint256[] calldata ids, uint256[] calldata amounts)
external
virtual
override
onlyOwner
{
a.safeBatchTransferFrom(address(this), msg.sender, ids, amounts, "");
}
}
文件 36 的 44：LSSVMPairERC721ERC20.sol
pragma solidity ^0.8.0;
import {IRoyaltyEngineV1} from "manifoldxyz/IRoyaltyEngineV1.sol";
import {LSSVMPair} from "../LSSVMPair.sol";
import {LSSVMPairERC20} from "../LSSVMPairERC20.sol";
import {LSSVMPairERC721} from "./LSSVMPairERC721.sol";
import {ILSSVMPairFactoryLike} from "../ILSSVMPairFactoryLike.sol";
contract LSSVMPairERC721ERC20 is LSSVMPairERC721, LSSVMPairERC20 {
uint256 internal constant IMMUTABLE_PARAMS_LENGTH = 101;
constructor(IRoyaltyEngineV1 royaltyEngine) LSSVMPair(royaltyEngine) {}
function pairVariant() public pure override returns (ILSSVMPairFactoryLike.PairVariant) {
return ILSSVMPairFactoryLike.PairVariant.ERC721_ERC20;
}
function _immutableParamsLength() internal pure override returns (uint256) {
return IMMUTABLE_PARAMS_LENGTH;
}
}
文件 37 的 44：LSSVMPairERC721ETH.sol
pragma solidity ^0.8.0;
import {IRoyaltyEngineV1} from "manifoldxyz/IRoyaltyEngineV1.sol";
import {LSSVMPair} from "../LSSVMPair.sol";
import {LSSVMPairETH} from "../LSSVMPairETH.sol";
import {LSSVMPairERC721} from "./LSSVMPairERC721.sol";
import {ILSSVMPairFactoryLike} from "../ILSSVMPairFactoryLike.sol";
contract LSSVMPairERC721ETH is LSSVMPairERC721, LSSVMPairETH {
uint256 internal constant IMMUTABLE_PARAMS_LENGTH = 81;
constructor(IRoyaltyEngineV1 royaltyEngine) LSSVMPair(royaltyEngine) {}
function pairVariant() public pure override returns (ILSSVMPairFactoryLike.PairVariant) {
return ILSSVMPairFactoryLike.PairVariant.ERC721_ETH;
}
function _immutableParamsLength() internal pure override returns (uint256) {
return IMMUTABLE_PARAMS_LENGTH;
}
}
文件 38 的 44：LSSVMPairETH.sol
pragma solidity ^0.8.0;
import {ERC20} from "solmate/tokens/ERC20.sol";
import {SafeTransferLib} from "solmate/utils/SafeTransferLib.sol";
import {LSSVMPair} from "./LSSVMPair.sol";
import {ILSSVMPairFactoryLike} from "./ILSSVMPairFactoryLike.sol";
abstract contract LSSVMPairETH is LSSVMPair {
using SafeTransferLib for address payable;
using SafeTransferLib for ERC20;
error LSSVMPairETH__InsufficientInput();
function _pullTokenInputs(
uint256 inputAmountExcludingRoyalty,
uint256[] memory royaltyAmounts,
address payable[] memory royaltyRecipients,
uint256 royaltyTotal,
uint256 tradeFeeAmount,
bool,
address,
uint256 protocolFee
) internal override {
if (msg.value < (royaltyTotal + inputAmountExcludingRoyalty)) revert LSSVMPairETH__InsufficientInput();
address payable _assetRecipient = getAssetRecipient();
if (poolType() == PoolType.TRADE && tradeFeeAmount != 0) {
address payable _feeRecipient = getFeeRecipient();
if (_feeRecipient != _assetRecipient) {
inputAmountExcludingRoyalty -= tradeFeeAmount;
_feeRecipient.safeTransferETH(tradeFeeAmount);
}
}
if (_assetRecipient != address(this)) {
_assetRecipient.safeTransferETH(inputAmountExcludingRoyalty - protocolFee);
}
for (uint256 i; i < royaltyRecipients.length;) {
royaltyRecipients[i].safeTransferETH(royaltyAmounts[i]);
unchecked {
++i;
}
}
if (protocolFee != 0) {
payable(address(factory())).safeTransferETH(protocolFee);
}
}
function _refundTokenToSender(uint256 inputAmount) internal override {
if (msg.value > inputAmount) {
payable(msg.sender).safeTransferETH(msg.value - inputAmount);
}
}
function _sendTokenOutput(address payable tokenRecipient, uint256 outputAmount) internal override {
if (outputAmount != 0) {
tokenRecipient.safeTransferETH(outputAmount);
}
}
function withdrawAllETH() external onlyOwner {
withdrawETH(address(this).balance);
}
function withdrawETH(uint256 amount) public onlyOwner {
payable(msg.sender).safeTransferETH(amount);
emit TokenWithdrawal(amount);
}
function withdrawERC20(ERC20 a, uint256 amount) external override onlyOwner {
a.safeTransfer(msg.sender, amount);
}
receive() external payable {
emit TokenDeposit(msg.value);
}
fallback() external payable {
require(msg.data.length == _immutableParamsLength());
emit TokenDeposit(msg.value);
}
function _preCallCheck(address) internal pure override {}
}
文件 39 的 44：LSSVMPairFactory.sol
pragma solidity ^0.8.0;
import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import {IERC1155} from "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import {Owned} from "solmate/auth/Owned.sol";
import {ERC20} from "solmate/tokens/ERC20.sol";
import {SafeTransferLib} from "solmate/utils/SafeTransferLib.sol";
import {LSSVMPair} from "./LSSVMPair.sol";
import {LSSVMRouter} from "./LSSVMRouter.sol";
import {ICurve} from "./bonding-curves/ICurve.sol";
import {LSSVMPairCloner} from "./lib/LSSVMPairCloner.sol";
import {LSSVMPairERC1155} from "./erc1155/LSSVMPairERC1155.sol";
import {ILSSVMPairFactoryLike} from "./ILSSVMPairFactoryLike.sol";
import {LSSVMPairERC20} from "./LSSVMPairERC20.sol";
import {LSSVMPairERC721ETH} from "./erc721/LSSVMPairERC721ETH.sol";
import {LSSVMPairERC1155ETH} from "./erc1155/LSSVMPairERC1155ETH.sol";
import {LSSVMPairERC721ERC20} from "./erc721/LSSVMPairERC721ERC20.sol";
import {LSSVMPairERC1155ERC20} from "./erc1155/LSSVMPairERC1155ERC20.sol";
import {ISettings} from "./settings/ISettings.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/IAccessControlUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
import "@manifoldxyz/libraries-solidity/contracts/access/IAdminControl.sol";
import "./royalty-auth/INiftyGateway.sol";
import "./royalty-auth/IFoundation.sol";
import "./royalty-auth/IDigitalax.sol";
import "./royalty-auth/IArtBlocks.sol";
contract LSSVMPairFactory is Owned, ILSSVMPairFactoryLike {
using LSSVMPairCloner for address;
using AddressUpgradeable for address;
using SafeTransferLib for address payable;
using SafeTransferLib for ERC20;
uint256 internal constant MAX_PROTOCOL_FEE = 0.1e18;
LSSVMPairERC721ETH public immutable erc721ETHTemplate;
LSSVMPairERC721ERC20 public immutable erc721ERC20Template;
LSSVMPairERC1155ETH public immutable erc1155ETHTemplate;
LSSVMPairERC1155ERC20 public immutable erc1155ERC20Template;
address payable public override protocolFeeRecipient;
uint256 public override protocolFeeMultiplier;
mapping(ICurve => bool) public bondingCurveAllowed;
mapping(address => bool) public override callAllowed;
mapping(address => mapping(address => bool)) public settingsForCollection;
mapping(address => address) public settingsForPair;
struct RouterStatus {
bool allowed;
bool wasEverTouched;
}
mapping(LSSVMRouter => RouterStatus) public override routerStatus;
address private constant _NOT_ENTERED = address(1);
address private _caller;
event NewERC721Pair(address indexed poolAddress, uint256[] initialIds);
event NewERC1155Pair(address indexed poolAddress, uint256 initialBalance);
event ERC20Deposit(address indexed poolAddress, uint256 amount);
event NFTDeposit(address indexed poolAddress, uint256[] ids);
event ERC1155Deposit(address indexed poolAddress, uint256 indexed id, uint256 amount);
event ProtocolFeeRecipientUpdate(address indexed recipientAddress);
event ProtocolFeeMultiplierUpdate(uint256 newMultiplier);
event BondingCurveStatusUpdate(ICurve indexed bondingCurve, bool isAllowed);
event CallTargetStatusUpdate(address indexed target, bool isAllowed);
event RouterStatusUpdate(LSSVMRouter indexed router, bool isAllowed);
error LSSVMPairFactory__FeeTooLarge();
error LSSVMPairFactory__BondingCurveNotWhitelisted();
error LSSVMPairFactory__ReentrantCall();
error LSSVMPairFactory__ZeroAddress();
error LSSVMPairFactory__CannotCallRouter();
error LSSVMPairFactory__UnauthorizedCaller();
error LSSVMPairFactory__InvalidPair();
error LSSVMPairFactory__SettingsNotEnabledForCollection();
error LSSVMPairFactory__SettingsNotEnabledForPair();
constructor(
LSSVMPairERC721ETH _erc721ETHTemplate,
LSSVMPairERC721ERC20 _erc721ERC20Template,
LSSVMPairERC1155ETH _erc1155ETHTemplate,
LSSVMPairERC1155ERC20 _erc1155ERC20Template,
address payable _protocolFeeRecipient,
uint256 _protocolFeeMultiplier,
address _owner
) Owned(_owner) {
erc721ETHTemplate = _erc721ETHTemplate;
erc721ERC20Template = _erc721ERC20Template;
erc1155ETHTemplate = _erc1155ETHTemplate;
erc1155ERC20Template = _erc1155ERC20Template;
protocolFeeRecipient = _protocolFeeRecipient;
if (_protocolFeeMultiplier > MAX_PROTOCOL_FEE) revert LSSVMPairFactory__FeeTooLarge();
protocolFeeMultiplier = _protocolFeeMultiplier;
_caller = _NOT_ENTERED;
}
function createPairERC721ETH(
IERC721 _nft,
ICurve _bondingCurve,
address payable _assetRecipient,
LSSVMPair.PoolType _poolType,
uint128 _delta,
uint96 _fee,
uint128 _spotPrice,
address _propertyChecker,
uint256[] calldata _initialNFTIDs
) external payable returns (LSSVMPairERC721ETH pair) {
if (!bondingCurveAllowed[_bondingCurve]) revert LSSVMPairFactory__BondingCurveNotWhitelisted();
pair = LSSVMPairERC721ETH(
payable(
address(erc721ETHTemplate).cloneERC721ETHPair(
this, _bondingCurve, _nft, uint8(_poolType), _propertyChecker
)
)
);
_initializePairERC721ETH(pair, _nft, _assetRecipient, _delta, _fee, _spotPrice, _initialNFTIDs);
emit NewERC721Pair(address(pair), _initialNFTIDs);
}
struct CreateERC721ERC20PairParams {
ERC20 token;
IERC721 nft;
ICurve bondingCurve;
address payable assetRecipient;
LSSVMPair.PoolType poolType;
uint128 delta;
uint96 fee;
uint128 spotPrice;
address propertyChecker;
uint256[] initialNFTIDs;
uint256 initialTokenBalance;
}
function createPairERC721ERC20(CreateERC721ERC20PairParams calldata params)
external
returns (LSSVMPairERC721ERC20 pair)
{
if (!bondingCurveAllowed[params.bondingCurve]) revert LSSVMPairFactory__BondingCurveNotWhitelisted();
pair = LSSVMPairERC721ERC20(
payable(
address(erc721ERC20Template).cloneERC721ERC20Pair(
this, params.bondingCurve, params.nft, uint8(params.poolType), params.propertyChecker, params.token
)
)
);
_initializePairERC721ERC20(
pair,
params.token,
params.nft,
params.assetRecipient,
params.delta,
params.fee,
params.spotPrice,
params.initialNFTIDs,
params.initialTokenBalance
);
emit NewERC721Pair(address(pair), params.initialNFTIDs);
}
function createPairERC1155ETH(
IERC1155 _nft,
ICurve _bondingCurve,
address payable _assetRecipient,
LSSVMPairERC1155ETH.PoolType _poolType,
uint128 _delta,
uint96 _fee,
uint128 _spotPrice,
uint256 _nftId,
uint256 _initialNFTBalance
) external payable returns (LSSVMPairERC1155ETH pair) {
if (!bondingCurveAllowed[_bondingCurve]) revert LSSVMPairFactory__BondingCurveNotWhitelisted();
pair = LSSVMPairERC1155ETH(
payable(
address(erc1155ETHTemplate).cloneERC1155ETHPair(this, _bondingCurve, _nft, uint8(_poolType), _nftId)
)
);
_initializePairERC1155ETH(pair, _nft, _assetRecipient, _delta, _fee, _spotPrice, _nftId, _initialNFTBalance);
emit NewERC1155Pair(address(pair), _initialNFTBalance);
}
struct CreateERC1155ERC20PairParams {
ERC20 token;
IERC1155 nft;
ICurve bondingCurve;
address payable assetRecipient;
LSSVMPairERC1155ERC20.PoolType poolType;
uint128 delta;
uint96 fee;
uint128 spotPrice;
uint256 nftId;
uint256 initialNFTBalance;
uint256 initialTokenBalance;
}
function createPairERC1155ERC20(CreateERC1155ERC20PairParams calldata params)
external
returns (LSSVMPairERC1155ERC20 pair)
{
if (!bondingCurveAllowed[params.bondingCurve]) revert LSSVMPairFactory__BondingCurveNotWhitelisted();
pair = LSSVMPairERC1155ERC20(
payable(
address(erc1155ERC20Template).cloneERC1155ERC20Pair(
this, params.bondingCurve, params.nft, uint8(params.poolType), params.nftId, params.token
)
)
);
_initializePairERC1155ERC20(
pair,
params.token,
params.nft,
params.assetRecipient,
params.delta,
params.fee,
params.spotPrice,
params.nftId,
params.initialNFTBalance,
params.initialTokenBalance
);
emit NewERC1155Pair(address(pair), params.initialNFTBalance);
}
function isValidPair(address pairAddress) public view returns (bool) {
PairVariant variant = LSSVMPair(pairAddress).pairVariant();
if (variant == PairVariant.ERC721_ETH) {
return LSSVMPairCloner.isERC721ETHPairClone(address(this), address(erc721ETHTemplate), pairAddress);
} else if (variant == PairVariant.ERC721_ERC20) {
return LSSVMPairCloner.isERC721ERC20PairClone(address(this), address(erc721ERC20Template), pairAddress);
} else if (variant == PairVariant.ERC1155_ETH) {
return LSSVMPairCloner.isERC1155ETHPairClone(address(this), address(erc1155ETHTemplate), pairAddress);
} else if (variant == PairVariant.ERC1155_ERC20) {
return LSSVMPairCloner.isERC1155ERC20PairClone(address(this), address(erc1155ERC20Template), pairAddress);
} else {
return false;
}
}
function getPairNFTType(address pairAddress) public pure returns (PairNFTType) {
PairVariant variant = LSSVMPair(pairAddress).pairVariant();
return PairNFTType(uint8(variant) / 2);
}
function getPairTokenType(address pairAddress) public pure returns (PairTokenType) {
PairVariant variant = LSSVMPair(pairAddress).pairVariant();
return PairTokenType(uint8(variant) % 2);
}
function openLock() public {
if (_caller == msg.sender) revert LSSVMPairFactory__ReentrantCall();
_caller = msg.sender;
}
function closeLock() public {
if (_caller != msg.sender) revert LSSVMPairFactory__ReentrantCall();
_caller = _NOT_ENTERED;
}
function authAllowedForToken(address tokenAddress, address proposedAuthAddress) public view returns (bool) {
if (
ERC165Checker.supportsInterface(tokenAddress, type(IAdminControl).interfaceId)
&& IAdminControl(tokenAddress).isAdmin(proposedAuthAddress)
) {
return true;
}
try OwnableUpgradeable(tokenAddress).owner() returns (address owner) {
if (owner == proposedAuthAddress) return true;
if (owner.isContract()) {
try OwnableUpgradeable(owner).owner() returns (address passThroughOwner) {
if (passThroughOwner == proposedAuthAddress) return true;
} catch {}
}
} catch {}
try IAccessControlUpgradeable(tokenAddress).hasRole(0x00, proposedAuthAddress) returns (bool hasRole) {
if (hasRole) return true;
} catch {}
try INiftyBuilderInstance(tokenAddress).niftyRegistryContract() returns (address niftyRegistry) {
try INiftyRegistry(niftyRegistry).isValidNiftySender(proposedAuthAddress) returns (bool valid) {
if (valid) return true;
} catch {}
} catch {}
try IFoundationTreasuryNode(tokenAddress).getFoundationTreasury() returns (address payable foundationTreasury) {
try IFoundationTreasury(foundationTreasury).isAdmin(proposedAuthAddress) returns (bool isAdmin) {
if (isAdmin) return true;
} catch {}
} catch {}
try IDigitalax(tokenAddress).accessControls() returns (address externalAccessControls) {
try IDigitalaxAccessControls(externalAccessControls).hasAdminRole(proposedAuthAddress) returns (
bool hasRole
) {
if (hasRole) return true;
} catch {}
} catch {}
try IArtBlocks(tokenAddress).admin() returns (address admin) {
if (admin == proposedAuthAddress) return true;
} catch {}
return false;
}
receive() external payable {}
function withdrawETHProtocolFees() external onlyOwner {
protocolFeeRecipient.safeTransferETH(address(this).balance);
}
function withdrawERC20ProtocolFees(ERC20 token, uint256 amount) external onlyOwner {
token.safeTransfer(protocolFeeRecipient, amount);
}
function changeProtocolFeeRecipient(address payable _protocolFeeRecipient) external onlyOwner {
if (_protocolFeeRecipient == address(0)) revert LSSVMPairFactory__ZeroAddress();
protocolFeeRecipient = _protocolFeeRecipient;
emit ProtocolFeeRecipientUpdate(_protocolFeeRecipient);
}
function changeProtocolFeeMultiplier(uint256 _protocolFeeMultiplier) external onlyOwner {
if (_protocolFeeMultiplier > MAX_PROTOCOL_FEE) revert LSSVMPairFactory__FeeTooLarge();
protocolFeeMultiplier = _protocolFeeMultiplier;
emit ProtocolFeeMultiplierUpdate(_protocolFeeMultiplier);
}
function setBondingCurveAllowed(ICurve bondingCurve, bool isAllowed) external onlyOwner {
bondingCurveAllowed[bondingCurve] = isAllowed;
emit BondingCurveStatusUpdate(bondingCurve, isAllowed);
}
function setCallAllowed(address payable target, bool isAllowed) external onlyOwner {
if (isAllowed) {
if (routerStatus[LSSVMRouter(target)].wasEverTouched) revert LSSVMPairFactory__CannotCallRouter();
}
callAllowed[target] = isAllowed;
emit CallTargetStatusUpdate(target, isAllowed);
}
function setRouterAllowed(LSSVMRouter _router, bool isAllowed) external onlyOwner {
if (isAllowed) {
if (callAllowed[address(_router)]) revert LSSVMPairFactory__CannotCallRouter();
}
routerStatus[_router] = RouterStatus({allowed: isAllowed, wasEverTouched: true});
emit RouterStatusUpdate(_router, isAllowed);
}
function getSettingsForPair(address pairAddress) public view returns (bool settingsEnabled, uint96 bps) {
address settingsAddress = settingsForPair[pairAddress];
if (settingsAddress == address(0)) {
return (false, 0);
}
return ISettings(settingsAddress).getRoyaltyInfo(pairAddress);
}
function toggleSettingsForCollection(address settings, address collectionAddress, bool enable) public {
if (!authAllowedForToken(collectionAddress, msg.sender)) revert LSSVMPairFactory__UnauthorizedCaller();
if (enable) {
settingsForCollection[collectionAddress][settings] = true;
} else {
delete settingsForCollection[collectionAddress][settings];
}
}
function enableSettingsForPair(address settings, address pairAddress) public {
if (!isValidPair(pairAddress)) revert LSSVMPairFactory__InvalidPair();
LSSVMPair pair = LSSVMPair(pairAddress);
if (pair.owner() != msg.sender) revert LSSVMPairFactory__UnauthorizedCaller();
if (!settingsForCollection[address(pair.nft())][settings]) {
revert LSSVMPairFactory__SettingsNotEnabledForCollection();
}
settingsForPair[pairAddress] = settings;
}
function disableSettingsForPair(address settings, address pairAddress) public {
if (!isValidPair(pairAddress)) revert LSSVMPairFactory__InvalidPair();
if (settingsForPair[pairAddress] != settings) revert LSSVMPairFactory__SettingsNotEnabledForPair();
LSSVMPair pair = LSSVMPair(pairAddress);
if (pair.owner() != msg.sender) revert LSSVMPairFactory__UnauthorizedCaller();
delete settingsForPair[pairAddress];
}
function _initializePairERC721ETH(
LSSVMPairERC721ETH _pair,
IERC721 _nft,
address payable _assetRecipient,
uint128 _delta,
uint96 _fee,
uint128 _spotPrice,
uint256[] calldata _initialNFTIDs
) internal {
_pair.initialize(msg.sender, _assetRecipient, _delta, _fee, _spotPrice);
if (msg.value != 0) payable(address(_pair)).safeTransferETH(msg.value);
uint256 numNFTs = _initialNFTIDs.length;
for (uint256 i; i < numNFTs;) {
_nft.transferFrom(msg.sender, address(_pair), _initialNFTIDs[i]);
unchecked {
++i;
}
}
}
function _initializePairERC721ERC20(
LSSVMPairERC721ERC20 _pair,
ERC20 _token,
IERC721 _nft,
address payable _assetRecipient,
uint128 _delta,
uint96 _fee,
uint128 _spotPrice,
uint256[] calldata _initialNFTIDs,
uint256 _initialTokenBalance
) internal {
_pair.initialize(msg.sender, _assetRecipient, _delta, _fee, _spotPrice);
if (_initialTokenBalance != 0) {
_token.safeTransferFrom(msg.sender, address(_pair), _initialTokenBalance);
}
uint256 numNFTs = _initialNFTIDs.length;
for (uint256 i; i < numNFTs;) {
_nft.transferFrom(msg.sender, address(_pair), _initialNFTIDs[i]);
unchecked {
++i;
}
}
}
function _initializePairERC1155ETH(
LSSVMPairERC1155ETH _pair,
IERC1155 _nft,
address payable _assetRecipient,
uint128 _delta,
uint96 _fee,
uint128 _spotPrice,
uint256 _nftId,
uint256 _initialNFTBalance
) internal {
_pair.initialize(msg.sender, _assetRecipient, _delta, _fee, _spotPrice);
if (msg.value != 0) payable(address(_pair)).safeTransferETH(msg.value);
if (_initialNFTBalance != 0) {
_nft.safeTransferFrom(msg.sender, address(_pair), _nftId, _initialNFTBalance, bytes(""));
}
}
function _initializePairERC1155ERC20(
LSSVMPairERC1155ERC20 _pair,
ERC20 _token,
IERC1155 _nft,
address payable _assetRecipient,
uint128 _delta,
uint96 _fee,
uint128 _spotPrice,
uint256 _nftId,
uint256 _initialNFTBalance,
uint256 _initialTokenBalance
) internal {
_pair.initialize(msg.sender, _assetRecipient, _delta, _fee, _spotPrice);
if (_initialTokenBalance != 0) {
_token.safeTransferFrom(msg.sender, address(_pair), _initialTokenBalance);
}
if (_initialNFTBalance != 0) {
_nft.safeTransferFrom(msg.sender, address(_pair), _nftId, _initialNFTBalance, bytes(""));
}
}
function depositNFTs(IERC721 _nft, uint256[] calldata ids, address recipient) external {
uint256 numNFTs = ids.length;
if (numNFTs == 0) return;
for (uint256 i; i < numNFTs;) {
_nft.transferFrom(msg.sender, recipient, ids[i]);
unchecked {
++i;
}
}
if (isValidPair(recipient) && (address(_nft) == LSSVMPair(recipient).nft())) {
emit NFTDeposit(recipient, ids);
}
}
function depositERC20(ERC20 token, address recipient, uint256 amount) external {
if (amount == 0) return;
token.safeTransferFrom(msg.sender, recipient, amount);
if (
isValidPair(recipient) && getPairTokenType(recipient) == PairTokenType.ERC20
&& token == LSSVMPairERC20(recipient).token()
) {
emit ERC20Deposit(recipient, amount);
}
}
function depositERC1155(IERC1155 nft, uint256 id, address recipient, uint256 amount) external {
if (amount == 0) return;
nft.safeTransferFrom(msg.sender, recipient, id, amount, bytes(""));
if (
isValidPair(recipient) && getPairNFTType(recipient) == PairNFTType.ERC1155
&& address(nft) == LSSVMPair(recipient).nft() && id == LSSVMPairERC1155(recipient).nftId()
) {
emit ERC1155Deposit(recipient, id, amount);
}
}
}
文件 40 的 44：LSSVMRouter.sol
pragma solidity ^0.8.0;
import {ERC20} from "solmate/tokens/ERC20.sol";
import {SafeTransferLib} from "solmate/utils/SafeTransferLib.sol";
import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import {IERC1155} from "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import {LSSVMPair} from "./LSSVMPair.sol";
import {ILSSVMPairFactoryLike} from "./ILSSVMPairFactoryLike.sol";
import {CurveErrorCodes} from "./bonding-curves/CurveErrorCodes.sol";
contract LSSVMRouter {
using SafeTransferLib for address payable;
using SafeTransferLib for ERC20;
struct PairSwapSpecific {
LSSVMPair pair;
uint256[] nftIds;
}
struct RobustPairSwapSpecific {
PairSwapSpecific swapInfo;
uint256 maxCost;
}
struct RobustPairSwapSpecificForToken {
PairSwapSpecific swapInfo;
uint256 minOutput;
}
struct NFTsForSpecificNFTsTrade {
PairSwapSpecific[] nftToTokenTrades;
PairSwapSpecific[] tokenToNFTTrades;
}
struct RobustPairNFTsFoTokenAndTokenforNFTsTrade {
RobustPairSwapSpecific[] tokenToNFTTrades;
RobustPairSwapSpecificForToken[] nftToTokenTrades;
uint256 inputAmount;
address payable tokenRecipient;
address nftRecipient;
}
modifier checkDeadline(uint256 deadline) {
_checkDeadline(deadline);
_;
}
ILSSVMPairFactoryLike public immutable factory;
constructor(ILSSVMPairFactoryLike _factory) {
factory = _factory;
}
function swapETHForSpecificNFTs(
PairSwapSpecific[] calldata swapList,
address payable ethRecipient,
address nftRecipient,
uint256 deadline
) external payable checkDeadline(deadline) returns (uint256 remainingValue) {
return _swapETHForSpecificNFTs(swapList, msg.value, ethRecipient, nftRecipient);
}
function swapNFTsForSpecificNFTsThroughETH(
NFTsForSpecificNFTsTrade calldata trade,
uint256 minOutput,
address payable ethRecipient,
address nftRecipient,
uint256 deadline
) external payable checkDeadline(deadline) returns (uint256 outputAmount) {
outputAmount = _swapNFTsForToken(trade.nftToTokenTrades, 0, payable(address(this)));
outputAmount += msg.value;
outputAmount = _swapETHForSpecificNFTs(
trade.tokenToNFTTrades, outputAmount - minOutput, ethRecipient, nftRecipient
) + minOutput;
}
function swapERC20ForSpecificNFTs(
PairSwapSpecific[] calldata swapList,
uint256 inputAmount,
address nftRecipient,
uint256 deadline
) external checkDeadline(deadline) returns (uint256 remainingValue) {
return _swapERC20ForSpecificNFTs(swapList, inputAmount, nftRecipient);
}
function swapNFTsForToken(
PairSwapSpecific[] calldata swapList,
uint256 minOutput,
address tokenRecipient,
uint256 deadline
) external checkDeadline(deadline) returns (uint256 outputAmount) {
return _swapNFTsForToken(swapList, minOutput, payable(tokenRecipient));
}
function swapNFTsForSpecificNFTsThroughERC20(
NFTsForSpecificNFTsTrade calldata trade,
uint256 inputAmount,
uint256 minOutput,
address nftRecipient,
uint256 deadline
) external checkDeadline(deadline) returns (uint256 outputAmount) {
outputAmount = _swapNFTsForToken(trade.nftToTokenTrades, 0, payable(msg.sender));
outputAmount += inputAmount;
outputAmount =
_swapERC20ForSpecificNFTs(trade.tokenToNFTTrades, outputAmount - minOutput, nftRecipient) + minOutput;
}
function robustSwapETHForSpecificNFTs(
RobustPairSwapSpecific[] calldata swapList,
address payable ethRecipient,
address nftRecipient,
uint256 deadline
) public payable virtual checkDeadline(deadline) returns (uint256 remainingValue) {
remainingValue = msg.value;
uint256 pairCost;
CurveErrorCodes.Error error;
uint256 numSwaps = swapList.length;
for (uint256 i; i < numSwaps;) {
(error,,, pairCost,,) = swapList[i].swapInfo.pair.getBuyNFTQuote(
swapList[i].swapInfo.nftIds[0], swapList[i].swapInfo.nftIds.length
);
if (pairCost <= swapList[i].maxCost && error == CurveErrorCodes.Error.OK) {
remainingValue -= swapList[i].swapInfo.pair.swapTokenForSpecificNFTs{value: pairCost}(
swapList[i].swapInfo.nftIds, pairCost, nftRecipient, true, msg.sender
);
}
unchecked {
++i;
}
}
if (remainingValue > 0) {
ethRecipient.safeTransferETH(remainingValue);
}
}
function robustSwapERC20ForSpecificNFTs(
RobustPairSwapSpecific[] calldata swapList,
uint256 inputAmount,
address nftRecipient,
uint256 deadline
) public virtual checkDeadline(deadline) returns (uint256 remainingValue) {
remainingValue = inputAmount;
uint256 pairCost;
CurveErrorCodes.Error error;
uint256 numSwaps = swapList.length;
for (uint256 i; i < numSwaps;) {
(error,,, pairCost,,) = swapList[i].swapInfo.pair.getBuyNFTQuote(
swapList[i].swapInfo.nftIds[0], swapList[i].swapInfo.nftIds.length
);
if (pairCost <= swapList[i].maxCost && error == CurveErrorCodes.Error.OK) {
remainingValue -= swapList[i].swapInfo.pair.swapTokenForSpecificNFTs(
swapList[i].swapInfo.nftIds, pairCost, nftRecipient, true, msg.sender
);
}
unchecked {
++i;
}
}
}
function robustSwapNFTsForToken(
RobustPairSwapSpecificForToken[] calldata swapList,
address payable tokenRecipient,
uint256 deadline
) public virtual checkDeadline(deadline) returns (uint256 outputAmount) {
uint256 numSwaps = swapList.length;
for (uint256 i; i < numSwaps;) {
uint256 pairOutput;
{
CurveErrorCodes.Error error;
uint256[] memory nftIds = swapList[i].swapInfo.nftIds;
if (nftIds.length == 0) {
unchecked {
++i;
}
continue;
}
(error,,, pairOutput,,) = swapList[i].swapInfo.pair.getSellNFTQuote(nftIds[0], nftIds.length);
if (error != CurveErrorCodes.Error.OK) {
unchecked {
++i;
}
continue;
}
}
if (pairOutput >= swapList[i].minOutput) {
outputAmount += swapList[i].swapInfo.pair.swapNFTsForToken(
swapList[i].swapInfo.nftIds, 0, tokenRecipient, true, msg.sender
);
}
unchecked {
++i;
}
}
}
function robustSwapETHForSpecificNFTsAndNFTsToToken(RobustPairNFTsFoTokenAndTokenforNFTsTrade calldata params)
external
payable
virtual
returns (uint256 remainingValue, uint256 outputAmount)
{
{
remainingValue = msg.value;
uint256 pairCost;
CurveErrorCodes.Error error;
uint256 numSwaps = params.tokenToNFTTrades.length;
for (uint256 i; i < numSwaps;) {
(error,,, pairCost,,) = params.tokenToNFTTrades[i].swapInfo.pair.getBuyNFTQuote(
params.tokenToNFTTrades[i].swapInfo.nftIds[0], params.tokenToNFTTrades[i].swapInfo.nftIds.length
);
if (pairCost <= params.tokenToNFTTrades[i].maxCost && error == CurveErrorCodes.Error.OK) {
remainingValue -= params.tokenToNFTTrades[i].swapInfo.pair.swapTokenForSpecificNFTs{value: pairCost}(
params.tokenToNFTTrades[i].swapInfo.nftIds, pairCost, params.nftRecipient, true, msg.sender
);
}
unchecked {
++i;
}
}
if (remainingValue > 0) {
params.tokenRecipient.safeTransferETH(remainingValue);
}
}
{
uint256 numSwaps = params.nftToTokenTrades.length;
for (uint256 i; i < numSwaps;) {
uint256 pairOutput;
{
CurveErrorCodes.Error error;
uint256 assetId = params.nftToTokenTrades[i].swapInfo.nftIds[0];
(error,,, pairOutput,,) = params.nftToTokenTrades[i].swapInfo.pair.getSellNFTQuote(
assetId, params.nftToTokenTrades[i].swapInfo.nftIds.length
);
if (error != CurveErrorCodes.Error.OK) {
unchecked {
++i;
}
continue;
}
}
if (pairOutput >= params.nftToTokenTrades[i].minOutput) {
outputAmount += params.nftToTokenTrades[i].swapInfo.pair.swapNFTsForToken(
params.nftToTokenTrades[i].swapInfo.nftIds, 0, params.tokenRecipient, true, msg.sender
);
}
unchecked {
++i;
}
}
}
}
function robustSwapERC20ForSpecificNFTsAndNFTsToToken(RobustPairNFTsFoTokenAndTokenforNFTsTrade calldata params)
external
virtual
returns (uint256 remainingValue, uint256 outputAmount)
{
{
remainingValue = params.inputAmount;
uint256 pairCost;
CurveErrorCodes.Error error;
uint256 numSwaps = params.tokenToNFTTrades.length;
for (uint256 i; i < numSwaps;) {
(error,,, pairCost,,) = params.tokenToNFTTrades[i].swapInfo.pair.getBuyNFTQuote(
params.tokenToNFTTrades[i].swapInfo.nftIds[0], params.tokenToNFTTrades[i].swapInfo.nftIds.length
);
if (pairCost <= params.tokenToNFTTrades[i].maxCost && error == CurveErrorCodes.Error.OK) {
remainingValue -= params.tokenToNFTTrades[i].swapInfo.pair.swapTokenForSpecificNFTs(
params.tokenToNFTTrades[i].swapInfo.nftIds, pairCost, params.nftRecipient, true, msg.sender
);
}
unchecked {
++i;
}
}
}
{
uint256 numSwaps = params.nftToTokenTrades.length;
for (uint256 i; i < numSwaps;) {
uint256 pairOutput;
{
CurveErrorCodes.Error error;
uint256 assetId = params.nftToTokenTrades[i].swapInfo.nftIds[0];
(error,,, pairOutput,,) = params.nftToTokenTrades[i].swapInfo.pair.getSellNFTQuote(
assetId, params.nftToTokenTrades[i].swapInfo.nftIds.length
);
if (error != CurveErrorCodes.Error.OK) {
unchecked {
++i;
}
continue;
}
}
if (pairOutput >= params.nftToTokenTrades[i].minOutput) {
outputAmount += params.nftToTokenTrades[i].swapInfo.pair.swapNFTsForToken(
params.nftToTokenTrades[i].swapInfo.nftIds, 0, params.tokenRecipient, true, msg.sender
);
}
unchecked {
++i;
}
}
}
}
receive() external payable {}
function pairTransferERC20From(ERC20 token, address from, address to, uint256 amount) external {
require(factory.isValidPair(msg.sender), "Not pair");
require(factory.getPairTokenType(msg.sender) == ILSSVMPairFactoryLike.PairTokenType.ERC20, "Not ERC20 pair");
token.safeTransferFrom(from, to, amount);
}
function pairTransferNFTFrom(IERC721 nft, address from, address to, uint256 id) external {
require(factory.isValidPair(msg.sender), "Not pair");
nft.transferFrom(from, to, id);
}
function pairTransferERC1155From(
IERC1155 nft,
address from,
address to,
uint256[] calldata ids,
uint256[] calldata amounts
) external {
require(factory.isValidPair(msg.sender), "Not pair");
nft.safeBatchTransferFrom(from, to, ids, amounts, bytes(""));
}
function _checkDeadline(uint256 deadline) internal view {
require(block.timestamp <= deadline, "Deadline passed");
}
function _swapETHForSpecificNFTs(
PairSwapSpecific[] calldata swapList,
uint256 inputAmount,
address payable ethRecipient,
address nftRecipient
) internal virtual returns (uint256 remainingValue) {
remainingValue = inputAmount;
uint256 pairCost;
CurveErrorCodes.Error error;
uint256 numSwaps = swapList.length;
for (uint256 i; i < numSwaps;) {
(error,,, pairCost,,) = swapList[i].pair.getBuyNFTQuote(swapList[i].nftIds[0], swapList[i].nftIds.length);
require(error == CurveErrorCodes.Error.OK, "Bonding curve error");
remainingValue -= swapList[i].pair.swapTokenForSpecificNFTs{value: pairCost}(
swapList[i].nftIds, remainingValue, nftRecipient, true, msg.sender
);
unchecked {
++i;
}
}
if (remainingValue > 0) {
ethRecipient.safeTransferETH(remainingValue);
}
}
function _swapERC20ForSpecificNFTs(PairSwapSpecific[] calldata swapList, uint256 inputAmount, address nftRecipient)
internal
virtual
returns (uint256 remainingValue)
{
remainingValue = inputAmount;
uint256 numSwaps = swapList.length;
for (uint256 i; i < numSwaps;) {
remainingValue -= swapList[i].pair.swapTokenForSpecificNFTs(
swapList[i].nftIds, remainingValue, nftRecipient, true, msg.sender
);
unchecked {
++i;
}
}
}
function _swapNFTsForToken(PairSwapSpecific[] calldata swapList, uint256 minOutput, address payable tokenRecipient)
internal
virtual
returns (uint256 outputAmount)
{
uint256 numSwaps = swapList.length;
for (uint256 i; i < numSwaps;) {
outputAmount += swapList[i].pair.swapNFTsForToken(swapList[i].nftIds, 0, tokenRecipient, true, msg.sender);
unchecked {
++i;
}
}
require(outputAmount >= minOutput, "outputAmount too low");
}
}
文件 41 的 44：OwnableUpgradeable.sol
pragma solidity ^0.8.0;
import "../utils/ContextUpgradeable.sol";
import "../proxy/utils/Initializable.sol";
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function __Ownable_init() internal onlyInitializing {
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal onlyInitializing {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
uint256[49] private __gap;
}
文件 42 的 44：OwnableWithTransferCallback.sol
pragma solidity ^0.8.4;
import {Address} from "@openzeppelin/contracts/utils/Address.sol";
import {ERC165Checker} from "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
import {IOwnershipTransferReceiver} from "./IOwnershipTransferReceiver.sol";
abstract contract OwnableWithTransferCallback {
using ERC165Checker for address;
using Address for address;
bytes4 constant TRANSFER_CALLBACK = type(IOwnershipTransferReceiver).interfaceId;
error Ownable_NotOwner();
error Ownable_NewOwnerZeroAddress();
address private _owner;
event OwnershipTransferred(address indexed newOwner);
function __Ownable_init(address initialOwner) internal {
_owner = initialOwner;
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
if (owner() != msg.sender) revert Ownable_NotOwner();
_;
}
function transferOwnership(address newOwner, bytes calldata data) public payable virtual onlyOwner {
if (newOwner == address(0)) revert Ownable_NewOwnerZeroAddress();
_transferOwnership(newOwner);
if (newOwner.isContract()) {
try IOwnershipTransferReceiver(newOwner).onOwnershipTransferred{value: msg.value}(msg.sender, data) {}
catch (bytes memory reason) {
if (reason.length == 0) {
}
else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
}
}
function _transferOwnership(address newOwner) internal virtual {
_owner = newOwner;
emit OwnershipTransferred(newOwner);
}
}
文件 43 的 44：Owned.sol
pragma solidity >=0.8.0;
abstract contract Owned {
event OwnershipTransferred(address indexed user, address indexed newOwner);
address public owner;
modifier onlyOwner() virtual {
require(msg.sender == owner, "UNAUTHORIZED");
_;
}
constructor(address _owner) {
owner = _owner;
emit OwnershipTransferred(address(0), _owner);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
owner = newOwner;
emit OwnershipTransferred(msg.sender, newOwner);
}
}
文件 44 的 44：SafeTransferLib.sol
pragma solidity >=0.8.0;
import {ERC20} from "../tokens/ERC20.sol";
library SafeTransferLib {
function safeTransferETH(address to, uint256 amount) internal {
bool success;
assembly {
success := call(gas(), to, amount, 0, 0, 0, 0)
}
require(success, "ETH_TRANSFER_FAILED");
}
function safeTransferFrom(
ERC20 token,
address from,
address to,
uint256 amount
) internal {
bool success;
assembly {
let freeMemoryPointer := mload(0x40)
mstore(freeMemoryPointer, 0x23b872dd00000000000000000000000000000000000000000000000000000000)
mstore(add(freeMemoryPointer, 4), from)
mstore(add(freeMemoryPointer, 36), to)
mstore(add(freeMemoryPointer, 68), amount)
success := and(
or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())),
call(gas(), token, 0, freeMemoryPointer, 100, 0, 32)
)
}
require(success, "TRANSFER_FROM_FAILED");
}
function safeTransfer(
ERC20 token,
address to,
uint256 amount
) internal {
bool success;
assembly {
let freeMemoryPointer := mload(0x40)
mstore(freeMemoryPointer, 0xa9059cbb00000000000000000000000000000000000000000000000000000000)
mstore(add(freeMemoryPointer, 4), to)
mstore(add(freeMemoryPointer, 36), amount)
success := and(
or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())),
call(gas(), token, 0, freeMemoryPointer, 68, 0, 32)
)
}
require(success, "TRANSFER_FAILED");
}
function safeApprove(
ERC20 token,
address to,
uint256 amount
) internal {
bool success;
assembly {
let freeMemoryPointer := mload(0x40)
mstore(freeMemoryPointer, 0x095ea7b300000000000000000000000000000000000000000000000000000000)
mstore(add(freeMemoryPointer, 4), to)
mstore(add(freeMemoryPointer, 36), amount)
success := and(
or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())),
call(gas(), token, 0, freeMemoryPointer, 68, 0, 32)
)
}
require(success, "APPROVE_FAILED");
}
}
{
"compilationTarget": {
"src/LSSVMPairFactory.sol": "LSSVMPairFactory"
},
"evmVersion": "paris",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs"
},
"optimizer": {
"enabled": true,
"runs": 1000000
},
"remappings": [
":@manifoldxyz/=lib/",
":@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",
":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
":@prb/math/=lib/prb-math/src/",
":clones-with-immutable-args/=lib/clones-with-immutable-args/src/",
":create3-factory/=lib/create3-factory/src/",
":ds-test/=lib/forge-std/lib/ds-test/src/",
":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
":forge-std/=lib/forge-std/src/",
":libraries-solidity/=lib/libraries-solidity/contracts/",
":manifoldxyz/=lib/royalty-registry-solidity/contracts/",
":openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",
":openzeppelin-contracts/=lib/openzeppelin-contracts/contracts/",
":royalty-registry-solidity/=lib/royalty-registry-solidity/contracts/",
":solmate/=lib/solmate/src/"
]
}[{"inputs":[{"internalType":"contract LSSVMPairERC721ETH","name":"_erc721ETHTemplate","type":"address"},{"internalType":"contract LSSVMPairERC721ERC20","name":"_erc721ERC20Template","type":"address"},{"internalType":"contract LSSVMPairERC1155ETH","name":"_erc1155ETHTemplate","type":"address"},{"internalType":"contract LSSVMPairERC1155ERC20","name":"_erc1155ERC20Template","type":"address"},{"internalType":"address payable","name":"_protocolFeeRecipient","type":"address"},{"internalType":"uint256","name":"_protocolFeeMultiplier","type":"uint256"},{"internalType":"address","name":"_owner","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"LSSVMPairFactory__BondingCurveNotWhitelisted","type":"error"},{"inputs":[],"name":"LSSVMPairFactory__CannotCallRouter","type":"error"},{"inputs":[],"name":"LSSVMPairFactory__FeeTooLarge","type":"error"},{"inputs":[],"name":"LSSVMPairFactory__InvalidPair","type":"error"},{"inputs":[],"name":"LSSVMPairFactory__ReentrantCall","type":"error"},{"inputs":[],"name":"LSSVMPairFactory__SettingsNotEnabledForCollection","type":"error"},{"inputs":[],"name":"LSSVMPairFactory__SettingsNotEnabledForPair","type":"error"},{"inputs":[],"name":"LSSVMPairFactory__UnauthorizedCaller","type":"error"},{"inputs":[],"name":"LSSVMPairFactory__ZeroAddress","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"contract ICurve","name":"bondingCurve","type":"address"},{"indexed":false,"internalType":"bool","name":"isAllowed","type":"bool"}],"name":"BondingCurveStatusUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"target","type":"address"},{"indexed":false,"internalType":"bool","name":"isAllowed","type":"bool"}],"name":"CallTargetStatusUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"poolAddress","type":"address"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"ERC1155Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"poolAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"ERC20Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"poolAddress","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"name":"NFTDeposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"poolAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"initialBalance","type":"uint256"}],"name":"NewERC1155Pair","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"poolAddress","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"initialIds","type":"uint256[]"}],"name":"NewERC721Pair","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newMultiplier","type":"uint256"}],"name":"ProtocolFeeMultiplierUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"recipientAddress","type":"address"}],"name":"ProtocolFeeRecipientUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"contract LSSVMRouter","name":"router","type":"address"},{"indexed":false,"internalType":"bool","name":"isAllowed","type":"bool"}],"name":"RouterStatusUpdate","type":"event"},{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"address","name":"proposedAuthAddress","type":"address"}],"name":"authAllowedForToken","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract ICurve","name":"","type":"address"}],"name":"bondingCurveAllowed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"callAllowed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_protocolFeeMultiplier","type":"uint256"}],"name":"changeProtocolFeeMultiplier","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"_protocolFeeRecipient","type":"address"}],"name":"changeProtocolFeeRecipient","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"closeLock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"contract ERC20","name":"token","type":"address"},{"internalType":"contract IERC1155","name":"nft","type":"address"},{"internalType":"contract ICurve","name":"bondingCurve","type":"address"},{"internalType":"address payable","name":"assetRecipient","type":"address"},{"internalType":"enum LSSVMPair.PoolType","name":"poolType","type":"uint8"},{"internalType":"uint128","name":"delta","type":"uint128"},{"internalType":"uint96","name":"fee","type":"uint96"},{"internalType":"uint128","name":"spotPrice","type":"uint128"},{"internalType":"uint256","name":"nftId","type":"uint256"},{"internalType":"uint256","name":"initialNFTBalance","type":"uint256"},{"internalType":"uint256","name":"initialTokenBalance","type":"uint256"}],"internalType":"struct LSSVMPairFactory.CreateERC1155ERC20PairParams","name":"params","type":"tuple"}],"name":"createPairERC1155ERC20","outputs":[{"internalType":"contract LSSVMPairERC1155ERC20","name":"pair","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC1155","name":"_nft","type":"address"},{"internalType":"contract ICurve","name":"_bondingCurve","type":"address"},{"internalType":"address payable","name":"_assetRecipient","type":"address"},{"internalType":"enum LSSVMPair.PoolType","name":"_poolType","type":"uint8"},{"internalType":"uint128","name":"_delta","type":"uint128"},{"internalType":"uint96","name":"_fee","type":"uint96"},{"internalType":"uint128","name":"_spotPrice","type":"uint128"},{"internalType":"uint256","name":"_nftId","type":"uint256"},{"internalType":"uint256","name":"_initialNFTBalance","type":"uint256"}],"name":"createPairERC1155ETH","outputs":[{"internalType":"contract LSSVMPairERC1155ETH","name":"pair","type":"address"}],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"contract ERC20","name":"token","type":"address"},{"internalType":"contract IERC721","name":"nft","type":"address"},{"internalType":"contract ICurve","name":"bondingCurve","type":"address"},{"internalType":"address payable","name":"assetRecipient","type":"address"},{"internalType":"enum LSSVMPair.PoolType","name":"poolType","type":"uint8"},{"internalType":"uint128","name":"delta","type":"uint128"},{"internalType":"uint96","name":"fee","type":"uint96"},{"internalType":"uint128","name":"spotPrice","type":"uint128"},{"internalType":"address","name":"propertyChecker","type":"address"},{"internalType":"uint256[]","name":"initialNFTIDs","type":"uint256[]"},{"internalType":"uint256","name":"initialTokenBalance","type":"uint256"}],"internalType":"struct LSSVMPairFactory.CreateERC721ERC20PairParams","name":"params","type":"tuple"}],"name":"createPairERC721ERC20","outputs":[{"internalType":"contract LSSVMPairERC721ERC20","name":"pair","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC721","name":"_nft","type":"address"},{"internalType":"contract ICurve","name":"_bondingCurve","type":"address"},{"internalType":"address payable","name":"_assetRecipient","type":"address"},{"internalType":"enum LSSVMPair.PoolType","name":"_poolType","type":"uint8"},{"internalType":"uint128","name":"_delta","type":"uint128"},{"internalType":"uint96","name":"_fee","type":"uint96"},{"internalType":"uint128","name":"_spotPrice","type":"uint128"},{"internalType":"address","name":"_propertyChecker","type":"address"},{"internalType":"uint256[]","name":"_initialNFTIDs","type":"uint256[]"}],"name":"createPairERC721ETH","outputs":[{"internalType":"contract LSSVMPairERC721ETH","name":"pair","type":"address"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"contract IERC1155","name":"nft","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"depositERC1155","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract ERC20","name":"token","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"depositERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC721","name":"_nft","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"address","name":"recipient","type":"address"}],"name":"depositNFTs","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"settings","type":"address"},{"internalType":"address","name":"pairAddress","type":"address"}],"name":"disableSettingsForPair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"settings","type":"address"},{"internalType":"address","name":"pairAddress","type":"address"}],"name":"enableSettingsForPair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"erc1155ERC20Template","outputs":[{"internalType":"contract LSSVMPairERC1155ERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"erc1155ETHTemplate","outputs":[{"internalType":"contract LSSVMPairERC1155ETH","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"erc721ERC20Template","outputs":[{"internalType":"contract LSSVMPairERC721ERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"erc721ETHTemplate","outputs":[{"internalType":"contract LSSVMPairERC721ETH","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pairAddress","type":"address"}],"name":"getPairNFTType","outputs":[{"internalType":"enum ILSSVMPairFactoryLike.PairNFTType","name":"","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"pairAddress","type":"address"}],"name":"getPairTokenType","outputs":[{"internalType":"enum ILSSVMPairFactoryLike.PairTokenType","name":"","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"pairAddress","type":"address"}],"name":"getSettingsForPair","outputs":[{"internalType":"bool","name":"settingsEnabled","type":"bool"},{"internalType":"uint96","name":"bps","type":"uint96"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pairAddress","type":"address"}],"name":"isValidPair","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"openLock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"protocolFeeMultiplier","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"protocolFeeRecipient","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract LSSVMRouter","name":"","type":"address"}],"name":"routerStatus","outputs":[{"internalType":"bool","name":"allowed","type":"bool"},{"internalType":"bool","name":"wasEverTouched","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract ICurve","name":"bondingCurve","type":"address"},{"internalType":"bool","name":"isAllowed","type":"bool"}],"name":"setBondingCurveAllowed","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"target","type":"address"},{"internalType":"bool","name":"isAllowed","type":"bool"}],"name":"setCallAllowed","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract LSSVMRouter","name":"_router","type":"address"},{"internalType":"bool","name":"isAllowed","type":"bool"}],"name":"setRouterAllowed","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"settingsForCollection","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"settingsForPair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"settings","type":"address"},{"internalType":"address","name":"collectionAddress","type":"address"},{"internalType":"bool","name":"enable","type":"bool"}],"name":"toggleSettingsForCollection","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract ERC20","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdrawERC20ProtocolFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawETHProtocolFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]
