Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
Latest 1 internal transaction
Advanced mode:
Parent Transaction Hash | Block | From | To | |||
---|---|---|---|---|---|---|
17309196 | 419 days ago | Contract Creation | 0 ETH |
Loading...
Loading
This contract may be a proxy contract. Click on More Options and select Is this a proxy? to confirm and enable the "Read as Proxy" & "Write as Proxy" tabs.
Contract Name:
LSSVMPairERC721ERC20
Compiler Version
v0.8.20+commit.a1b79de6
Optimization Enabled:
Yes with 1000000 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: AGPL-3.0 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"; /** * @title An NFT/Token pair where the token is an ERC20 * @author boredGenius, 0xmons, 0xCygaar */ contract LSSVMPairERC721ERC20 is LSSVMPairERC721, LSSVMPairERC20 { uint256 internal constant IMMUTABLE_PARAMS_LENGTH = 101; constructor(IRoyaltyEngineV1 royaltyEngine) LSSVMPair(royaltyEngine) {} /** * Public functions */ /** * @inheritdoc LSSVMPair */ function pairVariant() public pure override returns (ILSSVMPairFactoryLike.PairVariant) { return ILSSVMPairFactoryLike.PairVariant.ERC721_ERC20; } /** * Internal functions */ /** * @inheritdoc LSSVMPair * @dev see LSSVMPairCloner for params length calculation */ function _immutableParamsLength() internal pure override returns (uint256) { return IMMUTABLE_PARAMS_LENGTH; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /// @author: manifold.xyz import "@openzeppelin/contracts/utils/introspection/IERC165.sol"; /** * @dev Lookup engine interface */ interface IRoyaltyEngineV1 is IERC165 { /** * Get the royalty for a given token (address, id) and value amount. Does not cache the bps/amounts. Caches the spec for a given token address * * @param tokenAddress - The address of the token * @param tokenId - The id of the token * @param value - The value you wish to get the royalty of * * returns Two arrays of equal length, royalty recipients and the corresponding amount each recipient should get */ function getRoyalty(address tokenAddress, uint256 tokenId, uint256 value) external returns (address payable[] memory recipients, uint256[] memory amounts); /** * View only version of getRoyalty * * @param tokenAddress - The address of the token * @param tokenId - The id of the token * @param value - The value you wish to get the royalty of * * returns Two arrays of equal length, royalty recipients and the corresponding amount each recipient should get */ function getRoyaltyView(address tokenAddress, uint256 tokenId, uint256 value) external view returns (address payable[] memory recipients, uint256[] memory amounts); }
// SPDX-License-Identifier: AGPL-3.0 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"; /** * @title The base contract for an NFT/TOKEN AMM pair * @author boredGenius, 0xmons, 0xCygaar * @notice This implements the core swap logic from NFT to TOKEN */ abstract contract LSSVMPair is OwnableWithTransferCallback, ERC721Holder, ERC1155Holder { /** * Library usage ** */ using Address for address; /** * Enums ** */ enum PoolType { TOKEN, NFT, TRADE } /** * Constants ** */ /** * @dev 50%, must <= 1 - MAX_PROTOCOL_FEE (set in LSSVMPairFactory) */ uint256 internal constant MAX_TRADE_FEE = 0.5e18; /** * Immutable params ** */ /** * @notice Sudoswap Royalty Engine */ IRoyaltyEngineV1 public immutable ROYALTY_ENGINE; /** * Storage variables ** */ /** * @dev This is generally used to mean the immediate sell price for the next marginal NFT. * However, this should NOT be assumed, as bonding curves may use spotPrice in different ways. * Use getBuyNFTQuote and getSellNFTQuote for accurate pricing info. */ uint128 public spotPrice; /** * @notice The parameter for the pair's bonding curve. * Units and meaning are bonding curve dependent. */ uint128 public delta; /** * @notice The spread between buy and sell prices, set to be a multiplier we apply to the buy price * Fee is only relevant for TRADE pools. Units are in base 1e18. */ uint96 public fee; /** * @notice The address that swapped assets are sent to. * For TRADE pools, assets are always sent to the pool, so this is used to track trade fee. * If set to address(0), will default to owner() for NFT and TOKEN pools. */ address payable internal assetRecipient; /** * Events */ 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); /** * Errors */ 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; } /** * @notice Called during pair creation to set initial parameters * @dev Only called once by factory to initialize. * We verify this by making sure that the current owner is address(0). * The Ownable library we use disallows setting the owner to be address(0), so this condition * should only be valid before the first initialize call. * @param _owner The owner of the pair * @param _assetRecipient The address that will receive the TOKEN or NFT sent to this pair during swaps. NOTE: If set to address(0), they will go to the pair itself. * @param _delta The initial delta of the bonding curve * @param _fee The initial % fee taken, if this is a trade pair * @param _spotPrice The initial price to sell an asset into the pair */ 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; } /** * External state-changing functions */ /** * @notice Sends token to the pair in exchange for a specific set of NFTs * @dev To compute the amount of token to send, call bondingCurve.getBuyInfo * This swap is meant for users who want specific IDs. Also higher chance of * reverting if some of the specified IDs leave the pool before the swap goes through. * @param nftIds The list of IDs of the NFTs to purchase * @param maxExpectedTokenInput The maximum acceptable cost from the sender. If the actual * amount is greater than this value, the transaction will be reverted. * @param nftRecipient The recipient of the NFTs * @param isRouter True if calling from LSSVMRouter, false otherwise. Not used for ETH pairs. * @param routerCaller If isRouter is true, ERC20 tokens will be transferred from this address. Not used for ETH pairs. * @return - The amount of token used for purchase */ function swapTokenForSpecificNFTs( uint256[] calldata nftIds, uint256 maxExpectedTokenInput, address nftRecipient, bool isRouter, address routerCaller ) external payable virtual returns (uint256); /** * @notice Sends a set of NFTs to the pair in exchange for token * @dev To compute the amount of token to that will be received, call bondingCurve.getSellInfo. * @param nftIds The list of IDs of the NFTs to sell to the pair * @param minExpectedTokenOutput The minimum acceptable token received by the sender. If the actual * amount is less than this value, the transaction will be reverted. * @param tokenRecipient The recipient of the token output * @param isRouter True if calling from LSSVMRouter, false otherwise. Not used for * ETH pairs. * @param routerCaller If isRouter is true, ERC20 tokens will be transferred from this address. Not used for * ETH pairs. * @return outputAmount The amount of token received */ function swapNFTsForToken( uint256[] calldata nftIds, uint256 minExpectedTokenOutput, address payable tokenRecipient, bool isRouter, address routerCaller ) external virtual returns (uint256 outputAmount); /** * View functions */ /** * @dev Used as read function to query the bonding curve for buy pricing info * @param numNFTs The number of NFTs to buy from the pair */ 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) { // Calculate the inputAmount minus tradeFee and protocolFee uint256 inputAmountMinusFees = inputAmount - tradeFee - protocolFee; // Compute royalties (,, royaltyAmount) = calculateRoyaltiesView(assetId, inputAmountMinusFees); inputAmount += royaltyAmount; } } /** * @dev Used as read function to query the bonding curve for sell pricing info including royalties * @param numNFTs The number of NFTs to sell to the pair */ 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, /* tradeFee */, protocolFee) = bondingCurve().getSellInfo(spotPrice, delta, numNFTs, fee, factory().protocolFeeMultiplier()); if (numNFTs != 0) { // Compute royalties (,, royaltyAmount) = calculateRoyaltiesView(assetId, outputAmount); // Deduct royalties from outputAmount unchecked { // Safe because we already require outputAmount >= royaltyAmount in _calculateRoyalties() outputAmount -= royaltyAmount; } } } /** * @notice Returns the pair's variant (Pair uses ETH or ERC20) */ 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))) } } /** * @notice Returns the type of bonding curve that parameterizes the pair */ function bondingCurve() public pure returns (ICurve _bondingCurve) { uint256 paramsLength = _immutableParamsLength(); assembly { _bondingCurve := shr(0x60, calldataload(add(sub(calldatasize(), paramsLength), 20))) } } /** * @notice Returns the address of NFT collection that parameterizes the pair */ function nft() public pure returns (address _nft) { uint256 paramsLength = _immutableParamsLength(); assembly { _nft := shr(0x60, calldataload(add(sub(calldatasize(), paramsLength), 40))) } } /** * @notice Returns the pair's type (TOKEN/NFT/TRADE) */ function poolType() public pure returns (PoolType _poolType) { uint256 paramsLength = _immutableParamsLength(); assembly { _poolType := shr(0xf8, calldataload(add(sub(calldatasize(), paramsLength), 60))) } } /** * @notice Returns the address that receives assets when a swap is done with this pair * Can be set to another address by the owner, but has no effect on TRADE pools * If set to address(0), defaults to owner() for NFT/TOKEN pools */ function getAssetRecipient() public view returns (address payable) { // TRADE pools will always receive the asset themselves if (poolType() == PoolType.TRADE) { return payable(address(this)); } address payable _assetRecipient = assetRecipient; // Otherwise, we return the recipient if it's been set // Or, we replace it with owner() if it's address(0) if (_assetRecipient == address(0)) { return payable(owner()); } return _assetRecipient; } /** * @notice Returns the address that receives trade fees when a swap is done with this pair * Only relevant for TRADE pools * If set to address(0), defaults to the pair itself */ function getFeeRecipient() public view returns (address payable _feeRecipient) { _feeRecipient = assetRecipient; if (_feeRecipient == address(0)) { _feeRecipient = payable(address(this)); } } /** * Internal functions */ /** * @notice Calculates the amount needed to be sent into the pair for a buy and adjusts spot price or delta if necessary * @param numNFTs The amount of NFTs to purchase from the pair * @param _bondingCurve The bonding curve to use for price calculation * @param _factory The factory to use for protocol fee lookup * @return tradeFee The amount of tokens to send as trade fee * @return protocolFee The amount of tokens to send as protocol fee * @return inputAmount The amount of tokens total tokens receive */ function _calculateBuyInfoAndUpdatePoolParams(uint256 numNFTs, ICurve _bondingCurve, ILSSVMPairFactoryLike _factory) internal returns (uint256 tradeFee, uint256 protocolFee, uint256 inputAmount) { CurveErrorCodes.Error error; // Save on 2 SLOADs by caching uint128 currentSpotPrice = spotPrice; uint128 currentDelta = delta; uint128 newDelta; uint128 newSpotPrice; (error, newSpotPrice, newDelta, inputAmount, tradeFee, protocolFee) = _bondingCurve.getBuyInfo(currentSpotPrice, currentDelta, numNFTs, fee, _factory.protocolFeeMultiplier()); // Revert if bonding curve had an error if (error != CurveErrorCodes.Error.OK) { revert LSSVMPair__BondingCurveError(error); } // Consolidate writes to save gas if (currentSpotPrice != newSpotPrice || currentDelta != newDelta) { spotPrice = newSpotPrice; delta = newDelta; } // Emit spot price update if it has been updated if (currentSpotPrice != newSpotPrice) { emit SpotPriceUpdate(newSpotPrice); } // Emit delta update if it has been updated if (currentDelta != newDelta) { emit DeltaUpdate(newDelta); } } /** * @notice Calculates the amount needed to be sent by the pair for a sell and adjusts spot price or delta if necessary * @param numNFTs The amount of NFTs to send to the the pair * @param _bondingCurve The bonding curve to use for price calculation * @param _factory The factory to use for protocol fee lookup * @return protocolFee The amount of tokens to send as protocol fee * @return outputAmount The amount of tokens total tokens receive */ function _calculateSellInfoAndUpdatePoolParams( uint256 numNFTs, ICurve _bondingCurve, ILSSVMPairFactoryLike _factory ) internal returns (uint256 protocolFee, uint256 outputAmount) { CurveErrorCodes.Error error; // Save on 2 SLOADs by caching uint128 currentSpotPrice = spotPrice; uint128 currentDelta = delta; uint128 newSpotPrice; uint128 newDelta; (error, newSpotPrice, newDelta, outputAmount, /*tradeFee*/, protocolFee) = _bondingCurve.getSellInfo(currentSpotPrice, currentDelta, numNFTs, fee, _factory.protocolFeeMultiplier()); // Revert if bonding curve had an error if (error != CurveErrorCodes.Error.OK) { revert LSSVMPair__BondingCurveError(error); } // Consolidate writes to save gas if (currentSpotPrice != newSpotPrice || currentDelta != newDelta) { spotPrice = newSpotPrice; delta = newDelta; } // Emit spot price update if it has been updated if (currentSpotPrice != newSpotPrice) { emit SpotPriceUpdate(newSpotPrice); } // Emit delta update if it has been updated if (currentDelta != newDelta) { emit DeltaUpdate(newDelta); } } /** * @notice Pulls the token input of a trade from the trader (including all royalties and fees) * @param inputAmountExcludingRoyalty The amount of tokens to be sent, excluding the royalty (includes protocol fee) * @param royaltyAmounts The amounts of tokens to be sent as royalties * @param royaltyRecipients The recipients of the royalties * @param royaltyTotal The sum of all royaltyAmounts * @param tradeFeeAmount The amount of tokens to be sent as trade fee (if applicable) * @param isRouter Whether or not the caller is LSSVMRouter * @param routerCaller If called from LSSVMRouter, store the original caller * @param protocolFee The protocol fee to be paid */ function _pullTokenInputs( uint256 inputAmountExcludingRoyalty, uint256[] memory royaltyAmounts, address payable[] memory royaltyRecipients, uint256 royaltyTotal, uint256 tradeFeeAmount, bool isRouter, address routerCaller, uint256 protocolFee ) internal virtual; /** * @notice Sends excess tokens back to the caller (if applicable) * @dev Swap callers interacting with an ETH pair must be able to receive ETH (e.g. if the caller sends too much ETH) */ function _refundTokenToSender(uint256 inputAmount) internal virtual; /** * @notice Sends tokens to a recipient * @param tokenRecipient The address receiving the tokens * @param outputAmount The amount of tokens to send */ function _sendTokenOutput(address payable tokenRecipient, uint256 outputAmount) internal virtual; /** * @dev Used internally to grab pair parameters from calldata, see LSSVMPairCloner for technical details */ function _immutableParamsLength() internal pure virtual returns (uint256); /** * Royalty support functions */ 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); } /** * @dev Same as _calculateRoyalties, but uses getRoyaltyView to avoid state mutations and is public for external callers */ 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); } /** * @dev Common logic used by _calculateRoyalties() and calculateRoyaltiesView() */ function _calculateRoyaltiesLogic(address payable[] memory recipients, uint256[] memory amounts, uint256 saleAmount) internal view returns (address payable[] memory royaltyRecipients, uint256[] memory royaltyAmounts, uint256 royaltyTotal) { // Cache to save gas uint256 numRecipients = recipients.length; if (numRecipients != 0) { // If a pair has custom Settings, use the overridden royalty amount and only use the first receiver 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; // Update numRecipients to match new recipients list numRecipients = 1; } else { royaltyRecipients = recipients; royaltyAmounts = amounts; } } catch { // Use the input values to calculate royalties if factory call fails royaltyRecipients = recipients; royaltyAmounts = amounts; } } for (uint256 i; i < numRecipients;) { royaltyTotal += royaltyAmounts[i]; unchecked { ++i; } } // Ensure royalty total is at most 25% of the sale amount // This defends against a rogue Manifold registry that charges extremely high royalties if (royaltyTotal > saleAmount >> 2) { revert LSSVMPair__RoyaltyTooLarge(); } } /** * Owner functions */ /** * @notice Rescues a specified set of NFTs owned by the pair to the owner address. (onlyOwnable modifier is in the implemented function) * @param a The NFT to transfer * @param nftIds The list of IDs of the NFTs to send to the owner */ function withdrawERC721(IERC721 a, uint256[] calldata nftIds) external virtual; /** * @notice Rescues ERC20 tokens from the pair to the owner. Only callable by the owner (onlyOwnable modifier is in the implemented function). * @param a The token to transfer * @param amount The amount of tokens to send to the owner */ function withdrawERC20(ERC20 a, uint256 amount) external virtual; /** * @notice Rescues ERC1155 tokens from the pair to the owner. Only callable by the owner. * @param a The NFT to transfer * @param ids The NFT ids to transfer * @param amounts The amounts of each id to transfer */ function withdrawERC1155(IERC1155 a, uint256[] calldata ids, uint256[] calldata amounts) external virtual; /** * @notice Updates the selling spot price. Only callable by the owner. * @param newSpotPrice The new selling spot price value, in Token */ function changeSpotPrice(uint128 newSpotPrice) external onlyOwner { ICurve _bondingCurve = bondingCurve(); if (!_bondingCurve.validateSpotPrice(newSpotPrice)) revert LSSVMPair__InvalidSpotPrice(); if (spotPrice != newSpotPrice) { spotPrice = newSpotPrice; emit SpotPriceUpdate(newSpotPrice); } } /** * @notice Updates the delta parameter. Only callable by the owner. * @param newDelta The new delta parameter */ function changeDelta(uint128 newDelta) external onlyOwner { ICurve _bondingCurve = bondingCurve(); if (!_bondingCurve.validateDelta(newDelta)) revert LSSVMPair__InvalidDelta(); if (delta != newDelta) { delta = newDelta; emit DeltaUpdate(newDelta); } } /** * @notice Updates the fee taken by the LP. Only callable by the owner. * Only callable if the pool is a Trade pool. Reverts if the fee is >= MAX_FEE. * @param newFee The new LP fee percentage, 18 decimals */ 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); } } /** * @notice Changes the address that will receive assets received from * trades. Only callable by the owner. * @param newRecipient The new asset recipient */ function changeAssetRecipient(address payable newRecipient) external onlyOwner { if (assetRecipient != newRecipient) { assetRecipient = newRecipient; emit AssetRecipientChange(newRecipient); } } function _preCallCheck(address target) internal virtual; /** * @notice Allows the pair to make arbitrary external calls to contracts * whitelisted by the protocol. Only callable by the owner. * @param target The contract to call * @param data The calldata to pass to the contract */ function call(address payable target, bytes calldata data) external onlyOwner { ILSSVMPairFactoryLike _factory = factory(); if (!_factory.callAllowed(target)) revert LSSVMPair__TargetNotAllowed(); // Ensure the call isn't calling a banned function 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(); } // Prevent calling the pair's underlying nft // (We ban calling the underlying NFT/ERC20 to avoid maliciously transferring assets approved for the pair to spend) if (target == nft()) revert LSSVMPair__TargetNotAllowed(); _preCallCheck(target); (bool success,) = target.call{value: 0}(data); if (!success) revert LSSVMPair__CallFailed(); } /** * @notice Allows owner to batch multiple calls, forked from: https://github.com/boringcrypto/BoringSolidity/blob/master/contracts/BoringBatchable.sol * @notice The revert handling is forked from: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/c239e1af8d1a1296577108dd6989a17b57434f8e/contracts/utils/Address.sol#L201 * @dev Intended for withdrawing/altering pool pricing in one tx, only callable by owner, cannot change owner * @param calls The calldata for each call to make * @param revertOnFail Whether or not to revert the entire tx if any of the calls fail. Calls to transferOwnership will revert regardless. */ function multicall(bytes[] calldata calls, bool revertOnFail) external onlyOwner { for (uint256 i; i < calls.length;) { bytes4 sig = bytes4(calls[i][:4]); // We ban calling transferOwnership when ownership 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; } } } }
// SPDX-License-Identifier: AGPL-3.0 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"; /** * @title An NFT/Token pair where the token is an ERC20 * @author boredGenius, 0xmons, 0xCygaar */ abstract contract LSSVMPairERC20 is LSSVMPair { using SafeTransferLib for ERC20; error LSSVMPairERC20__RoyaltyNotPaid(); error LSSVMPairERC20__MsgValueNotZero(); error LSSVMPairERC20__AssetRecipientNotPaid(); /** * @notice Returns the ERC20 token associated with the pair * @dev See LSSVMPairCloner for an explanation on how this works * @dev The last 20 bytes of the immutable data contain the ERC20 token address */ function token() public pure returns (ERC20 _token) { assembly { _token := shr(0x60, calldataload(sub(calldatasize(), 20))) } } /** * @inheritdoc LSSVMPair */ function _pullTokenInputs( uint256 inputAmountExcludingRoyalty, uint256[] memory royaltyAmounts, address payable[] memory royaltyRecipients, uint256, /* royaltyTotal */ uint256 tradeFeeAmount, bool isRouter, address routerCaller, uint256 protocolFee ) internal override { address _assetRecipient = getAssetRecipient(); // Transfer tokens if (isRouter) { // Verify if router is allowed // Locally scoped to avoid stack too deep { (bool routerAllowed,) = factory().routerStatus(LSSVMRouter(payable(msg.sender))); if (!routerAllowed) revert LSSVMPair__NotRouter(); } // Cache state and then call router to transfer tokens from user uint256 beforeBalance = token().balanceOf(_assetRecipient); LSSVMRouter(payable(msg.sender)).pairTransferERC20From( token(), routerCaller, _assetRecipient, inputAmountExcludingRoyalty - protocolFee ); // Verify token transfer (protect pair against malicious router) ERC20 token_ = token(); if (token_.balanceOf(_assetRecipient) - beforeBalance != (inputAmountExcludingRoyalty - protocolFee)) { revert LSSVMPairERC20__AssetRecipientNotPaid(); } // Transfer royalties (if they exist) 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; } } // Take protocol fee (if it exists) if (protocolFee != 0) { LSSVMRouter(payable(msg.sender)).pairTransferERC20From( token_, routerCaller, address(factory()), protocolFee ); } } else { // Transfer tokens directly (sans the protocol fee) ERC20 token_ = token(); token_.safeTransferFrom(msg.sender, _assetRecipient, inputAmountExcludingRoyalty - protocolFee); // Transfer royalties (if they exists) for (uint256 i; i < royaltyRecipients.length;) { token_.safeTransferFrom(msg.sender, royaltyRecipients[i], royaltyAmounts[i]); unchecked { ++i; } } // Take protocol fee (if it exists) if (protocolFee != 0) { token_.safeTransferFrom(msg.sender, address(factory()), protocolFee); } } // Send trade fee if it exists, is TRADE pool, and fee recipient != pool address // @dev: (note that tokens are sent from the pool and not the caller) if (poolType() == PoolType.TRADE && tradeFeeAmount != 0) { address payable _feeRecipient = getFeeRecipient(); if (_feeRecipient != _assetRecipient) { token().safeTransfer(_feeRecipient, tradeFeeAmount); } } } /** * @inheritdoc LSSVMPair */ function _refundTokenToSender(uint256 inputAmount) internal override { // Do nothing since we transferred the exact input amount } /** * @inheritdoc LSSVMPair */ function _sendTokenOutput(address payable tokenRecipient, uint256 outputAmount) internal override { // Send tokens to caller if (outputAmount != 0) { token().safeTransfer(tokenRecipient, outputAmount); } } /** * @inheritdoc LSSVMPair */ function withdrawERC20(ERC20 a, uint256 amount) external override onlyOwner { a.safeTransfer(msg.sender, amount); if (a == token()) { // emit event since it is the pair token emit TokenWithdrawal(amount); } } function _preCallCheck(address target) internal pure override { if (target == address(token())) revert LSSVMPair__TargetNotAllowed(); } }
// SPDX-License-Identifier: AGPL-3.0 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"; /** * @title LSSVMPairERC721 * @author boredGenius, 0xmons, 0xCygaar * @notice An NFT/Token pair for an ERC721 NFT */ abstract contract LSSVMPairERC721 is LSSVMPair { error LSSVMPairERC721__PropertyCheckFailed(); error LSSVMPairERC721__NeedPropertyChecking(); /** * External state-changing functions */ /** * @inheritdoc LSSVMPair */ function swapTokenForSpecificNFTs( uint256[] calldata nftIds, uint256 maxExpectedTokenInput, address nftRecipient, bool isRouter, address routerCaller ) external payable virtual override returns (uint256) { // Store locally to remove extra calls factory().openLock(); // Input validation { PoolType _poolType = poolType(); if (_poolType == PoolType.TOKEN) revert LSSVMPair__WrongPoolType(); if (nftIds.length == 0) revert LSSVMPair__ZeroSwapAmount(); } // Call bonding curve for pricing information uint256 protocolFee; uint256 tradeFee; uint256 inputAmountExcludingRoyalty; (tradeFee, protocolFee, inputAmountExcludingRoyalty) = _calculateBuyInfoAndUpdatePoolParams(nftIds.length, bondingCurve(), factory()); // Calculate royalties (address payable[] memory royaltyRecipients, uint256[] memory royaltyAmounts, uint256 royaltyTotal) = _calculateRoyalties(nftIds[0], inputAmountExcludingRoyalty - protocolFee - tradeFee); // Revert if the input amount is too large 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); } /** * @inheritdoc LSSVMPair */ 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); } /** * @notice Sends a set of NFTs to the pair in exchange for token * @dev To compute the amount of token to that will be received, call bondingCurve.getSellInfo. * @param nftIds The list of IDs of the NFTs to sell to the pair * @param minExpectedTokenOutput The minimum acceptable token received by the sender. If the actual * amount is less than this value, the transaction will be reverted. * @param tokenRecipient The recipient of the token output * @param isRouter True if calling from LSSVMRouter, false otherwise. Not used for * ETH pairs. * @param routerCaller If isRouter is true, ERC20 tokens will be transferred from this address. Not used for * ETH pairs. * @param propertyCheckerParams Parameters to pass into the pair's underlying property checker * @return outputAmount The amount of token received */ 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); } /** * View functions */ /** * @notice Returns the property checker address */ function propertyChecker() public pure returns (address _propertyChecker) { uint256 paramsLength = _immutableParamsLength(); assembly { _propertyChecker := shr(0x60, calldataload(add(sub(calldatasize(), paramsLength), 61))) } } /** * Internal functions */ function _swapNFTsForToken( uint256[] calldata nftIds, uint256 minExpectedTokenOutput, address payable tokenRecipient, bool isRouter, address routerCaller ) internal virtual returns (uint256 outputAmount) { // Store locally to remove extra calls ILSSVMPairFactoryLike _factory = factory(); _factory.openLock(); // Input validation { PoolType _poolType = poolType(); if (_poolType == PoolType.NFT) revert LSSVMPair__WrongPoolType(); if (nftIds.length == 0) revert LSSVMPair__ZeroSwapAmount(); } // Call bonding curve for pricing information uint256 protocolFee; (protocolFee, outputAmount) = _calculateSellInfoAndUpdatePoolParams(nftIds.length, bondingCurve(), _factory); // Compute royalties (address payable[] memory royaltyRecipients, uint256[] memory royaltyAmounts, uint256 royaltyTotal) = _calculateRoyalties(nftIds[0], outputAmount); // Deduct royalties from outputAmount unchecked { // Safe because we already require outputAmount >= royaltyTotal in calculateRoyalties() 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); } /** * @notice Sends specific NFTs to a recipient address * @dev Even though we specify the NFT address here, this internal function is only * used to send NFTs associated with this specific pool. * @param _nft The address of the NFT to send * @param nftRecipient The receiving address for the NFTs * @param nftIds The specific IDs of NFTs to send */ function _sendSpecificNFTsToRecipient(IERC721 _nft, address nftRecipient, uint256[] calldata nftIds) internal virtual { // Send NFTs to recipient uint256 numNFTs = nftIds.length; for (uint256 i; i < numNFTs;) { _nft.transferFrom(address(this), nftRecipient, nftIds[i]); unchecked { ++i; } } } /** * @notice Takes NFTs from the caller and sends them into the pair's asset recipient * @dev This is used by the LSSVMPair's swapNFTForToken function. * @param _nft The NFT collection to take from * @param nftIds The specific NFT IDs to take * @param isRouter True if calling from LSSVMRouter, false otherwise. Not used for ETH pairs. * @param routerCaller If isRouter is true, ERC20 tokens will be transferred from this address. Not used for ETH pairs. */ function _takeNFTsFromSender( IERC721 _nft, uint256[] calldata nftIds, ILSSVMPairFactoryLike _factory, bool isRouter, address routerCaller ) internal virtual { { address _assetRecipient = getAssetRecipient(); uint256 numNFTs = nftIds.length; if (isRouter) { // Verify if router is allowed LSSVMRouter router = LSSVMRouter(payable(msg.sender)); (bool routerAllowed,) = _factory.routerStatus(router); if (!routerAllowed) revert LSSVMPair__NotRouter(); // Call router to pull NFTs // If more than 1 NFT is being transfered, and there is no property checker, we can do a balance check // instead of an ownership check, as pools are indifferent between NFTs from the same collection 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(); } } // Otherwise we need to pull each asset 1 at a time and verify ownership 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 { // Pull NFTs directly from sender for (uint256 i; i < numNFTs;) { _nft.transferFrom(msg.sender, _assetRecipient, nftIds[i]); unchecked { ++i; } } } } } /** * Owner functions */ /** * @notice Rescues a specified set of NFTs owned by the pair to the owner address. (onlyOwner modifier is in the implemented function) * @param a The NFT to transfer * @param nftIds The list of IDs of the NFTs to send to the owner */ 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); } } /** * @notice Rescues ERC1155 tokens from the pair to the owner. Only callable by the owner. * @param a The NFT to transfer * @param ids The NFT ids to transfer * @param amounts The amounts of each id to transfer */ function withdrawERC1155(IERC1155 a, uint256[] calldata ids, uint256[] calldata amounts) external virtual override onlyOwner { a.safeBatchTransferFrom(address(this), msg.sender, ids, amounts, ""); } }
// SPDX-License-Identifier: AGPL-3.0 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; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); }
// SPDX-License-Identifier: AGPL-3.0-only pragma solidity >=0.8.0; /// @notice Modern and gas efficient ERC20 + EIP-2612 implementation. /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC20.sol) /// @author Modified from Uniswap (https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2ERC20.sol) /// @dev Do not manually set balances without updating totalSupply, as the sum of all user balances must not exceed it. abstract contract ERC20 { /*////////////////////////////////////////////////////////////// EVENTS //////////////////////////////////////////////////////////////*/ event Transfer(address indexed from, address indexed to, uint256 amount); event Approval(address indexed owner, address indexed spender, uint256 amount); /*////////////////////////////////////////////////////////////// METADATA STORAGE //////////////////////////////////////////////////////////////*/ string public name; string public symbol; uint8 public immutable decimals; /*////////////////////////////////////////////////////////////// ERC20 STORAGE //////////////////////////////////////////////////////////////*/ uint256 public totalSupply; mapping(address => uint256) public balanceOf; mapping(address => mapping(address => uint256)) public allowance; /*////////////////////////////////////////////////////////////// EIP-2612 STORAGE //////////////////////////////////////////////////////////////*/ uint256 internal immutable INITIAL_CHAIN_ID; bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR; mapping(address => uint256) public nonces; /*////////////////////////////////////////////////////////////// CONSTRUCTOR //////////////////////////////////////////////////////////////*/ constructor( string memory _name, string memory _symbol, uint8 _decimals ) { name = _name; symbol = _symbol; decimals = _decimals; INITIAL_CHAIN_ID = block.chainid; INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator(); } /*////////////////////////////////////////////////////////////// ERC20 LOGIC //////////////////////////////////////////////////////////////*/ 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; // Cannot overflow because the sum of all user // balances can't exceed the max uint256 value. 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]; // Saves gas for limited approvals. if (allowed != type(uint256).max) allowance[from][msg.sender] = allowed - amount; balanceOf[from] -= amount; // Cannot overflow because the sum of all user // balances can't exceed the max uint256 value. unchecked { balanceOf[to] += amount; } emit Transfer(from, to, amount); return true; } /*////////////////////////////////////////////////////////////// EIP-2612 LOGIC //////////////////////////////////////////////////////////////*/ 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 because the only math done is incrementing // the owner's nonce which cannot realistically overflow. 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) ) ); } /*////////////////////////////////////////////////////////////// INTERNAL MINT/BURN LOGIC //////////////////////////////////////////////////////////////*/ function _mint(address to, uint256 amount) internal virtual { totalSupply += amount; // Cannot overflow because the sum of all user // balances can't exceed the max uint256 value. unchecked { balanceOf[to] += amount; } emit Transfer(address(0), to, amount); } function _burn(address from, uint256 amount) internal virtual { balanceOf[from] -= amount; // Cannot underflow because a user's balance // will never be larger than the total supply. unchecked { totalSupply -= amount; } emit Transfer(from, address(0), amount); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * * Furthermore, `isContract` will also return true if the target contract within * the same transaction is already scheduled for destruction by `SELFDESTRUCT`, * which only has an effect at the end of a transaction. * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ 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"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ 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"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ 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); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ 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); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ 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); } /** * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract. * * _Available since v4.8._ */ function verifyCallResultFromTarget( address target, bool success, bytes memory returndata, string memory errorMessage ) internal view returns (bytes memory) { if (success) { if (returndata.length == 0) { // only check isContract if the call was successful and the return data is empty // otherwise we already know that it was a contract require(isContract(target), "Address: call to non-contract"); } return returndata; } else { _revert(returndata, errorMessage); } } /** * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason or using the provided one. * * _Available since v4.3._ */ 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 { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/IERC721.sol) pragma solidity ^0.8.0; import "../../utils/introspection/IERC165.sol"; /** * @dev Required interface of an ERC721 compliant contract. */ interface IERC721 is IERC165 { /** * @dev Emitted when `tokenId` token is transferred from `from` to `to`. */ event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token. */ event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets. */ event ApprovalForAll(address indexed owner, address indexed operator, bool approved); /** * @dev Returns the number of tokens in ``owner``'s account. */ function balanceOf(address owner) external view returns (uint256 balance); /** * @dev Returns the owner of the `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function ownerOf(uint256 tokenId) external view returns (address owner); /** * @dev Safely transfers `tokenId` token from `from` to `to`. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external; /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom(address from, address to, uint256 tokenId) external; /** * @dev Transfers `tokenId` token from `from` to `to`. * * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721 * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must * understand this adds an external call which potentially creates a reentrancy vulnerability. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * * Emits a {Transfer} event. */ function transferFrom(address from, address to, uint256 tokenId) external; /** * @dev Gives permission to `to` to transfer `tokenId` token to another account. * The approval is cleared when the token is transferred. * * Only a single account can be approved at a time, so approving the zero address clears previous approvals. * * Requirements: * * - The caller must own the token or be an approved operator. * - `tokenId` must exist. * * Emits an {Approval} event. */ function approve(address to, uint256 tokenId) external; /** * @dev Approve or remove `operator` as an operator for the caller. * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. * * Requirements: * * - The `operator` cannot be the caller. * * Emits an {ApprovalForAll} event. */ function setApprovalForAll(address operator, bool approved) external; /** * @dev Returns the account approved for `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`. * * See {setApprovalForAll} */ function isApprovedForAll(address owner, address operator) external view returns (bool); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (token/ERC1155/IERC1155.sol) pragma solidity ^0.8.0; import "../../utils/introspection/IERC165.sol"; /** * @dev Required interface of an ERC1155 compliant contract, as defined in the * https://eips.ethereum.org/EIPS/eip-1155[EIP]. * * _Available since v3.1._ */ interface IERC1155 is IERC165 { /** * @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`. */ event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value); /** * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all * transfers. */ event TransferBatch( address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values ); /** * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to * `approved`. */ event ApprovalForAll(address indexed account, address indexed operator, bool approved); /** * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI. * * If an {URI} event was emitted for `id`, the standard * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value * returned by {IERC1155MetadataURI-uri}. */ event URI(string value, uint256 indexed id); /** * @dev Returns the amount of tokens of token type `id` owned by `account`. * * Requirements: * * - `account` cannot be the zero address. */ function balanceOf(address account, uint256 id) external view returns (uint256); /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}. * * Requirements: * * - `accounts` and `ids` must have the same length. */ function balanceOfBatch( address[] calldata accounts, uint256[] calldata ids ) external view returns (uint256[] memory); /** * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`, * * Emits an {ApprovalForAll} event. * * Requirements: * * - `operator` cannot be the caller. */ function setApprovalForAll(address operator, bool approved) external; /** * @dev Returns true if `operator` is approved to transfer ``account``'s tokens. * * See {setApprovalForAll}. */ function isApprovedForAll(address account, address operator) external view returns (bool); /** * @dev Transfers `amount` tokens of token type `id` from `from` to `to`. * * Emits a {TransferSingle} event. * * Requirements: * * - `to` cannot be the zero address. * - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}. * - `from` must have a balance of tokens of type `id` of at least `amount`. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the * acceptance magic value. */ function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes calldata data) external; /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}. * * Emits a {TransferBatch} event. * * Requirements: * * - `ids` and `amounts` must have the same length. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the * acceptance magic value. */ function safeBatchTransferFrom( address from, address to, uint256[] calldata ids, uint256[] calldata amounts, bytes calldata data ) external; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (token/ERC721/utils/ERC721Holder.sol) pragma solidity ^0.8.0; import "../IERC721Receiver.sol"; /** * @dev Implementation of the {IERC721Receiver} interface. * * Accepts all token transfers. * Make sure the contract is able to use its token with {IERC721-safeTransferFrom}, {IERC721-approve} or {IERC721-setApprovalForAll}. */ contract ERC721Holder is IERC721Receiver { /** * @dev See {IERC721Receiver-onERC721Received}. * * Always returns `IERC721Receiver.onERC721Received.selector`. */ function onERC721Received(address, address, uint256, bytes memory) public virtual override returns (bytes4) { return this.onERC721Received.selector; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/utils/ERC1155Holder.sol) pragma solidity ^0.8.0; import "./ERC1155Receiver.sol"; /** * Simple implementation of `ERC1155Receiver` that will allow a contract to hold ERC1155 tokens. * * IMPORTANT: When inheriting this contract, you must include a way to use the received tokens, otherwise they will be * stuck. * * @dev _Available since v3.1._ */ 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; } }
// SPDX-License-Identifier: AGPL-3.0 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; } /** * ETH swaps */ /** * @notice Swaps ETH into specific NFTs using multiple pairs. * @param swapList The list of pairs to trade with and the IDs of the NFTs to buy from each. * @param ethRecipient The address that will receive the unspent ETH input * @param nftRecipient The address that will receive the NFT output * @param deadline The Unix timestamp (in seconds) at/after which the swap will revert * @return remainingValue The unspent ETH amount */ 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); } /** * @notice Swaps one set of NFTs into another set of specific NFTs using multiple pairs, using * ETH as the intermediary. * @param trade The struct containing all NFT-to-ETH swaps and ETH-to-NFT swaps. * @param minOutput The minimum acceptable total excess ETH received * @param ethRecipient The address that will receive the ETH output * @param nftRecipient The address that will receive the NFT output * @param deadline The Unix timestamp (in seconds) at/after which the swap will revert * @return outputAmount The total ETH received */ function swapNFTsForSpecificNFTsThroughETH( NFTsForSpecificNFTsTrade calldata trade, uint256 minOutput, address payable ethRecipient, address nftRecipient, uint256 deadline ) external payable checkDeadline(deadline) returns (uint256 outputAmount) { // Swap NFTs for ETH // minOutput of swap set to 0 since we're doing an aggregate slippage check outputAmount = _swapNFTsForToken(trade.nftToTokenTrades, 0, payable(address(this))); // Add extra value to buy NFTs outputAmount += msg.value; // Swap ETH for specific NFTs // cost <= inputValue = outputAmount - minOutput, so outputAmount' = (outputAmount - minOutput - cost) + minOutput >= minOutput outputAmount = _swapETHForSpecificNFTs( trade.tokenToNFTTrades, outputAmount - minOutput, ethRecipient, nftRecipient ) + minOutput; } /** * ERC20 swaps * * Note: All ERC20 swaps assume that a single ERC20 token is used for all the pairs involved. * Swapping using multiple tokens in the same transaction is possible, but the slippage checks * & the return values will be meaningless, and may lead to undefined behavior. * * Note: The sender should ideally grant infinite token approval to the router in order for NFT-to-NFT * swaps to work smoothly. */ /** * @notice Swaps ERC20 tokens into specific NFTs using multiple pairs. * @param swapList The list of pairs to trade with and the IDs of the NFTs to buy from each. * @param inputAmount The amount of ERC20 tokens to add to the ERC20-to-NFT swaps * @param nftRecipient The address that will receive the NFT output * @param deadline The Unix timestamp (in seconds) at/after which the swap will revert * @return remainingValue The unspent token amount */ function swapERC20ForSpecificNFTs( PairSwapSpecific[] calldata swapList, uint256 inputAmount, address nftRecipient, uint256 deadline ) external checkDeadline(deadline) returns (uint256 remainingValue) { return _swapERC20ForSpecificNFTs(swapList, inputAmount, nftRecipient); } /** * @notice Swaps NFTs into ETH/ERC20 using multiple pairs. * @param swapList The list of pairs to trade with and the IDs of the NFTs to sell to each. * @param minOutput The minimum acceptable total tokens received * @param tokenRecipient The address that will receive the token output * @param deadline The Unix timestamp (in seconds) at/after which the swap will revert * @return outputAmount The total tokens received */ function swapNFTsForToken( PairSwapSpecific[] calldata swapList, uint256 minOutput, address tokenRecipient, uint256 deadline ) external checkDeadline(deadline) returns (uint256 outputAmount) { return _swapNFTsForToken(swapList, minOutput, payable(tokenRecipient)); } /** * @notice Swaps one set of NFTs into another set of specific NFTs using multiple pairs, using * an ERC20 token as the intermediary. * @param trade The struct containing all NFT-to-ERC20 swaps and ERC20-to-NFT swaps. * @param inputAmount The amount of ERC20 tokens to add to the ERC20-to-NFT swaps * @param minOutput The minimum acceptable total excess tokens received * @param nftRecipient The address that will receive the NFT output * @param deadline The Unix timestamp (in seconds) at/after which the swap will revert * @return outputAmount The total ERC20 tokens received */ function swapNFTsForSpecificNFTsThroughERC20( NFTsForSpecificNFTsTrade calldata trade, uint256 inputAmount, uint256 minOutput, address nftRecipient, uint256 deadline ) external checkDeadline(deadline) returns (uint256 outputAmount) { // Swap NFTs for ERC20 // minOutput of swap set to 0 since we're doing an aggregate slippage check // output tokens are sent to msg.sender outputAmount = _swapNFTsForToken(trade.nftToTokenTrades, 0, payable(msg.sender)); // Add extra value to buy NFTs outputAmount += inputAmount; // Swap ERC20 for specific NFTs // cost <= maxCost = outputAmount - minOutput, so outputAmount' = outputAmount - cost >= minOutput // input tokens are taken directly from msg.sender outputAmount = _swapERC20ForSpecificNFTs(trade.tokenToNFTTrades, outputAmount - minOutput, nftRecipient) + minOutput; } /** * Robust Swaps * These are "robust" versions of the NFT<>Token swap functions which will never revert due to slippage * Instead, users specify a per-swap max cost. If the price changes more than the user specifies, no swap is attempted. This allows users to specify a batch of swaps, and execute as many of them as possible. */ /** * @dev Ensure msg.value >= sum of values in maxCostPerPair to make sure the transaction doesn't revert * @param swapList The list of pairs to trade with and the IDs of the NFTs to buy from each. * @param ethRecipient The address that will receive the unspent ETH input * @param nftRecipient The address that will receive the NFT output * @param deadline The Unix timestamp (in seconds) at/after which the swap will revert * @return remainingValue The unspent token amount */ 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; // Try doing each swap uint256 numSwaps = swapList.length; for (uint256 i; i < numSwaps;) { // Calculate actual cost per swap (error,,, pairCost,,) = swapList[i].swapInfo.pair.getBuyNFTQuote( swapList[i].swapInfo.nftIds[0], swapList[i].swapInfo.nftIds.length ); // If within our maxCost and no error, proceed if (pairCost <= swapList[i].maxCost && error == CurveErrorCodes.Error.OK) { // We know how much ETH to send because we already did the math above // So we just send that much remainingValue -= swapList[i].swapInfo.pair.swapTokenForSpecificNFTs{value: pairCost}( swapList[i].swapInfo.nftIds, pairCost, nftRecipient, true, msg.sender ); } unchecked { ++i; } } // Return remaining value to sender if (remainingValue > 0) { ethRecipient.safeTransferETH(remainingValue); } } /** * @notice Swaps as many ERC20 tokens for specific NFTs as possible, respecting the per-swap max cost. * @param swapList The list of pairs to trade with and the IDs of the NFTs to buy from each. * @param inputAmount The amount of ERC20 tokens to add to the ERC20-to-NFT swaps * @param nftRecipient The address that will receive the NFT output * @param deadline The Unix timestamp (in seconds) at/after which the swap will revert * @return remainingValue The unspent token amount */ 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; // Try doing each swap uint256 numSwaps = swapList.length; for (uint256 i; i < numSwaps;) { // Calculate actual cost per swap (error,,, pairCost,,) = swapList[i].swapInfo.pair.getBuyNFTQuote( swapList[i].swapInfo.nftIds[0], swapList[i].swapInfo.nftIds.length ); // If within our maxCost and no error, proceed 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; } } } /** * @notice Swaps as many NFTs for tokens as possible, respecting the per-swap min output * @param swapList The list of pairs to trade with and the IDs of the NFTs to sell to each. * @param tokenRecipient The address that will receive the token output * @param deadline The Unix timestamp (in seconds) at/after which the swap will revert * @return outputAmount The total ETH/ERC20 received */ function robustSwapNFTsForToken( RobustPairSwapSpecificForToken[] calldata swapList, address payable tokenRecipient, uint256 deadline ) public virtual checkDeadline(deadline) returns (uint256 outputAmount) { // Try doing each swap uint256 numSwaps = swapList.length; for (uint256 i; i < numSwaps;) { uint256 pairOutput; // Locally scoped to avoid stack too deep error { 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 at least equal to our minOutput, proceed if (pairOutput >= swapList[i].minOutput) { // Do the swap and update outputAmount with how many tokens we got outputAmount += swapList[i].swapInfo.pair.swapNFTsForToken( swapList[i].swapInfo.nftIds, 0, tokenRecipient, true, msg.sender ); } unchecked { ++i; } } } /** * @notice Buys NFTs with ETH and sells them for tokens in one transaction * @param params All the parameters for the swap (packed in struct to avoid stack too deep), containing: * - ethToNFTSwapList The list of NFTs to buy * - nftToTokenSwapList The list of NFTs to sell * - inputAmount The max amount of tokens to send (if ERC20) * - tokenRecipient The address that receives tokens from the NFTs sold * - nftRecipient The address that receives NFTs * - deadline UNIX timestamp deadline for the swap */ function robustSwapETHForSpecificNFTsAndNFTsToToken(RobustPairNFTsFoTokenAndTokenforNFTsTrade calldata params) external payable virtual returns (uint256 remainingValue, uint256 outputAmount) { { remainingValue = msg.value; uint256 pairCost; CurveErrorCodes.Error error; // Try doing each swap uint256 numSwaps = params.tokenToNFTTrades.length; for (uint256 i; i < numSwaps;) { // Calculate actual cost per swap (error,,, pairCost,,) = params.tokenToNFTTrades[i].swapInfo.pair.getBuyNFTQuote( params.tokenToNFTTrades[i].swapInfo.nftIds[0], params.tokenToNFTTrades[i].swapInfo.nftIds.length ); // If within our maxCost and no error, proceed if (pairCost <= params.tokenToNFTTrades[i].maxCost && error == CurveErrorCodes.Error.OK) { // We know how much ETH to send because we already did the math above // So we just send that much remainingValue -= params.tokenToNFTTrades[i].swapInfo.pair.swapTokenForSpecificNFTs{value: pairCost}( params.tokenToNFTTrades[i].swapInfo.nftIds, pairCost, params.nftRecipient, true, msg.sender ); } unchecked { ++i; } } // Return remaining value to sender if (remainingValue > 0) { params.tokenRecipient.safeTransferETH(remainingValue); } } { // Try doing each swap uint256 numSwaps = params.nftToTokenTrades.length; for (uint256 i; i < numSwaps;) { uint256 pairOutput; // Locally scoped to avoid stack too deep error { 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 at least equal to our minOutput, proceed if (pairOutput >= params.nftToTokenTrades[i].minOutput) { // Do the swap and update outputAmount with how many tokens we got outputAmount += params.nftToTokenTrades[i].swapInfo.pair.swapNFTsForToken( params.nftToTokenTrades[i].swapInfo.nftIds, 0, params.tokenRecipient, true, msg.sender ); } unchecked { ++i; } } } } /** * @notice Buys NFTs with ERC20, and sells them for tokens in one transaction * @param params All the parameters for the swap (packed in struct to avoid stack too deep), containing: * - ethToNFTSwapList The list of NFTs to buy * - nftToTokenSwapList The list of NFTs to sell * - inputAmount The max amount of tokens to send (if ERC20) * - tokenRecipient The address that receives tokens from the NFTs sold * - nftRecipient The address that receives NFTs * - deadline UNIX timestamp deadline for the swap */ function robustSwapERC20ForSpecificNFTsAndNFTsToToken(RobustPairNFTsFoTokenAndTokenforNFTsTrade calldata params) external virtual returns (uint256 remainingValue, uint256 outputAmount) { { remainingValue = params.inputAmount; uint256 pairCost; CurveErrorCodes.Error error; // Try doing each swap uint256 numSwaps = params.tokenToNFTTrades.length; for (uint256 i; i < numSwaps;) { // Calculate actual cost per swap (error,,, pairCost,,) = params.tokenToNFTTrades[i].swapInfo.pair.getBuyNFTQuote( params.tokenToNFTTrades[i].swapInfo.nftIds[0], params.tokenToNFTTrades[i].swapInfo.nftIds.length ); // If within our maxCost and no error, proceed 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; } } } { // Try doing each swap uint256 numSwaps = params.nftToTokenTrades.length; for (uint256 i; i < numSwaps;) { uint256 pairOutput; // Locally scoped to avoid stack too deep error { 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 at least equal to our minOutput, proceed if (pairOutput >= params.nftToTokenTrades[i].minOutput) { // Do the swap and update outputAmount with how many tokens we got outputAmount += params.nftToTokenTrades[i].swapInfo.pair.swapNFTsForToken( params.nftToTokenTrades[i].swapInfo.nftIds, 0, params.tokenRecipient, true, msg.sender ); } unchecked { ++i; } } } } receive() external payable {} /** * Restricted functions */ /** * @dev Allows an ERC20 pair contract to transfer ERC20 tokens directly from * the sender, in order to minimize the number of token transfers. Only callable by an ERC20 pair. * @param token The ERC20 token to transfer * @param from The address to transfer tokens from * @param to The address to transfer tokens to * @param amount The amount of tokens to transfer */ function pairTransferERC20From(ERC20 token, address from, address to, uint256 amount) external { // verify caller is a trusted pair contract require(factory.isValidPair(msg.sender), "Not pair"); // verify caller is an ERC20 pair require(factory.getPairTokenType(msg.sender) == ILSSVMPairFactoryLike.PairTokenType.ERC20, "Not ERC20 pair"); // transfer tokens to pair token.safeTransferFrom(from, to, amount); } /** * @dev Allows a pair contract to transfer ERC721 NFTs directly from * the sender, in order to minimize the number of token transfers. Only callable by a pair. * @param nft The ERC721 NFT to transfer * @param from The address to transfer tokens from * @param to The address to transfer tokens to * @param id The ID of the NFT to transfer */ function pairTransferNFTFrom(IERC721 nft, address from, address to, uint256 id) external { // verify caller is a trusted pair contract require(factory.isValidPair(msg.sender), "Not pair"); // transfer NFTs to pair nft.transferFrom(from, to, id); } function pairTransferERC1155From( IERC1155 nft, address from, address to, uint256[] calldata ids, uint256[] calldata amounts ) external { // verify caller is a trusted pair contract require(factory.isValidPair(msg.sender), "Not pair"); nft.safeBatchTransferFrom(from, to, ids, amounts, bytes("")); } /** * Internal functions */ /** * @param deadline The last valid time for a swap */ function _checkDeadline(uint256 deadline) internal view { require(block.timestamp <= deadline, "Deadline passed"); } /** * @notice Internal function used to swap ETH for a specific set of NFTs * @param swapList The list of pairs and swap calldata * @param inputAmount The total amount of ETH to send * @param ethRecipient The address receiving excess ETH * @param nftRecipient The address receiving the NFTs from the pairs * @return remainingValue The unspent token amount */ function _swapETHForSpecificNFTs( PairSwapSpecific[] calldata swapList, uint256 inputAmount, address payable ethRecipient, address nftRecipient ) internal virtual returns (uint256 remainingValue) { remainingValue = inputAmount; uint256 pairCost; CurveErrorCodes.Error error; // Do swaps uint256 numSwaps = swapList.length; for (uint256 i; i < numSwaps;) { // Calculate the cost per swap first to send exact amount of ETH over, saves gas by avoiding the need to send back excess ETH (error,,, pairCost,,) = swapList[i].pair.getBuyNFTQuote(swapList[i].nftIds[0], swapList[i].nftIds.length); // Require no errors require(error == CurveErrorCodes.Error.OK, "Bonding curve error"); // Total ETH taken from sender cannot exceed inputAmount // because otherwise the deduction from remainingValue will fail remainingValue -= swapList[i].pair.swapTokenForSpecificNFTs{value: pairCost}( swapList[i].nftIds, remainingValue, nftRecipient, true, msg.sender ); unchecked { ++i; } } // Return remaining value to sender if (remainingValue > 0) { ethRecipient.safeTransferETH(remainingValue); } } /** * @notice Internal function used to swap an ERC20 token for specific NFTs * @dev Note that we don't need to query the pair's bonding curve first for pricing data because * we just calculate and take the required amount from the caller during swap time. * However, we can't "pull" ETH, which is why for the ETH->NFT swaps, we need to calculate the pricing info * to figure out how much the router should send to the pool. * @param swapList The list of pairs and swap calldata * @param inputAmount The total amount of ERC20 tokens to send * @param nftRecipient The address receiving the NFTs from the pairs * @return remainingValue The unspent token amount */ function _swapERC20ForSpecificNFTs(PairSwapSpecific[] calldata swapList, uint256 inputAmount, address nftRecipient) internal virtual returns (uint256 remainingValue) { remainingValue = inputAmount; // Do swaps uint256 numSwaps = swapList.length; for (uint256 i; i < numSwaps;) { // Tokens are transferred in by the pair calling router.pairTransferERC20From // Total tokens taken from sender cannot exceed inputAmount // because otherwise the deduction from remainingValue will fail remainingValue -= swapList[i].pair.swapTokenForSpecificNFTs( swapList[i].nftIds, remainingValue, nftRecipient, true, msg.sender ); unchecked { ++i; } } } /** * @notice Swaps NFTs for tokens, designed to be used for 1 token at a time * @dev Calling with multiple tokens is permitted, BUT minOutput will be * far from enough of a safety check because different tokens almost certainly have different unit prices. * @param swapList The list of pairs and swap calldata * @param minOutput The minimum number of tokens to be receieved from the swaps * @param tokenRecipient The address that receives the tokens * @return outputAmount The number of tokens to be received */ function _swapNFTsForToken(PairSwapSpecific[] calldata swapList, uint256 minOutput, address payable tokenRecipient) internal virtual returns (uint256 outputAmount) { // Do swaps uint256 numSwaps = swapList.length; for (uint256 i; i < numSwaps;) { // Do the swap for token and then update outputAmount // Note: minExpectedTokenOutput is set to 0 since we're doing an aggregate slippage check below outputAmount += swapList[i].pair.swapNFTsForToken(swapList[i].nftIds, 0, tokenRecipient, true, msg.sender); unchecked { ++i; } } // Aggregate slippage check require(outputAmount >= minOutput, "outputAmount too low"); } }
// SPDX-License-Identifier: AGPL-3.0 pragma solidity ^0.8.0; import {CurveErrorCodes} from "./CurveErrorCodes.sol"; interface ICurve { /** * @notice Validates if a delta value is valid for the curve. The criteria for * validity can be different for each type of curve, for instance ExponentialCurve * requires delta to be greater than 1. * @param delta The delta value to be validated * @return valid True if delta is valid, false otherwise */ function validateDelta(uint128 delta) external pure returns (bool valid); /** * @notice Validates if a new spot price is valid for the curve. Spot price is generally assumed to be the immediate sell price of 1 NFT to the pool, in units of the pool's paired token. * @param newSpotPrice The new spot price to be set * @return valid True if the new spot price is valid, false otherwise */ function validateSpotPrice(uint128 newSpotPrice) external view returns (bool valid); /** * @notice Given the current state of the pair and the trade, computes how much the user * should pay to purchase an NFT from the pair, the new spot price, and other values. * @param spotPrice The current selling spot price of the pair, in tokens * @param delta The delta parameter of the pair, what it means depends on the curve * @param numItems The number of NFTs the user is buying from the pair * @param feeMultiplier Determines how much fee the LP takes from this trade, 18 decimals * @param protocolFeeMultiplier Determines how much fee the protocol takes from this trade, 18 decimals * @return error Any math calculation errors, only Error.OK means the returned values are valid * @return newSpotPrice The updated selling spot price, in tokens * @return newDelta The updated delta, used to parameterize the bonding curve * @return inputValue The amount that the user should pay, in tokens * @return tradeFee The amount that is sent to the trade fee recipient * @return protocolFee The amount of fee to send to the protocol, in tokens */ 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 ); /** * @notice Given the current state of the pair and the trade, computes how much the user * should receive when selling NFTs to the pair, the new spot price, and other values. * @param spotPrice The current selling spot price of the pair, in tokens * @param delta The delta parameter of the pair, what it means depends on the curve * @param numItems The number of NFTs the user is selling to the pair * @param feeMultiplier Determines how much fee the LP takes from this trade, 18 decimals * @param protocolFeeMultiplier Determines how much fee the protocol takes from this trade, 18 decimals * @return error Any math calculation errors, only Error.OK means the returned values are valid * @return newSpotPrice The updated selling spot price, in tokens * @return newDelta The updated delta, used to parameterize the bonding curve * @return outputValue The amount that the user should receive, in tokens * @return tradeFee The amount that is sent to the trade fee recipient * @return protocolFee The amount of fee to send to the protocol, in tokens */ 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 ); }
// SPDX-License-Identifier: AGPL-3.0 pragma solidity ^0.8.0; contract CurveErrorCodes { enum Error { OK, // No error INVALID_NUMITEMS, // The numItem value is 0 SPOT_PRICE_OVERFLOW, // The updated spot price doesn't fit into 128 bits DELTA_OVERFLOW, // The updated delta doesn't fit into 128 bits SPOT_PRICE_UNDERFLOW // The updated spot price goes too low } }
// SPDX-License-Identifier: AGPL-3.0 pragma solidity ^0.8.4; interface IOwnershipTransferReceiver { function onOwnershipTransferred(address oldOwner, bytes memory data) external payable; }
// SPDX-License-Identifier: AGPL-3.0 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); /** * @dev Initializes the contract setting the deployer as the initial owner. */ function __Ownable_init(address initialOwner) internal { _owner = initialOwner; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { if (owner() != msg.sender) revert Ownable_NotOwner(); _; } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * @param newOwner The new address to become owner * @param data Any additional data to send to the ownership received callback. * Disallows setting to the zero address as a way to more gas-efficiently avoid reinitialization. * When ownership is transferred, if the new owner implements IOwnershipTransferCallback, we make a callback. * Can only be called by the current owner. */ 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) {} // If revert... catch (bytes memory reason) { // If we just transferred to a contract w/ no callback, this is fine if (reason.length == 0) { // i.e., no need to revert } // Otherwise, the callback had an error, and we should revert else { /// @solidity memory-safe-assembly assembly { revert(add(32, reason), mload(reason)) } } } } } /** * @notice Transfers ownership of the contract to a new account (`newOwner`). * @dev Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { _owner = newOwner; emit OwnershipTransferred(newOwner); } }
// SPDX-License-Identifier: AGPL-3.0-only pragma solidity >=0.8.0; import {ERC20} from "../tokens/ERC20.sol"; /// @notice Safe ETH and ERC20 transfer library that gracefully handles missing return values. /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/SafeTransferLib.sol) /// @dev Use with caution! Some functions in this library knowingly create dirty bits at the destination of the free memory pointer. /// @dev Note that none of the functions in this library check that a token has code at all! That responsibility is delegated to the caller. library SafeTransferLib { /*////////////////////////////////////////////////////////////// ETH OPERATIONS //////////////////////////////////////////////////////////////*/ function safeTransferETH(address to, uint256 amount) internal { bool success; /// @solidity memory-safe-assembly assembly { // Transfer the ETH and store if it succeeded or not. success := call(gas(), to, amount, 0, 0, 0, 0) } require(success, "ETH_TRANSFER_FAILED"); } /*////////////////////////////////////////////////////////////// ERC20 OPERATIONS //////////////////////////////////////////////////////////////*/ function safeTransferFrom( ERC20 token, address from, address to, uint256 amount ) internal { bool success; /// @solidity memory-safe-assembly assembly { // Get a pointer to some free memory. let freeMemoryPointer := mload(0x40) // Write the abi-encoded calldata into memory, beginning with the function selector. mstore(freeMemoryPointer, 0x23b872dd00000000000000000000000000000000000000000000000000000000) mstore(add(freeMemoryPointer, 4), from) // Append the "from" argument. mstore(add(freeMemoryPointer, 36), to) // Append the "to" argument. mstore(add(freeMemoryPointer, 68), amount) // Append the "amount" argument. success := and( // Set success to whether the call reverted, if not we check it either // returned exactly 1 (can't just be non-zero data), or had no return data. or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())), // We use 100 because the length of our calldata totals up like so: 4 + 32 * 3. // We use 0 and 32 to copy up to 32 bytes of return data into the scratch space. // Counterintuitively, this call must be positioned second to the or() call in the // surrounding and() call or else returndatasize() will be zero during the computation. call(gas(), token, 0, freeMemoryPointer, 100, 0, 32) ) } require(success, "TRANSFER_FROM_FAILED"); } function safeTransfer( ERC20 token, address to, uint256 amount ) internal { bool success; /// @solidity memory-safe-assembly assembly { // Get a pointer to some free memory. let freeMemoryPointer := mload(0x40) // Write the abi-encoded calldata into memory, beginning with the function selector. mstore(freeMemoryPointer, 0xa9059cbb00000000000000000000000000000000000000000000000000000000) mstore(add(freeMemoryPointer, 4), to) // Append the "to" argument. mstore(add(freeMemoryPointer, 36), amount) // Append the "amount" argument. success := and( // Set success to whether the call reverted, if not we check it either // returned exactly 1 (can't just be non-zero data), or had no return data. or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())), // We use 68 because the length of our calldata totals up like so: 4 + 32 * 2. // We use 0 and 32 to copy up to 32 bytes of return data into the scratch space. // Counterintuitively, this call must be positioned second to the or() call in the // surrounding and() call or else returndatasize() will be zero during the computation. call(gas(), token, 0, freeMemoryPointer, 68, 0, 32) ) } require(success, "TRANSFER_FAILED"); } function safeApprove( ERC20 token, address to, uint256 amount ) internal { bool success; /// @solidity memory-safe-assembly assembly { // Get a pointer to some free memory. let freeMemoryPointer := mload(0x40) // Write the abi-encoded calldata into memory, beginning with the function selector. mstore(freeMemoryPointer, 0x095ea7b300000000000000000000000000000000000000000000000000000000) mstore(add(freeMemoryPointer, 4), to) // Append the "to" argument. mstore(add(freeMemoryPointer, 36), amount) // Append the "amount" argument. success := and( // Set success to whether the call reverted, if not we check it either // returned exactly 1 (can't just be non-zero data), or had no return data. or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())), // We use 68 because the length of our calldata totals up like so: 4 + 32 * 2. // We use 0 and 32 to copy up to 32 bytes of return data into the scratch space. // Counterintuitively, this call must be positioned second to the or() call in the // surrounding and() call or else returndatasize() will be zero during the computation. call(gas(), token, 0, freeMemoryPointer, 68, 0, 32) ) } require(success, "APPROVE_FAILED"); } }
// SPDX-License-Identifier: AGPL-3.0 pragma solidity ^0.8.0; interface IPropertyChecker { function hasProperties(uint256[] calldata ids, bytes calldata params) external returns (bool); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol) pragma solidity ^0.8.0; /** * @title ERC721 token receiver interface * @dev Interface for any contract that wants to support safeTransfers * from ERC721 asset contracts. */ interface IERC721Receiver { /** * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom} * by `operator` from `from`, this function is called. * * It must return its Solidity selector to confirm the token transfer. * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted. * * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`. */ function onERC721Received( address operator, address from, uint256 tokenId, bytes calldata data ) external returns (bytes4); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (token/ERC1155/utils/ERC1155Receiver.sol) pragma solidity ^0.8.0; import "../IERC1155Receiver.sol"; import "../../../utils/introspection/ERC165.sol"; /** * @dev _Available since v3.1._ */ abstract contract ERC1155Receiver is ERC165, IERC1155Receiver { /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) { return interfaceId == type(IERC1155Receiver).interfaceId || super.supportsInterface(interfaceId); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.2) (utils/introspection/ERC165Checker.sol) pragma solidity ^0.8.0; import "./IERC165.sol"; /** * @dev Library used to query support of an interface declared via {IERC165}. * * Note that these functions return the actual result of the query: they do not * `revert` if an interface is not supported. It is up to the caller to decide * what to do in these cases. */ library ERC165Checker { // As per the EIP-165 spec, no interface should ever match 0xffffffff bytes4 private constant _INTERFACE_ID_INVALID = 0xffffffff; /** * @dev Returns true if `account` supports the {IERC165} interface. */ function supportsERC165(address account) internal view returns (bool) { // Any contract that implements ERC165 must explicitly indicate support of // InterfaceId_ERC165 and explicitly indicate non-support of InterfaceId_Invalid return supportsERC165InterfaceUnchecked(account, type(IERC165).interfaceId) && !supportsERC165InterfaceUnchecked(account, _INTERFACE_ID_INVALID); } /** * @dev Returns true if `account` supports the interface defined by * `interfaceId`. Support for {IERC165} itself is queried automatically. * * See {IERC165-supportsInterface}. */ function supportsInterface(address account, bytes4 interfaceId) internal view returns (bool) { // query support of both ERC165 as per the spec and support of _interfaceId return supportsERC165(account) && supportsERC165InterfaceUnchecked(account, interfaceId); } /** * @dev Returns a boolean array where each value corresponds to the * interfaces passed in and whether they're supported or not. This allows * you to batch check interfaces for a contract where your expectation * is that some interfaces may not be supported. * * See {IERC165-supportsInterface}. * * _Available since v3.4._ */ function getSupportedInterfaces( address account, bytes4[] memory interfaceIds ) internal view returns (bool[] memory) { // an array of booleans corresponding to interfaceIds and whether they're supported or not bool[] memory interfaceIdsSupported = new bool[](interfaceIds.length); // query support of ERC165 itself if (supportsERC165(account)) { // query support of each interface in interfaceIds for (uint256 i = 0; i < interfaceIds.length; i++) { interfaceIdsSupported[i] = supportsERC165InterfaceUnchecked(account, interfaceIds[i]); } } return interfaceIdsSupported; } /** * @dev Returns true if `account` supports all the interfaces defined in * `interfaceIds`. Support for {IERC165} itself is queried automatically. * * Batch-querying can lead to gas savings by skipping repeated checks for * {IERC165} support. * * See {IERC165-supportsInterface}. */ function supportsAllInterfaces(address account, bytes4[] memory interfaceIds) internal view returns (bool) { // query support of ERC165 itself if (!supportsERC165(account)) { return false; } // query support of each interface in interfaceIds for (uint256 i = 0; i < interfaceIds.length; i++) { if (!supportsERC165InterfaceUnchecked(account, interfaceIds[i])) { return false; } } // all interfaces supported return true; } /** * @notice Query if a contract implements an interface, does not check ERC165 support * @param account The address of the contract to query for support of an interface * @param interfaceId The interface identifier, as specified in ERC-165 * @return true if the contract at account indicates support of the interface with * identifier interfaceId, false otherwise * @dev Assumes that account contains a contract that supports ERC165, otherwise * the behavior of this method is undefined. This precondition can be checked * with {supportsERC165}. * * Some precompiled contracts will falsely indicate support for a given interface, so caution * should be exercised when using this function. * * Interface identification is specified in ERC-165. */ function supportsERC165InterfaceUnchecked(address account, bytes4 interfaceId) internal view returns (bool) { // prepare call bytes memory encodedParams = abi.encodeWithSelector(IERC165.supportsInterface.selector, interfaceId); // perform static call 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; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol) pragma solidity ^0.8.0; import "../../utils/introspection/IERC165.sol"; /** * @dev _Available since v3.1._ */ interface IERC1155Receiver is IERC165 { /** * @dev Handles the receipt of a single ERC1155 token type. This function is * called at the end of a `safeTransferFrom` after the balance has been updated. * * NOTE: To accept the transfer, this must return * `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` * (i.e. 0xf23a6e61, or its own function selector). * * @param operator The address which initiated the transfer (i.e. msg.sender) * @param from The address which previously owned the token * @param id The ID of the token being transferred * @param value The amount of tokens being transferred * @param data Additional data with no specified format * @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed */ function onERC1155Received( address operator, address from, uint256 id, uint256 value, bytes calldata data ) external returns (bytes4); /** * @dev Handles the receipt of a multiple ERC1155 token types. This function * is called at the end of a `safeBatchTransferFrom` after the balances have * been updated. * * NOTE: To accept the transfer(s), this must return * `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` * (i.e. 0xbc197c81, or its own function selector). * * @param operator The address which initiated the batch transfer (i.e. msg.sender) * @param from The address which previously owned the token * @param ids An array containing ids of each token being transferred (order and length must match values array) * @param values An array containing amounts of each token being transferred (order and length must match ids array) * @param data Additional data with no specified format * @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed */ function onERC1155BatchReceived( address operator, address from, uint256[] calldata ids, uint256[] calldata values, bytes calldata data ) external returns (bytes4); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol) pragma solidity ^0.8.0; import "./IERC165.sol"; /** * @dev Implementation of the {IERC165} interface. * * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check * for the additional interface id that will be supported. For example: * * ```solidity * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); * } * ``` * * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation. */ abstract contract ERC165 is IERC165 { /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IERC165).interfaceId; } }
{ "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/" ], "optimizer": { "enabled": true, "runs": 1000000 }, "metadata": { "bytecodeHash": "ipfs", "appendCBOR": true }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "evmVersion": "paris", "libraries": {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"contract IRoyaltyEngineV1","name":"royaltyEngine","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"LSSVMPairERC20__AssetRecipientNotPaid","type":"error"},{"inputs":[],"name":"LSSVMPairERC20__MsgValueNotZero","type":"error"},{"inputs":[],"name":"LSSVMPairERC20__RoyaltyNotPaid","type":"error"},{"inputs":[],"name":"LSSVMPairERC721__NeedPropertyChecking","type":"error"},{"inputs":[],"name":"LSSVMPairERC721__PropertyCheckFailed","type":"error"},{"inputs":[],"name":"LSSVMPair__AlreadyInitialized","type":"error"},{"inputs":[{"internalType":"enum CurveErrorCodes.Error","name":"error","type":"uint8"}],"name":"LSSVMPair__BondingCurveError","type":"error"},{"inputs":[],"name":"LSSVMPair__CallFailed","type":"error"},{"inputs":[],"name":"LSSVMPair__DemandedInputTooLarge","type":"error"},{"inputs":[],"name":"LSSVMPair__FunctionNotAllowed","type":"error"},{"inputs":[],"name":"LSSVMPair__InvalidDelta","type":"error"},{"inputs":[],"name":"LSSVMPair__InvalidSpotPrice","type":"error"},{"inputs":[],"name":"LSSVMPair__NftNotTransferred","type":"error"},{"inputs":[],"name":"LSSVMPair__NonTradePoolWithTradeFee","type":"error"},{"inputs":[],"name":"LSSVMPair__NotRouter","type":"error"},{"inputs":[],"name":"LSSVMPair__OutputTooSmall","type":"error"},{"inputs":[],"name":"LSSVMPair__RoyaltyTooLarge","type":"error"},{"inputs":[],"name":"LSSVMPair__TargetNotAllowed","type":"error"},{"inputs":[],"name":"LSSVMPair__TradeFeeTooLarge","type":"error"},{"inputs":[],"name":"LSSVMPair__WrongPoolType","type":"error"},{"inputs":[],"name":"LSSVMPair__ZeroSwapAmount","type":"error"},{"inputs":[],"name":"Ownable_NewOwnerZeroAddress","type":"error"},{"inputs":[],"name":"Ownable_NotOwner","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"a","type":"address"}],"name":"AssetRecipientChange","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint128","name":"newDelta","type":"uint128"}],"name":"DeltaUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint96","name":"newFee","type":"uint96"}],"name":"FeeUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"name":"NFTWithdrawal","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"numNFTs","type":"uint256"}],"name":"NFTWithdrawal","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint128","name":"newSpotPrice","type":"uint128"}],"name":"SpotPriceUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amountOut","type":"uint256"},{"indexed":false,"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"name":"SwapNFTInPair","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amountOut","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"numNFTs","type":"uint256"}],"name":"SwapNFTInPair","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amountIn","type":"uint256"},{"indexed":false,"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"name":"SwapNFTOutPair","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amountIn","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"numNFTs","type":"uint256"}],"name":"SwapNFTOutPair","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokenDeposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokenWithdrawal","type":"event"},{"inputs":[],"name":"ROYALTY_ENGINE","outputs":[{"internalType":"contract IRoyaltyEngineV1","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"bondingCurve","outputs":[{"internalType":"contract ICurve","name":"_bondingCurve","type":"address"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"assetId","type":"uint256"},{"internalType":"uint256","name":"saleAmount","type":"uint256"}],"name":"calculateRoyaltiesView","outputs":[{"internalType":"address payable[]","name":"royaltyRecipients","type":"address[]"},{"internalType":"uint256[]","name":"royaltyAmounts","type":"uint256[]"},{"internalType":"uint256","name":"royaltyTotal","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address payable","name":"target","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"call","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"newRecipient","type":"address"}],"name":"changeAssetRecipient","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint128","name":"newDelta","type":"uint128"}],"name":"changeDelta","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint96","name":"newFee","type":"uint96"}],"name":"changeFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint128","name":"newSpotPrice","type":"uint128"}],"name":"changeSpotPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"delta","outputs":[{"internalType":"uint128","name":"","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"factory","outputs":[{"internalType":"contract ILSSVMPairFactoryLike","name":"_factory","type":"address"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"fee","outputs":[{"internalType":"uint96","name":"","type":"uint96"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getAssetRecipient","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"assetId","type":"uint256"},{"internalType":"uint256","name":"numNFTs","type":"uint256"}],"name":"getBuyNFTQuote","outputs":[{"internalType":"enum CurveErrorCodes.Error","name":"error","type":"uint8"},{"internalType":"uint256","name":"newSpotPrice","type":"uint256"},{"internalType":"uint256","name":"newDelta","type":"uint256"},{"internalType":"uint256","name":"inputAmount","type":"uint256"},{"internalType":"uint256","name":"protocolFee","type":"uint256"},{"internalType":"uint256","name":"royaltyAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getFeeRecipient","outputs":[{"internalType":"address payable","name":"_feeRecipient","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"assetId","type":"uint256"},{"internalType":"uint256","name":"numNFTs","type":"uint256"}],"name":"getSellNFTQuote","outputs":[{"internalType":"enum CurveErrorCodes.Error","name":"error","type":"uint8"},{"internalType":"uint256","name":"newSpotPrice","type":"uint256"},{"internalType":"uint256","name":"newDelta","type":"uint256"},{"internalType":"uint256","name":"outputAmount","type":"uint256"},{"internalType":"uint256","name":"protocolFee","type":"uint256"},{"internalType":"uint256","name":"royaltyAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address payable","name":"_assetRecipient","type":"address"},{"internalType":"uint128","name":"_delta","type":"uint128"},{"internalType":"uint96","name":"_fee","type":"uint96"},{"internalType":"uint128","name":"_spotPrice","type":"uint128"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes[]","name":"calls","type":"bytes[]"},{"internalType":"bool","name":"revertOnFail","type":"bool"}],"name":"multicall","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"nft","outputs":[{"internalType":"address","name":"_nft","type":"address"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155BatchReceived","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pairVariant","outputs":[{"internalType":"enum ILSSVMPairFactoryLike.PairVariant","name":"","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"poolType","outputs":[{"internalType":"enum LSSVMPair.PoolType","name":"_poolType","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"propertyChecker","outputs":[{"internalType":"address","name":"_propertyChecker","type":"address"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"spotPrice","outputs":[{"internalType":"uint128","name":"","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"nftIds","type":"uint256[]"},{"internalType":"uint256","name":"minExpectedTokenOutput","type":"uint256"},{"internalType":"address payable","name":"tokenRecipient","type":"address"},{"internalType":"bool","name":"isRouter","type":"bool"},{"internalType":"address","name":"routerCaller","type":"address"},{"internalType":"bytes","name":"propertyCheckerParams","type":"bytes"}],"name":"swapNFTsForToken","outputs":[{"internalType":"uint256","name":"outputAmount","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"nftIds","type":"uint256[]"},{"internalType":"uint256","name":"minExpectedTokenOutput","type":"uint256"},{"internalType":"address payable","name":"tokenRecipient","type":"address"},{"internalType":"bool","name":"isRouter","type":"bool"},{"internalType":"address","name":"routerCaller","type":"address"}],"name":"swapNFTsForToken","outputs":[{"internalType":"uint256","name":"outputAmount","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"nftIds","type":"uint256[]"},{"internalType":"uint256","name":"maxExpectedTokenInput","type":"uint256"},{"internalType":"address","name":"nftRecipient","type":"address"},{"internalType":"bool","name":"isRouter","type":"bool"},{"internalType":"address","name":"routerCaller","type":"address"}],"name":"swapTokenForSpecificNFTs","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"contract ERC20","name":"_token","type":"address"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"transferOwnership","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"contract IERC1155","name":"a","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"withdrawERC1155","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract ERC20","name":"a","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdrawERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC721","name":"a","type":"address"},{"internalType":"uint256[]","name":"nftIds","type":"uint256[]"}],"name":"withdrawERC721","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
000000000000000000000000bc40d21999b4bf120d330ee3a2de415287f626c9
-----Decoded View---------------
Arg [0] : royaltyEngine (address): 0xBc40d21999b4BF120d330Ee3a2DE415287f626C9
-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000bc40d21999b4bf120d330ee3a2de415287f626c9
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 26 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.