One post tagged with "NFT Marketplace"

// ERC-721 Interface
interface IERC721 {
    function balanceOf(address owner) external view returns (uint256);
    function ownerOf(uint256 tokenId) external view returns (address);
    function transferFrom(address from, address to, uint256 tokenId) external;
    function approve(address to, uint256 tokenId) external;
    function getApproved(uint256 tokenId) external view returns (address);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";

contract MyNFT is ERC721 {
    uint256 private _tokenIds;
    mapping(uint256 => string) private _tokenURIs;
    
    constructor() ERC721("MyNFT", "MNFT") {}
    
    function mint(address to, string memory tokenURI) public returns (uint256) {
        _tokenIds++;
        uint256 newTokenId = _tokenIds;
        
        _mint(to, newTokenId);
        _setTokenURI(newTokenId, tokenURI);
        
        return newTokenId;
    }
    
    function tokenURI(uint256 tokenId) public view override returns (string memory) {
        return _tokenURIs[tokenId];
    }
}

// ERC-1155 allows both
contract MyMultiToken is ERC1155 {
    // Fungible: amount > 1
    // Non-fungible: amount = 1
    function mint(
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) public {
        _mint(to, id, amount, data);
    }
}

contract NFTMarketplace {
    struct Listing {
        address seller;
        uint256 price;
        bool active;
    }
    
    mapping(uint256 => Listing) public listings;
    IERC721 public nftContract;
    
    function listNFT(uint256 tokenId, uint256 price) external {
        require(nftContract.ownerOf(tokenId) == msg.sender, "Not owner");
        require(nftContract.isApprovedForAll(msg.sender, address(this)), "Not approved");
        
        listings[tokenId] = Listing({
            seller: msg.sender,
            price: price,
            active: true
        });
    }
    
    function buyNFT(uint256 tokenId) external payable {
        Listing memory listing = listings[tokenId];
        require(listing.active, "Not for sale");
        require(msg.value >= listing.price, "Insufficient payment");
        
        nftContract.safeTransferFrom(listing.seller, msg.sender, tokenId);
        payable(listing.seller).transfer(listing.price);
        
        delete listings[tokenId];
    }
}

contract RoyaltyNFT is ERC721 {
    uint256 public royaltyPercentage = 5; // 5%
    address public artist;
    
    function _calculateRoyalty(uint256 salePrice) internal view returns (uint256) {
        return (salePrice * royaltyPercentage) / 100;
    }
}

interface IERC2981 {
    function royaltyInfo(uint256 tokenId, uint256 salePrice)
        external
        view
        returns (address receiver, uint256 royaltyAmount);
}

function mint(address to) public {
    uint256 tokenId = totalSupply() + 1;
    _mint(to, tokenId);
}

mapping(address => bool) public whitelist;
bool public presaleActive;

function presaleMint() external {
    require(presaleActive, "Presale not active");
    require(whitelist[msg.sender], "Not whitelisted");
    // Mint logic
}

uint256 public startPrice = 1 ether;
uint256 public endPrice = 0.1 ether;
uint256 public duration = 1 hours;

function getCurrentPrice() public view returns (uint256) {
    uint256 elapsed = block.timestamp - startTime;
    if (elapsed >= duration) return endPrice;
    
    uint256 priceRange = startPrice - endPrice;
    return startPrice - (priceRange * elapsed / duration);
}

// Inefficient ❌
function mintMultiple(address[] memory to) public {
    for (uint i = 0; i < to.length; i++) {
        _mint(to[i], i + 1);
    }
}

// More efficient ✅
function batchMint(address[] memory to) public {
    for (uint i = 0; i < to.length; i++) {
        _mint(to[i], totalSupply() + i + 1);
    }
}

bool private locked;

modifier nonReentrant() {
    require(!locked, "Reentrant call");
    locked = true;
    _;
    locked = false;
}

mapping(address => bool) public authorizedMinters;

modifier onlyAuthorized() {
    require(authorizedMinters[msg.sender] || msg.sender == owner, "Not authorized");
    _;
}

function mint(address to, string memory uri) external {
    require(to != address(0), "Invalid address");
    require(bytes(uri).length > 0, "Empty URI");
    // Mint logic
}