xln

XLN: Where Traditional Finance Meets DeFi

TradFi + DeFi = XLN — The superset of both worlds, delivering institutional-grade governance with crypto-native innovation.

XLN is not a rollup or another L2. It is the organizational layer for digital finance: each Entity is a state-time machine with its own blocks, quorum, and storage. There is no single global ledger; instead, every Jurisdiction/Entity/Account maintains its own append-only ledger and interops via signed messages.

For Crypto: Zero-cost DAO creation, infinite organizational complexity, cross-chain identity
For Institutions: Cryptographic audit trails, hierarchical approvals, dual-class governance
For Everyone: The missing infrastructure for programmable organizations

At a glance (J/E/A machines)

Diagram: Layered architecture

graph TD
  subgraph J["J-machine (Jurisdiction)"]
    JR["Registry / Reserves / Disputes"]
  end

  subgraph E["E-machine (Entity)"]
    EG["Governance & Policy"]
    AR["Committed A-root"]
    EG --> AR
  end

  subgraph A["A-machine (Account)"]
    CH["Channels & Subcontracts"]
  end

  CH -->|proofs| EG
  EG -->|registration / numbering| JR

Why XLN: The Best of Both Worlds

From Traditional Finance

From DeFi

Beyond Both

Key Concepts

  1. JEA: Jurisdiction → Entity → Account hierarchy. Think of it as Registry → Organization → Operations.
  2. State-time machines: Each participant maintains their own cryptographically-secured ledger. No single point of failure.
  3. Personal consensus: Your organization advances when YOUR quorum signs. No waiting for global agreement.
  4. Hanko signatures: One signature proves entire approval hierarchies. Board→CEO→CFO→Treasury in one proof.
  5. Universal integration: Single Hanko authorization works across Uniswap, Aave, Compound, and any protocol.

We refer to these as J/E/A machines: a Jurisdiction machine (J-machine), an Entity machine (E-machine), and an Account machine (A-machine).

Machines in XLN (J/E/A)

These ledgers are sovereign and composable. Interactions are mediated by signatures, not by a global sequencer.

Account Layer (generalized)

Diagram: Account/channel structure

graph LR
  A["A-machine"] --> CKey["channelKey = sha256(min(L,R)||max(L,R))"]
  CKey --> State["channel state: blockId, timestamp, transitionId, prev hashes"]
  State --> SubC["subchannels: token→(delta, limits, nonces)"]
  State --> SubK["subcontracts: deposits/withdrawals, status"]
  SubC --> Proofs["typed proposedEvents → proofs"]
  SubK --> Proofs
  Proofs --> ECommit["E-machine commit (A-root)"]

Quick Start

Run the server

bun run src/server.ts

Optional flags: set NO_DEMO=1 to skip the demo.

Explore docs

Why XLN vs L2/Rollups

Security & Invariants

Diagram: Entity quorum flow

sequenceDiagram
  participant P as Proposer (replica)
  participant V as Validators (quorum)
  participant E as E-machine

  P->>V: propose(frame)
  V-->>P: precommit(sig)
  P->>E: commit(frame, sigs)
  E-->>V: new block (height+1)

Visual Demo

Run the deterministic demo:

bun run src/server.ts

You should see output like:

🎯 === FINAL VERIFICATION ===
🔍 Consensus: ✅ SUCCESS (messages: ✅, proposals: ✅)
📊 Entity #1: 10 messages, 0 proposals, height 3
📊 Entity #2: proposals pending (gossip mode)
📸 Snapshot captured: "Tick 59: ..."

On-chain registration will attempt via local RPCs; if none are running you’ll see connection errors, which is expected for offline runs.

Glossary

The XLN Advantage: Best of Both Worlds

From Wall Street: Hierarchies, controls, audit trails, compliance
From Web3: Permissionless, composable, global, instant
Beyond Both: Programmable organizations at zero marginal cost

We’re not building another blockchain. We’re building the organizational infrastructure that makes both traditional and decentralized finance obsolete by delivering everything each promises and more.

Tagline options