Native decentralized messaging on Ramestta. V4 Split Architecture: Registry (Identity) + RelayManager (Nodes). Kademlia DHT, STUN/UDP hole punching, X25519+AES-256-GCM encryption.
┌─────────────────────────────────────────────────────────────────────────┐
│ MUMBLECHAT PROTOCOL V4.0 STACK │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ RamaPay │ │ Chrome │ │ Desktop │ CLIENTS │
│ │ Android │ │ Extension │ │ Relay Node │ │
│ └──────┬──────┘ └──────┬──────┘ └──────┬──────┘ │
│ │ │ │ │
│ └───────────────────┼───────────────────┘ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ MumbleChat Core Layer │ │
│ │ ┌────────────┐ ┌────────────┐ ┌────────────┐ │ │
│ │ │ Crypto │ │ MessageCodec│ │ ChatService│ │ │
│ │ │X25519+GCM │ │ Binary Wire │ │ Orchestrator│ │ │
│ │ └────────────┘ └────────────┘ └────────────┘ │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │ │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ P2P Transport Layer │ │
│ │ ┌────────────┐ ┌────────────┐ ┌────────────┐ │ │
│ │ │ KademliaDHT│ │ STUN/NAT │ │ Rate │ SECURITY │ │
│ │ │ +Sybil Res.│ │ Traversal │ │ Limiter │ │ │
│ │ └────────────┘ └────────────┘ └────────────┘ │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │ │
│ ┌───────────────────┼───────────────────┐ │
│ ▼ ▼ ▼ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ UDP Direct │ │ Relay │ │ Ramestta │ NETWORK │
│ │ (Hole Punch)│◄───►│ Nodes │◄───►│ Blockchain │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
│ │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ V4 SMART CONTRACT ARCHITECTURE │ │
│ │ ┌──────────────────┐ ┌──────────────────┐ ┌──────────────┐ │ │
│ │ │ MCTToken │ │ Registry V4 │ │ RelayManager │ │ │
│ │ │ (ERC-20) │ │ (Identity) │ │ (Nodes) │ │ │
│ │ └──────────────────┘ └──────────────────┘ └──────────────┘ │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
Your wallet address is your identity. Public keys stored immutably on blockchain.
// 1. Generate X25519 keypair on device
val keyPair = X25519.generateKeyPair()
// 2. Store public key on-chain
registry.register(
publicKeyX: keyPair.publicKey,
displayName: "alice.rama"
)
// 3. Identity now discoverable
// Anyone can lookup your public key by wallet address
struct Identity {
bytes32 publicKeyX; // X25519 public key
bytes32 publicKeyY; // Reserved
uint256 registeredAt; // Timestamp
uint256 lastUpdated; // Key rotation
bool isActive; // Active status
string displayName; // Optional name
}
You own your identity. No platform can ban or censor you.
Update your public key anytime via updatePublicKey().
Anyone can lookup your public key by wallet address.
X25519 ECDH key exchange + AES-256-GCM encryption. Military-grade security.
┌─────────────────────────────────────────────────────────────────────────┐
│ ENCRYPTION PROCESS │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ SENDER (Alice) RECIPIENT (Bob) │
│ ────────────── ────────────── │
│ │
│ 1. Lookup Bob's public key from blockchain │
│ bobPubKey = registry.getPublicKey(bobAddress) │
│ │
│ 2. Generate ephemeral keypair │
│ ephemeralKey = X25519.generateKeyPair() │
│ │
│ 3. Derive shared secret (ECDH) │
│ sharedSecret = X25519.agree(ephemeralKey.private, bobPubKey) │
│ │
│ 4. Derive AES key using HKDF │
│ aesKey = HKDF(sharedSecret, salt, info) │
│ │
│ 5. Encrypt message with AES-256-GCM │
│ ciphertext = AES_GCM.encrypt(aesKey, nonce, plaintext) │
│ │
│ 6. Package: [ephemeralPubKey | nonce | ciphertext | authTag] │
│ │
│ 7. Send to relay node or directly to Bob │
│ │
│ ───────────────────────────────────────────────────────────────────── │
│ │
│ Bob receives and: │
│ 1. Uses his private key + ephemeral public key to derive same secret │
│ 2. Decrypts message with AES-256-GCM │
│ │
└─────────────────────────────────────────────────────────────────────────┘
Elliptic-curve Diffie-Hellman for secure key exchange. Each message uses a unique ephemeral key for forward secrecy.
Authenticated encryption with 256-bit key. Provides confidentiality AND integrity verification.
Ephemeral keys ensure past messages stay secure even if long-term keys are compromised.
How messages are structured, routed, and delivered in the MumbleChat network.
data class MumbleChatMessage(
val version: Int = 1, // Protocol version
val type: MessageType, // TEXT, FILE, PAYMENT
val senderKeyHash: ByteArray, // keccak256(sender)[:8]
val recipientKeyHash: ByteArray, // keccak256(recipient)[:8]
val ephemeralPubKey: ByteArray, // 32 bytes
val nonce: ByteArray, // 12 bytes
val ciphertext: ByteArray, // Encrypted content
val authTag: ByteArray, // 16 bytes
val timestamp: Long, // Unix millis
val signature: ByteArray // ECDSA signature
)
When recipient is online, messages go directly peer-to-peer.
// 1. Discover peer via DHT
peerInfo = dht.findPeer(recipientAddress)
// 2. Establish libp2p connection
conn = network.dial(peerInfo.multiaddr)
// 3. Send encrypted message
conn.send(encryptedMessage)
// 4. Receive ACK
ack = conn.receive()
When recipient is offline, relay nodes store messages.
// 1. Peer not found online
if (dht.findPeer(recipient) == null) {
// 2. Find relay nodes for recipient
relays = dht.findRelays(recipientKeyHash)
// 3. Send to multiple relays
relays.forEach { relay ->
relay.store(encryptedMessage, ttl = 7.days)
}
}
Decentralized nodes that store encrypted messages for offline users and earn MCT rewards.
┌─────────────────────────────────────────────────────────────────────────┐
│ RELAY NODE ARCHITECTURE │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ SENDER RELAY NETWORK RECIPIENT │
│ ────── ───────────── ───────── │
│ │
│ [Alice] ─────────────► ┌─────────────┐ │
│ │ Encrypted │ Relay A │ Store for Bob │
│ │ Message │ (Gold Tier)│◄──────────────► [Bob] │
│ │ └─────────────┘ │ (offline) │
│ │ │ │
│ │ ┌─────────────┐ │ │
│ └──────────────────► │ Relay B │ │ │
│ Redundancy │(Silver Tier)│◄──────┘ [Bob] │
│ └─────────────┘ (online) │
│ │ ▲ │
│ │ Deliver when │ │
│ └───────Bob online──────────┘ │
│ │
│ RELAY STORAGE: │
│ ─────────────── │
│ • recipientKeyHash: First 8 bytes of keccak256(address) │
│ • encryptedBlob: Opaque to relay (can't read content) │
│ • expiresAt: TTL (default 7 days) │
│ • size: For storage tracking │
│ │
└─────────────────────────────────────────────────────────────────────────┘