1. The weight object

Sequencing weight is a channel note carrying an active declaration in a dedicated base-layer registry (PROPOSED, unbuilt). Not a new token, not a zone-held balance, not a scalar carved out of channel state, and not every deposited note implicitly. The zone holds no stake state at all; its half of the design reduces to the float-exclusion convention (section 8), which the base layer cannot verify.

Why channel notes. The denomination was first taken from the protocol lead’s steer to reuse channel notes, a steer that survives only as a transcription with no primary capture; that gap costs provenance, not the decision, because three lines force the denomination independently:

  1. A selection rule must bind at append time. It binds only if expressible over state the base layer already holds when appending, and a stake-relative predicate needs an observable, summable total; registered, locked base-layer stake satisfies both requirements.
  2. The age-reset attack makes the location structural. An open franchise must derive from state its incumbents cannot write. Channel content is incumbent-written and undeclared notes are incumbent-mutable, so zone-held weight fails a type check: the writers of the electorate would be the elected (section 3).
  3. The substrate moved. Per-note channel state is merged (MERGED, Mantle): channel value is notes, and there is no scalar balance left to carve stake from.

Weight is raw declared value, uncapped. A note wins a slot independently with probability 1 - (1-f)^(v/D), where v is the note’s declared value and D the channel’s frozen denominator: the Proof of Leadership win-probability function with a registered channel denominator in place of the L1 total-stake indicator (PROPOSED; evaluation belongs to PCS X: Draw and the Win ). This form is exactly split-invariant for first-win probability, and notes and identities are free to create, so any transform not linear in the exponent is gamed: a cap makes large holders split under it, and a concave weighting pays splitters. Raw value is the only Sybil-neutral weight assignment. The residual: expected number of wins is sub-additive, a measured splitting gain of about 1.7% at the default rate, the same order as collision waste (the normative rule as specified has never been executed).

One declaration per note, one channel per note (PROPOSED). The registry keys on note identifier with exactly one declaration per note, so a note weights at most one channel’s lottery, ever; a holder who wants weight on two channels splits value into two notes, costless by split-invariance. A declaration also binds a separate signing key, the sequencing key, with proof of possession at declaration, no rotation, and no revocation short of a two-epoch undeclare (PROPOSED; both the term and the object are this proposal’s, not the substrate’s). A limit, stated plainly: a stolen sequencing key is unremovable inside the undeclare window; a fast-removal path is open, outside this document.

2. Bundling and the registry

Chosen: a declaration is valid only inside the same transaction as the CHANNEL_DEPOSIT that creates the note being declared (PROPOSED; transaction-level atomicity is MERGED). Existing channel float is never declarable directly; declared value is always new value entering the channel. Two arguments:

Rejected: contest windows and age-before-declare (each leaves a pendency during which an incumbent consumes entrants’ notes, at a cost of one slot win per victim-week), and implicit all-notes participation (an undeclared note’s age is writable by any slot winner, so an all-notes electorate is mutable by exactly the actors the lottery elects; immobilising everything would freeze the float; the base layer cannot tell which deposited notes still belong to the key on record, so an all-notes franchise attaches power and duty to parties with no remaining exposure; and passive stake cuts the occupied-slot rate to (1-q)f for passive fraction q).

Cost, stated plainly: entry for capital already inside the channel runs through release, re-deposit, re-declare, and the release leg requires two winner-produced artefacts plus a full ageing window, so entry for in-channel capital is winner-gated by construction. A permissionlessness limit, not a convenience cost; carried in PCS X: Exit and Custody The atomic withlottery-deposit-declare conversion remains blocked on the sequential-validation reading and on the release predicate’s authorisation, both outside this document.

The dedicated registry. The declaration is recorded in a dedicated ledger map, channel_seq_declarations: dict[NoteId, SeqDeclaration], owned entirely by the channel machinery (PROPOSED). The immobilisation check is one assertion added to the else-branch of the existing spendability check (MERGED, Mantle: that check already runs for exactly CHANNEL_WITHlottery and CHANNEL_TRANSFER and already resolves the channel identifier). The rejected alternative is the Service Declaration Protocol (SDP)’s locked_notes structure, on three grounds:

  1. The release condition is SDP’s, not this design’s. An entry with an empty declarations set is what SDP’s epoch finalisation garbage-collects, so a declarer could lift its own channel lock via an unrelated SDP declare/withlottery round trip.
  2. The threat models are inverted. SDP’s lock is a self-binding commitment, so keying release to the owner’s lifecycle is correct there. This lock is a third-party restraint: nobody may move the note, including the slot winners who normally can (MERGED). A restraint the restrained party did not impose must not be releasable through a lifecycle that party controls.
  3. Barred as service collateral. The Mantle bridging table lotterys the exclusion (“They are distinct from Locked Notes as they can’t be used to declare a service”, MERGED, Mantle), and the implementation refuses channel notes as service collateral (core/src/mantle/ops/sdp/declare.rs).

Smallness: repairing the locked_notes route would mean amending SDP’s epoch-finalisation path, a shared consensus hot path; the dedicated route adds one map and one lookup inside a function that already runs.

3. Immobilisation