Centram Documentation
Welcome to the Centram documentation. This guide covers everything from initial setup to advanced configuration, economic incentives, and policies.
System Requirements
| Platform | Minimum | Recommended |
|---|---|---|
| Desktop | 4 GB RAM, 2 GB free disk | 8 GB RAM, 50+ GB shareable |
| Android | Android 8.0+ (API 26) | Android 12+ with 4 GB RAM |
| iOS | iOS 14.0+ | iOS 16+ with 4 GB RAM |
| Web Monitor | Any modern browser | Chrome, Safari, or Firefox |
Installation
Desktop
Download the latest release for your platform:
| OS | Format |
|---|---|
| macOS | DMG or ZIP |
| Windows | Installer (NSIS) or Portable |
| Linux | AppImage or DEB |
Mobile
Install from your device's app store or sideload the APK / IPA directly from the releases page.
From Source
Clone the repository
git clone https://github.com/centram/centram.git cd centram
Install dependencies
npm install
Install the daemon
cd daemon pip install -e .
Build the C++ core (optional, for native crypto)
cd core mkdir build && cd build cmake .. make
Quick Start
Start the daemon
The daemon is the backend service that handles storage, P2P networking, and blockchain operations.
centram-daemon
You should see output confirming the API is listening and the P2P node is active.
Launch a client
Open whichever client you prefer. All clients connect to the daemon running on your machine.
# Desktop (Electron) npm run start:electron # Desktop (JavaFX) cd desktop && ./gradlew run # Web Monitor cd web-monitor/frontend && npm run dev # Android npm run build:android && npm run open:android
Upload a file
Navigate to the Files tab, choose a file, and enter a passphrase. Centram will encrypt, chunk, and distribute it automatically.
Daemon Configuration
The daemon reads its configuration from ~/.centram/config.json. If the file doesn't exist, defaults are used.
Default Configuration
{
"api_host": "127.0.0.1",
"api_port": 9740,
"p2p_port": 9741,
"data_dir": "~/.centram",
"reserved_gb": 50,
"node_type": "storage",
"subscription_cost": 0.0,
"accept_24_7_policy": false,
"bluetooth_fallback": false,
"bootstrap_peers": []
}
Configuration Options
| Key | Default | Description |
|---|---|---|
api_port | 9740 | Port for the REST API and WebSocket |
p2p_port | 9741 | Port for peer-to-peer connections |
reserved_gb | 50 | Disk space reserved for the OS (not shared) |
node_type | "storage" | Node role: "storage", "server", or "database" |
subscription_cost | 0.0 | Price you charge per GB/month for storage |
accept_24_7_policy | false | Required for server/database nodes |
bootstrap_peers | [] | List of "host:port" peers to connect to on startup |
Node Types
Every Centram node operates as one of three types. Your node type affects allocation priority, trust rewards, and uptime requirements.
Storage (Default)
Casual participants. Share unused disk space when your device is online. No uptime commitment required. Lowest allocation priority but easiest to run.
Server
Always-on hosting nodes with highest allocation priority. Server nodes commit to the 24/7 Uptime Policy and must remain online at all times. Downtime results in trust score penalties. Best for dedicated machines or VPS instances.
Database
Persistent data nodes with medium allocation priority. Like servers, database nodes require the 24/7 policy. Designed for nodes that store large volumes of indexed data.
Storage Configuration
Data Directory
All Centram data is stored under ~/.centram/ by default:
~/.centram/ chunks/ Encrypted file chunks (256-way fan-out) chain/ Blockchain data trust_scores.json Peer trust records config.json Your configuration
Chunk Storage
Files are split into 4 MB chunks, encrypted individually, and stored in a fan-out directory structure. The first two hex characters of each chunk's SHA-256 hash determine the subdirectory (256 possible directories), ensuring efficient file system lookup.
Reserved Space
The reserved_gb setting (default: 50 GB) tells Centram how much disk space to leave free for the operating system and other applications. Only space beyond this reserve is available for the network.
Replication
Every chunk is replicated to 3 independent peers. The replication manager checks for under-replicated chunks every 60 seconds and automatically repairs them by pushing copies to new peers.
Networking
Connecting to Peers
Centram discovers peers through:
- Bootstrap peers — configured in
config.jsonor via the API - Peer exchange — connected peers share their known peer lists
- DHT discovery — Kademlia distributed hash table for decentralized lookup
Firewall
If you're behind a firewall or NAT, ensure port 9741 (P2P) is open for incoming connections. The API port (9740) only needs to be accessible from localhost.
CenTrust Score
CenTrust is Centram's reputation system. Every peer starts with a score of 50 (range: 0–100). Your score reflects your reliability on the network.
How Your Score Changes
| Event | Effect | Description |
|---|---|---|
| Storage proof success | +0.5 | You proved you hold a chunk when challenged |
| Storage proof failure | -5.0 | You failed to prove chunk possession |
| Uptime tick (per hour) | +0.1 | Earned for each hour your node stays online |
| Downtime penalty (per hour) | -2.0 | 24/7 nodes only — when your node goes offline |
| Successful transfer | +0.2 | You completed a chunk transfer to another peer |
| Failed transfer | -1.0 | A transfer to/from your node failed |
Trust Levels
| Score | Level | Gas Discount |
|---|---|---|
| 80 – 100 | Trusted | 40% – 50% |
| 60 – 79 | Reliable | 30% – 39% |
| 40 – 59 | Normal | 20% – 29% |
| 0 – 39 | Low | 0% – 19% |
Benefits of High Trust
- Gas discounts — up to 50% off all transaction fees
- Allocation priority — your node is chosen first for new chunk storage
- Network reputation — visible on the trust leaderboard
Gas Fees
Every storage transaction incurs a 5% base gas fee. This fee is paid to the block miner who validates the transaction.
How Gas is Calculated
Base gas rate: 5% Trust discount: (your_score / 100) × 50% Effective rate: 5% × (1 - trust_discount) Example (trust score = 80): Trust discount = (80 / 100) × 50% = 40% Effective rate = 5% × (1 - 0.40) = 3% On a 100 unit tx: gas = 3 units, you pay 97
Subscription Pricing
As a storage sharer, you set your own price per GB per month. This is the amount peers pay you for storing their data on your node.
Setting Your Price
- Go to Cloud / Node Settings in any client
- Enter your desired price in the Subscription Price field
- Your price is advertised to the network automatically
Pricing Strategy
- $0.00 — Free storage. Generous to the network, earns trust.
- $0.01 – $0.10 — Competitive pricing. Attracts allocations.
- $0.10+ — Premium pricing. May reduce allocations unless you have high trust and uptime.
Marketplace
The Centram marketplace lists all peers offering storage. It's accessible through the web monitor or any client's Economics section.
Each listing shows:
- Peer ID (anonymized)
- Node type (Storage / Server / Database)
- Trust score
- Price per GB/month
- Available storage capacity
Encryption
Centram uses a layered encryption scheme to ensure only you can access your files:
Encryption Pipeline
- Key Derivation — Your passphrase is run through PBKDF2-SHA256 (100,000 iterations) with a random 16-byte salt to produce a 256-bit master key.
- Per-Chunk Keys — Each chunk gets its own key, derived from the master key using HKDF-SHA256 with the chunk index as info parameter.
- Encryption — Each chunk is encrypted with AES-256-GCM using a random 12-byte IV. The output is:
[IV (12B) | Ciphertext | Auth Tag (16B)]
Zero-Knowledge Design
Storage nodes hold encrypted chunks but have no ability to decrypt them. They don't know what files the chunks belong to, what the content is, or who uploaded them. Only the file owner with the correct passphrase can reconstruct and decrypt the data.
Storage Proofs
Centram uses Proof of Storage (PoSt) to verify that peers actually hold the data they claim. This prevents free-riding and ensures data integrity.
How It Works
- A challenge is derived from the previous block hash and a chunk hash
- The challenged node must produce a proof by hashing the challenge with the actual chunk data
- The proof is verified by miners and recorded on the blockchain
- Successful proofs increase your trust score; failures decrease it
Blockchain
Centram's blockchain is a lightweight chain optimized for storage operations. It records all allocations, storage proofs, trust updates, and economic transactions.
Consensus
Blocks are mined using Proof of Storage rather than Proof of Work. This means mining rewards go to nodes that prove they store data, not nodes that waste energy on hash puzzles.
What Gets Recorded On-Chain
- Storage proofs (chunk possession verification)
- Chunk allocations (which peers hold which chunks)
- Capacity advertisements
- File registrations
- Subscription pricing changes
- Trust score updates
- Node type declarations
- Gas fee payments
Privacy Policy
Data We Never Collect
- Your files, filenames, or file contents
- Your encryption passphrase or keys
- Personal information (name, email, phone)
- Browsing history or usage analytics
Data That Exists on the Network
- Peer ID — a randomly generated identifier (SHA-256 hash). Not linked to your identity.
- IP Address — visible to peers you connect to directly. This is inherent to any P2P network.
- Trust Score — your reputation score is public to other peers.
- Subscription Price — your storage pricing is advertised to the network if you're a sharer.
- Storage Proofs — recorded on-chain, proving you hold specific chunks (but not revealing their content).
Encryption Guarantee
All file data is encrypted client-side before leaving your device. No peer, relay, or server on the network can read your files. Even if every other node on the network colluded, they could not access your data without your passphrase.
Terms of Use
Acceptable Use
By using Centram, you agree to:
- Not store illegal content on the network
- Not attempt to attack, overload, or disrupt the network
- Not impersonate other peers or manipulate trust scores
- Accept that Centram is decentralized software provided "as is" with no warranty
Liability
Centram is open-source software. The developers are not responsible for data loss, service interruption, or any damages arising from the use of this software. You are solely responsible for your passphrase and data backups.
Data Responsibility
As a storage sharer, you store encrypted chunks on behalf of other peers. You cannot see or access the content of these chunks. You are not responsible for their content.
24/7 Uptime Policy
Server and Database nodes must accept the 24/7 Uptime Policy. This is a commitment to keep your node online at all times.
Requirements
- Your node must remain reachable and responsive 24 hours a day, 7 days a week
- Heartbeat responses must be sent within 90 seconds of each challenge
- Scheduled maintenance windows are acceptable if brief
Penalties
- -2.0 trust per hour of downtime
- Extended downtime may result in chunks being re-allocated to other peers
- Severe or repeated downtime degrades your trust score significantly
Opting Out
You can switch back to a Storage node at any time, which removes the 24/7 requirement. However, this also reduces your allocation priority.
API Reference
The daemon exposes a REST API at http://127.0.0.1:9740. All endpoints are prefixed with /api.
Status & Info
| Method | Endpoint | Description |
|---|---|---|
GET | /api/status | Node status, peer count, chain height, trust |
GET | /api/storage | Disk usage stats |
GET | /api/peers | Connected peers list |
GET | /api/files | Local file chunks |
Node Configuration
| Method | Endpoint | Description |
|---|---|---|
GET | /api/node/type | Current node type and policy |
POST | /api/node/type | Set node type + accept policy |
GET | /api/node/subscription | Current subscription price |
POST | /api/node/subscription | Set subscription price |
Trust & Economics
| Method | Endpoint | Description |
|---|---|---|
GET | /api/trust/self | Your trust score and gas discount |
GET | /api/trust/{peer_id} | A peer's trust info |
GET | /api/trust/leaderboard | Top trusted peers |
GET | /api/gas/estimate?amount=X | Gas fee estimate |
GET | /api/economics/summary | Full economics overview |
GET | /api/marketplace/sharers | Browse sharers |
Blockchain
| Method | Endpoint | Description |
|---|---|---|
GET | /api/blockchain/status | Chain height and validity |
GET | /api/blockchain/blocks | Paginated block list |
GET | /api/blockchain/block/{n} | Single block by height |
POST | /api/upload | Upload file (multipart + passphrase) |
WebSocket
Real-time events are available at ws://127.0.0.1:9740/ws.
Ports & Endpoints
| Port | Service | Binding | Notes |
|---|---|---|---|
9740 | REST API + WebSocket | localhost | Client-daemon communication |
9741 | P2P Node | 0.0.0.0 | Open this port for incoming peer connections |
FAQ
Can I recover my files if I lose my passphrase?
No. Centram is zero-knowledge by design. Your passphrase is never stored anywhere. Without it, your encryption keys cannot be derived and your files are permanently lost.
What happens if peers storing my data go offline?
Every chunk is replicated to 3 peers. If one goes offline, the replication manager automatically detects the under-replication and pushes the chunk to a new peer. Your data is safe as long as at least one copy remains available.
Can storage nodes read my files?
No. All chunks are encrypted with AES-256-GCM before they leave your device. Storage nodes only hold encrypted blobs. They cannot determine what file a chunk belongs to, its content, or who uploaded it.
How much can I earn by sharing storage?
Earnings depend on your subscription price, available capacity, trust score, and network demand. You set your own price and the marketplace determines how competitive it is.
Do I need a static IP address?
No. Centram supports relay connections for peers behind NAT or firewalls. However, a static IP or open port 9741 will improve your connectivity and peer discovery.
Is there a minimum storage requirement?
No. You can share as little or as much as you want. The reserved_gb setting ensures your OS always has enough space.
What's the difference between the Electron app and the JavaFX app?
Both are full desktop clients. The Electron app wraps the web-based React UI for a familiar experience. The JavaFX app is a fully native desktop interface. Both connect to the same daemon backend.