<aside> 💡

This proposition is close to the Native Zone we originally proposed. The difference is instead of using ZK to prove the correct L1 notes transitions backed by the zone state transitions, we use an optimistic protocol to prove L1 note transitions and instead of backing the transitions to the STF we back it by user or program authorizations.

</aside>

This preliminary research explores how to stop a malicious sequencer set from taking the funds a channel holds on Mantle.

The mechanism in one sentence: every channel note already carries a key, and we make that key the one that authorizes moving the note. The L1 does not verify transfers by default. It asks for the authorization only if someone challenges one.

The result in one sentence: capturing a channel's configuration stops being a way to steal and becomes only a way to stall.

Vocabulary

term meaning
transfer the note-moving part of a CHANNEL_INSCRIBE, which this proposal merges with CHANNEL_TRANSFER
authorization a ZkSignature by a note's owner, saying what may happen to that note
claim an output a step asks for, a value towards a key. Claims towards the same key merge
collateral the stake a sequencer puts up to post, slashed when a challenge is lost
staked put up as collateral, held as a service note and therefore unspendable
bond one ordinary note a challenger or an answerer locks for a single action
locked a channel note on the ledger, not spendable until the transfer that created it becomes final
pool value inside a zone that no single user owns, such as an AMM reserve
image_id which Risc0 program a pool runs
instance_id which pool it is, among those running that program
pool key the key on a note sent to or held by a pool, naming the pool and, on a deposit, the sender's intent
intent what a user wants a pool to do with the note they send, committed in that note's key
pool state the pool's own state, kept by the L1 and advanced one step at a time
attestation what a pool gives instead of an authorization, produced by proving its program ran
step one move inside a challenge answer, consuming some notes and creating others
challenge answer the full accounting of a challenged transfer, as a list of steps
challenge window how long a posted transfer may be challenged
response window how long an answer may arrive after that

The problem

A channel note splits two rights that a normal note bundles together.

normal note        channel note
-----------        ------------
ownership   ---->  the channel
staking key ---->  the depositor

The depositor keeps the ZkPublicKey, but it only lets them create a Proof of Leadership and earn its reward. It gives no claim on the value.

The two operations behave very differently.

CHANNEL_WITHDRAW    the note keeps its NoteId, value and key. It
                    leaves the channel still owned by the key holder.

CHANNEL_TRANSFER    the note is consumed and a new one is created,
                    under any key the sequencers choose.

A withdrawal alone pays the key holder, so theft requires a CHANNEL_TRANSFER first (today's operation, which this proposal removes). That is the operation to protect. And the real security level of a channel is min(transfer_threshold, configuration_threshold), because a group reaching the configuration_threshold can rewrite the key list and lower the transfer_threshold at will.

Ethereum rollups have a similar committee power, and what protects their users is a delay before an upgrade applies, during which users exit. That delay only works because the user can prove what they own, can reach the L1 without the sequencer, and the L1 can check the exit. We have the second, because anyone can post to Mantle, but there is no operation to post. The first and the third are missing.

Cosmos bounds the damage instead, letting a zone spend no more than it holds, and falls back on social consensus. Its whitepaper does sketch a Total Accountability of Bridge Zones, with collateral, delayed transfers and auditors, but leaves the design open. What follows is close to that sketch, scoped to notes.

The idea, with user notes only

Every channel note already carries a ZkPublicKey. Today it only means "this key may stake the note". We give it back the meaning it has on a normal note: this key authorizes moving the note.

A user sending a transaction to the zone now also produces an authorization. It is not a zone object. It is a statement about their L1 note, saying which note may be consumed and what must come out of it.

auth_msg = zkhash("CHANNEL_NOTE_AUTH_V1", channel, inputs, outputs)
auth     = ZkSignature(keys of the input notes, auth_msg)

It cannot be replayed, because a NoteId is consumed only once. It does not sign the mantle_txhash either. The user cannot know it, as the sequencer builds one transfer out of many users' authorizations. That is a departure from the rule that every proof is bound to its mantle_txhash, so the spec needs an explicit carve-out: an authorization is payload data, not an operation proof.