1// SPDX-License-Identifier: Apache License2pragma solidity >=0.8.0;3import {CollectionHelpers} from "../api/CollectionHelpers.sol";4import {ContractHelpers} from "../api/ContractHelpers.sol";5import {UniqueRefungibleToken} from "../api/UniqueRefungibleToken.sol";6import {UniqueRefungible} from "../api/UniqueRefungible.sol";7import {UniqueNFT} from "../api/UniqueNFT.sol";89/// @dev Fractionalization contract. It stores mappings between NFT and RFT tokens,10/// stores allowlist of NFT tokens available for fractionalization, has methods11/// for fractionalization and defractionalization of NFT tokens.12contract Fractionalizer {13 struct Token {14 address _collection;15 uint256 _tokenId;16 }17 address rftCollection;18 mapping(address => bool) nftCollectionAllowList;19 mapping(address => mapping(uint256 => uint256)) public nft2rftMapping;20 mapping(address => Token) public rft2nftMapping;21 bytes32 refungibleCollectionType = keccak256(bytes("ReFungible"));2223 receive() external payable onlyOwner {}2425 /// @dev Method modifier to only allow contract owner to call it.26 modifier onlyOwner() {27 address contracthelpersAddress = 0x842899ECF380553E8a4de75bF534cdf6fBF64049;28 ContractHelpers contractHelpers = ContractHelpers(29 contracthelpersAddress30 );31 address contractOwner = contractHelpers.contractOwner(address(this));32 require(msg.sender == contractOwner, "Only owner can");33 _;34 }3536 /// @dev This emits when RFT collection setting is changed.37 event RFTCollectionSet(address _collection);3839 /// @dev This emits when NFT collection is allowed or disallowed.40 event AllowListSet(address _collection, bool _status);4142 /// @dev This emits when NFT token is fractionalized by contract.43 event Fractionalized(44 address _collection,45 uint256 _tokenId,46 address _rftToken,47 uint128 _amount48 );4950 /// @dev This emits when NFT token is defractionalized by contract.51 event Defractionalized(52 address _rftToken,53 address _nftCollection,54 uint256 _nftTokenId55 );5657 /// Set RFT collection that contract will work with. RFT tokens for fractionalized NFT tokens58 /// would be created in this collection.59 /// @dev Throws if RFT collection is already configured for this contract.60 /// Throws if collection of wrong type (NFT, Fungible) is provided instead61 /// of RFT collection.62 /// Throws if `msg.sender` is not owner or admin of provided RFT collection.63 /// Can only be called by contract owner.64 /// @param _collection address of RFT collection.65 function setRFTCollection(address _collection) public onlyOwner {66 require(rftCollection == address(0), "RFT collection is already set");67 UniqueRefungible refungibleContract = UniqueRefungible(_collection);68 string memory collectionType = refungibleContract69 .uniqueCollectionType();7071 require(72 keccak256(bytes(collectionType)) == refungibleCollectionType,73 "Wrong collection type. Collection is not refungible."74 );75 require(76 refungibleContract.isOwnerOrAdmin(address(this)),77 "Fractionalizer contract should be an admin of the collection"78 );79 rftCollection = _collection;80 emit RFTCollectionSet(rftCollection);81 }8283 /// Creates and sets RFT collection that contract will work with. RFT tokens for fractionalized NFT tokens84 /// would be created in this collection.85 /// @dev Throws if RFT collection is already configured for this contract.86 /// Can only be called by contract owner.87 /// @param _name name for created RFT collection.88 /// @param _description description for created RFT collection.89 /// @param _tokenPrefix token prefix for created RFT collection.90 function createAndSetRFTCollection(91 string calldata _name,92 string calldata _description,93 string calldata _tokenPrefix94 ) public onlyOwner {95 require(rftCollection == address(0), "RFT collection is already set");96 address collectionHelpers = 0x6C4E9fE1AE37a41E93CEE429e8E1881aBdcbb54F;97 rftCollection = CollectionHelpers(collectionHelpers)98 .createRFTCollection(_name, _description, _tokenPrefix);99 emit RFTCollectionSet(rftCollection);100 }101102 /// Allow or disallow NFT collection tokens from being fractionalized by this contract.103 /// @dev Can only be called by contract owner.104 /// @param collection NFT token address.105 /// @param status `true` to allow and `false` to disallow NFT token.106 function setNftCollectionIsAllowed(address collection, bool status)107 public108 onlyOwner109 {110 nftCollectionAllowList[collection] = status;111 emit AllowListSet(collection, status);112 }113114 /// Fractionilize NFT token.115 /// @dev Takes NFT token from `msg.sender` and transfers RFT token to `msg.sender`116 /// instead. Creates new RFT token if provided NFT token never was fractionalized117 /// by this contract or existing RFT token if it was.118 /// Throws if RFT collection isn't configured for this contract.119 /// Throws if fractionalization of provided NFT token is not allowed120 /// Throws if `msg.sender` is not owner of provided NFT token121 /// @param _collection NFT collection address122 /// @param _token id of NFT token to be fractionalized123 /// @param _pieces number of pieces new RFT token would have124 function nft2rft(125 address _collection,126 uint256 _token,127 uint128 _pieces128 ) public {129 require(rftCollection != address(0), "RFT collection is not set");130 UniqueRefungible rftCollectionContract = UniqueRefungible(131 rftCollection132 );133 require(134 nftCollectionAllowList[_collection] == true,135 "Fractionalization of this collection is not allowed by admin"136 );137 require(138 UniqueNFT(_collection).ownerOf(_token) == msg.sender,139 "Only token owner could fractionalize it"140 );141 UniqueNFT(_collection).transferFrom(msg.sender, address(this), _token);142 uint256 rftTokenId;143 address rftTokenAddress;144 UniqueRefungibleToken rftTokenContract;145 if (nft2rftMapping[_collection][_token] == 0) {146 rftTokenId = rftCollectionContract.nextTokenId();147 rftCollectionContract.mint(address(this), rftTokenId);148 rftTokenAddress = rftCollectionContract.tokenContractAddress(149 rftTokenId150 );151 nft2rftMapping[_collection][_token] = rftTokenId;152 rft2nftMapping[rftTokenAddress] = Token(_collection, _token);153154 rftTokenContract = UniqueRefungibleToken(rftTokenAddress);155 } else {156 rftTokenId = nft2rftMapping[_collection][_token];157 rftTokenAddress = rftCollectionContract.tokenContractAddress(158 rftTokenId159 );160 rftTokenContract = UniqueRefungibleToken(rftTokenAddress);161 }162 rftTokenContract.repartition(_pieces);163 rftTokenContract.transfer(msg.sender, _pieces);164 emit Fractionalized(_collection, _token, rftTokenAddress, _pieces);165 }166167 /// Defrationalize NFT token.168 /// @dev Takes RFT token from `msg.sender` and transfers corresponding NFT token169 /// to `msg.sender` instead.170 /// Throws if RFT collection isn't configured for this contract.171 /// Throws if provided RFT token is no from configured RFT collection.172 /// Throws if RFT token was not created by this contract.173 /// Throws if `msg.sender` isn't owner of all RFT token pieces.174 /// @param _collection RFT collection address175 /// @param _token id of RFT token176 function rft2nft(address _collection, uint256 _token) public {177 require(rftCollection != address(0), "RFT collection is not set");178 require(rftCollection == _collection, "Wrong RFT collection");179 UniqueRefungible rftCollectionContract = UniqueRefungible(180 rftCollection181 );182 address rftTokenAddress = rftCollectionContract.tokenContractAddress(183 _token184 );185 Token memory nftToken = rft2nftMapping[rftTokenAddress];186 require(187 nftToken._collection != address(0),188 "No corresponding NFT token found"189 );190 UniqueRefungibleToken rftTokenContract = UniqueRefungibleToken(191 rftTokenAddress192 );193 require(194 rftTokenContract.balanceOf(msg.sender) ==195 rftTokenContract.totalSupply(),196 "Not all pieces are owned by the caller"197 );198 rftCollectionContract.transferFrom(msg.sender, address(this), _token);199 UniqueNFT(nftToken._collection).transferFrom(200 address(this),201 msg.sender,202 nftToken._tokenId203 );204 emit Defractionalized(205 rftTokenAddress,206 nftToken._collection,207 nftToken._tokenId208 );209 }210}