ideas:

• Do exactly the same as what we planned for Native zone but replace each indiviual zk proofs by the signature of the sequencer on the batch of transfers.
• Prove the balance of the share of the ledger to enable participation in PoS
• Use directly Groth16 with 3 different circuits (small, medium and large) that compute how much value was created and how much was removed between two merkle root representing the state of the shard of the Ledger.
• The proof is verified by L1 to update the state root of the channel (representing the notes). The Ledger only guarantees one thing: there is the same amount of value as in the bridge (only supports LGO for now).
• The proof only show the amount of the bridge (destroyed and created at every update).
• When updated the L1 can check that it match the amount deposited in the bridge by checking that previous_amount + value_created - value_destroyed == actual_amount_in_the_bridge. It doesn’t guarantee anything else. So the users must trust the sequencer to organize the ledger correctly and they could use all the founds in PoS for themselves if they want.
• We can shape the operation to be valid only with a threshold of sequencer signature if we want
• PoL and code would need an update. Instead of a single root we would need to build a root of all the channel state and the L1 state ledger_aged and ledger_latest that’s not a big change but it’s still important to note it.
• PPoS would then prove you win the lotery without disclosing from where and the stake estimation is based only on PoL so the repartition of stake would be unknown.
• The shape of the sharded ledger is the same as the L1 Ledger. Sequencers can chose what’s there best way to organize their Ledger part. For LEZ it could be once every X block, update the Ledger such that LGO in private account are staked by the sequencers and LGO in public accounts are under the address of the owner and change if transfered.

Groth16 Circuit for proof of channel balance:

A proof attesting that given these public values:

class StateTransitionBalance:
	previous_root: zkhash # Merkle root of the channel ledger before the update
	new_root: zkhash # Merkle root of the channel ledger after the update
	value_added: TokenValue
	value_removed: TokenValue

The prover knows the following witness:

class StateTransitionBalanceWitness:
	previous_notes: list[Note]
	new_notes: list[Note]
	notes_merkle_path: list[list[zkhash]] # each path is the path against the 
							# root of the state after the update of all the previous notes
	notes_merkle_path_selectors: list[list[bool]]

such that the following constraints hold:

• Verify the update of the root and the membership of the previous notes

  for (previous_note, new_note, path, selectors) in 
  		zip(previous_notes, notes_merkle_path, notes_merkle_path_selectors):
  		assert previous_root == path_root(leaf=derive_note_id(0,0,previous_note),
  				path=path,
  				selectors=selectors)
  		previous_root = update_root(leaf=derive_note_id(0,0,new_note),
  				path=path,
  				selectors=selectors)
  # The new root is the previous root after all the updates
  assert new_root == previous_root
  		
  

• The proof ouput the balances

  added = 0
  removed = 0
  for note in previous_notes:
  		removed += note.value
  for note in new_notes:
  		added += note.value
  assert value_added == added
  assert value_removed == removed