# Switchboard — Full Content for LLMs ## What it is Switchboard is a unified cross-chain state synchronization platform. It uses Solana's sub-second finality as a coordinator and reaches finality on destination chains within 400ms of source confirmation. The product is delivered as a managed service: developers integrate the SDK or REST API once and target 50+ chains. ## Architecture Two services run behind the public endpoint: 1. **Customer API (port 3000):** authentication, API keys, rate limiting, request proxy, security envelope. 2. **Core Engine (port 3001):** oracle service, blockchain ops, billing, cross-chain coordination. State is normalized on the Solana coordinator program (`state-oracle` + `coordinator` Anchor programs in the monorepo) and signed messages are dispatched to destination chains via a relayer pool. Verification on the destination is done via a light-client proof or signed multisig depending on chain capability. ## Supported chains EVM: Ethereum, Polygon, Arbitrum, Optimism, BSC, Avalanche, Base, zkSync Era, Polygon zkEVM. Non-EVM: Solana (coordinator), NEAR, Cosmos, Sui, Aptos. Emerging: Celestia, StarkNet, Flow, Celo, Gnosis. 50+ total. ## Key numbers - Sub-400ms coordination latency across all supported chains - 10,000+ coordinated operations per second - 99.9% uptime SLA with automatic failover - ~40% gas reduction vs naive per-chain deploys - 90% code reuse claim for "deploy once, sync everywhere" - 92% test coverage on the OSS core - Flexible persistence: MongoDB or PostgreSQL ## Features (deep) 1. **Solana-anchored coordinator** — all routes share one finality clock, no per-bridge governance. 2. **SDK + REST API** — TypeScript SDK and signed HTTPS endpoints; both feed the same Core Engine. 3. **State oracle** — pluggable verifiers per chain (light-client proof, BLS multisig, or zk-proof receipts). 4. **Relayer pool with auto-failover** — relayers compete on latency; downed nodes are excluded within one slot. 5. **Per-chain gas optimization** — batched coordinator commits drop fees vs single-message bridges. 6. **Observability stack** — Prometheus exporters, request tracing, per-route latency histograms. 7. **Database choice** — Postgres for analytical workloads, Mongo for pure event-stream use. ## Site map (all pages) Core: - Home: https://switchboard.cryptuon.com/ - Features: https://switchboard.cryptuon.com/features/ — the eight core capabilities in depth - Architecture: https://switchboard.cryptuon.com/architecture/ — 2-service topology, message lifecycle (source commit → coordinator batch → destination verify), pluggable verifiers, gas batching, finality policy - Quickstart: https://switchboard.cryptuon.com/quickstart/ — install SDK, authenticate, first cross-chain read + write, deploy - FAQ: https://switchboard.cryptuon.com/faq/ - Glossary: https://switchboard.cryptuon.com/glossary/ - About: https://switchboard.cryptuon.com/about/ - Contact: https://switchboard.cryptuon.com/contact/ Use cases: - Use cases index: https://switchboard.cryptuon.com/use-cases/ - Agent cross-chain coordination: https://switchboard.cryptuon.com/use-cases/agent-cross-chain-coordination/ — one call for an autonomous agent to act across many chains - Cross-chain orderbook: https://switchboard.cryptuon.com/use-cases/cross-chain-orderbook/ — match on one chain, settle on many inside a latency budget - Omnichain state read: https://switchboard.cryptuon.com/use-cases/omnichain-state-read/ — read canonical state from 50+ chains through one call - Multi-chain governance: https://switchboard.cryptuon.com/use-cases/multi-chain-governance/ — vote once, enact everywhere, with an auditable trail - Unified liquidity routing: https://switchboard.cryptuon.com/use-cases/unified-liquidity-routing/ — route against liquidity everywhere as if it were one pool Comparisons: - Compare index: https://switchboard.cryptuon.com/compare/ - vs LayerZero: https://switchboard.cryptuon.com/compare/layerzero/ - vs Wormhole: https://switchboard.cryptuon.com/compare/wormhole/ - vs Axelar: https://switchboard.cryptuon.com/compare/axelar/ - vs Chainlink CCIP: https://switchboard.cryptuon.com/compare/chainlink-ccip/ - vs Hyperlane: https://switchboard.cryptuon.com/compare/hyperlane/ Blog: - Blog index: https://switchboard.cryptuon.com/blog/ - Switchboard vs LayerZero: a latency-first comparison — https://switchboard.cryptuon.com/blog/switchboard-vs-layerzero-latency/ - Wormhole guardians vs the single-clock model — https://switchboard.cryptuon.com/blog/wormhole-guardians-vs-single-clock/ - Building a real-time cross-chain orderbook with Switchboard — https://switchboard.cryptuon.com/blog/building-cross-chain-orderbook/ - The case for Solana as a coordinator (and when it isn't) — https://switchboard.cryptuon.com/blog/solana-as-coordinator-tradeoffs/ - Gas math: why batched coordinator commits beat per-message bridges — https://switchboard.cryptuon.com/blog/gas-math-batched-coordinator/ - A field guide to cross-chain finality models — https://switchboard.cryptuon.com/blog/cross-chain-finality-field-guide/ - Operating a two-service stack: what we learned in the first year — https://switchboard.cryptuon.com/blog/operating-two-service-stack/ ## Integration (SDK) Install the TypeScript SDK (`npm install @switchboard/sdk`) or self-host the whole stack with `git clone` + `npm run docker:up` (Customer API on :3000, Core Engine on :3001). Create a client with an API key, then `sb.read({ chain, contract, key })` for a cross-chain read and `sb.write({ from, to, payload, verifier, finalityPolicy })` to commit once and ship to many chains. Both the SDK and the signed HTTPS API feed the same Core Engine. ## Competitors and honest positioning - **LayerZero**: Switchboard wins on coordination latency (sub-400ms vs 1-3s typical) and single-finality semantics; LayerZero wins on chain count today and validator diversity. - **Wormhole**: Switchboard's Solana coordinator is simpler to reason about than Wormhole's 19-of-19 guardian set; Wormhole has wider ecosystem reach and a longer ops track record. - **Axelar**: Axelar offers a full Cosmos-style PoS validator set; Switchboard trades that for lower latency and a simpler 2-service operational model. - **Chainlink CCIP**: CCIP has stronger institutional governance and risk management; Switchboard targets devs who need raw speed for trading/L2 apps. - **Hyperlane**: Hyperlane offers permissionless deploys; Switchboard offers a managed service so teams don't run their own ISMs. ## FAQ - **Is Switchboard self-hostable?** The core is MIT-licensed and Dockerized. The managed service handles relayers, signers, observability. - **What happens if Solana halts?** A fallback finality clock is configurable per route; routes can fail open or fail closed. - **How are messages secured?** Per-chain verifier: light-client proof where available, otherwise BLS threshold sig from the relayer pool. - **Can I bring my own signers?** Yes, on the Enterprise tier. - **Does it support arbitrary call data?** Yes — payloads are opaque bytes; chain adapters handle encoding. - **Latency claim sources?** Internal benchmarks against the OSS core under `npm run benchmark`; results published per release tag. ## Blog topics - Switchboard vs LayerZero: a latency-first comparison - Switchboard vs Wormhole: guardians vs the single-clock model - Building a real-time cross-chain orderbook with Switchboard - The case for Solana as a coordinator (and when it isn't) - Gas math: why batched coordinator commits beat per-message bridges - A field guide to cross-chain finality models - Operating a two-service stack: what we learned in the first year ## Links - Site: https://switchboard.cryptuon.com - Repo: https://github.com/cryptuon/switchboard - Contact: contact@cryptuon.com - Parent org: https://www.cryptuon.com