DCEmail
DCEMAIL / KNOWLEDGE

White paper.

A familiar inbox. A more verifiable future.

The vision, architecture, privacy principles and roadmap behind browser email with required Base sending proofs.

Version 0.1September 2026Base · Chain 8453
Current release & future direction

Hosted email with required Base sending commitments. End-to-end encryption, decentralized storage and inheritance are planned. The website and backend are deployed. Mailbox sign-in is verified. Email delivery and wallet acceptance checks are still pending.

Purpose

DCEmail brings familiar browser email together with mandatory, publicly verifiable sending commitments on Base. The first release prioritizes compatibility: a user signs into an @dcemail.io mailbox and confirms a Base commitment with a wallet before the website sends each email.

The long-term direction is more independent communication. The current implementation is a hybrid system: mail delivery and mailbox storage depend on the hosting provider; proof transactions use Base. It is not a fully decentralized mail transport, and it does not provide end-to-end encryption. This distinction is part of the product, not a footnote.

No native mobile application, token, investment return, audit certification, or guaranteed delivery is represented by this release. The website adapts to desktop and mobile browsers.

Product scope

Implemented in the release code: mailbox authentication, Inbox and other server folders, search, pagination, plain-text message reading, attachments, reply, compose, stars, read status, recoverable movement to Trash, sign-out, wallet binding, proof creation, proof history, proof export, and Base transaction verification.

Public signup creates a 800 MB hosted mailbox. Registration is limited to ten valid attempts per IP per fifteen minutes and fifty total attempts daily during early access. Password recovery and quota management remain in the hosting control panel. There is no app-specific password database. The UI does not permanently delete messages.

Planned capabilities: client-side end-to-end encryption, decentralized content storage, recipient-signed acknowledgements, inheritance workflows, and additional networks. Concept illustrations and inheritance controls are previews, not active services.

System architecture

Browser → HTTPS website/API → IMAP over TLS → hosting mailbox.
Browser → HTTPS website/API → SMTP over TLS → mail server → recipient mail server.
Browser → wallet → Base transaction. Website verifier → Base JSON-RPC → transaction, receipt, block and confirmation checks.

The Node.js 24 server serves both the website and its same-origin API. Express handles routing; ImapFlow accesses mailboxes; Nodemailer builds and submits messages; ethers verifies wallet signatures and reads Base. SQLite stores encrypted sessions, sending status, wallet bindings and proof records. It does not replace the mail server.

Public web files live under dist. Application code, the database and the encryption key must remain outside the public document root. Hosting uses a Node application mapped to dcemail.io, with separate private data storage.

Mail lifecycle

A user enters the mailbox address and existing mailbox password. The server validates the dcemail.io domain and authenticates against IMAP using certificate-verified TLS. A successful login creates an eight-hour session. Each mailbox operation is scoped to that authenticated account.

Messages are selected by folder, UID and UIDVALIDITY. The server rejects operations when the mailbox generation changes, preventing an old selection from acting on a different message. Lists return up to 30 messages, with pagination and optional search.

Outgoing messages use the authenticated address as the sender. The user supplies a single recipient, subject and text. The server constructs MIME; attachments are limited to five files totalling 8 MB. Message bodies are limited to 250 KB. Incoming messages larger than 15 MB require the provider's webmail.

Each send has a unique idempotency key. Replaying the same accepted request returns its stored result instead of sending again. Reusing the key with a different payload fails. If SMTP times out after possible acceptance, the status remains uncertain; the user must inspect Sent before sending again. A Sent-copy failure never causes automatic resubmission.

SMTP acceptance means the outgoing server accepted the message. It does not guarantee delivery, inbox placement, recipient identity, or that the recipient read the email. External delivery depends on the receiving server, reputation, DNS and spam filtering.

Proof protocol: DCE1

A proof is an account holder's wallet assertion about a selected sent or Inbox message. It does not independently establish that another person received or read that message.

The server creates a random 32-byte salt and serializes an object in this exact key order: version, salt, event, from, to, subject, text, messageId. Version is 1; event is sent or received. SHA-256 over the UTF-8 JSON serialization produces the 32-byte commitment. The selected message fields come from the authenticated mailbox. Attachments are not committed in version 1.

Transaction calldata is the concatenation of 0x44434531 (ASCII DCE1), event byte 01 for sent or 02 for received, and the commitment. The transaction transfers zero ETH to the same wallet that sends it. A Base network fee still applies and must be approved by the wallet owner. No custom smart contract is deployed in this version.

The chain ID must be 8453. Verification requires the expected sender and recipient wallet, zero value, exact calldata, a successful receipt, matching canonical block hash, and at least 12 confirmations. Twelve confirmations are an application threshold, not a claim of Ethereum settlement finality. A later reorganization can change the result; verification can be run again.

The private proof export contains the exact serialized evidence, salt, hash, wallet, transaction hash and recorded block. It allows independent commitment recomputation. Treat this export as sensitive: it includes message text. Public proof records do not include the raw email addresses, subject or text, but the wallet and transaction timing are public. On-chain records are persistent.

Wallet identity and consent

Wallet binding uses an expiring, one-use message signature with the website origin, an account identifier hash, nonce and expiration. The server recovers the signing address and binds it to the authenticated mailbox. Reusing a consumed challenge fails.

A signature links a wallet; it does not send a blockchain transaction. The UI separately requests a network switch and a transaction. The user reviews and confirms in the wallet. The service does not collect seed phrases or wallet private keys, sponsor gas, or control user funds.

Proofs retain the wallet used at their creation even if the account later connects a different wallet. Submitted transaction hashes are saved for later verification. A transaction cannot be attached to two proof records.

Security and privacy model

HTTPS is required for production API access. Cookies are HttpOnly, Secure in production, SameSite=Strict and scoped to the site. Mutating requests require the expected Origin and an account session CSRF token. Login, sending, wallet and proof operations are rate limited.

Mailbox credentials are encrypted with AES-256-GCM while stored in a session. The random 256-bit master key is a private file. Sessions use random tokens; only token hashes are stored in SQLite. The application must decrypt the mailbox credential to contact IMAP and SMTP. The operator and a compromised application host can therefore access mailbox contents.

Email is displayed as plain text using DOM textContent. Remote images and arbitrary email HTML are not rendered. Attachments download as files rather than inline HTML. Downloading and opening a file still requires ordinary user caution; the application does not claim to scan files for malware.

Encrypted proof evidence is retained until the operator's retention process removes it. On-chain commitments cannot be erased by deleting the local database. A salted commitment reduces easy guessing but is not anonymity and does not hide wallet activity.

Before public onboarding, the operator must publish an accurate privacy notice identifying the legal operator, contact channel, purposes, providers, retention periods, user rights and applicable jurisdiction. No fictional legal entity or compliance certification is supplied here.

Roadmap and acceptance gates

Phase 1

Website and mailbox foundation. Deliver the responsive site, documentation, authenticated webmail and mandatory Base sending records. Exit gate: successful live mailbox sign-in, a sent-and-received test, attachment handling, independent Base verification, HTTPS, backup and restore rehearsal.

Phase 2

Reliability and administration. Add monitoring, alerts, retention controls, audit events without message content, operational dashboards, spam/abuse controls, dependency review and tested recovery. Exit gate: measured reliability targets and an operator-approved incident runbook.

Phase 3

Privacy and independent verification. Design client-side key management, recovery and multi-device E2EE; define attachment commitments and recipient-signed acknowledgements. Evaluate decentralized storage with deletion and availability implications. Exit gate: documented threat model, interoperability tests and independent security assessment.

Phase 4

Digital inheritance research. Specify nominee identity, revocation, false-inactivity prevention, escrow/key release, reminders and a legally reviewed consent model. Exit gate: independent security review, recovery and cancellation tests, and explicit user approval. Do not store seed phrases in the current prototype.

Phase 5

Network expansion. Evaluate additional chains only after Base operation is stable. Each network needs its own transaction, finality, cost and privacy design. No dates or release promises are attached to these gates.