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.
Start here
Sign in with your existing @dcemail.io mailbox using the Open webmail link. Create a free 800 MB mailbox on the signup page. Your hosting administrator handles password recovery.
Choose a folder to read messages, use New message to compose, and use Reply or Star from the message view. Attach up to five files totalling 8 MB. Move to Trash is recoverable through your mail provider.
Every message sent through DCEmail requires a confirmed Base proof. Connect an Ethereum-compatible wallet, open a message, and choose Create on-chain proof. Review and approve the transaction in your wallet; network fees apply. Verify it after the confirmation threshold, then find it again in Your Base proof history.
The private proof export contains the message text and salt. Keep it private. A verified wallet commitment does not independently prove that someone received or read your email.
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.
API reference
All paths below are relative to /api. JSON request and response bodies are used except attachment downloads. Authenticated writes require the session cookie, Origin and X-CSRF-Token. Errors return {error: string}; common statuses are 400 invalid input, 401 sign-in required, 403 rejected origin/token, 409 stale mailbox or pending proof, 413 size limit, 429 rate limit, and 5xx upstream/service failure.
GET /healthservice identity and version; not an end-to-end delivery check.
POST /login{email,password}; authenticates mailbox and returns {email,csrf}, setting session cookie.
GET /sessioncurrent {email,csrf,wallet}; POST /logout — clears current session.
GET /foldersserver folder names, paths and special-use flags.
GET /messages?folder=INBOX&before=UID&search=TEXTpage of messages, validity and nextBefore.
GET /message?folder=INBOX&uid=UID&validity=VALUEplain-text message and attachment metadata.
GET /attachment?folder=INBOX&uid=UID&validity=VALUE&index=0authenticated file download.
PATCH /message{folder,uid,validity,flag,value}; flag is seen or starred, value is boolean.
POST /message/trash{folder,uid,validity}; recoverable move, no permanent deletion.
POST /send/intentcreates or resumes a draft commitment using Idempotency-Key. Connect a wallet, publish the returned transaction on Base and submit its hash through /proofs/submitted.
POST /send{to,subject,text,attachments:[{filename,content}]}; content is base64. Requires Idempotency-Key and a matching outgoing commitment verified on Base with at least 12 confirmations. Missing, changed or unconfirmed proofs cannot send. Returns SMTP acceptance status and Sent-copy result.
POST /wallet/challenge{}; returns {id,message}.
POST /wallet/bind{id,signature}; returns recovered wallet.
POST /proofs/intent{folder,uid,validity}; returns commitment and unsigned transaction.
POST /proofs/submitted{id,transactionHash}; saves pending hash without asserting verification.
POST /proofs/verify{id,transactionHash}; independently checks Base and returns block and confirmations.
GET /proofsup to 100 most recent account proofs.
GET /proofs/:id/exportprivate evidence export; never publish without reviewing its contents.
Deployment guide
Runtime: Node.js 24 or newer; production dependencies are declared in package.json. Startup file for cPanel is app.cjs. The web server maps the Node application to https://dcemail.io/. Keep the application root separate from the public document root, and do not upload secrets under dist.
Set NODE_ENV=production, APP_ORIGIN=https://dcemail.io, MAIL_HOST=business30.web-hosting.com, DATA_DIR=/home/dybkuahl/dcemail-private, and BASE_RPC_URL to a trusted Base mainnet HTTPS endpoint. TRUST_PROXY=1 trusts loopback proxies only; verify the actual hosting proxy and req.secure before enabling sign-in. Do not broadly trust arbitrary forwarded headers.
Install production dependencies, start the Node application, and verify /api/health over HTTPS. Confirm static assets, /mail, /docs.html and all authenticated routes. A successful health response does not prove email or blockchain operation.
For mail, confirm the existing Namecheap DNS, MX and local mail routing. Check SPF and DKIM in the provider's Email Deliverability screen. DMARC should be staged using real delivery reports before enforcement. Never replace existing DNS records blindly or assume a successful local send demonstrates external deliverability.
The data directory is created with private permissions; the master key has owner-only permissions. Back up the database and its key together using a consistent SQLite snapshot or a stopped service. Mailbox backups are separately provided by the mail host. Losing the key makes encrypted session/evidence records unreadable.
Operations and recovery
Before a release: retain the previous application package and domain configuration, run automated tests, review dependency changes, verify configuration, and stage the new build. Do not change unrelated hosted domains. Restore the previous application and restart to roll back; preserve compatible private data.
If SMTP acceptance is uncertain, inspect the provider's delivery tracking and Sent folder. Do not blindly retry. If IMAP authentication fails, verify mailbox existence, password, quota and provider status without recording the password in logs. If Base RPC fails, normal mail should remain usable; retry verification later.
If credentials may be exposed, disable affected sessions, change the mailbox password through the provider, investigate hosting access, rotate relevant operational credentials and communicate through the operator's incident process. Do not log email bodies, passwords, session cookies or private proof exports.
For a restore rehearsal, use a separate private staging directory and a disposable mailbox. Restore a consistent database and key, verify login and proof export, confirm the host mailbox is intact, and record the outcome. Define and test recovery-time and recovery-point objectives before making availability promises.
Validation and remaining release checks
Automated tests cover header injection and domain validation, authenticated encryption integrity, Base network/commitment/confirmation checks, wallet replay resistance, proof evidence reproducibility and account isolation, Origin and CSRF checks, session sign-out, and duplicate-send prevention. These tests use controlled mail and blockchain fixtures; they are not live delivery or mainnet transaction tests.
Live acceptance must demonstrate: user-entered mailbox sign-in; a message sent to the test mailbox and read back; attachments intact; Sent copy present; search and read/star/Trash behavior; wallet binding; a user-confirmed Base transaction independently verified after the confirmation threshold; proof export hash matching; mobile layout and reduced-motion controls; production HTTPS and backup checks.
No system can credibly be certified as 100% working from a build alone. Launch status must reflect the actual completed checks. No independent penetration test, legal review, or formal security audit has been completed by this implementation process.
Reference implementations
The repository is the authoritative description of the deployed release. Relevant libraries and primary documentation: ImapFlow (https://imapflow.com/docs/), Nodemailer SMTP (https://nodemailer.com/smtp), ethers providers (https://docs.ethers.org/v6/api/providers/), Node.js SQLite (https://nodejs.org/api/sqlite.html), and Base documentation (https://docs.base.org/).
Changes to the proof serialization or calldata format require a version change and compatibility tests. Future white papers should distinguish shipped behavior, measured results and planned features just as this version does.