Marketplace Test

contracts/BlockMarket.sol

@@ -0,0 +1,132 @@
+// // SPDX-License-Identifier: SEE LICENSE IN LICENSE
+// pragma solidity 0.8.28;
+
+// import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+// import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
+
+// struct Listing{
+//     address owner;
+//     uint256 tokenId;
+//     IERC20 paymentToken;
+//     address NftToken;
+//     bool isNative;
+//     uint256 price;
+//     bool sold;
+//     uint minOffer;
+// }
+
+// struct OfferDetails{
+//     uint256 listId;
+//     uint256 offerAmount;
+//     address offerrer;
+//     address paymentToken;
+//     bool status;
+// }
+
+// contract BlockMarketPlace {
+
+// mapping (uint256 listid => Listing list) public idToListing;
+// mapping (uint256 offerid => OfferDetails offer) public idToOffer;
+// uint256 lastUpdatedid;
+// address marketOwner;
+//     function listNft(Listing memory list) external {
+//        uint listId =  lastUpdatedid++;
+//        require(list.price > 0, "Invalid price");
+//        require(list.minOffer > 0, "Invalid min offer");
+//        if(list.isNative){
+//         require(address(list.paymentToken) == address(0));
+//        }
+//         Listing memory listing;
+//         listing.owner = msg.sender;
+//         listing.tokenId = list.tokenId;
+//         listing.paymentToken = list.paymentToken;
+//         listing.price = list.price;
+//         listing.isNative = list.isNative;
+//         listing.minOffer = list.minOffer;
+//         listing.NftToken = list.NftToken;
+//         idToListing[listId] = listing; 
+
+
+//         IERC721(list.NftToken).transferFrom(msg.sender, address(this), list.tokenId);
+//     }
+
+//     function buyNft(uint256 listId) external payable {
+//         Listing memory l = idToListing[listId];
+//         require(!l.sold, "ALready Sold");
+//         idToListing[listId].sold = true;
+//         if(l.isNative){
+//             require(msg.value == l.price, "Incorrect price");
+//             (bool s,) = l.owner.call{value: l.price * 97/100}("");
+//             (bool ss,) = marketOwner.call{value: l.price * 3/100}("");
+//             require(s, "Owner transfer failed");
+//             require(ss, "MarketOwner Transfer failed");
+//         }else{
+//             l.paymentToken.transferFrom(msg.sender, l.owner, l.price * 97/100);
+//             l.paymentToken.transferFrom(msg.sender, marketOwner, l.price * 3/100);
+//         }
+//         IERC721(l.NftToken).transferFrom(address(this), msg.sender, l.tokenId);
+//     }
+
+//     function offer(uint256 listid, address paymentToken, uint256 amount) external payable {
+//     Listing storage l = idToListing[listid];
+//     require(!l.sold, "Already sold");
+//     require(msg.sender != l.owner, "Owner cannot offer");
+
+//     uint256 offerAmount;
+//     if (l.isNative) {
+//         offerAmount = msg.value;
+//         require(offerAmount >= l.minOffer, "Offer too low");
+//     } else {
+//         require(paymentToken != address(0), "Invalid token");
+//         require(amount >= l.minOffer, "Offer too low");
+//         require(IERC20(paymentToken).transferFrom(msg.sender, address(this), amount), "ERC20 transfer failed");
+//         offerAmount = amount;
+//     }
+
+//     uint256 offerid = ++lastUpdatedid;
+//     idToOffer[offerid] = OfferDetails({
+//         listId: listid,
+//         offerAmount: offerAmount,
+//         offerrer: msg.sender,
+//         paymentToken: paymentToken
+//     });
+// }
+
+//     function acceptOffer(uint256 offerid) external {
+//     OfferDetails memory offer = idToOffer[offerid];
+//     Listing storage l = idToListing[offer.listId];
+//     require(msg.sender == l.owner, "Only owner can accept offer");
+//     require(!l.sold, "Already sold");
+
+//     l.sold = true;
+//     if (l.isNative) {
+//         (bool success,) = l.owner.call{value: offer.offerAmount}("");
+//         require(success, "Transfer to owner failed");
+//     } else {
+//         require(IERC20(offer.paymentToken).transfer(l.owner, offer.offerAmount), "Transfer to owner failed");
+//     }
+//     IERC721(l.NftToken).transferFrom(address(this), offer.offerrer, l.tokenId);
+//     delete idToOffer[offerid];
+// }
+
+// function cancelOffer(uint256 offerid) external {
+//         OfferDetails storage offer = idToOffer[offerid];
+//         require(offer.offerrer == msg.sender, "Not offerer");
+//         Listing memory l = idToListing[offer.listId];
+//     if (l.isNative) {
+//         (bool s,) = msg.sender.call{value: offer.offerAmount}("");
+//         require(s, "Refund failed");
+//     } else {
+//         IERC20(offer.paymentToken).transfer(msg.sender, offer.offerAmount);
+//     }
+//     delete idToOffer[offerid];
+// }
+
+//     function cancelListing(uint256 listid) external {
+//         Listing storage l = idToListing[listid];
+//         require(msg.sender == l.owner, "Not owner");
+//         require(!l.sold, "Already sold");
+//         delete idToListing[listid];
+//         IERC721(l.NftToken).transferFrom(address(this), msg.sender, l.tokenId);
+//     }  
+// }

contracts/BlockMarketPlace.sol

@@ -0,0 +1,133 @@
+// SPDX-License-Identifier: SEE LICENSE IN LICENSE
+pragma solidity 0.8.28;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
+c
+
+uint256 public lastUpdatedid;
+uint256 public lastOfferId;
+address public marketOwner;
+
+    constructor() {
+        marketOwner = msg.sender;
+    }    
+
+    function listNft(Listing memory list) external {
+       uint listId =  lastUpdatedid++;
+       require(list.price > 0, "Invalid price");
+       require(list.minOffer > 0, "Invalid min offer");
+       if(list.isNative){
+        require(address(list.paymentToken) == address(0), "ERC20 Payment is not supported");
+       }
+        Listing memory listing;
+        listing.owner = msg.sender;
+        listing.tokenId = list.tokenId;
+        listing.paymentToken = list.paymentToken;
+        listing.price = list.price;
+        listing.isNative = list.isNative;
+        listing.minOffer = list.minOffer;
+        listing.NftToken = list.NftToken;
+        idToListing[listId] = listing; 
+
+
+        IERC721(list.NftToken).transferFrom(msg.sender, address(this), list.tokenId);
+    }
+    function getListing(uint256 listId) external view returns(Listing memory){
+        return idToListing[listId];
+    }
+    function buyNft(uint256 listId) external payable {
+        Listing memory l = idToListing[listId];
+        require(!l.sold, "ALready Sold");
+        idToListing[listId].sold = true;
+
+        if(l.isNative){
+            require(msg.value == l.price, "Incorrect price");
+            (bool s,) = l.owner.call{value: l.price * 97/100}("");
+            (bool ss,) = marketOwner.call{value: l.price * 3/100}("");
+            require(s, "Owner transfer failed");
+            require(ss, "MarketOwner Transfer failed");
+        }else{
+            l.paymentToken.transferFrom(msg.sender, l.owner, l.price * 97/100);
+            l.paymentToken.transferFrom(msg.sender, marketOwner, l.price * 3/100);
+        }
+        IERC721(l.NftToken).transferFrom(address(this), msg.sender, l.tokenId);
+    }
+
+    function offer(uint256 listid, uint256 offerAmount) external payable {
+        uint256 offerId = lastOfferId++;
+        Listing memory l = idToListing[listid];
+        require(!l.sold, "Already sold");
+        if(l.isNative){
+            require(msg.value >= l.minOffer, "Invalid offer");
+            require(offerAmount == 0, "Cannot offer erc20");
+        }else {
+        require(offerAmount >= l.minOffer, "Invalid offer");  
+        l.paymentToken.transferFrom(msg.sender, address(this), offerAmount);         
+        }
+        require(msg.sender != l.owner, "Owner cannot offer");
+        OfferDetails memory offer_;
+        offer_.listId = listid;
+        offer_.offerrer = msg.sender;
+        offer_.offerAmount = l.isNative ? msg.value : offerAmount;
+
+        idToOffer[offerId] = offer_;
+    }
+
+    function getOffer(uint256 offerId) external view returns(OfferDetails memory o) {
+        o = idToOffer[offerId];
+    }
+
+    function acceptOffer(uint256 offerid) external {
+        OfferDetails memory offer_ = idToOffer[offerid];
+        Listing memory l = idToListing[offer_.listId];
+        // Checks
+        require(l.owner == msg.sender, "Unauthorized seller");
+        require(!l.sold, "Already Sold");
+        require(offer_.offerrer != address(0), "Invalid offer");
+        // Effects
+        idToListing[offer_.listId].sold = true;
+        idToOffer[offerid].status = true;
+        // Interactions
+        if(l.isNative){
+            (bool success,) = l.owner.call{value: offer_.offerAmount * 97/100}("");
+            (bool success2,) = marketOwner.call{value: offer_.offerAmount * 3/100}("");
+            require(success, "Failed owner transfer");
+            require(success2, "Failed marketPlace commission transfer");
+        }else{
+            l.paymentToken.transfer(l.owner, offer_.offerAmount * 97/100);
+            l.paymentToken.transfer(marketOwner, offer_.offerAmount * 3/100);
+        }
+        IERC721(l.NftToken).transferFrom(address(this), offer_.offerrer, l.tokenId);
+    }
+
+    function cancelOffer(uint256 offerid) external{
+        OfferDetails memory offer_ = idToOffer[offerid];
+        Listing memory l = idToListing[offer_.listId];
+        // Checks
+        require(!offer_.status, "Offer already accepted");
+        require(msg.sender == offer_.offerrer, "Unauthorized offerrer");
+        // Effects
+        delete idToOffer[offerid];
+        // Interactions
+        if(l.isNative){
+            (bool s,) = offer_.offerrer.call{value: offer_.offerAmount}("");
+            require(s, "Failed refund");
+        }else{
+            l.paymentToken.transfer(offer_.offerrer, offer_.offerAmount);
+        }
+
+    }
+
+    function cancelListing(uint256 listid) external {
+        Listing memory l = idToListing[listid];
+        // Checks
+        require(msg.sender == l.owner, "Unauthorized user");
+        require(!l.sold, "Already sold");
+        // Effects
+        delete idToListing[listid];
+        // Interaction
+        IERC721(l.NftToken).transferFrom(address(this), l.owner, l.tokenId);
+    }
+
+}

contracts/BlockNft.sol

@@ -0,0 +1,16 @@
+// // SPDX-License-Identifier: SEE LICENSE IN LICENSE
+// pragma solidity ^0.8.28;
+
+// import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
+
+// contract BlockNft is ERC721{
+//     uint256 public tokenID;
+//     constructor() ERC721("BlockNft", "BKN"){}
+
+//     function mint(address recepient) external returns(uint256){
+//      tokenID++;
+//      uint256 tokenId = tokenID;
+//         _safeMint(recepient, tokenId);
+//         return tokenId;
+//     }
+// }

contracts/MyBlockMarketPlace.sol

@@ -0,0 +1,30 @@
+// // SPDX-License-Identifier: MIT
+// pragma solidity ^0.8.20;
+
+// struct Listing {
+//         address owner;
+//         uint256 id;
+//         address nftToken;
+//         uint256 tokenId;
+//         IERC20 paymentToken;
+//         bool isNative;
+//         uint256 price;
+//         bool sold;
+//         uint256 minOffer;
+//     }
+
+//     struct OfferDetails {
+//         uint256 offerAmount;
+//         address offerer;
+//     }
+
+//     contract BlockMarketPlace [
+
+//         mapping(uint256 listid => Listing list) public idToListing;
+//         mapping(uint256 offerid => OfferDetails offer) public idToOffer;
+//         uint256 lastUpdated;
+
+//             function listNft(Listing memory list) external {
+//                 uint listid = 
+//             }
+//     ]