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 //use constant to reduce gas cost22 bytes32 constant refungibleCollectionType = keccak256(bytes("ReFungible"));2324 receive() external payable onlyOwner {}2526 /// @dev Method modifier to only allow contract owner to call it.27 modifier onlyOwner() {28 address contracthelpersAddress = 0x842899ECF380553E8a4de75bF534cdf6fBF64049;29 ContractHelpers contractHelpers = ContractHelpers(contracthelpersAddress);30 address contractOwner = contractHelpers.contractOwner(address(this));31 require(msg.sender == contractOwner, "Only owner can");32 _;33 }3435 /// @dev This emits when RFT collection setting is changed.36 event RFTCollectionSet(address _collection);3738 /// @dev This emits when NFT collection is allowed or disallowed.39 event AllowListSet(address _collection, bool _status);4041 /// @dev This emits when NFT token is fractionalized by contract.42 event Fractionalized(address _collection, uint256 _tokenId, address _rftToken, uint128 _amount);4344 /// @dev This emits when NFT token is defractionalized by contract.45 event Defractionalized(address _rftToken, address _nftCollection, uint256 _nftTokenId);4647 /// Set RFT collection that contract will work with. RFT tokens for fractionalized NFT tokens48 /// would be created in this collection.49 /// @dev Throws if RFT collection is already configured for this contract.50 /// Throws if collection of wrong type (NFT, Fungible) is provided instead51 /// of RFT collection.52 /// Throws if `msg.sender` is not owner or admin of provided RFT collection.53 /// Can only be called by contract owner.54 /// @param _collection address of RFT collection.55 function setRFTCollection(address _collection) external onlyOwner {56 require(rftCollection == address(0), "RFT collection is already set");57 UniqueRefungible refungibleContract = UniqueRefungible(_collection);58 string memory collectionType = refungibleContract.uniqueCollectionType();5960 // compare hashed to reduce gas cost61 require(62 keccak256(bytes(collectionType)) == refungibleCollectionType,63 "Wrong collection type. Collection is not refungible."64 );65 require(66 refungibleContract.isOwnerOrAdmin(address(this)),67 "Fractionalizer contract should be an admin of the collection"68 );69 rftCollection = _collection;70 emit RFTCollectionSet(rftCollection);71 }7273 /// Creates and sets RFT collection that contract will work with. RFT tokens for fractionalized NFT tokens74 /// would be created in this collection.75 /// @dev Throws if RFT collection is already configured for this contract.76 /// Can only be called by contract owner.77 /// @param _name name for created RFT collection.78 /// @param _description description for created RFT collection.79 /// @param _tokenPrefix token prefix for created RFT collection.80 function createAndSetRFTCollection(81 string calldata _name,82 string calldata _description,83 string calldata _tokenPrefix84 ) external payable onlyOwner {85 require(rftCollection == address(0), "RFT collection is already set");86 address collectionHelpers = 0x6C4E9fE1AE37a41E93CEE429e8E1881aBdcbb54F;87 rftCollection = CollectionHelpers(collectionHelpers).createRFTCollection{value: msg.value}(_name, _description, _tokenPrefix);88 emit RFTCollectionSet(rftCollection);89 }9091 /// Allow or disallow NFT collection tokens from being fractionalized by this contract.92 /// @dev Can only be called by contract owner.93 /// @param collection NFT token address.94 /// @param status `true` to allow and `false` to disallow NFT token.95 function setNftCollectionIsAllowed(address collection, bool status) external onlyOwner {96 nftCollectionAllowList[collection] = status;97 emit AllowListSet(collection, status);98 }99100 /// Fractionilize NFT token.101 /// @dev Takes NFT token from `msg.sender` and transfers RFT token to `msg.sender`102 /// instead. Creates new RFT token if provided NFT token never was fractionalized103 /// by this contract or existing RFT token if it was.104 /// Throws if RFT collection isn't configured for this contract.105 /// Throws if fractionalization of provided NFT token is not allowed106 /// Throws if `msg.sender` is not owner of provided NFT token107 /// @param _collection NFT collection address108 /// @param _token id of NFT token to be fractionalized109 /// @param _pieces number of pieces new RFT token would have110 function nft2rft(111 address _collection,112 uint256 _token,113 uint128 _pieces114 ) external {115 require(rftCollection != address(0), "RFT collection is not set");116 UniqueRefungible rftCollectionContract = UniqueRefungible(rftCollection);117 require(118 nftCollectionAllowList[_collection] == true,119 "Fractionalization of this collection is not allowed by admin"120 );121 require(UniqueNFT(_collection).ownerOf(_token) == msg.sender, "Only token owner could fractionalize it");122 UniqueNFT(_collection).transferFrom(msg.sender, address(this), _token);123 uint256 rftTokenId;124 address rftTokenAddress;125 UniqueRefungibleToken rftTokenContract;126 if (nft2rftMapping[_collection][_token] == 0) {127 rftTokenId = rftCollectionContract.nextTokenId();128 rftCollectionContract.mint(address(this), rftTokenId);129 rftTokenAddress = rftCollectionContract.tokenContractAddress(rftTokenId);130 nft2rftMapping[_collection][_token] = rftTokenId;131 rft2nftMapping[rftTokenAddress] = Token(_collection, _token);132133 rftTokenContract = UniqueRefungibleToken(rftTokenAddress);134 } else {135 rftTokenId = nft2rftMapping[_collection][_token];136 rftTokenAddress = rftCollectionContract.tokenContractAddress(rftTokenId);137 rftTokenContract = UniqueRefungibleToken(rftTokenAddress);138 }139 rftTokenContract.repartition(_pieces);140 rftTokenContract.transfer(msg.sender, _pieces);141 emit Fractionalized(_collection, _token, rftTokenAddress, _pieces);142 }143144 /// Defrationalize NFT token.145 /// @dev Takes RFT token from `msg.sender` and transfers corresponding NFT token146 /// to `msg.sender` instead.147 /// Throws if RFT collection isn't configured for this contract.148 /// Throws if provided RFT token is no from configured RFT collection.149 /// Throws if RFT token was not created by this contract.150 /// Throws if `msg.sender` isn't owner of all RFT token pieces.151 /// @param _collection RFT collection address152 /// @param _token id of RFT token153 function rft2nft(address _collection, uint256 _token) external {154 require(rftCollection != address(0), "RFT collection is not set");155 require(rftCollection == _collection, "Wrong RFT collection");156 UniqueRefungible rftCollectionContract = UniqueRefungible(rftCollection);157 address rftTokenAddress = rftCollectionContract.tokenContractAddress(_token);158 Token memory nftToken = rft2nftMapping[rftTokenAddress];159 require(nftToken._collection != address(0), "No corresponding NFT token found");160 UniqueRefungibleToken rftTokenContract = UniqueRefungibleToken(rftTokenAddress);161 require(162 rftTokenContract.balanceOf(msg.sender) == rftTokenContract.totalSupply(),163 "Not all pieces are owned by the caller"164 );165 rftCollectionContract.transferFrom(msg.sender, address(this), _token);166 UniqueNFT(nftToken._collection).transferFrom(address(this), msg.sender, nftToken._tokenId);167 emit Defractionalized(rftTokenAddress, nftToken._collection, nftToken._tokenId);168 }169}