Native RamaPay messaging on Ramestta with strong encryption, wallet-based authentication, protected local storage, message-request approval, self-destruct controls, and dependable relay-assisted delivery.
A high-level view of how identity, private messaging, relay participation, and MCT utility work together.
MumbleChat is designed around a few clear layers so identity, delivery, and token utility can work together cleanly:
Wallet Identity — lets users connect through their wallet instead of phone-number identity.
Private Messaging — keeps conversations secure and user-controlled.
Relay Participation — helps maintain dependable delivery across the network.
MCT Utility — supports staking, rewards, and broader ecosystem participation.
┌─────────────────────────────────────────────────────────────────────────┐
│ 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. Eligible routed work can later become rewardable
}
Decentralized nodes that store encrypted messages for offline users while the coordinator tracks eligible routed work, proof readiness, and abuse controls.
Relay nodes store encrypted blobs only — they never see plaintext content. Current reward eligibility is tied to coordinator-signed delivery proofs and verified relay accounting rather than blind forwarding alone.
Anti-abuse protections: 10 msg/sec rate limiting, 256KB max payload, 200 messages per user queue cap, 50K total message cap, wallet-authenticated sessions, and cooldown-backed proof submission.