Modules
Stable public client facade for ExWapp.
Cryptographic primitives for WhatsApp App State Sync.
Public façade for WhatsApp app-state sync.
Builders for outgoing app-state mutations.
Encoding and decoding helpers for app-state patches.
Applies decoded app-state mutations to local contact and chat state.
Persistence helpers for app-state hash-chain metadata.
Synchronization and transport helpers for app-state collections.
Linked-list Truncated Hash for WhatsApp App State integrity verification.
OTP Application for ExWapp.
WhatsApp binary node encoder/decoder (ported from whatsmeow).
Call log storage and queries.
Chat and conversation management.
High-level, runtime-neutral ExWapp client.
Runtime-neutral operations for ExWapp.Client.
Behaviour for high-level, runtime-neutral ExWapp client adapters.
Default high-level transport adapter.
Diagnostic client adapter backed directly by the low-level WebSocket transport.
Built-in high-level transport backed by the full ExWapp.Session engine.
Deprecated compatibility name for ExWapp.Client.Transport.RawWebSocket.
Thin wrapper around the WhatsApp WebSocket transport.
Runtime state owned by ExWapp.Conn.
Contact struct and local CRUD operations.
Provides interactive diagnostics for the WhatsApp WebSocket and Noise handshake.
WebSockex callback process used internally by ExWapp.Debug to inspect
handshake frames.
WebSockex callback process that drives a complete diagnostic Noise handshake
for ExWapp.Debug.
Persists normalized contacts in an ExWapp.Store.
Structured error returned by high-level ExWapp client operations.
Classifies the error attribute WhatsApp puts on a message acknowledgement.
Runtime-neutral events emitted by the high-level client API.
Behaviour for delivering high-level ExWapp events.
Default event adapter that ignores events.
Event adapter that forwards high-level ExWapp events to :telemetry.
Minimal representation of a WhatsApp JID.
Configurable JSON boundary used by ExWapp.
Contract expected from the configured JSON implementation.
Manual integration helper for running a real WhatsApp Web session in IEx.
Map path helpers that tolerate both atom and string keys.
Public media helpers shared by send and receive flows.
WhatsApp media encryption and decryption helpers.
Downloaded and decrypted media payload.
Minimal WhatsApp media upload/download client.
Downloadable media reference extracted from an inbound message or upload.
Implements WhatsApp's media re-upload protocol.
Metadata returned after uploading encrypted media to WhatsApp.
User-facing WhatsApp message struct.
Canonical content contract for inbound WhatsApp messages.
Turns inbound <call> stanzas into call-log records and live call events.
Provides shared normalization and lookup helpers for inbound node handlers.
Coordinates the inbound message pipeline after a <message> node reaches a
session.
Decodes inbound plaintext into the canonical message-content contract.
Signal and sender-key decryption for inbound message envelopes.
Inbound envelope normalization and sender/payload candidate resolution.
Applies inbound presentation metadata to the local chat projection.
Projects normalized inbound data into the public chat message and event stream.
Builds delivery, retry, placeholder-resend, and Signal-session actions.
Ingests protocol messages that update local synchronized state.
Handles server notifications and translates them into session actions.
Handles inbound delivery/read receipts and message acknowledgements.
Compatibility façade for inbound XML-envelope and protobuf wire helpers.
Pure decoder for supported WhatsApp message content.
Pure protobuf wire-field primitives, independent of the generated protos.
High-level router for incoming WhatsApp nodes.
High-level helpers for constructing and sending WhatsApp messages.
Implements the Noise_XX_25519_AESGCM_SHA256 handshake used by WhatsApp Web.
Validates the WhatsApp Noise certificate chain presented during handshake.
Builds the protobuf client payload encrypted into the Noise handshake.
Pure Elixir implementation of the Noise handshake engine.
Mutable state passed between Noise XX handshake steps.
Implements the Noise_XX handshake primitives used by WhatsApp Web.
Immutable container for the transport keys and metadata derived from a Noise handshake.
Implements the QR-code based pairing handshake used by WhatsApp Web.
Helpers for parsing and validating WhatsApp ADV (Account Device Verification) payloads.
Implements WhatsApp's phone-number (link-code) companion pairing protocol.
Handles prekey generation and upload to WhatsApp servers.
Validates trusted-contact privacy tokens used by direct-message sends.
Extracts WhatsApp history sync payloads embedded in protocol messages.
Tracks configurable daily outbound-message quotas.
Applies configurable token-bucket throttling before outbound sends.
Internal facade for the built-in WhatsApp session engine.
Account/state helpers for session send flows.
Chat and contact commands that reach the server through app-state sync.
Persists recently observed multi-device fanout targets.
Builders/parsers for IQ stanzas used in send session setup (USync + prekeys).
Decouples transport ingestion from session node processing.
Pure JID helpers used by session send/decrypt flows.
Builders/parsers for encrypted message participant nodes.
Pure device-discovery decisions for outbound messages.
Direct-message and self-chat outbound orchestration decisions.
Encrypts one outbound payload for all resolved target devices.
Resolves direct-message fanout targets.
Group-specific outbound transformations and routing decisions.
Effect boundary for outbound USync, prekey, and group-info IQ requests.
Prekey target decisions and Signal-session bootstrap for outbound messages.
Per-session outbound command queue.
Bounded bookkeeping for the per-message retry counters in the session state.
DynamicSupervisor for managing multiple WhatsApp sessions.
Target resolution helpers for direct-message fanout.
Coordinates the lifecycle of a WhatsApp Web connection.
The session's connection lifecycle: opening the transport, reacting to what it reports, tearing it down and deciding when to try again.
What the session tells the outside world: telemetry, lifecycle metadata and the QR notifications that carry an error.
Converts inbound message handler outputs into sendable action nodes.
Dispatches inbound Binary.Node stanzas received after the Noise handshake.
Coordinates outbound sends from the session worker.
Tracks outbound message delivery confirmation and handles the silent-drop fallback strategy for self-chat messages.
Post-authentication helpers triggered after the success node is received.
Builds receipt and retry-receipt nodes for inbound message acknowledgement.
Reconnect/backoff policy for session workers.
Outbound retry and message lookup helpers for Session.
Implements the session's outbound safety circuit breaker.
Tracks how well outbound sending is going, and decides when to trip the guard.
What the session does when a send does not land.
Keeps the session's Signal sessions loaded, pruned and persisted.
Subscriber bookkeeping for QR and message streams.
Manages Signal protocol key material and session state.
Pure Elixir Signal adapter.
High-level Signal encryption/decryption for WhatsApp messages.
Generates Signal Curve25519 key material and implements XEdDSA signatures.
Fetches prekey bundles from WhatsApp server for establishing Signal sessions.
Group sender-key support for WhatsApp skmsg payloads.
Signal Protocol session management for WhatsApp encryption.
Manages Signal sessions for multiple recipients.
Reference to an ETS-backed Signal session store.
Signal Protocol wire format implementation.
Persistence adapter behaviour for WhatsApp session state.
Versioned codec for persisted ExWapp store data.
ETS-backed store with file persistence.
In-memory store adapter for testing.
Indexed message storage used by the built-in store adapters.
Telemetry helpers and canonical event list for ExWapp.
Behaviour for wire-level WhatsApp protocol transports.
WhatsApp-specific websocket frame encoding.
Optional wire-level WebSocket/Noise process for WhatsApp Web.
Holds runtime state for the WhatsApp WebSocket transport.