Platform notes, encryption guidance, relay participation references, privacy controls, and Android integration details for teams building on MumbleChat.
Core platform components used across the Ramestta experience
Utility token used across staking, rewards, and ecosystem participation.
Integrated through official app and platform tools
// ERC-20
function balanceOf(address) view returns (uint256)
function transfer(address to, uint256 amount) returns (bool)
// MCT-specific
function mintForRelay(address relay, uint256 messages)
function claimFeePoolReward()
function currentRate() view returns (uint256)
function halvingLevel() view returns (uint256)
function feePool() view returns (uint256)On-chain identity, user blocking, and public key storage, paired in the app with local report tools and conversation safety controls.
Integrated through official app and platform tools
// Identity
function register(bytes32 publicKeyX, string displayName)
function isRegistered(address) view returns (bool)
function updatePublicKey(bytes32 newPublicKeyX)
// User Blocking
function blockUser(address userToBlock)
function isBlocked(address blocker, address blocked) viewNode identity, tier-based staking, service participation, and reward activity for the relay network.
Integrated through official app and platform tools
// Node Registration (V7 Node Identity)
function registerNodeWithId(
bytes32 nodeId,
bytes32 machineIdHash,
bytes32 serialHash,
string endpoint,
uint256 storageMB,
NodeTier tier // Bronze=0 to Platinum=3
)
function heartbeatByNodeId(bytes32 nodeId)
function deactivateNodeById(bytes32 nodeId)
// Daily Pool Rewards
function claimDailyPoolReward(uint256 dayId)
// Protection
function reportViolation(bytes32 nodeId, string reason)
function slashNode(bytes32 nodeId, string reason)Verified delivery records and reward-path references for relay participation.
Integrated through official app and platform tools
// Signed proof submission
function submitSignedDeliveryProof(
DeliveryProof proof,
bytes signature
)
// Reward path
function recordVerifiedRelay(...)
function claimDailyPoolReward(uint256 dayId)
// Anti-gaming
// Coordinator signature required
// Proof uniqueness checks
// Eligibility tied to assigned routed work
MumbleChat uses real X25519 Diffie-Hellman key exchange (BouncyCastle on Android, Web Crypto P-256 on browser) with AES-256-GCM symmetric encryption. Messages are authenticated with Ed25519 digital signatures.
On top of transport security, the current clients expose message requests, self-destruct timers, screenshot protection, pinned conversations, attachments, block-unblock controls, and report flows so users can manage privacy and abuse at the conversation layer.
┌───────────────────────────────────────────────────────────────────────┐
│ MUMBLECHAT ENCRYPTION FLOW │
├───────────────────────────────────────────────────────────────────────┤
│ │
│ 1. KEY GENERATION (per user) │
│ ├── Algorithm: X25519 (Curve25519 ECDH via BouncyCastle) │
│ ├── Private Key: 32 bytes random │
│ └── Public Key: 32 bytes (stored on-chain in Registry) │
│ │
│ 2. KEY EXCHANGE (per conversation) │
│ ├── Alice gets Bob's public key from Registry contract │
│ ├── Perform X25519 ECDH: shared = X25519(alice_priv, bob_pub) │
│ ├── Derive key: HKDF-SHA256(shared, salt, 256 bits) │
│ └── Same shared secret on both sides (symmetric) │
│ │
│ 3. MESSAGE ENCRYPTION │
│ ├── Algorithm: AES-256-GCM │
│ ├── Key: derived shared secret (256 bits) │
│ ├── Nonce: 12 bytes random (unique per message) │
│ └── Output: nonce ‖ ciphertext ‖ authTag (16 bytes) │
│ │
│ 4. MESSAGE AUTHENTICATION │
│ ├── Algorithm: Ed25519 (BouncyCastle) │
│ ├── Sign: Ed25519(privateKey, messageHash) │
│ └── Verify: Ed25519.verify(publicKey, signature, hash) │
│ │
│ 5. LOCAL STORAGE │
│ ├── Database: SQLCipher (AES-256 encrypted SQLite) │
│ ├── Key: Derived from wallet private key │
│ └── All messages, contacts, keys encrypted at rest │
│ │
└───────────────────────────────────────────────────────────────────────┘
Register on-chain identity with X25519 public key. Wallet-signed authentication.
username - Display name (3-32 chars)publicKey - 32-byte X25519 public keyvoidGet X25519 public key for ECDH key exchange.
Rotate your public key. Old conversations will need re-keying.
Register as relay node with V7 Node Identity. Requires MCT stake.
nodeId - SHA256 hash of node identitymachineIdHash - Hash of machine MAC addressserialHash - Hash of hardware serialendpoint - P2P endpoint (multiaddr)tier - Bronze=0, Silver=1, Gold=2, Platinum=3Record uptime. Call every 5 minutes.
Claim your eligible share of the current daily pool after verified work has been recorded.
Report a node for protocol violation. Triggers review.
Submit a coordinator-signed proof for assigned routed work so the relay can become reward-eligible.
Verified relay accounting and daily reward claims complete the signed-proof payout path.
import { ethers } from 'ethers';
// Connect to Ramestta Mainnet (Chain ID: 1370)
const provider = new ethers.JsonRpcProvider('https://blockchain.ramestta.com');
const signer = new ethers.Wallet(PRIVATE_KEY, provider);
// Contract addresses are loaded from app runtime config.
const REGISTRY = import.meta.env.VITE_REGISTRY_ADDRESS;
const MCT = import.meta.env.VITE_MCT_TOKEN_ADDRESS;
const RELAY_MGR = import.meta.env.VITE_RELAY_MANAGER_ADDRESS;
const VERIFIER = import.meta.env.VITE_PROOF_VERIFIER_ADDRESS;
// Register identity with X25519 public key
const { publicKey, privateKey } = generateX25519KeyPair();
await registry.register('MyUsername', publicKey);
// Get recipient's public key for encryption
const recipientPubKey = await registry.getPublicKey(recipientAddress);
// X25519 ECDH → shared secret → AES-256-GCM encrypt
const sharedSecret = x25519.scalarMult(myPrivateKey, recipientPubKey);
const ciphertext = encryptAES256GCM(message, sharedSecret);
// Send via relay node (encrypted, zero-knowledge)
relay.send({ to: recipientAddress, data: ciphertext });| Network Name | Ramestta Mainnet |
| Chain ID | 1370 |
| RPC URL | https://blockchain.ramestta.com |
| Block Explorer | https://ramascan.com |
| Currency Symbol | RAMA |
| Currency Decimals | 18 |
Kademlia DHT for peer discovery, UDP hole punching for NAT traversal, wallet-signed Sybil resistance, and battery-aware notification strategies. Rate limiting prevents DoS attacks at every layer.
| Strategy | Condition | Behavior |
|---|---|---|
| PERSISTENT | Charging + WiFi | Always-on WebSocket, act as relay |
| ACTIVE | App in foreground | Full P2P, 1-minute keepalive |
| LAZY | Battery saver / low | 15-minute polling, no relay |
| STORE_FORWARD | Background / doze | Rely on relay nodes, sync on wake |
Source code for RamaPay & MumbleChat.
Ramestta blockchain explorer.
Ramestta blockchain official site.
Use runtime contract config inside MumbleChat.
Check users by address without exposing a full user list.
Get the Android wallet with MumbleChat.
Full ABI JSON for contract integration.
[
"function name() view returns (string)",
"function symbol() view returns (string)",
"function totalSupply() view returns (uint256)",
"function balanceOf(address) view returns (uint256)",
"function transfer(address to, uint256 amount) returns (bool)",
"function approve(address spender, uint256 amount) returns (bool)",
"function mintForRelay(address relay, uint256 messageCount)",
"function claimFeePoolReward()",
"function currentRate() view returns (uint256)",
"function halvingLevel() view returns (uint256)",
"function totalMinted() view returns (uint256)",
"function feePool() view returns (uint256)",
"event Transfer(address indexed from, address indexed to, uint256 value)",
"event RewardClaimed(address indexed user, uint256 amount)"
][
"function register(string username, bytes32 publicKey)",
"function updatePublicKey(bytes32 newPublicKey)",
"function isRegistered(address user) view returns (bool)",
"function getPublicKey(address user) view returns (bytes32)",
"function blockUser(address userToBlock)",
"function unblockUser(address userToUnblock)",
"function isBlocked(address,address) view returns (bool)",
"function registerAsRelay(uint256 storageGB)",
"function getActiveRelays() view returns (address[])",
"event UserRegistered(address indexed user, string username)",
"event RelayRegistered(address indexed relay, uint256 storageGB)"
]