Solple Metaverse Exchange

Metaverse NFT Exchange for Game Companies

Platform Architecture

Game-Centric Design

• ▶Isolated marketplaces per game
• ▶Cross-game asset trading support
• ▶Unified wallet integration
• ▶Customizable storefronts

Smart Contract Implementation

Multi-Game NFT Management

solidity
// Solple Multi-Game Marketplace
contract SolpleMarketplace {
    struct Game {
        string name;
        address admin;
        uint256 feePercent;
        bool active;
    }
    
    struct Listing {
        address nftContract;
        uint256 tokenId;
        address seller;
        uint256 price;
        string gameId;
        bool isActive;
    }
    
    mapping(string => Game) public games;
    mapping(bytes32 => Listing) public listings;
    
    function registerGame(
        string memory gameId,
        string memory gameName,
        address admin,
        uint256 feePercent
    ) external onlyOwner {
        games[gameId] = Game({
            name: gameName,
            admin: admin,
            feePercent: feePercent,
            active: true
        });
    }
    
    function listAsset(
        string memory gameId,
        address nftContract,
        uint256 tokenId,
        uint256 price
    ) external {
        require(games[gameId].active, "Game not active");
        
        bytes32 listingId = keccak256(abi.encodePacked(
            nftContract,
            tokenId,
            msg.sender,
            block.timestamp
        ));
        
        listings[listingId] = Listing({
            nftContract: nftContract,
            tokenId: tokenId,
            seller: msg.sender,
            price: price,
            gameId: gameId,
            isActive: true
        });
        
        // Transfer NFT to marketplace escrow
        IERC721(nftContract).transferFrom(msg.sender, address(this), tokenId);
    }
    
    function purchaseAsset(bytes32 listingId) external payable {
        Listing storage listing = listings[listingId];
        require(listing.isActive, "Listing not active");
        require(msg.value >= listing.price, "Insufficient payment");
        
        Game memory game = games[listing.gameId];
        
        // Calculate fees
        uint256 gameFee = (listing.price * game.feePercent) / 10000;
        uint256 platformFee = (listing.price * 250) / 10000; // 2.5%
        uint256 sellerProceeds = listing.price - gameFee - platformFee;
        
        // Distribute funds
        payable(game.admin).transfer(gameFee);
        payable(platformAddress).transfer(platformFee);
        payable(listing.seller).transfer(sellerProceeds);
        
        // Transfer NFT to buyer
        IERC721(listing.nftContract).transferFrom(
            address(this),
            msg.sender,
            listing.tokenId
        );
        
        listing.isActive = false;
    }
}

In-Game Asset Types

Supported NFT Categories

1. ▶
   Avatars & Skins
   • ▶Character appearances
   • ▶Customization items
   • ▶Accessories
2. ▶
   Virtual Land
   • ▶Parcels and estates
   • ▶Building rights
   • ▶Location metadata
3. ▶
   In-Game Items
   • ▶Weapons and tools
   • ▶Consumables
   • ▶Collectibles
4. ▶
   Virtual Currency
   • ▶Game-specific tokens (ERC-20)
   • ▶Currency bundles
   • ▶Reward points

On-Chain Implementation

NFT Standard Customization

solidity
contract GameAssetNFT is ERC721 {
    struct AssetMetadata {
        string assetType;      // 'avatar', 'land', 'item', 'currency'
        string gameId;
        uint256 rarity;        // 1-5 scale
        mapping(string => string) attributes;  // Dynamic attributes
        bool transferable;
        bool tradable;
    }
    
    mapping(uint256 => AssetMetadata) public assetData;
    
    function mintGameAsset(
        address to,
        string memory gameId,
        string memory assetType,
        uint256 rarity,
        string[] memory attrKeys,
        string[] memory attrValues
    ) external onlyGameAdmin(gameId) returns (uint256) {
        uint256 tokenId = _nextTokenId++;
        _safeMint(to, tokenId);
        
        AssetMetadata storage metadata = assetData[tokenId];
        metadata.assetType = assetType;
        metadata.gameId = gameId;
        metadata.rarity = rarity;
        metadata.transferable = true;
        metadata.tradable = true;
        
        for (uint256 i = 0; i < attrKeys.length; i++) {
            metadata.attributes[attrKeys[i]] = attrValues[i];
        }
        
        return tokenId;
    }
}

Backend Services

Game Integration API

• ▶POST /api/game/register: Register new game
• ▶POST /api/asset/mint: Mint new in-game asset
• ▶GET /api/marketplace/{gameId}: Get game marketplace listings
• ▶POST /api/trade/initiate: Start asset trade
• ▶GET /api/player/{address}/inventory: Get player assets

Metadata Management

javascript
// Asset Metadata Service
class MetadataService {
    async uploadAssetMetadata(assetData) {
        const metadata = {
            name: assetData.name,
            description: assetData.description,
            image: assetData.imageUrl,
            attributes: assetData.attributes,
            game_info: {
                game_id: assetData.gameId,
                asset_type: assetData.assetType,
                rarity: assetData.rarity
            },
            created_at: new Date().toISOString()
        };
        
        // Upload to IPFS
        const cid = await ipfs.add(JSON.stringify(metadata));
        const metadataURI = `ipfs://${cid}`;
        
        // Store mapping in database
        await db.assetMetadata.create({
            tokenId: assetData.tokenId,
            metadataURI: metadataURI,
            cid: cid
        });
        
        return metadataURI;
    }
}

Frontend Development

Player Dashboard

• ▶Portfolio View: Display all owned assets across games
• ▶Marketplace Browser: Search and filter by game/type/rarity
• ▶Trade Interface: Initiate trades and accept offers
• ▶Transaction History: Track all asset movements

Game Studio Portal

• ▶Asset minting tools
• ▶Marketplace configuration
• ▶Revenue analytics
• ▶Player statistics

Cross-Game Features

Universal Inventory System

javascript
// Unified Inventory Query
async function getPlayerInventory(playerAddress) {
    const registeredGames = await solpleContract.getActiveGames();
    const inventory = [];
    
    for (const game of registeredGames) {
        const nftContract = await solpleContract.getGameNFTContract(game.id);
        const tokenIds = await nftContract.tokensOfOwner(playerAddress);
        
        for (const tokenId of tokenIds) {
            const metadata = await fetchMetadata(nftContract, tokenId);
            inventory.push({
                game: game.name,
                tokenId: tokenId,
                ...metadata
            });
        }
    }
    
    return inventory;
}

Technical Achievements