MANDALA मण्डल

Sacred geometry of interconnected nodes.

Overview

MANDALA (Mesh Architecture for Network Distribution & Layered Aggregation) provides peer-to-peer mesh networking for the Yakmesh network. It handles node discovery, connection management, message routing, and topology maintenance— creating the underlying fabric that connects all network participants.

Message Types

MANDALA defines a set of message types that flow through the sacred geometry, each serving a specific purpose in maintaining the cosmic web:

Core Components

MandalaNetwork

The main mesh networking engine—the cosmic web of interconnection:

import { MandalaNetwork, MandalaMessageTypes } from 'yakmesh/mesh/network';

// Initialize the mandala mesh (identity first, config second)
const mandala = new MandalaNetwork(identity, {
  wsPort: 9001,                    // WebSocket listen port (auto-retries +10)
  pingInterval: 30000,             // Peer ping cadence
  maxConcurrentHandshakes: 50,     // Sybil gate — connected peers are unbounded
  holdTimeoutMs: 30000,            // SAMUHA HOLD queue wait
  holdQueueMax: 10,                // HOLD queue depth
});

await mandala.start();

// Listen for events
mandala.on('peer-registered', (peerId) => {
  console.log(`🌐 New connection in the mandala: ${peerId}`);
});

mandala.on('gossip', (payload, fromNodeId) => {
  console.log(`📨 Gossip received from ${fromNodeId}`);
});

// Connect to a peer
await mandala.connect('ws://peer.example.com:9001');

// Broadcast to all peers
mandala.broadcast({
  type: MandalaMessageTypes.GOSSIP,
  payload: { content: 'Hello Mandala!' }
});

Connection Lifecycle

Each connection follows a sacred journey through the mandala:

Network Topology

The MANDALA forms a self-organizing mesh topology, with nodes naturally clustering into a sacred geometry pattern:

                    ┌───────┐
                    │ Edge  │
                    │ Node  │
                    └───┬───┘
                        │
          ┌─────────────┼─────────────┐
          │             │             │
      ┌───┴───┐    ┌────┴────┐    ┌───┴───┐
      │ Outer │    │   Hub   │    │ Outer │
      │ Ring  │────│  Node   │────│ Ring  │
      └───┬───┘    └────┬────┘    └───┬───┘
          │             │             │
          └─────────────┼─────────────┘
                        │
                    ┌───┴───┐
                    │ Peer  │
                    └───────┘

        Legend:
        ─── Primary connection (low latency)
        ··· Secondary connection (backup)
        

Connection States

Configuration

const mandala = new MandalaNetwork(identity, {
  // Listener
  wsPort: 9001,                  // WebSocket listen port
  portRetries: 10,               // Sequential ports tried on bind failure
  
  // Handshake gate (Sybil defense — connected peers stay unbounded)
  maxConcurrentHandshakes: 50,   // Simultaneous HELLO/WELCOME exchanges
  
  // SAMUHA HOLD queue
  holdTimeoutMs: 30000,          // Wait for slot before REDIRECT
  holdQueueMax: 10,              // HOLD queue depth
  
  // Peer maintenance
  pingInterval: 30000,           // PING interval (ms)
  reconnectMaxDelay: 60000,      // Maximum backoff (ms)
  
  // Identity & upgrades
  networkFingerprint: hex,       // Expected network fingerprint
  tribhujRotation: {...},        // Tribhuj key-rotation cadence
  tribhujGrace: {...},           // Grace window for rotated keys
  publicHost: 'host:port',       // Advertised endpoint for inbound peers
});

Integration with Other Protocols

MANDALA serves as the foundation layer, integrating with all other Himalayan protocols:

Metrics

// Get network statistics
const stats = mandala.getStats();

console.log(`Connected peers: ${stats.connectedPeers}`);
console.log(`Messages sent: ${stats.messagesSent}`);
console.log(`Messages received: ${stats.messagesReceived}`);
console.log(`Average latency: ${stats.averageLatency}ms`);
console.log(`Uptime: ${stats.uptime}s`);