TrustlessConcepts

Messenger

This document describes the Messenger, the infrastructure layer that powers the Trustless Messaging Protocol (TMP).

What is it

The Messenger is the concrete implementation of the message transportation pipeline defined by TMP. Where TMP specifies what happens (that any blockchain data committed by a source chain's consensus can be securely transported and verified at a destination), the Messenger specifies how: a light client on the destination verifies the source chain's consensus, running the check directly where the destination can afford it (direct mode) and verifying a zero-knowledge proof of the check where it cannot (zk-proof mode).

Core idea

The Messenger reduces message verification to consensus verification on the destination, in one of two verification modes, fixed per (source, destination) light client at deployment:

  • Direct. The light client runs the source chain's consensus check itself with the destination's native primitives. No prover is involved; the relayer only delivers the consensus data.
  • ZK-proof. An off-chain prover replays the consensus check and produces a zero-knowledge proof attesting that it passed; the destination verifies the succinct proof in constant time, gaining the same guarantee as if it had run the check itself.

Which mode a (source, destination) pair uses is fixed at deployment; see Light Client § Verification mode for the rule.

Either way the result is full consensus-level security at bounded on-chain cost. See Consensus Verification for the underlying technique.

Technical spec

Overall architecture

messenger-architecture

ComponentLocationRole
RelayerOff-chain (permissioned)The submitter. Watches the source chain on behalf of destination applications and assembles the proof the destination light client expects: the consensus data itself in direct mode, a succinct ZK proof of consensus finality (obtained from the off-chain prover) in zk-proof mode.
RouterOn-chainThe dispatcher. Connects sources to destinations: directs each incoming submission to the right light client for verification, then hands verified messages to the right application.
Light ClientOn-chain (one per source chain)The verifier and on-chain root of trust for a single source chain. Holds a view of the source chain's consensus and checks every submitted proof against it, in its verification mode.

The Relayer is permissioned: only Security-Admin-authorized relayers can submit to the light client. This is a deliberate trust-boundary choice. See Security model below for the rationale.

Functional decomposition

The transport work decomposes into three functional stages, each owned by one of the components above:

message-transportation

End-to-end flow

messenger-flow

#ActorFunctionalityDescription
0ApplicationRegister FilterApplication supplies a relay filter — declares which messages to relay
1RelayerSource Data IngestionContinuously pulls blocks from the source chain
2RelayerConsensus State TrackingMaintains an off-chain mirror of the source chain's consensus state (validator set, stake weights, finalized checkpoints)
3RelayerMessage ExtractionFilters ingested block data against the application's relay filter
4RelayerProof GenerationProduces (consensus state, proof) and (message, proof): in direct mode the consensus data plus the Merkle inclusion proof, in zk-proof mode a ZK proof bundle
5RelayerMessage DeliverySubmits the proofs to the destination chain via the Router
6RouterLight Client RoutingDispatches each incoming submission to the matching source-chain light client
7Light ClientConsensus State Update(on a (consensus state, proof) submission) Advances the light client's view of the source chain
8Light ClientMessage Verification(on a (message, proof) submission) Confirms the message is committed in a finalized block, against a compatible stored checkpoint
9RouterApplication RoutingDelivers the verified message to the application(s) whose registered filter matches; the MessageID is marked delivered (exactly-once)

Security model

TMP layers two independent defenses rather than relying on either alone:

  • Cryptographic consensus verification. Every message must pass the source chain's consensus check on the destination before delivery — run directly by the light client (direct mode) or attested by a zero-knowledge proof the light client verifies (zk-proof mode).
  • Permissioned relaying. Only Security-Admin-authorized relayers can submit to the light client, and each syncs the canonical fork of the source chain.

Either layer alone seems sufficient — but the cryptographic layer can fail:

  • Verifier implementations are complex. In direct mode the light client is the verifier, and light-client bugs are a proven attack surface: the Hyperbridge ISMP exploit (April 2026) weaponized insufficient state-proof verification, and it is not the only light-client exploit. In zk-proof mode the circuit is the verifier, and ZK proof systems are still maturing: soundness bugs in zkVMs and circuit compilers keep surfacing (RISC Zero's missing-constraint flaw, SP1's register-handling bug, and many more). Even audited implementations cannot be assumed bug-free.

Combining both is the central security argument of TMP: it puts the trust model of a multisig bridge on top of the cryptographic guarantee of a light-client bridge, so an attacker must defeat both at once: break the consensus verifier (exploit the light client, or forge a proof) and compromise the permissioned relayer. Each is unlikely on its own; both together are rarer still.

Trust assumptions

  1. Security Admin (in practice a security council / multisig): trusted for initial light-client setup and code upgrades. Both are publicly verifiable, keeping the assumption tightly scoped.
  2. Permissioned relaying: trusted only partially; the verification layer backstops a relayer compromise.
  3. Consensus-verifier soundness (light-client correctness in direct mode, circuit soundness in zk-proof mode): trusted only partially; the permissioned layer backstops a verifier bug.

On this page