One network, two ledgers.
Notis keeps content and value on two separate ledgers — a Posts DAG for what people say, a UTXO ledger for karma and credits — bound together by stumps and secured by proof-of-work. Here's how the pieces fit.
The dual ledger
Most systems try to force one data structure to do everything. Notis doesn't. Content and value have opposite needs, so they live on two ledgers that are cryptographically independent — neither one's integrity depends on the other:
Posts DAG
- Author-sovereign — you own your subtree
- Prunable — deletable for privacy
- Threaded — posts reference parents
UTXO Ledger
- Immutable lineage — every coin's history
- Spendable state — balances change
- Karma & credits live here
A purely additive content graph can't model deletion or account balances; a pure ledger can't model threaded, deletable conversation. Splitting them keeps the strengths of both — and a third tiny layer, stumps, is what ties them together.
The content layer — Posts DAG
Every post is the root of a sovereign subtree. The author controls everything beneath it — replies, replies to replies, the whole transitive tree. Replying to someone's post is consent to that: it places your reply inside their tree.
What a post is
A post carries its content (1–300 bytes), its author (an Ed25519 public key), zero to eight parent references, a proof-of-work solution, and a signature. Its hash is its identity — and that identity survives even if the content is later deleted, so links between posts never break.
Pruning — deletion as a first-class right
An author can prune their subtree at any time. Pruning cascades to every reply underneath — because even the replies to a deleted post can leak what it said, cascade deletion is the only privacy-preserving default. Pruning is irreversible, authorized solely by the author's signature, and what it leaves behind is a stump.
Stumps — binding content to value
A stump is the compact, signed proof left where a subtree used to be. It records that the subtree existed and what value was earned inside it — so pruned content still settles correctly on the value ledger.
This is the crucial property: settlement is deterministically computable from the ledger alone. Any node can verify a prune and its value effects without ever having seen the deleted content. Stumps are the single bridge from content-compaction to value on the ledger — the reason you can delete your words without corrupting anyone's karma.
The value layer — UTXO ledger
Value lives in boxes — ledger entries locked by a guard script, consumed and re-created in atomic transactions. The set of unspent boxes is the current state. Every transaction conserves value (in = out) except at explicit mint and burn points, and a box can only be spent if its guard permits it. Two asset types share this layer:
Karma
- Non-transferable
- Earned by being liked
- Decays if you go inactive
Credits
- Freely tradeable
- Mined as block rewards
- Pays fees, secures the chain
How karma and credits are earned, spent, and kept honest — invites, likes, decay, mining, the fair launch — is the whole subject of the Economy page. This page is about the container they live in.
Authenticated state — the AVL+ root
The unspent-box set is indexed by an authenticated dictionary (an AVL+ tree). Every block header carries a stateRoot — a single hash committing to the entire ledger at that height. That lets a light client prove a given box does or doesn't exist, with a short proof, without downloading the whole ledger.
Consensus — two tiers of proof-of-work
Notis mines at two levels, and keeping them separate is deliberate:
Sub-blocks — users mine their own posts
To publish, an author solves a lightweight proof-of-work against a fresh challenge from a node (the challenge prevents precomputation). That solved post is a sub-block — it gets fast inclusion without waiting on a validator.
Ordering blocks — validators anchor the chain
Validators solve a full proof-of-work to produce ordering blocks, which batch the sub-blocks since the last one, put them in canonical order, and anchor the chain. Validator selection is pure PoW — no stake, no karma gating. Anyone who solves the puzzle can produce the next block.
Because mining is decided by work alone — not by karma and not by wealth — the security layer stays independent of the social and economic layers. Being popular buys you no consensus power; being rich in credits buys you no reputation. Each layer is walled off from the others.
Identity
An account is just an Ed25519 keypair — there's no registration step and no account table. You come into existence the first time your key appears in a committed box on the ledger. Notis is invite-only: an existing account has to bring in each newcomer (the mechanics of that live on the Economy page).
Usernames and profiles are DAG-native — they're just posts. A username is claimed first-come-first-served and can be released by pruning the claim; a profile (display name, bio, avatar) is a set of small posts under a profile anchor. Your identity is something you publish, not something a server grants you.
Protocol versioning
Every post, block, and transaction carries a protocolVersion, and validation rules are keyed to it. An object made under an old version is validated against that version's rules forever; a node rejects versions it doesn't support. This is how the protocol can evolve — new mechanics, new rules — without rewriting or breaking the history that came before.
The node records; it doesn't rank
One principle runs through the whole design: the node's job is to record, validate, and serve verifiable data faithfully — posts, likes, karma, blocks — and nothing more. Feed ranking, reputation scoring, spam-flagging, algorithmic curation: all of that lives in clients and indexers, not the protocol. The chain hands everyone the same honest dataset; what to surface and how to weight it is a decision made above it, out in the open.