ADAMANT Messenger PWA

ADAMANT Messenger is an open-source decentralized messenger and non-custodial wallet built on the ADAMANT blockchain. This repository contains the main client for Web, Tor, Android (Capacitor), and Desktop (Electron).

ADAMANT is designed around privacy, censorship resistance, and user custody. Accounts do not require phone numbers or emails, private keys stay on the user side, and the client can work with distributed nodes instead of a single provider.

Your ADAMANT passphrase cannot be recovered by developers, support, or infrastructure operators. Store it offline and treat it like a wallet seed phrase.

Why ADAMANT

• No phone numbers, no emails, no contact-book scraping by default
• End-to-end encrypted messaging using Diffie-Hellman Curve25519, Salsa20, Poly1305, SHA-256, and Ed25519
• Censorship-resistant account model backed by a decentralized blockchain network
• Non-custodial wallets and in-chat crypto transfers with full user-side key control
• Multi-node architecture with failover, self-hostability, and Tor-friendly deployment options

What This Repository Powers

• Progressive Web App for the public web
• Tor build for users who need stronger network anonymity
• Electron desktop app for macOS, Windows, and Linux
• Capacitor Android app

Highlights

• Anonymous onboarding without a phone number or email
• Encrypted chats with blockchain-backed message ordering and authenticity
• Built-in wallets for ADM, BTC, ETH, DOGE, DASH, USDT, USDC, and ERC20 tokens
• In-chat transfers, exchanger flows, and Adelina AI chat integration
• IPFS-based file sharing for attachments and media
• Custom node configuration with health checks and failover
• Open-source, community-driven, and self-hostable by design

Official Links

Resource	Link
Website	adamant.im
Apps	adamant.im/#adm-apps
Documentation	docs.adamant.im
Whitepaper	adamant-whitepaper-en.pdf
Releases	GitHub Releases
Media pack	media_pack.zip
Project profile	About ADAMANT: Description and Details

Community PWA Deployments

Mainnet app:

• GitHub Pages auto-build: adamant-im.github.io/adamant-im from master only due to GitHub Pages limitations
• Vercel auto-build: msg2.adamant.im from master on Vercel US
• Server-side auto-build: msg.adamant.im and adm.im from master
• Server-side auto-build: msgtest.adamant.im from dev
• Server-side Tor auto-build: http://adamant6457join2rxdkr2y7iqatar7n4n72lordxeknj435i4cjhpyd.onion from master
• Server-side Tor auto-build: http://il2fcw65jrrv4au7mtuvodzfwtc6hje6r4ooz7yoqu2jl422b44iofyd.onion from dev
• Vercel auto-build: dev.adamant.im from the dev branch on Vercel US
• Massa DeWeb auto-build: adm.massahub.network from master, hosted on the Massa blockchain
• GitHub Actions auto-build can also be configured by any user for their own master deployment

Testnet app:

• GitHub Actions auto-build in Surge: msg-adamant-testnet.surge.sh from master, mirrored at http://msg-testnet.adamant.im (HTTP-only for the mirror)
• GitHub Actions auto-build in Surge: dev-adamant-testnet.surge.sh from dev, mirrored at http://dev-testnet.adamant.im (HTTP-only for the mirror)

Quick Start

Recommended environment:

• Node.js >=24.15.0
• npm >=12

Clone and run the app locally:

git clone --recursive https://github.com/Adamant-im/adamant-im.git
cd adamant-im
corepack enable npm
npm install
npm run dev

Start a local HTTPS dev server with hot reload:

npm run dev-https

npm run https is kept as a shortcut for the same flow.

Common Commands

Task	Command
Start local development	npm run dev
Start local HTTPS development	npm run dev-https
Start localnet development on 0.0.0.0	npm run dev:localnet
Start testnet development	npm run dev:testnet
Start Tor-mode development	npm run dev:tor
Build production PWA	npm run build
Build testnet PWA	npm run build:testnet
Build Tor PWA	npm run build:tor
Preview production build	npm run serve
Preview testnet build	npm run serve:testnet
Build Electron app	npm run electron:build
Run Electron in development	npm run electron:dev
Preview Electron production build	npm run electron:serve
Prepare Android build assets	npm run android:prebuild
Open Android Studio project	npm run android:open
Run Android app on device/emulator	npm run android:run

CSP hardening on Vercel builds

Production builds inject a CSP meta policy that blocks JavaScript eval and Function constructors on every static hosting target. Vercel also delivers the same script policy as a response header. wasm-unsafe-eval remains narrowly enabled for the bundled secp256k1 WebAssembly module.

The policy intentionally allows HTTP(S) and WebSocket connections, images, and media from arbitrary origins so user-configured and self-hosted nodes keep working. This is broader than a fixed ADAMANT domain allowlist, while script execution is substantially narrower. Static meta policies cannot enforce frame-ancestors. Deployments with response-header support must deny framing there; the Vercel and Electron targets enforce frame-ancestors 'none' and X-Frame-Options: DENY.

The build fails if a generated JavaScript chunk contains a direct eval or a Function constructor. This gate scans reachable emitted chunks and direct lexical calls; runtime CSP remains the enforcement boundary for indirect forms. Keep runtime dependencies compatible with this gate instead of adding unsafe-eval.

Validation

Baseline validation for non-trivial changes:

npm run lint
npm run typecheck
npm run test -- --run

Useful additional checks:

npm run build
npm run test:e2e

When changes affect schema-driven artifacts:

npm run schema:generate
npm run wallets:types:generate

Playwright Smoke Checks

Install Chromium for local e2e runs:

npm run test:e2e:install

Run the smoke suite:

npm run test:e2e

Tests explicitly marked with the @long-running tag are skipped by default. Use longRunningTestTitle() to mark tests whose observed runtime exceeds the configured threshold, then include them explicitly:

npm run test:e2e -- --perform-long-running

Change the threshold in tests/e2e/helpers/longRunning.ts (LONG_RUNNING_TEST_THRESHOLD_MS = 40_000) and reassess the tagged tests when updating it.

Run with extended artifacts:

npm run test:e2e:detailed

Open the latest HTML report:

npm run test:e2e:report

Desktop and Android Notes

Run Electron locally:

npm run electron:dev

Force legacy Chrome extension-based Vue DevTools inside Electron:

ELECTRON_USE_CHROME_DEVTOOLS_EXTENSION=true npm run electron:dev

Keep DevTools open while suppressing noisy Chromium logs in terminal:

npm run electron:dev

Disable log suppression and show full Chromium/Electron internals:

ELECTRON_SUPPRESS_CHROMIUM_LOGS=false npm run electron:dev

Build Electron packages:

npm run electron:build

Build a macOS arm64 app and notarize it:

npm run electron:build:mac:arm64:notarize

Preview the Electron production build:

npm run electron:serve

macOS signing and notarization (local/CI)

For distributable macOS builds, use a valid Developer ID Application certificate and notarization.

The notarization hook (scripts/electron/notarize.cjs) supports 3 auth strategies:

1. Apple ID + app-specific password
2. Keychain profile (xcrun notarytool store-credentials)
3. App Store Connect API key

Supported environment variables:

# Common
APPLE_NOTARIZE=true

# Strategy 1 (Apple ID)
APPLE_ID=...
APPLE_APP_SPECIFIC_PASSWORD=...
APPLE_TEAM_ID=...

# Strategy 2 (Keychain profile)
APPLE_KEYCHAIN_PROFILE=...
# optional
APPLE_KEYCHAIN=...

# Strategy 3 (App Store Connect API key)
APPLE_API_KEY=/absolute/path/to/AuthKey_XXXXXXXXXX.p8
APPLE_API_KEY_ID=XXXXXXXXXX
# optional for team keys
APPLE_API_ISSUER=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx

Local builds can store these variables in electron-builder.env.local or electron-builder.env and the hook will load them automatically. For Apple ID strategy, APPLE_APP_PASSWORD is also accepted as an alias for APPLE_APP_SPECIFIC_PASSWORD.

Code-signing for electron-builder:

# local identity in Keychain
CSC_NAME="Developer ID Application: <Company> (<TEAM_ID>)"

# or CI/base64 P12
CSC_LINK=...
CSC_KEY_PASSWORD=...

Prepare and open Android project:

npm run android:prebuild
npm run android:open

Build and sign Android app:

cp capacitor.env.example capacitor.env
npm run android:build

Self-hosted

If you are unable to access adm.im (e.g., due to censorship), you can run a self-hosted instance of ADAMANT Messenger to:

• Increase reliability and decentralization of the ADAMANT Messenger ecosystem
• Help other users access the messenger in countries with strong Internet limitations

We always encourage people to build it from source.

As an option, you can build and deploy the app to GitHub Pages.

Follow the instructions below.

Enable GH Actions

1. Fork the repository
2. Go to the repository Settings
3. Navigate to the Pages tab
4. Set the source as GitHub Actions

Run GH Workflow

1. Go to the Actions tab
2. Enable workflows
3. Select the GitHub Pages workflow
4. Click Run workflow
5. Wait until the build succeeds
6. Open ADAMANT Messenger at username.github.io/adamant-im

You can as well point your GitHub Pages subdomain to a custom domain.

Security and Privacy Notes

• Private keys are derived and stored client-side
• Do not log or share passphrases, mnemonic material, or exported private keys
• Treat the browser runtime as potentially hostile and prefer trusted devices
• For stronger network anonymity, use the Tor build or a self-hosted instance

Contributing

Issues and pull requests are welcome. When contributing, prioritize security, privacy, decentralization, and compatibility with the existing ADAMANT protocol and user data.

Before opening a substantial PR, it is helpful to run:

npm run lint
npm run typecheck
npm run test -- --run
npm run build