Decentraland SDK Integration

Decentraland SDK Integration

Decentraland is a browser-based metaverse on Ethereum, where land plots (LAND) are NFTs. SDK 7 (current version) provides the ability to create interactive scenes with 3D objects, game logic, and Web3 integration.

Decentraland Project Structure

npx @dcl/sdk-commands init my-scene --skip-install
cd my-scene && npm install

Structure:

my-scene/
├── src/
│   ├── index.ts     # scene entry point
│   └── systems/     # game systems
├── assets/          # 3D models, textures
└── scene.json       # metadata (plot coordinates, title)

Creating an Interactive Scene

import { engine, Entity, Transform, GltfContainer, 
         PointerEvents, InputAction, inputSystem } from '@dcl/sdk/ecs'
import { Vector3, Quaternion } from '@dcl/sdk/math'

export function main() {
  // Create interactive object
  const nftDisplay = engine.addEntity()
  
  Transform.create(nftDisplay, {
    position: Vector3.create(8, 1, 8),
    scale: Vector3.create(1, 1, 1),
    rotation: Quaternion.fromEulerDegrees(0, 0, 0),
  })
  
  GltfContainer.create(nftDisplay, {
    src: 'assets/nft_frame.glb',
  })
  
  // Click handler
  PointerEvents.create(nftDisplay, {
    pointerEvents: [{ eventType: PointerEventType.PET_DOWN,
                      info: { button: InputAction.IA_POINTER, hoverText: 'Inspect NFT' } }],
  })
  
  // Update system
  engine.addSystem(() => {
    if (inputSystem.isTriggered(InputAction.IA_POINTER, PointerEventType.PET_DOWN, nftDisplay)) {
      openNFTDetails()
    }
  })
}

Web3 Integration

Decentraland SDK 7 supports wallet interaction via @dcl/sdk/ethereum-provider:

import { createEthereumProvider } from '@dcl/sdk/ethereum-provider'
import { ethers } from 'ethers'

async function checkNFTOwnership(tokenId: number): Promise<boolean> {
  const provider = createEthereumProvider()
  const ethProvider = new ethers.BrowserProvider(provider)
  const signer = await ethProvider.getSigner()
  const userAddress = await signer.getAddress()
  
  const nftContract = new ethers.Contract(NFT_CONTRACT_ADDRESS, ERC721_ABI, ethProvider)
  const owner = await nftContract.ownerOf(tokenId)
  
  return owner.toLowerCase() === userAddress.toLowerCase()
}

// Show exclusive content only to NFT holders
async function unlockExclusiveArea() {
  const hasAccess = await checkNFTOwnership(MEMBERSHIP_TOKEN_ID)
  
  if (hasAccess) {
    showExclusiveContent()
  } else {
    showPurchasePrompt()
  }
}

Server Logic via Scene Runtime

For complex logic (multiplayer, game mechanics) use Decentraland Scene Server based on TypeScript:

// server/index.ts
import { WebSocketServer } from 'ws'

const wss = new WebSocketServer({ port: 8080 })
const players = new Map<string, PlayerState>()

wss.on('connection', (ws, req) => {
  const playerId = getPlayerIdFromRequest(req)
  
  ws.on('message', (data) => {
    const event = JSON.parse(data.toString())
    
    switch(event.type) {
      case 'MOVE':
        players.set(playerId, event.position)
        broadcastToAll({ type: 'PLAYER_MOVED', playerId, position: event.position })
        break
      case 'INTERACT':
        handleInteraction(playerId, event.objectId)
        break
    }
  })
})

Scene deployment: npx @dcl/sdk-commands deploy — uploads content to Decentraland Content Server. Private scenes are deployed on own infrastructure via catalyst node.

Development of a simple interactive Decentraland scene with Web3 integration: 3–5 weeks. Complex scene with multiplayer and game mechanics — 2–3 months.