In-Game NFT Marketplace Development

In-Game NFT Marketplace Development

In-game NFT marketplace differs from general NFT marketplaces (OpenSea, Blur) with specialized content, game context, and requirement for deep integration with game mechanics. Item is displayed not just as JPEG—showing its attributes, level, usage history, character class compatibility.

Architectural Decisions

On-chain vs Custom Marketplace

Can use Seaport (OpenSea protocol) as base—it's production-ready, audited, supports batch orders, criteria-based orders (sell any token from collection). Saves 2-3 months of development.

Custom marketplace needed when: specific mechanics (auction with in-game currency, bundle deals "sell character with inventory"), royalty distribution among multiple stakeholders, rating-based listings (not just price, but price/power ratio).

In-game Currency vs ETH/USDC

Critical choice: accept ETH or only game token.

Only in-game currency: creates sink for token, keeps economy inside game, simpler tax-wise. Minus: user must buy token first.

ETH/USDC: wider buyer market, liquidity. Minus: value "escapes" game economy.

Hybrid: listings in in-game token, but "Buy for USDC" button automatically swaps token → USDC through DEX. Seamless UX, both markets happy.

Marketplace Smart Contract

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

contract GameNFTMarketplace {
    IERC20 public gameToken;
    IERC1155 public gameItems;
    
    uint256 public marketFeePercent = 250; // 2.5%
    uint256 public royaltyPercent = 500;   // 5% to creators
    address public treasury;
    address public developersWallet;
    
    struct Listing {
        address seller;
        uint256 itemTypeId;
        uint256 amount;
        uint256 pricePerUnit;       // in gameToken
        uint256 minimumPurchase;    // minimum buy
        bool acceptsBundle;         // accepts bundle offers
        uint256 expiresAt;
        ListingType listingType;
    }
    
    enum ListingType { FIXED_PRICE, ENGLISH_AUCTION, DUTCH_AUCTION }
    
    struct Auction {
        address seller;
        uint256 itemTypeId;
        uint256 tokenId;
        uint256 startPrice;
        uint256 currentBid;
        address currentBidder;
        uint256 endTime;
        uint256 minBidIncrement;
    }
    
    mapping(uint256 => Listing) public listings;
    mapping(uint256 => Auction) public auctions;
    
    // Fixed price purchase
    function buyItem(uint256 listingId, uint256 amount) external {
        Listing storage listing = listings[listingId];
        require(listing.seller != address(0), "Listing not found");
        require(block.timestamp <= listing.expiresAt, "Listing expired");
        require(amount >= listing.minimumPurchase, "Below minimum purchase");
        
        uint256 totalPrice = listing.pricePerUnit * amount;
        uint256 fee = (totalPrice * marketFeePercent) / 10000;
        uint256 royalty = (totalPrice * royaltyPercent) / 10000;
        uint256 sellerProceeds = totalPrice - fee - royalty;
        
        // Payments
        gameToken.transferFrom(msg.sender, listing.seller, sellerProceeds);
        gameToken.transferFrom(msg.sender, treasury, fee);
        gameToken.transferFrom(msg.sender, developersWallet, royalty);
        
        // Transfer items
        listing.amount -= amount;
        if (listing.amount == 0) delete listings[listingId];
        
        gameItems.safeTransferFrom(listing.seller, msg.sender, listing.itemTypeId, amount, "");
        
        emit ItemSold(listingId, msg.sender, amount, totalPrice);
    }
    
    // English auction
    function placeBid(uint256 auctionId, uint256 bidAmount) external {
        Auction storage auction = auctions[auctionId];
        require(block.timestamp < auction.endTime, "Auction ended");
        require(bidAmount >= auction.currentBid + auction.minBidIncrement, "Bid too low");
        
        // Return to previous bidder
        if (auction.currentBidder != address(0)) {
            gameToken.transfer(auction.currentBidder, auction.currentBid);
        }
        
        // New bid in escrow
        gameToken.transferFrom(msg.sender, address(this), bidAmount);
        auction.currentBid = bidAmount;
        auction.currentBidder = msg.sender;
        
        // Anti-snipe: extend if bid < 5 min before end
        if (auction.endTime - block.timestamp < 5 minutes) {
            auction.endTime += 5 minutes;
        }
        
        emit BidPlaced(auctionId, msg.sender, bidAmount);
    }
    
    // Dutch auction: price decreases over time
    function getDutchPrice(uint256 listingId) public view returns (uint256) {
        Listing storage listing = listings[listingId];
        // ... linearly interpolate price from startPrice to endPrice over duration
    }
}

Item Attribute Display

Game marketplace specificity—rich context for each NFT:

interface GameItemListing {
  tokenId: number;
  itemType: {
    id: number;
    name: string;
    rarity: "common" | "rare" | "epic" | "legendary";
    category: "weapon" | "armor" | "consumable" | "companion";
    imageUrl: string;
  };
  attributes: {
    level: number;
    damage?: number;
    defense?: number;
    speed?: number;
    durability: number;  // current condition
    upgradeCount: number;
    enchantments: string[];
  };
  gameContext: {
    compatibleClasses: string[];  // which character classes fit
    compatibleGames: string[];    // if cross-game NFT
    requiredLevel: number;        // character minimum level
    lastUsedInBattle?: Date;
    totalBattlesUsed: number;
  };
  listing: {
    price: bigint;
    currency: "GGD" | "USDC";
    seller: string;
    listedAt: Date;
    expiresAt: Date;
  };
  priceHistory: Array<{ price: bigint; date: Date }>;
  floorPrice: bigint;  // minimum price in this category
  pricePower: number;  // price / power ratio vs floor
}

Search and Filtering

interface MarketplaceFilters {
  itemCategory?: string[];
  rarities?: string[];
  minPrice?: bigint;
  maxPrice?: bigint;
  minLevel?: number;
  maxLevel?: number;
  compatibleClass?: string;
  hasEnchantment?: string;
  currency?: "GGD" | "USDC";
  sortBy?: "price_asc" | "price_desc" | "recently_listed" | "ending_soon" | "price_power";
}

// Elasticsearch or PostgreSQL with GIN indices for JSONB attributes
async function searchListings(filters: MarketplaceFilters, page: number) {
  const query = db("listings")
    .where("status", "active")
    .where("expires_at", ">", new Date());
  
  if (filters.itemCategory?.length) {
    query.whereIn("item_category", filters.itemCategory);
  }
  
  if (filters.minLevel) {
    query.where("attributes->>'level'", ">=", filters.minLevel.toString());
  }
  
  if (filters.hasEnchantment) {
    query.whereRaw("attributes->'enchantments' @> ?", [JSON.stringify([filters.hasEnchantment])]);
  }
  
  return query
    .orderBy(getSortColumn(filters.sortBy))
    .limit(PAGE_SIZE)
    .offset(page * PAGE_SIZE);
}

Bundle Deals

Game context enables bundle sales: "Sell character with full equipment":

struct BundleListing {
    address seller;
    uint256[] itemTypeIds;
    uint256[] amounts;
    uint256 bundlePrice;       // discount vs sum of individual
    bool requireAllItems;      // all items or optional
}

NFT Renting

For expensive items—renting mechanic: NFT holder rents it, renter uses in game and pays daily/weekly rent fee. After period—item automatically returns.

// ERC-4907 standard for rentable NFT
interface IERC4907 {
    function setUser(uint256 tokenId, address user, uint64 expires) external;
    function userOf(uint256 tokenId) external view returns (address);
    function userExpires(uint256 tokenId) external view returns (uint256);
}

Timeline

• Basic marketplace (fixed price + simple auction): 4-6 weeks
• Extended (dutch auction, bundle, rent): +3-4 weeks
• Search and indexing (backend + Elasticsearch): +2-3 weeks
• Frontend with rich item UI: 4-6 weeks
• Security audit: +3-4 weeks
• Total: 3-5 months