Native decentralized messaging on Ramestta. Real BouncyCastle X25519+AES-256-GCM encryption, wallet-signed authentication, SQLCipher encrypted storage, and rate-limited relay network.
V8 Split Architecture: Registry (Identity) + RelayManager (Nodes) + ProofVerifier
MumbleChat V8 uses a split smart contract design for modularity and upgradeability:
Registry V7 — On-chain identity, public key storage, user blocking, and endpoint discovery.
RelayManager V13 — Node registration, staking tiers, verified relay proofs, and reward distribution.
ProofVerifier V1 — Commit-verify flow for on-chain relay proof validation.
MCT Token V8 — ERC-20 with fee pool, halving, and governance.
┌─────────────────────────────────────────────────────────────────────────┐
│ MUMBLECHAT PROTOCOL V4.0 STACK │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ RamaPay │ │ Chrome │ │ Desktop │ CLIENTS │
│ │ Android │ │ Extension │ │ Relay Node │ │
│ └──────┬──────┘ └──────┬──────┘ └──────┬──────┘ │
│ │ │ │ │
│ └───────────────────┼───────────────────┘ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ MumbleChat Core Layer (Hardened) │ │
│ │ ┌────────────┐ ┌────────────┐ ┌────────────┐ │ │
│ │ │ BouncyCastle│ │ MessageCodec│ │ ChatService│ │ │
│ │ │ X25519+GCM │ │ Binary Wire │ │ Orchestrator│ │ │
│ │ └────────────┘ └────────────┘ └────────────┘ │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │ │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ Security Layer (Production Hardened) │ │
│ │ ┌────────────┐ ┌────────────┐ ┌────────────┐ │ │
│ │ │ Wallet-Sign│ │ SQLCipher │ │ Rate │ │ │
│ │ │ Auth (ECDSA)│ │ Encrypted DB│ │ Limiter │ │ │
│ │ └────────────┘ └────────────┘ └────────────┘ │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │ │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ V8 Smart Contracts (Ramestta Mainnet) │ │
│ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │
│ │ │MCT Token │ │Registry │ │RelayMgr │ │ProofVeri │ │ │
│ │ │ V8 │ │ V7 │ │ V13 │ │ V2 │ │ │
│ │ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
Your wallet address is your identity. Public keys stored immutably on blockchain. No emails. No phone numbers. Self-sovereign.
// 1. Generate X25519 keypair (BouncyCastle)
val keyPair = X25519KeyPairGenerator().generateKeyPair()
// 2. Sign with wallet (ECDSA authentication)
val signature = wallet.signMessage(publicKey)
// 3. Store public key on-chain
registry.register(
publicKeyX: keyPair.publicKey,
displayName: "alice.rama"
)
// 4. Identity now discoverable on-chain
// Anyone can lookup 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.
Real BouncyCastle X25519 ECDH + AES-256-GCM. Production-grade, audited security.
1. Lookup recipient's X25519 public key from blockchain
2. Generate ephemeral X25519 keypair (forward secrecy)
3. Derive shared secret via ECDH agreement
4. Derive AES key using HKDF with unique salt
5. Encrypt with AES-256-GCM (authenticated encryption)
6. Sign with Ed25519 for message authenticity
7. Package: [ephemeral key | nonce | ciphertext | auth tag]
Elliptic-curve Diffie-Hellman using BouncyCastle library. Each message uses a unique ephemeral key for perfect forward secrecy.
Authenticated encryption with 256-bit key. Provides confidentiality AND integrity verification in one operation.
All messages encrypted at rest with SQLCipher. Even physical device access can't compromise your chat history without your wallet key.
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 (X25519)
val nonce: ByteArray, // 12 bytes (GCM)
val ciphertext: ByteArray, // Encrypted content
val authTag: ByteArray, // 16 bytes (GCM auth)
val timestamp: Long, // Unix millis
val signature: ByteArray // Ed25519 signature
)
When recipient is online, messages go directly through the managed hub.
// 1. Connect to hub (WebSocket)
hub.connect(walletSignature)
// 2. Encrypt message with recipient's key
encrypted = E2E.encrypt(message, recipientPubKey)
// 3. Send through hub (opaque blob)
hub.send(encrypted) // Hub can't read content
// 4. Receive delivery confirmation
ack = hub.receiveAck()
When recipient is offline, relay nodes queue messages (200 per user cap).
// 1. Recipient not online
if (!hub.isOnline(recipient)) {
// 2. Queue encrypted message on relay
relay.queue(encrypted, ttl = 7.days)
// 3. Rate limited: 10 msg/sec
// Queue cap: 200 msg/user, 50K total
// 4. Relay earns MCT for delivery
}
Decentralized nodes that store encrypted messages for offline users and earn MCT rewards. Protection against abuse with queue caps and rate limiting.
Relay nodes store encrypted blobs only — they never see plaintext content. V13 includes on-chain verified relay proofs: nodes must commit message hashes before claiming rewards.
Anti-abuse protections: 10 msg/sec rate limiting, 256KB max payload, 200 messages per user queue cap, 50K total message cap, and 35s commit cooldown.