Skip to content

Chain Agnostic Applications

Problem

Cosmos appchains often spin up bespoke validator sets, multisigs, or IBC-only paths per use-case (governance messages, bridges, feeds). Each new route brings another committee, relayer and audit. Latency creeps in through off-chain hops; costs grow with validator counts; and security fragments across custom trust assumptions. Meanwhile, CometBFT finality and slashing exist, but slashing paths for cross-chain outcomes are typically indirect or out-of-band, and every extra chain or pairing demands new glue code and operations.

Solution

Relay gives Cosmos chains a single validation layer for cross-chain outcomes: turn any source-chain event into a stake-secured attestation that you can verify natively on your Cosmos app (module or contract) and act on immediately.

Why this is a fit for Cosmos:

  • Cheaper at scale. BLS aggregation (and optional ZK) keeps on-chain verify cost near-constant, even as the operator set grows → useful when verifying large, Ethereum-sourced validator sets on a Cosmos chain.
  • Clearer guarantees. Attestations are backed by bonded stake and explicit slashing rules in Symbiotic; you set the quorum and weights that must sign.
  • Faster to production. A thin Cosmos adapter (native module or contract) replaces ad-hoc relayers / committees; you deploy a single verifier and wire it to your app logic.
  • Portable across stacks. One attestation format, many destinations → verify on a Cosmos chain today and an EVM rollup tomorrow with the same cryptographic proof.
  • Works with IBC. Keep using IBC where it shines; feed Relay attestations into modules that need Ethereum (or other) state with explicit slashable guarantees, or hand the proof to existing routing / governance logic.
  • Operator control. Customize validator sets, quorum thresholds, stake types, challenge windows, and slashing rules per appchain or per route.

How it Works

  1. Observe & package. Off-chain Relay nodes watch a source chain (EVM or Cosmos), pick up your event / message, and package it with {source domain, block/height, nonce, expiry}.
  2. Attest & aggregate. A configurable quorum of operators signs; signatures are aggregated with BLS and linked to bonded stake in Symbiotic.
  3. Verify on Cosmos. Your Cosmos app verifies the attestation through a light verifier (part of the example in cosmos-relay-sdk/simapp), checking weights / quorum, metadata, replay protection, and the aggregate signature. With optional ZK, verify cost remains flat as the set grows.
  4. Settle the outcome. After verification, an adapter module executes: mint / burn, update a price / feed, finalize a bridge transfer, trigger governance, or emit an event for downstream modules - exactly like your EVM adapters, but idiomatic for Cosmos.

Chain Agnostic Applications

Application Examples

  1. Secure your L1 consensus at genesis (no bootstrap from 0)

    Launch without resorting to a centralized multisig or a tiny, weak validator set. Your chain imports slashable economic security directly from a Symbiotic vault: the Relay delivers an attested operator set and weights; your adapter maps those weights to consensus voting power and emits ValidatorUpdates. Mis-attestations are slashable at the vault, so security is real on day one - no “trust us until we decentralize” phase.

    Why it matters: you avoid the bootstrapping trap, ship safely on day 1, and can progressively add native stake over time (dual-sourcing security or switching entirely when ready).

  2. Canonical mint / burn across two Cosmos L1s

    Keep a single canonical supply without bespoke multisigs. Burns on Chain A are attested via Relay; your adapter on Chain B verifies and mints, with nonces / expiries for replay protection.

  3. DEX settlement & intent routing across Cosmos L1s

    Resolve on Chain A, finalize accounting on Chain B. The adapter verifies once and updates balances / positions in your DEX or settlement module.

  4. Cross-domain oracle / State feeds into a Cosmos module

    Import external state (e.g., LST rates, rollup headers) into a Cosmos oracle with explicit, slashable guarantees and sane expiries / challenge windows.