Metaverse Development with Web3 Economy and NFT Assets

Metaverse Development

The term "metaverse" is overloaded. Before designing, we always clarify: is it a persistent 3D world with real-time interaction (like Decentraland, The Sandbox), a social layer over applications, or virtual offices for enterprise? Each model has its own stack. Here we break down the architecture of a web3-native persistent world: a multiplayer 3D environment with NFT land, on-chain economy, and decentralized governance. This is the most technically complex and in-demand option.

We have five completed metaverse projects and over 5 years of experience in Web3. We share our experience so you can assess the scope of work and avoid common mistakes. However, it's important to understand: an empty world without content and community is dead. In parallel with development, we launch a program for early LAND holders and creators. Contact us to discuss the strategy for attracting creators.

Metaverse Architecture: Blockchain, Content, and Real-Time

Everything of value lives on-chain. The rest (3D assets, scenes) is off-chain on IPFS or Arweave. Here are the key layers.

How Are Ownership and Economy Separated?

• LAND NFTs — virtual land parcels (ERC-721).
• Avatar NFTs — characters with attributes.
• Wearables — items (ERC-1155 or ERC-721).
• Governance token — votes in the DAO.
• In-world currency — ERC-20 for internal transactions.

Content on LAND is not on-chain. The owner deploys 3D scenes and scripts to IPFS — this is flexible and cheap.

LAND System: Coordinate Grid and Estate

A classic model — a map of square parcels with coordinates. As noted in official Decentraland documentation, the coordinate grid is built from the center. Decentraland uses (-150,-150) to (150,150). We apply the same approach:

contract LandRegistry is ERC721 {
    int16 public constant MIN_X = -100;
    int16 public constant MAX_X = 100;
    int16 public constant MIN_Y = -100;
    int16 public constant MAX_Y = 100;

    function coordinatesToId(int16 x, int16 y) public pure returns (uint256) {
        require(x >= MIN_X && x <= MAX_X, "X out of range");
        require(y >= MIN_Y && y <= MAX_Y, "Y out of range");
        return uint256(uint16(x - MIN_X)) * 201 + uint256(uint16(y - MIN_Y));
    }

    function idToCoordinates(uint256 tokenId) public pure returns (int16 x, int16 y) {
        y = int16(int256(tokenId % 201)) + MIN_Y;
        x = int16(int256(tokenId / 201)) + MIN_X;
    }

    function isAdjacent(uint256 tokenId1, uint256 tokenId2) public pure returns (bool) {
        (int16 x1, int16 y1) = idToCoordinates(tokenId1);
        (int16 x2, int16 y2) = idToCoordinates(tokenId2);
        int16 dx = x1 - x2;
        int16 dy = y1 - y2;
        return (dx == 0 && (dy == 1 || dy == -1)) || (dy == 0 && (dx == 1 || dx == -1));
    }
}

To merge adjacent parcels, an Estate composite NFT is used. Ownership of a parcel gives control over the scene content.

Why Is Content Stored Off-Chain?

Storing 3D models and scripts on the blockchain is prohibitively expensive. One gigabyte on Ethereum costs thousands of dollars. Off-chain storage on IPFS or Arweave solves the problem: the LAND owner publishes a scene hash, and the network loads content through a gateway.

Content System: What Is Deployed on LAND

Each LAND has a scene — a JSON descriptor with links to 3D models, scripts, and portals. Publishing through a simple contract:

contract LandContent {
    mapping(uint256 => string) public sceneHash;
    mapping(uint256 => uint256) public sceneVersion;

    function publishScene(uint256 landId, string calldata ipfsHash) external {
        require(landRegistry.ownerOf(landId) == msg.sender, "Not owner");
        require(bytes(ipfsHash).length == 46, "Invalid IPFS hash");
        sceneHash[landId] = ipfsHash;
        sceneVersion[landId]++;
        emit ScenePublished(landId, msg.sender, ipfsHash, sceneVersion[landId]);
    }
}

Developers write interactive scripts in a sandbox environment via an SDK. Example — a door that opens on click, or an NFT gate for access.

How Does Real-Time Avatar Synchronization Work?

Players see each other through game servers, each region (N×N LAND) served by a separate server. When crossing a border — handoff.

Area Server on Node.js

class AreaServer {
    private players = new Map<string, PlayerState>();
    private physicsWorld = new World({ x: 0, y: -9.81, z: 0 });

    handlePlayerJoin(playerId: string, ws: WebSocket, position: Vector3) {
        // ... add player, send snapshot, broadcast
    }

    handleMovement(playerId: string, movement: MovementPacket) {
        // server-side validation, broadcast with delta compression
    }

    private tick() {
        this.physicsWorld.step();
        const updates = this.getDirtyPlayerStates();
        if (updates.length > 0) this.broadcast({ type: 'batch_update', updates });
    }
}

To reduce load, we use proximity-based broadcasting — visibility is limited by a radius (e.g., 100 meters). This turns O(N²) into O(N×K).

Metaverse Economy and Governance

In-World Marketplace with Royalties

A LAND owner earns 2.5% on sales on their land:

contract InWorldMarketplace {
    uint256 public constant LAND_ROYALTY = 250;

    function buy(uint256 listingId) external {
        // checks, calculations, transfer of tokens and NFT
    }
}

Play-to-earn generates in-world currency for attending events, completing quests, participating in mini-games. Emission is controlled by a weekly cap and halvening.

DAO and Voting

Governance via Compound-style Governor. LAND ownership gives voting power (1 LAND = 1 vote + bonus for staking governance token). Decisions include: map expansion, economic parameters, contract upgrades.

Technology Stack and Development Process

Full Stack

Note: Choosing an L2 (Polygon or Arbitrum) dramatically reduces gas — 100x cheaper than Ethereum. This is critical for mass adoption.

What's Included in the Work

• Smart contract audit (LAND, marketplace, token) — we guarantee absence of reentrancy and typical vulnerabilities.
• Full documentation for content creator SDK integration.
• Infrastructure setup: IPFS pinning, game servers, databases.
• Post-launch support: monitoring, hotfixes, economy adjustments.

Phases and Timelines

Realistic timeline: 12–18 months to public alpha for a team of 8–12 people. This is one of the most ambitious projects in Web3.

The main risk is not technical but product-oriented: without content and community, the world will be empty. Therefore, in parallel, we launch a program for early LAND holders and creators. To assess your project and propose the optimal architecture, request a consultation.