Full Node

A full node runs all three core services of the Zentalk network, providing maximum decentralization and resilience.

What is a Full Node?

A full node operates the complete Zentalk infrastructure stack:

Running a full node strengthens the network by:

• Providing additional relay capacity for anonymous message routing
• Participating in the DHT for decentralized peer discovery
• Contributing storage for offline message delivery and encrypted backups

Full Node vs Light Node

Light nodes connect to the network for messaging but don’t route traffic for others. They’re suitable for mobile devices and resource-constrained environments.

Full nodes are the backbone of the network, handling message relay, peer discovery, and distributed storage.

Architecture

┌─────────────────────────────────────────────────────────────────┐
│                         FULL NODE                                │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐  │
│  │  Relay Server   │  │  DHT Bootstrap  │  │  Mesh Storage   │  │
│  │     :9001       │  │     :9000       │  │     :8081       │  │
│  └────────┬────────┘  └────────┬────────┘  └────────┬────────┘  │
│           │                    │                    │           │
│           └────────────────────┼────────────────────┘           │
│                                │                                │
│                    ┌───────────┴───────────┐                    │
│                    │   Internal Message    │                    │
│                    │        Bus            │                    │
│                    └───────────────────────┘                    │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Relay Server (Port 9001)

The relay server handles:

• WebSocket Connections - Client connections for real-time messaging
• 3-Hop Relay Routing - Anonymous message routing through guard, middle, and exit relays
• Circuit Establishment - Building encrypted tunnels between nodes
• Offline Queue - Temporary storage for messages to offline recipients

DHT Bootstrap (Port 9000)

Kademlia-based distributed hash table for:

• Peer Discovery - Finding other nodes in the network
• Key Bundle Storage - Distributing X3DH public key bundles
• Node Routing - XOR-based routing to find the closest nodes to any key
• Health Monitoring - Network topology awareness

Mesh Storage (Port 8081)

Distributed storage layer providing:

• Encrypted Blob Storage - Store arbitrary encrypted data
• Erasure Coding - Split data into 10+5 shards (survives 5 node failures)
• Message Persistence - Store messages for offline delivery (7-day TTL)
• Backup Storage - User encrypted backups with redundancy

Hardware Requirements

Minimum

Recommended

Installation

Option 1: Docker Compose (Recommended)

# Clone the repository
git clone https://github.com/ZentaChain/zentalk-node.git
cd zentalk-node
 
# Configure environment
cp .env.example .env
nano .env  # Edit with your settings
 
# Start all services
docker-compose up -d

Option 2: Binary Download

Download pre-built binaries for your platform:

# Extract and run
tar -xzf zentalk-v1.2.0_*.tar.gz
./zentalk-node --full

Option 3: Homebrew (macOS & Linux)

brew tap ZentaChain/tap
brew install zentalk-validator
 
# Start full node
zentalk-node --full

Configuration

Create a .env file with your settings:

# Node Identity
NODE_NAME=my-full-node
NODE_ID=auto  # Auto-generated Ed25519 keypair
 
# Network
PUBLIC_IP=203.0.113.10
BOOTSTRAP_PEERS=dht1.zentalk.io:9000,dht2.zentalk.io:9000
 
# Relay Server
RELAY_PORT=9001
MAX_CONNECTIONS=1000
MAX_CIRCUITS_PER_CLIENT=10
 
# DHT
DHT_PORT=9000
DHT_REPLICATION_FACTOR=3
 
# Mesh Storage
MESH_PORT=8081
STORAGE_PATH=/var/lib/zentalk/mesh
STORAGE_RETENTION_HOURS=168  # 7 days
MAX_BLOB_SIZE_MB=100
ERASURE_DATA_SHARDS=10
ERASURE_PARITY_SHARDS=5
 
# Privacy
ENABLE_TRAFFIC_PADDING=true
PADDING_RATE_MS=100

Erasure Coding

Mesh storage uses Reed-Solomon erasure coding for fault tolerance:

Original Data: 100KB
        │
        ▼
┌───────────────────────────────────────────────────────────┐
│              Reed-Solomon Encoding (10+5)                  │
└───────────────────────────────────────────────────────────┘
        │
        ▼
Data Shards (10):    d1  d2  d3  d4  d5  d6  d7  d8  d9  d10
Parity Shards (5):   p1  p2  p3  p4  p5
        │
        ▼
Distributed to 15 different nodes

Recovery: Any 10 of the 15 shards can reconstruct the original data. The network survives up to 5 simultaneous node failures.

Privacy Features

Full nodes implement multiple privacy protections:

Traffic Padding

Real traffic:     ████████░░░░████░░████████░░░░
Padded traffic:   ████████████████████████████████
                  └── Constant rate, masks patterns

No Logging Policy

• No message content (E2EE ciphertext only)
• No sender/recipient correlation
• No IP address logging
• No timing data retention

Timestamp Bucketing

Messages grouped into time buckets to prevent timing correlation:

Message timestamps:  12:00:01, 12:00:03, 12:00:07
Bucketed:           [12:00:00 - 12:00:10] → all grouped

Monitoring

Check your node’s health:

# Overall status
curl http://localhost:9001/health
 
# Relay statistics
curl http://localhost:9001/stats
 
# DHT peer count
curl http://localhost:9000/peers
 
# Mesh storage usage
curl http://localhost:8081/status

Prometheus Metrics

Full nodes expose metrics at /metrics:

zentalk_relay_connections_total
zentalk_relay_circuits_active
zentalk_dht_peers_count
zentalk_mesh_storage_bytes
zentalk_mesh_shards_stored

Troubleshooting

Node not joining network

1. Verify firewall allows ports 9000, 9001, 8081
2. Check bootstrap peers are reachable: nc -zv dht1.zentalk.io 9000
3. Verify PUBLIC_IP matches your actual IP
4. Check logs: docker-compose logs -f

High memory usage

• Reduce MAX_CONNECTIONS in config
• Limit MAX_CIRCUITS_PER_CLIENT
• Check for connection leaks with docker stats

Storage filling up

• Reduce STORAGE_RETENTION_HOURS
• Increase storage capacity
• Check for orphaned shards: curl http://localhost:8081/gc

Security Considerations

Network Security

• Run behind a firewall
• Use fail2ban for DDoS protection
• Consider running on a dedicated server

Key Management

• Node identity keys are generated automatically
• Backup /var/lib/zentalk/keys/ directory
• Keys are Ed25519 for signing, X25519 for encryption

Updates

Keep your node updated for security patches:

# Docker
docker-compose pull && docker-compose up -d
 
# Homebrew
brew upgrade zentalk-validator

Related Documentation

• Run a Node - Lighter relay-only setup
• DHT & Kademlia - How peer discovery works
• 3-Hop Relay Routing - Anonymous message routing
• Network Protocol - Wire-level protocol details