├── README.md └── contracts ├── InGameMarket.sol ├── PsychoMarket.sol └── AssetsMarket.sol /README.md: -------------------------------------------------------------------------------- 1 | Market 2 | -------------------------------------------------------------------------------- /contracts/InGameMarket.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: GPL-3.0 2 | 3 | pragma experimental ABIEncoderV2; 4 | pragma solidity ^0.8.10; 5 | 6 | import "./PsychoMarket.sol"; 7 | 8 | contract InGameMarket is PsychoMarket{ 9 | 10 | } -------------------------------------------------------------------------------- /contracts/PsychoMarket.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: GPL-3.0 2 | 3 | pragma experimental ABIEncoderV2; 4 | pragma solidity ^0.8.10; 5 | 6 | import "@openzeppelin/contracts/utils/Counters.sol"; 7 | import "../../Game/Interfaces/IPsychospheres.sol"; 8 | import "./AssetsMarket.sol"; 9 | 10 | contract PsychoMarket is AssetsMarket { 11 | using Counters for Counters.Counter; 12 | Counters.Counter private _itemIds; 13 | Counters.Counter private _itemsSold; 14 | 15 | IPsychospheres public psychospheres; 16 | 17 | function setPsychospheres(address _psychospheres) public isOwner { 18 | psychospheres = IPsychospheres(_psychospheres); 19 | } 20 | 21 | struct MarketPsychoItem { 22 | uint256 itemId; 23 | uint256 psychoId; 24 | address payable seller; 25 | address payable owner; 26 | uint256 price; 27 | bool sold; 28 | } 29 | 30 | mapping(uint256 => MarketPsychoItem) private idToMarketPsychoItem; 31 | 32 | event MarketPsychoItemCreated ( 33 | uint256 indexed itemId, 34 | uint256 indexed psychoId, 35 | address seller, 36 | address owner, 37 | uint256 price, 38 | bool sold 39 | ); 40 | 41 | /* Returns the listing price of the contract */ 42 | // function getListingPrice() public view returns (uint256) { 43 | // return listingPrice; 44 | // } 45 | 46 | /* Places an item for sale on the marketplace */ 47 | function createMarketPsychoItem( 48 | uint256 psychoId, 49 | uint256 price 50 | ) public { 51 | require(price > 0, "Price must be at least 1 wei"); 52 | 53 | _itemIds.increment(); 54 | uint256 itemId = _itemIds.current(); 55 | 56 | psychospheres.transferPsychosphereFrom(msg.sender, address(this), psychoId); 57 | 58 | idToMarketPsychoItem[itemId] = MarketPsychoItem( 59 | itemId, 60 | psychoId, 61 | payable(msg.sender), 62 | payable(address(0)), 63 | price, 64 | false 65 | ); 66 | 67 | emit MarketPsychoItemCreated( 68 | itemId, 69 | psychoId, 70 | msg.sender, 71 | address(0), 72 | price, 73 | false 74 | ); 75 | } 76 | 77 | /* Creates the sale of a marketplace item */ 78 | /* Transfers ownership of the item, as well as funds between parties */ 79 | function createMarketPsychoSale( 80 | uint256 itemId 81 | ) public nonReentrant { 82 | uint256 price = idToMarketPsychoItem[itemId].price; 83 | uint256 psychoId = idToMarketPsychoItem[itemId].psychoId; 84 | DBT.transferFrom(msg.sender, idToMarketPsychoItem[itemId].seller, price); 85 | psychospheres.transferPsychosphere(msg.sender, psychoId); 86 | idToMarketPsychoItem[itemId].owner = payable(msg.sender); 87 | idToMarketPsychoItem[itemId].sold = true; 88 | _itemsSold.increment(); 89 | } 90 | 91 | /* Returns all unsold market items */ 92 | function fetchMarketPsychoItems() public view returns (MarketPsychoItem[] memory) { 93 | uint itemCount = _itemIds.current(); 94 | uint unsoldItemCount = _itemIds.current() - _itemsSold.current(); 95 | uint currentIndex = 0; 96 | 97 | MarketPsychoItem[] memory items = new MarketPsychoItem[](unsoldItemCount); 98 | for (uint i = 0; i < itemCount; i++) { 99 | if (idToMarketPsychoItem[i + 1].owner == address(0)) { 100 | uint currentId = i + 1; 101 | MarketPsychoItem storage currentItem = idToMarketPsychoItem[currentId]; 102 | items[currentIndex] = currentItem; 103 | currentIndex += 1; 104 | } 105 | } 106 | return items; 107 | } 108 | 109 | /* Returns only items that a user has purchased */ 110 | function fetchMyPsychos() public view returns (MarketPsychoItem[] memory) { 111 | uint totalItemCount = _itemIds.current(); 112 | uint itemCount = 0; 113 | uint currentIndex = 0; 114 | 115 | for (uint i = 0; i < totalItemCount; i++) { 116 | if (idToMarketPsychoItem[i + 1].owner == msg.sender) { 117 | itemCount += 1; 118 | } 119 | } 120 | 121 | MarketPsychoItem[] memory items = new MarketPsychoItem[](itemCount); 122 | for (uint i = 0; i < totalItemCount; i++) { 123 | if (idToMarketPsychoItem[i + 1].owner == msg.sender) { 124 | uint currentId = i + 1; 125 | MarketPsychoItem storage currentItem = idToMarketPsychoItem[currentId]; 126 | items[currentIndex] = currentItem; 127 | currentIndex += 1; 128 | } 129 | } 130 | return items; 131 | } 132 | 133 | /* Returns only items a user has created */ 134 | function fetchItemsCreated() public view returns (MarketPsychoItem[] memory) { 135 | uint totalItemCount = _itemIds.current(); 136 | uint itemCount = 0; 137 | uint currentIndex = 0; 138 | 139 | for (uint i = 0; i < totalItemCount; i++) { 140 | if (idToMarketPsychoItem[i + 1].seller == msg.sender) { 141 | itemCount += 1; 142 | } 143 | } 144 | 145 | MarketPsychoItem[] memory items = new MarketPsychoItem[](itemCount); 146 | for (uint i = 0; i < totalItemCount; i++) { 147 | if (idToMarketPsychoItem[i + 1].seller == msg.sender) { 148 | uint currentId = i + 1; 149 | MarketPsychoItem storage currentItem = idToMarketPsychoItem[currentId]; 150 | items[currentIndex] = currentItem; 151 | currentIndex += 1; 152 | } 153 | } 154 | return items; 155 | } 156 | } 157 | -------------------------------------------------------------------------------- /contracts/AssetsMarket.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: GPL-3.0 2 | 3 | pragma experimental ABIEncoderV2; 4 | pragma solidity 0.8.10; 5 | 6 | import "@openzeppelin/contracts/utils/Counters.sol"; 7 | import "@openzeppelin/contracts/security/ReentrancyGuard.sol"; 8 | import "../../Game/Interfaces/IAsset.sol"; 9 | import "../../Utils/Owner.sol"; 10 | import "../../Digibytes/Interfaces/IBEP20.sol"; 11 | 12 | contract AssetsMarket is ReentrancyGuard, Owner { 13 | using Counters for Counters.Counter; 14 | Counters.Counter private _itemIds; 15 | Counters.Counter private _itemsSold; 16 | 17 | // address payable owner; 18 | IAsset public assetsContract; 19 | IBEP20 public DBT; 20 | 21 | function setAssets(address _assetsAddress) public isOwner { 22 | assetsContract = IAsset(_assetsAddress); 23 | } 24 | 25 | function setDBT(address _DBTAddress) public isOwner { 26 | DBT = IBEP20(_DBTAddress); 27 | } 28 | 29 | struct MarketAssetItem { 30 | uint256 itemId; 31 | uint32 assetId; 32 | address seller; 33 | address owner; 34 | uint256 price; 35 | bool sold; 36 | } 37 | 38 | mapping(uint256 => MarketAssetItem) private idToMarketAssetItem; 39 | 40 | event MarketAssetItemCreated ( 41 | uint indexed itemId, 42 | uint32 indexed assetId, 43 | address seller, 44 | address owner, 45 | uint256 price, 46 | bool sold 47 | ); 48 | 49 | /* Returns the listing price of the contract */ 50 | // function getListingPrice() public view returns (uint256) { 51 | // return listingPrice; 52 | // } 53 | 54 | /* Places an item for sale on the marketplace */ 55 | function createMarketAssetItem( 56 | uint32 assetId, 57 | uint256 price 58 | ) public { 59 | require(price > 0, "Price must be at least 1 wei"); 60 | 61 | _itemIds.increment(); 62 | uint256 itemId = _itemIds.current(); 63 | 64 | assetsContract.transferAssetFrom(msg.sender, address(this), assetId); 65 | 66 | idToMarketAssetItem[itemId] = MarketAssetItem( 67 | itemId, 68 | assetId, 69 | address(msg.sender), 70 | address(0), 71 | price, 72 | false 73 | ); 74 | 75 | emit MarketAssetItemCreated( 76 | itemId, 77 | assetId, 78 | msg.sender, 79 | address(0), 80 | price, 81 | false 82 | ); 83 | } 84 | 85 | //CLOSE MARKET ITEM 86 | 87 | /* Creates the sale of a marketplace item */ 88 | /* Transfers ownership of the item, as well as funds between parties */ 89 | function createMarketAssetSale( 90 | uint256 itemId 91 | ) 92 | public nonReentrant 93 | { 94 | uint256 price = idToMarketAssetItem[itemId].price; 95 | uint32 assetId = idToMarketAssetItem[itemId].assetId; 96 | DBT.transferFrom(address(msg.sender), address(idToMarketAssetItem[itemId].seller), price); 97 | assetsContract.transferAsset(msg.sender, assetId); 98 | idToMarketAssetItem[itemId].owner = payable(msg.sender); 99 | idToMarketAssetItem[itemId].sold = true; 100 | _itemsSold.increment(); 101 | } 102 | 103 | /* Returns all unsold market items */ 104 | function fetchMarketAssetsItems() public view returns (MarketAssetItem[] memory) { 105 | uint itemCount = _itemIds.current(); 106 | uint unsoldItemCount = _itemIds.current() - _itemsSold.current(); 107 | uint currentIndex = 0; 108 | 109 | MarketAssetItem[] memory items = new MarketAssetItem[](unsoldItemCount); 110 | for (uint i = 0; i < itemCount; i++) { 111 | if (idToMarketAssetItem[i + 1].owner == address(0)) { 112 | uint currentId = i + 1; 113 | MarketAssetItem storage currentItem = idToMarketAssetItem[currentId]; 114 | items[currentIndex] = currentItem; 115 | currentIndex += 1; 116 | } 117 | } 118 | return items; 119 | } 120 | 121 | /* Returns only items that a user has purchased */ 122 | function fetchMyMarketAssets() public view returns (MarketAssetItem[] memory) { 123 | uint totalItemCount = _itemIds.current(); 124 | uint itemCount = 0; 125 | uint currentIndex = 0; 126 | 127 | for (uint i = 0; i < totalItemCount; i++) { 128 | if (idToMarketAssetItem[i + 1].owner == msg.sender) { 129 | itemCount += 1; 130 | } 131 | } 132 | 133 | MarketAssetItem[] memory items = new MarketAssetItem[](itemCount); 134 | for (uint i = 0; i < totalItemCount; i++) { 135 | if (idToMarketAssetItem[i + 1].owner == msg.sender) { 136 | uint currentId = i + 1; 137 | MarketAssetItem storage currentItem = idToMarketAssetItem[currentId]; 138 | items[currentIndex] = currentItem; 139 | currentIndex += 1; 140 | } 141 | } 142 | return items; 143 | } 144 | 145 | /* Returns only items a user has created */ 146 | function fetchAssetItemsCreated() public view returns (MarketAssetItem[] memory) { 147 | uint totalItemCount = _itemIds.current(); 148 | uint itemCount = 0; 149 | uint currentIndex = 0; 150 | 151 | for (uint i = 0; i < totalItemCount; i++) { 152 | if (idToMarketAssetItem[i + 1].seller == msg.sender) { 153 | itemCount += 1; 154 | } 155 | } 156 | 157 | MarketAssetItem[] memory items = new MarketAssetItem[](itemCount); 158 | for (uint i = 0; i < totalItemCount; i++) { 159 | if (idToMarketAssetItem[i + 1].seller == msg.sender) { 160 | uint currentId = i + 1; 161 | MarketAssetItem storage currentItem = idToMarketAssetItem[currentId]; 162 | items[currentIndex] = currentItem; 163 | currentIndex += 1; 164 | } 165 | } 166 | return items; 167 | } 168 | } 169 | --------------------------------------------------------------------------------