Development Guide

This guide covers testing, debugging, and deploying your Games.fun integration.

Development Mode

The SDK includes a development mode for testing without real tokens:

const sdk = new GamesFunSDK({
    debug: true, // Enable debug logging
    gameServerUrl: "your-validation-endpoint",
    dev: {
        enabled: true,
        mock: {
            wallet: {
                address: 'ED5nyyWEzpPPiWimP8vYm7sD7TD3LAt3Q3gRTWHzPJBY',
                tokenBalance: '1000',
                solBalance: '10',
                privyId: '123'
            }
        },
        validation: {
            auto: true, // Auto-validate transfers
            makeRequest: true // Still hit your server
        }
    }
});

Environment Setup

Set up your environment variables:

# .env
GAMES_FUN_API_KEY=your-api-key
GAME_TOKEN_MINT=your-token-mint-address
TRUSTED_DOMAINS=games.fun,your-domain.com

Load them in your server:

import dotenv from 'dotenv';
dotenv.config();

const walletClient = new WalletClient({
    apiKey: process.env.GAMES_FUN_API_KEY
});

Testing

Token Transfers

Test token transfers with dev mode:

// 1. Enable auto-validation
const sdk = new GamesFunSDK({
    dev: {
        enabled: true,
        validation: { auto: true }
    }
});

// 2. Test transfer
await sdk.triggerAction("transferTokens", {
    recipient: gameWalletAddress,
    amount: 100
});

// 3. Verify state update
expect(gameState.coins).toBe(1000);

Authentication

Test JWT flow:

// 1. Request token
const result = await sdk.triggerAction("issueJWT", {});
expect(result.params.jwt).toBeDefined();

// 2. Use token
gameServer.setJWT(result.params.jwt);
const purchaseResult = await gameServer.purchaseItem("shield", 100);
expect(purchaseResult.success).toBe(true);

// 3. Test expiry
const expiredToken = "expired.jwt.token";
gameServer.setJWT(expiredToken);
await expect(
    gameServer.purchaseItem("shield", 100)
).rejects.toThrow('Token expired');

WebSocket

Test real-time updates:

// 1. Connect
const gameServer = new GameServer('ws://localhost:3001');
await gameServer.connect(playerId);

// 2. Listen for updates
let stateUpdated = false;
gameServer.on('stateUpdate', (state) => {
    stateUpdated = true;
    expect(state.coins).toBe(1000);
});

// 3. Trigger update
await sdk.triggerAction("transferTokens", {
    recipient: gameWalletAddress,
    amount: 100
});

// 4. Verify update received
expect(stateUpdated).toBe(true);

Debugging

Client Side

Enable debug logging:

const sdk = new GamesFunSDK({
    debug: true,
    onError: (error) => {
        console.error('SDK error:', error);
    }
});

Monitor WebSocket messages:

gameServer.on('message', (data) => {
    console.log('WS message:', data);
});

gameServer.on('error', (error) => {
    console.error('WS error:', error);
});

Server Side

Log validation requests:

app.post('/api/validate', async (req, res) => {
    console.log('Validation request:', {
        action: req.body.actionName,
        params: req.body.params
    });
    
    // Process validation...
    
    console.log('Validation response:', {
        success: true,
        state: updatedState
    });
});

Monitor state changes:

class GameManager {
    updateState(playerId: string, update: Partial<GameState>) {
        const oldState = this.getState(playerId);
        const newState = { ...oldState, ...update };
        
        console.log('State update:', {
            playerId,
            old: oldState,
            new: newState,
            diff: this.getDiff(oldState, newState)
        });
        
        this.states.set(playerId, newState);
    }
}

Deployment

Game Server

1. Set up environment:

# Install dependencies
npm install

# Build TypeScript
npm run build

# Set environment variables
export GAMES_FUN_API_KEY=your-api-key
export GAME_TOKEN_MINT=your-token-mint

1. Run server:

# Development
npm run dev

# Production
npm run build
npm start

Client Side

1. Build React app:

# Install dependencies
npm install

# Build for production
npm run build

1. Configure SDK:

const sdk = new GamesFunSDK({
    gameServerUrl: process.env.REACT_APP_GAME_SERVER,
    dev: {
        enabled: process.env.NODE_ENV !== 'production'
    }
});

Production Checklist

1. Security

   • Validate all inputs

   • Use HTTPS

   • Set CORS headers

   • Rate limit requests

2. Error Handling

   • Log all errors

   • Show user messages

   • Handle edge cases

   • Monitor issues

3. Performance

   • Optimize state updates

   • Cache responses

   • Use WebSocket

   • Monitor latency

4. Monitoring

   • Log key events

   • Track metrics

   • Set up alerts

   • Monitor uptime

Best Practices

1. Development

   • Use TypeScript

   • Write tests

   • Document code

   • Follow patterns

2. Testing

   • Unit tests

   • Integration tests

   • Load tests

   • Error scenarios

3. Deployment

   • Use CI/CD

   • Stage changes

   • Back up data

   • Monitor logs

4. Maintenance

   • Update packages

   • Check logs

   • Monitor usage

   • Handle issues