// SPDX-License-Identifier: MIT pragma solidity ^0.8.20; interface IERC721 { function transferFrom(address from, address to, uint256 tokenId) external; function ownerOf(uint256 tokenId) external view returns (address); function approve(address to, uint256 tokenId) external; } interface IERC20 { function transfer(address to, uint256 amount) external returns (bool); function transferFrom(address from, address to, uint256 amount) external returns (bool); } library MinimalClones { function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) { assembly { let ptr := mload(0x40) mstore( ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000 ) mstore(add(ptr, 0x14), shl(0x60, implementation)) mstore( add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000 ) instance := create2(0, ptr, 0x37, salt) } require(instance != address(0), "create2 failed"); } function predictDeterministicAddress( address implementation, bytes32 salt, address deployer ) internal pure returns (address) { bytes32 codeHash = keccak256( abi.encodePacked( hex"3d602d80600a3d3981f3", hex"363d3d373d3d3d363d73", bytes20(implementation), hex"5af43d82803e903d91602b57fd5bf3" ) ); bytes32 digest = keccak256( abi.encodePacked(bytes1(0xff), deployer, salt, codeHash) ); return address(uint160(uint256(digest))); } } /// @title Shard /// @notice Fractional NFT-basket flip pool with ERC20-like shares. /// @dev Pools can hold a *basket* of one or more NFTs and settle in either /// native ETH or any ERC20 token (`paymentToken == address(0)` => ETH). contract Shard { uint256 public constant INITIAL_AUCTION_DURATION = 7 days; uint256 public constant BID_EXTENSION_DURATION = 1 days; address public factory; address public seller; /// @notice Currency the pool funds, bids and settles in. address(0) => native ETH. IERC20 public paymentToken; /// @notice The basket of NFTs locked in this pool (parallel arrays). address[] public nftAddrs; uint256[] public nftTokenIds; uint256 public price; uint256 public totalDeposited; uint256 public highestBid; uint256 public auctionEnd; uint256 public saleProceeds; address public highestBidder; bool public listed; bool public funded; bool public auctionStarted; bool public sold; mapping(address => uint256) public pendingReturns; string private _name; string private _symbol; uint256 private _totalSupply; bool private _initialized; uint256 private _entered; mapping(address => uint256) private _balances; mapping(address => mapping(address => uint256)) private _allowances; event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); event Listed(); event Deposited(address indexed who, uint256 amount, uint256 refund); event Withdrawn(address indexed who, uint256 amount); event Funded(); event Offered(address indexed bidder, uint256 amount, uint256 auctionEnd); event Bought(address indexed buyer, uint256 paid); event Claimed(address indexed who, uint256 amount); event RefundWithdrawn(address indexed who, uint256 amount); modifier nonReentrant() { require(_entered == 0, "reentrant"); _entered = 1; _; _entered = 0; } constructor() { factory = address(0xdead); _initialized = true; } /// @param _nfts Basket of NFT contract addresses (length >= 1). /// @param _tokenIds Token id per NFT contract (parallel to `_nfts`). /// @param _price Total pool size in `_paymentToken` units. /// @param _seller Owner that lists the basket and receives the proceeds. /// @param _paymentToken ERC20 used for funding/bids, or address(0) for ETH. function initialize( address[] calldata _nfts, uint256[] calldata _tokenIds, uint256 _price, address _seller, address _paymentToken ) external { require(!_initialized, "initialized"); require(_price > 0, "price=0"); require(_seller != address(0), "seller=0"); require(_nfts.length > 0, "no nfts"); require(_nfts.length == _tokenIds.length, "len mismatch"); _initialized = true; factory = msg.sender; seller = _seller; price = _price; paymentToken = IERC20(_paymentToken); for (uint256 i = 0; i < _nfts.length; i++) { require(_nfts[i] != address(0), "nft=0"); nftAddrs.push(_nfts[i]); nftTokenIds.push(_tokenIds[i]); } _name = string.concat("Shard #", _toString(_tokenIds[0])); _symbol = "SHARD"; } /* ----------------------------- views ----------------------------- */ function name() external view returns (string memory) { return _name; } function symbol() external view returns (string memory) { return _symbol; } /// @notice Share decimals. An ETH pool uses 18. A token pool uses the payment token's own decimals, so USDT is 6. function decimals() external view returns (uint8) { address token = address(paymentToken); if (token == address(0)) return 18; uint256 word; bool ok; // Copy at most one word. A token that returns a huge blob cannot blow up this view. assembly { let ptr := mload(0x40) mstore(ptr, 0x313ce56700000000000000000000000000000000000000000000000000000000) ok := staticcall(gas(), token, ptr, 4, ptr, 32) if lt(returndatasize(), 32) { ok := 0 } if ok { word := mload(ptr) } } if (!ok || word > type(uint8).max) return 18; return uint8(word); } /// @notice First NFT in the basket (convenience for single-asset pools). function nft() external view returns (address) { return nftAddrs[0]; } /// @notice First token id in the basket (convenience for single-asset pools). function tokenId() external view returns (uint256) { return nftTokenIds[0]; } function nftCount() external view returns (uint256) { return nftAddrs.length; } /// @notice Full basket as parallel arrays of (nft, tokenId). function getAssets() external view returns (address[] memory addrs, uint256[] memory ids) { return (nftAddrs, nftTokenIds); } function totalSupply() public view returns (uint256) { return _totalSupply; } function balanceOf(address account) public view returns (uint256) { return _balances[account]; } function shares(address account) external view returns (uint256) { return _balances[account]; } function allowance(address owner, address spender) external view returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) external returns (bool) { _allowances[msg.sender][spender] = amount; emit Approval(msg.sender, spender, amount); return true; } function transfer(address to, uint256 amount) external returns (bool) { _transfer(msg.sender, to, amount); return true; } function transferFrom(address from, address to, uint256 amount) external returns (bool) { uint256 allowed = _allowances[from][msg.sender]; require(allowed >= amount, "allowance"); if (allowed != type(uint256).max) { _allowances[from][msg.sender] = allowed - amount; emit Approval(from, msg.sender, allowed - amount); } _transfer(from, to, amount); return true; } function minBidIncrement() public view returns (uint256) { uint256 basis = auctionStarted && highestBid > 0 ? highestBid : price; return _ceilDiv(basis, 100); } /* --------------------------- lifecycle --------------------------- */ function list() external nonReentrant { require(msg.sender == seller, "not seller"); require(!listed, "listed"); listed = true; for (uint256 i = 0; i < nftAddrs.length; i++) { if (IERC721(nftAddrs[i]).ownerOf(nftTokenIds[i]) != address(this)) { IERC721(nftAddrs[i]).transferFrom(seller, address(this), nftTokenIds[i]); } else { IERC721(nftAddrs[i]).approve(address(0), nftTokenIds[i]); } require( IERC721(nftAddrs[i]).ownerOf(nftTokenIds[i]) == address(this), "transfer failed" ); } emit Listed(); if (totalDeposited == price) { funded = true; emit Funded(); _payOut(seller, price); } } /// @notice Fund the pool. For ETH pools send value; for ERC20 pools first /// approve this contract and pass the token `amount`. function deposit(uint256 amount) external payable nonReentrant { require(!funded, "filled"); uint256 offered = _takeFunds(amount); require(offered > 0, "zero"); uint256 remaining = price - totalDeposited; uint256 accepted = offered; uint256 refund; if (offered > remaining) { refund = offered - remaining; accepted = remaining; } totalDeposited += accepted; _mint(msg.sender, accepted); emit Deposited(msg.sender, accepted, refund); if (totalDeposited == price&& listed) { funded = true; emit Funded(); _payOut(seller, price); } if (refund > 0) { _payOut(msg.sender, refund); } } function withdraw() external nonReentrant { require(!funded, "filled"); uint256 amount = _balances[msg.sender]; require(amount > 0, "no shares"); _burn(msg.sender, amount); totalDeposited -= amount; _payOut(msg.sender, amount); emit Withdrawn(msg.sender, amount); } function offer(uint256 amount) external payable nonReentrant { _offer(amount); } function buy(uint256 amount) external payable nonReentrant { _offer(amount); } function _offer(uint256 amount) internal { require(funded, "not funded"); require(!sold, "sold"); uint256 bidIn = _takeFunds(amount); uint256 effectiveBid = bidIn + pendingReturns[msg.sender]; if (auctionStarted) { require(block.timestamp < auctionEnd, "auction ended"); require(effectiveBid * 100 >= highestBid * 101, "min +1%"); uint256 minEnd = block.timestamp + BID_EXTENSION_DURATION; if (auctionEnd < minEnd) auctionEnd = minEnd; } else { require(effectiveBid >= price * 2, "need 2x"); auctionStarted = true; auctionEnd = block.timestamp + INITIAL_AUCTION_DURATION; } pendingReturns[msg.sender] += bidIn; highestBidder = msg.sender; highestBid = effectiveBid; emit Offered(msg.sender, effectiveBid, auctionEnd); } function settle() external { if (_balances[msg.sender] == totalSupply()&& !sold) { require(!auctionStarted, "no auction"); require(funded, "not funded"); _burn(msg.sender, _balances[msg.sender]); sold = true; _transferBasket(msg.sender); highestBidder = msg.sender; emit Bought(msg.sender, 0); return; } require(auctionStarted, "no auction"); require(!sold, "sold"); require(block.timestamp >= auctionEnd, "auction live"); sold = true; saleProceeds = highestBid; _transferBasket(highestBidder); emit Bought(highestBidder, highestBid); } function claim(uint256[] memory nftIndex) external nonReentrant { if (!funded && !listed && msg.sender == seller) { for (uint256 i = 0; i < nftIndex.length; i++) { IERC721(nftAddrs[nftIndex[i]]).transferFrom(address(this), seller, nftTokenIds[nftIndex[i]]); } } if (sold && msg.sender == highestBidder) { for (uint256 i = 0; i < nftIndex.length; i++) { IERC721(nftAddrs[nftIndex[i]]).transferFrom(address(this), highestBidder, nftTokenIds[nftIndex[i]]); } } } function withdrawRefund() external nonReentrant { require(msg.sender != highestBidder, "winner can't refund"); _withdrawRefund(msg.sender); } function claim() external nonReentrant { require(sold, "not sold"); uint256 userShares = _balances[msg.sender]; require(userShares > 0, "no shares"); _burn(msg.sender, userShares); uint256 payout = (saleProceeds * userShares) / price; _payOut(msg.sender, payout); emit Claimed(msg.sender, payout); } function unlist() external nonReentrant { require(msg.sender == seller, "not seller"); require(listed, "not listed"); require(!funded, "filled"); listed = false; _transferBasket(seller); } function getBid(address bidder) external view returns (uint256 minBid, uint256 endTime) { uint256 requiredEffective = auctionStarted ? _ceilMulDiv(highestBid, 101, 100) : price * 2; uint256 alreadyBid = pendingReturns[bidder]; minBid = requiredEffective > alreadyBid ? requiredEffective - alreadyBid : 0; if (auctionStarted) { uint256 minEnd = block.timestamp + BID_EXTENSION_DURATION; endTime = auctionEnd < minEnd ? minEnd : auctionEnd; } else { endTime = block.timestamp + INITIAL_AUCTION_DURATION; } } /* --------------------------- internals --------------------------- */ function _withdrawRefund(address who) internal { uint256 amount = pendingReturns[who]; require(amount > 0, "no refund"); pendingReturns[who] = 0; _payOut(who, amount); emit RefundWithdrawn(who, amount); } /// @dev Pulls `amount` of the pool currency from the caller into the pool. /// ETH pools use msg.value (the `amount` argument is ignored); ERC20 /// pools pull `amount` via transferFrom and reject stray ETH. function _takeFunds(uint256 amount) internal returns (uint256) { if (address(paymentToken) == address(0)) { return msg.value; } require(msg.value == 0, "no eth"); if (amount > 0) { require(_erc20(true, msg.sender, address(this), amount), "pull fail"); } return amount; } /// @dev Sends `amount` of the pool currency to `to`. function _payOut(address to, uint256 amount) internal { if (amount == 0) return; if (address(paymentToken) == address(0)) { (bool ok, ) = to.call{value: amount}(""); require(ok, "pay fail"); } else { require(_erc20(false, to, address(0), amount), "pay fail"); } } /// @dev `pull` selects transferFrom(from, to, amount). Otherwise transfer(to, amount), with `from` as the recipient. /// USDT succeeds and returns nothing. A normal ERC-20 returns a bool. Empty success is accepted; false is not. function _erc20(bool pull, address from, address to, uint256 amount) internal returns (bool ok) { address token = address(paymentToken); assembly { let ptr := mload(0x40) switch pull case 0 { mstore(ptr, 0xa9059cbb00000000000000000000000000000000000000000000000000000000) mstore(add(ptr, 4), from) mstore(add(ptr, 36), amount) ok := call(gas(), token, 0, ptr, 68, ptr, 32) } default { mstore(ptr, 0x23b872dd00000000000000000000000000000000000000000000000000000000) mstore(add(ptr, 4), from) mstore(add(ptr, 36), to) mstore(add(ptr, 68), amount) ok := call(gas(), token, 0, ptr, 100, ptr, 32) } if and(ok, gt(returndatasize(), 0)) { if or(lt(returndatasize(), 32), iszero(mload(ptr))) { ok := 0 } } } } /// @dev Moves every NFT in the basket to `to`. function _transferBasket(address to) internal { for (uint256 i = 0; i < nftAddrs.length; i++) { try IERC721(nftAddrs[i]).transferFrom(address(this), to, nftTokenIds[i]) {} catch { try IERC721(nftAddrs[i]).approve(to, nftTokenIds[i]) {} catch {} } } } function _mint(address to, uint256 amount) internal { require(to != address(0), "mint to zero"); _totalSupply += amount; _balances[to] += amount; emit Transfer(address(0), to, amount); } function _burn(address from, uint256 amount) internal { require(from != address(0), "burn from zero"); uint256 bal = _balances[from]; require(bal >= amount, "balance"); _balances[from] = bal - amount; _totalSupply -= amount; emit Transfer(from, address(0), amount); } function _transfer(address from, address to, uint256 amount) internal { require(from != address(0), "transfer from zero"); require(to != address(0), "transfer to zero"); uint256 bal = _balances[from]; require(bal >= amount, "balance"); _balances[from] = bal - amount; _balances[to] += amount; emit Transfer(from, to, amount); } function _ceilDiv(uint256 value, uint256 divisor) private pure returns (uint256) { if (value == 0) return 0; return ((value - 1) / divisor) + 1; } function _ceilMulDiv( uint256 a, uint256 b, uint256 divisor ) private pure returns (uint256) { if (a == 0 || b == 0) return 0; return ((a * b) - 1) / divisor + 1; } function _toString(uint256 v) private pure returns (string memory) { if (v == 0) return "0"; uint256 n = v; uint256 len; while (n != 0) { len++; n /= 10; } bytes memory b = new bytes(len); while (v != 0) { len--; b[len] = bytes1(uint8(48 + (v % 10))); v /= 10; } return string(b); } } /// @title ShardFactory /// @notice Deterministic clone factory for {Shard} basket pools. contract ShardFactory { struct ShardInfo { address shard; address paymentToken; address nft; uint256 tokenId; uint256 nftCount; address seller; uint256 price; uint256 totalDeposited; uint256 highestBid; uint256 auctionEnd; uint256 saleProceeds; address highestBidder; bool listed; bool funded; bool auctionStarted; bool sold; } address public immutable implementation; mapping(address => address[]) public shardsByNFT; mapping(address => address[]) public myShards; address[] public allShards; mapping(bytes32 => uint256) private _saltNonce; event ShardCreated( address indexed shard, address indexed nft, uint256 indexed tokenId, address seller, uint256 price, address paymentToken, uint256 nftCount ); constructor(address _implementation) { require(_implementation != address(0), "impl=0"); implementation = _implementation; } /// @notice Create a basket pool for one or more NFTs settled in `_paymentToken`. /// @param _paymentToken ERC20 to settle in, or address(0) for native ETH. function createShard( address[] calldata _nfts, uint256[] calldata _tokenIds, uint256 _price, address _paymentToken ) external returns (address shard) { require(_price > 0, "price=0"); require(_nfts.length > 0, "no nfts"); require(_nfts.length == _tokenIds.length, "len mismatch"); bytes32 salt = _nextSalt(msg.sender, _nfts, _tokenIds, _price, _paymentToken); shard = MinimalClones.cloneDeterministic(implementation, salt); Shard(shard).initialize(_nfts, _tokenIds, _price, msg.sender, _paymentToken); for (uint256 i = 0; i < _nfts.length; i++) { shardsByNFT[_nfts[i]].push(shard); } myShards[msg.sender].push(shard); allShards.push(shard); emit ShardCreated( shard, _nfts[0], _tokenIds[0], msg.sender, _price, _paymentToken, _nfts.length ); } function predictShardAddress( address caller, address[] calldata _nfts, uint256[] calldata _tokenIds, uint256 _price, address _paymentToken ) external view returns (address) { bytes32 key = _saltKey(caller, _nfts, _tokenIds, _price, _paymentToken); bytes32 salt = keccak256(abi.encodePacked(key, _saltNonce[key])); return MinimalClones.predictDeterministicAddress( implementation, salt, address(this) ); } function getShardsByNFT(address _nft) external view returns (address[] memory) { return shardsByNFT[_nft]; } function getMyShards(address _owner) external view returns (address[] memory) { return myShards[_owner]; } function getAllShards(uint256 _start, uint256 _end) external view returns (address[] memory list) { require(_end >= _start, "invalid range"); require(_end <= allShards.length, "out of bounds"); list = new address[](_end - _start); for (uint256 i = _start; i < _end; i++) { list[i - _start] = allShards[i]; } } function getTotalShards() external view returns (uint256) { return allShards.length; } function getShardsBy(uint256 _start, uint256 _end) external view returns (ShardInfo[] memory infos) { require(_end >= _start, "invalid range"); require(_end <= allShards.length, "out of bounds"); infos = new ShardInfo[](_end - _start); for (uint256 i = _start; i < _end; i++) { address shardAddr = allShards[i]; Shard s = Shard(shardAddr); infos[i - _start] = ShardInfo({ shard: shardAddr, paymentToken: address(s.paymentToken()), nft: s.nft(), tokenId: s.tokenId(), nftCount: s.nftCount(), seller: s.seller(), price: s.price(), totalDeposited: s.totalDeposited(), highestBid: s.highestBid(), auctionEnd: s.auctionEnd(), saleProceeds: s.saleProceeds(), highestBidder: s.highestBidder(), listed: s.listed(), funded: s.funded(), auctionStarted: s.auctionStarted(), sold: s.sold() }); } } function _saltKey( address caller, address[] calldata _nfts, uint256[] calldata _tokenIds, uint256 _price, address _paymentToken ) private pure returns (bytes32) { return keccak256( abi.encode(caller, _nfts, _tokenIds, _price, _paymentToken) ); } function _nextSalt( address caller, address[] calldata _nfts, uint256[] calldata _tokenIds, uint256 _price, address _paymentToken ) private returns (bytes32) { bytes32 key = _saltKey(caller, _nfts, _tokenIds, _price, _paymentToken); uint256 nonce = _saltNonce[key]++; return keccak256(abi.encodePacked(key, nonce)); } }