Architecture

Norn reimagines the relationship between users and the chain. Rather than forcing every transaction through global consensus, Norn puts state ownership back in your hands. You hold the thread.

Users own their state through personal cryptographic chains called Threads. Transfers are signed by the sender and validated by the network. Clients can independently verify their balances using Merkle proofs against the on-chain state root.

Core Components

Component	Description
Threads	Personal state chains -- each user maintains their own signed history of state transitions, stored locally on their device.
Knots	Atomic state transitions -- signed transfers that update Thread state, validated by the network.
Weave	The anchor chain -- a minimal HotStuff BFT blockchain that processes commitments, registrations, and fraud proofs.
Looms	Off-chain smart contracts -- WebAssembly programs that execute off-chain with on-chain fraud proof guarantees.
Spindles	Watchtower services -- monitor the Weave on behalf of offline users and submit fraud proofs when misbehavior is detected.
Relays	P2P message buffers -- asynchronous message delivery between Threads via the libp2p protocol stack.

Thread-Centric State

Traditional blockchains hold your state and control access. This creates inherent scalability limits -- throughput is bounded by block size and consensus overhead.

Norn inverts this model. Users own their state through Threads -- the chain validates transitions and guarantees correctness. The anchor chain (the Weave) serves as a lightweight validator and arbiter:

Normal operation: Alice signs a transfer to Bob. The network validates the state transition and applies it.
State verification: Clients independently verify their balances using Merkle proofs against the on-chain state root.
Dispute resolution: If someone cheats (e.g., signs conflicting states), a Spindle submits a fraud proof. The Weave adjudicates and penalizes the cheater.

Threads

A Thread is a user's personal state chain -- an ordered sequence of signed state transitions stored on their own device. Each Thread entry contains:

A state hash (BLAKE3)
A version number (monotonically increasing)
The owner's Ed25519 signature

Threads are never uploaded to the chain in full. Only commitments (hash + version) are periodically published to the Weave.

Knots

A Knot is a signed state transition. When Alice sends Bob 10 NORN:

Alice creates and signs a Knot containing the transfer
The Knot is submitted to the network for validation
The network validates the state transition and applies it to both Threads

The transfer is confirmed in the next block (~3 seconds).

The Weave

The Weave is Norn's anchor chain -- a minimal blockchain running HotStuff BFT consensus. It processes:

Commitments -- Cryptographic state anchors from users
Registrations -- NornNames, NT-1 tokens, Loom deployments
Fraud proofs -- Evidence of cheating, triggering economic penalties

The Weave is intentionally minimal. It does not process transfers or smart contract executions.

Looms

Looms are off-chain smart contracts powered by WebAssembly. They execute on participants' devices (not on-chain) but are backed by on-chain fraud proof guarantees:

Contracts are registered on the Weave (with bytecode stored off-chain)
Execution happens locally with gas metering
Disputes trigger on-chain fraud proof verification
Cross-contract calls supported (max depth: 8)

Spindles

Spindles are watchtower services that monitor the Weave on behalf of offline users. They:

Watch for conflicting commitments
Construct and submit fraud proofs
Operate with rate limiting to prevent spam

Relays

Relays provide asynchronous P2P message delivery between Threads using the libp2p protocol stack. They enable:

Message buffering for offline recipients
Peer discovery and gossip
State synchronization between nodes