TrustlessProtocol spec

Security Model

This document describes the security model, trust assumptions, and threat mitigations for the Light Client.

Trust Assumptions

The Light Client's security rests on the following assumptions:

  1. Source chain consensus integrity. The source chain's consensus is not compromised, i.e., no supermajority collusion among active validators. This is the base security assumption of any cross-chain protocol.

  2. Trusted initialization. The initial consensus checkpoint provided via InitializeLightClient is correct. This trust is established by the Security Admin (security council).

  3. Trusted relayer (canonical fork). The authorized relayer syncs on the correct, canonical fork of the source chain. Relaying is permissioned to enforce this trust boundary. See Long-Range Attacks below.

Why Permissioned + Cryptographically Verifiable

The Light Client combines cryptographic verification (the source chain's consensus check run on the destination — directly by the light client in direct mode, or attested by a zero-knowledge proof in zk-proof mode — plus Merkle proofs of block inclusion) with permissioned relaying (only authorized relayers can submit to the light client). This is a deliberate choice to layer two independent security mechanisms, because neither is sufficient alone in the current state of the technology.

In zk-proof mode, the verifier is a proof system — and ZK proof systems are immature

ZK proof systems and zkVMs are newly developed technology with a track record of critical soundness bugs:

  • RISC Zero missing constraint (May 2025): A missing constraint in the rv32im circuit meant any 3-register RISC-V instruction (including remu and divu) could be exploited by a malicious prover. This was a complete compromise of zkVM soundness: the fundamental property that a verifier only accepts proofs for true statements. Awarded a $50,000 bounty.
  • RISC Zero sys_read RCE: A crafted host response to sys_read exploited pointer arithmetic for arbitrary memory writes in the zkVM guest, breaking soundness entirely.
  • SP1 memory register bug: A bug in how SP1 handles register 0 (departing from RISC-V spec) allowed an attacker to prove false statements.
  • ZK compiler bugs: Researchers evaluating 4 industrial ZK compilers uncovered 21 bugs, 96% of documented circuit bugs across the ecosystem are under-constrained logic, where insufficient constraints allow a malicious prover to generate a valid proof for an incorrect statement.

These are not theoretical concerns. They are real bugs in production systems, found within the last year.

In every mode, the light client is complex code — and complexity breeds vulnerabilities

Whatever the mode, the light client is complex code: the consensus check (the whole verifier in direct mode), the zk circuits (zk-proof mode), the state-proof verification logic, and the cross-chain message handling are all inherently complex, and complexity breeds vulnerabilities.

A stark real-world example: the Hyperbridge exploit (April 2026). An attacker forged cross-chain state proofs targeting Hyperbridge's ISMP (Interoperable State Machine Protocol) gateway on Ethereum. Due to insufficient state-proof verification in the EthereumHost contract, the attacker submitted a malicious ChangeAssetAdmin action via TokenGateway.onAccept(), seizing admin and minter privileges of the bridged DOT token contract. They minted 1 billion fake DOT and extracted ~$237K in ETH. A second exploit on the same day used the same pipeline to drain ~$12K in MANTA and CERE tokens. The root cause: bugs in the verification logic, exactly the kind of vulnerability that exists in any complex cross-chain verification system.

The combined approach

By requiring both a passing consensus verification and a trusted relayer, the system achieves defense in depth:

  • Cryptographic verification protects against a compromised or malicious relayer. Even if the relayer submits a forged message, it cannot make it pass consensus verification (assuming the verifier is sound).
  • Permissioned relaying protects against bugs in the verifier. Even if a light-client bug or a proof-system soundness bug lets a forged submission through, the permissioned relayer will only submit messages that actually exist on the canonical chain.

An attacker would need to simultaneously exploit a soundness bug in the verifier (the light client, or in zk-proof mode the proof system) and compromise the permissioned relayer. This is a fundamentally stronger security posture than either approach alone.

Threat Model

What the Light Client protects against

  • Forged messages. A message that was never included in any finalized block on the source chain cannot pass VerifyMessage: consensus verification and block-inclusion verification would fail, and the permissioned relayer would not submit it.
  • Unfinalized messages. A message in a block that has not reached finality (e.g., still in a pending/proposed state) cannot be verified: the consensus verification step requires proof of finality against a known validator set.
  • Tampered submissions. In direct mode the signature and Merkle checks reject altered data; in zk-proof mode the soundness of the proof system guarantees that a computationally bounded adversary cannot forge a valid proof for an invalid statement.
  • Verifier bugs (mitigated). If a light-client bug or a soundness bug in the zk proof system lets a forged submission pass, the permissioned relayer acts as a second line of defense: it will only relay messages from the canonical chain.

What is out of scope

  • Source chain consensus failure. If >2/3 of the source chain's active validators collude, they can finalize arbitrary blocks. The light client will accept these as valid because, from its perspective, consensus was followed correctly. This is a fundamental limitation shared by all cross-chain verification approaches.
  • Validator slashing. Detecting and punishing validator misbehavior (e.g., equivocation) is the source chain's responsibility, not the light client's. The light client trusts that the source chain's staking/slashing mechanism provides the economic deterrent.

Potential Attack Vectors

Long-Range Attack

In a long-range attack, a set of validators who have exited and fully un-bonded from the source chain use their old keys to forge an alternative chain history. Because they are no longer bonded, the source chain cannot slash them. If a light client on the destination chain holds a consensus checkpoint corresponding to these validators, it could accept forged blocks as finalized, breaking the security of the cross-chain messaging protocol.

No long-range attack has ever been successfully executed on any major PoS blockchain.

Why permissioned relaying makes this highly improbable:

The permissioned relayer is the only entity that can submit to the light client, and it is trusted to sync on the canonical fork of the source chain. A forged alternative chain, no matter how valid its consensus data or proofs appear, is never relayed because the relayer is simply not connected to it.

For a long-range attack to succeed under this setup, an attacker would need to simultaneously:

  1. Acquire keys from a supermajority of exited validators: validators who collectively held >2/3 of the stake at some past epoch and have all since un-bonded. This is expensive and logistically difficult.
  2. Compromise the permissioned relayer: either by directly breaching its infrastructure or colluding with the relayer operator, to make it relay from the forged chain instead of the canonical one.

Both conditions must hold at the same time. Each is individually unlikely; their conjunction is far less probable than either alone. In a permissionless setup, condition (2) is satisfied by default — anyone can submit proofs. Permissioned relaying eliminates this, making the attack require coordination across two independent trust boundaries.

On this page