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(contracthelpersAddress);29 address contractOwner = contractHelpers.contractOwner(address(this));30 require(msg.sender == contractOwner, "Only owner can");31 _;32 }3334 /// @dev This emits when RFT collection setting is changed.35 event RFTCollectionSet(address _collection);3637 /// @dev This emits when NFT collection is allowed or disallowed.38 event AllowListSet(address _collection, bool _status);3940 /// @dev This emits when NFT token is fractionalized by contract.41 event Fractionalized(address _collection, uint256 _tokenId, address _rftToken, uint128 _amount);4243 /// @dev This emits when NFT token is defractionalized by contract.44 event Defractionalized(address _rftToken, address _nftCollection, uint256 _nftTokenId);4546 /// Set RFT collection that contract will work with. RFT tokens for fractionalized NFT tokens47 /// would be created in this collection.48 /// @dev Throws if RFT collection is already configured for this contract.49 /// Throws if collection of wrong type (NFT, Fungible) is provided instead50 /// of RFT collection.51 /// Throws if `msg.sender` is not owner or admin of provided RFT collection.52 /// Can only be called by contract owner.53 /// @param _collection address of RFT collection.54 function setRFTCollection(address _collection) public onlyOwner {55 require(rftCollection == address(0), "RFT collection is already set");56 UniqueRefungible refungibleContract = UniqueRefungible(_collection);57 string memory collectionType = refungibleContract.uniqueCollectionType();5859 require(60 keccak256(bytes(collectionType)) == refungibleCollectionType,61 "Wrong collection type. Collection is not refungible."62 );63 require(64 refungibleContract.isOwnerOrAdmin(address(this)),65 "Fractionalizer contract should be an admin of the collection"66 );67 rftCollection = _collection;68 emit RFTCollectionSet(rftCollection);69 }7071 /// Creates and sets RFT collection that contract will work with. RFT tokens for fractionalized NFT tokens72 /// would be created in this collection.73 /// @dev Throws if RFT collection is already configured for this contract.74 /// Can only be called by contract owner.75 /// @param _name name for created RFT collection.76 /// @param _description description for created RFT collection.77 /// @param _tokenPrefix token prefix for created RFT collection.78 function createAndSetRFTCollection(79 string calldata _name,80 string calldata _description,81 string calldata _tokenPrefix82 ) public onlyOwner {83 require(rftCollection == address(0), "RFT collection is already set");84 address collectionHelpers = 0x6C4E9fE1AE37a41E93CEE429e8E1881aBdcbb54F;85 rftCollection = CollectionHelpers(collectionHelpers).createRFTCollection(_name, _description, _tokenPrefix);86 emit RFTCollectionSet(rftCollection);87 }8889 /// Allow or disallow NFT collection tokens from being fractionalized by this contract.90 /// @dev Can only be called by contract owner.91 /// @param collection NFT token address.92 /// @param status `true` to allow and `false` to disallow NFT token.93 function setNftCollectionIsAllowed(address collection, bool status) public onlyOwner {94 nftCollectionAllowList[collection] = status;95 emit AllowListSet(collection, status);96 }9798 /// Fractionilize NFT token.99 /// @dev Takes NFT token from `msg.sender` and transfers RFT token to `msg.sender`100 /// instead. Creates new RFT token if provided NFT token never was fractionalized101 /// by this contract or existing RFT token if it was.102 /// Throws if RFT collection isn't configured for this contract.103 /// Throws if fractionalization of provided NFT token is not allowed104 /// Throws if `msg.sender` is not owner of provided NFT token105 /// @param _collection NFT collection address106 /// @param _token id of NFT token to be fractionalized107 /// @param _pieces number of pieces new RFT token would have108 function nft2rft(109 address _collection,110 uint256 _token,111 uint128 _pieces112 ) public {113 require(rftCollection != address(0), "RFT collection is not set");114 UniqueRefungible rftCollectionContract = UniqueRefungible(rftCollection);115 require(116 nftCollectionAllowList[_collection] == true,117 "Fractionalization of this collection is not allowed by admin"118 );119 require(UniqueNFT(_collection).ownerOf(_token) == msg.sender, "Only token owner could fractionalize it");120 UniqueNFT(_collection).transferFrom(msg.sender, address(this), _token);121 uint256 rftTokenId;122 address rftTokenAddress;123 UniqueRefungibleToken rftTokenContract;124 if (nft2rftMapping[_collection][_token] == 0) {125 rftTokenId = rftCollectionContract.nextTokenId();126 rftCollectionContract.mint(address(this), rftTokenId);127 rftTokenAddress = rftCollectionContract.tokenContractAddress(rftTokenId);128 nft2rftMapping[_collection][_token] = rftTokenId;129 rft2nftMapping[rftTokenAddress] = Token(_collection, _token);130131 rftTokenContract = UniqueRefungibleToken(rftTokenAddress);132 } else {133 rftTokenId = nft2rftMapping[_collection][_token];134 rftTokenAddress = rftCollectionContract.tokenContractAddress(rftTokenId);135 rftTokenContract = UniqueRefungibleToken(rftTokenAddress);136 }137 rftTokenContract.repartition(_pieces);138 rftTokenContract.transfer(msg.sender, _pieces);139 emit Fractionalized(_collection, _token, rftTokenAddress, _pieces);140 }141142 /// Defrationalize NFT token.143 /// @dev Takes RFT token from `msg.sender` and transfers corresponding NFT token144 /// to `msg.sender` instead.145 /// Throws if RFT collection isn't configured for this contract.146 /// Throws if provided RFT token is no from configured RFT collection.147 /// Throws if RFT token was not created by this contract.148 /// Throws if `msg.sender` isn't owner of all RFT token pieces.149 /// @param _collection RFT collection address150 /// @param _token id of RFT token151 function rft2nft(address _collection, uint256 _token) public {152 require(rftCollection != address(0), "RFT collection is not set");153 require(rftCollection == _collection, "Wrong RFT collection");154 UniqueRefungible rftCollectionContract = UniqueRefungible(rftCollection);155 address rftTokenAddress = rftCollectionContract.tokenContractAddress(_token);156 Token memory nftToken = rft2nftMapping[rftTokenAddress];157 require(nftToken._collection != address(0), "No corresponding NFT token found");158 UniqueRefungibleToken rftTokenContract = UniqueRefungibleToken(rftTokenAddress);159 require(160 rftTokenContract.balanceOf(msg.sender) == rftTokenContract.totalSupply(),161 "Not all pieces are owned by the caller"162 );163 rftCollectionContract.transferFrom(msg.sender, address(this), _token);164 UniqueNFT(nftToken._collection).transferFrom(address(this), msg.sender, nftToken._tokenId);165 emit Defractionalized(rftTokenAddress, nftToken._collection, nftToken._tokenId);166 }167}