feat: admin changes and rotations take turns (admin-change-rotation, Phases 3 and 4)

A change that moves who holds a share -- any change of admins, or the
removal of a holder -- is refused while a rotation is under way, until
its key state is signed, and so are offers and step-down requests. A
step-down request or an accepted offer that arrives meanwhile waits and
is taken up on the next pass. A removal whose owed rotation would fail
the majority rule is refused before anyone signs (A12). The member rows
list the rotation as the reason, with whom it waits on.

rotateAway no longer takes a running rotation that still deals to the
removed member for the one it owes, which left them a live share and
said nothing.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Kgothatso NgakoandClaude Opus 5.5 committed 2026-11-20 10:55:19 +02:00
1 parent 521135c85c
commit c7d46258eb
15 files changed
+316 -18

No files matched your search

@@ -581,6 +581,10 @@
<string name="member_action_change_pending_body">A relay hasn't accepted the last change to this group yet. This clears by itself.</string>
<string name="member_action_offer_pending_title">%1$s has already been asked</string>
<string name="member_action_offer_pending_body">They've been offered admin and haven't answered yet.</string>
<string name="member_action_rotation_pending_title">The group's shares are being rotated</string>
<string name="member_action_rotation_pending_body">Admins can change once the group has signed the new shares. This clears by itself.</string>
<string name="member_action_rotation_pending_waiting_body">Waiting on %1$s. Admins can change once the group has signed the new shares.</string>
<string name="see_the_rotation">See the rotation</string>
<string name="also_in_the_way">Also in the way</string>
<string name="you_can_do_this_now">You can do this now</string>
<string name="you_can_do_this_now_body">Nothing stands in the way any more. Go back to the group to do it.</string>
@@ -35,6 +35,10 @@ abstract class ShareRefreshDao {
@Query("SELECT * FROM ShareRefreshSession WHERE userPublicKey = :userPublicKey AND stage NOT IN ('COMPLETE', 'FAILED') ORDER BY createdAt ASC")
abstract suspend fun getRunningSessionsFor(userPublicKey: HexKey): List<ShareRefreshSession>
/** How many refreshes are running on this device: what an admin change waits on. */
@Query("SELECT COUNT(*) FROM ShareRefreshSession WHERE stage NOT IN ('COMPLETE', 'FAILED')")
abstract fun observeRunningCount(): Flow<Int>
@Query("SELECT * FROM ShareRefreshSession WHERE chatRoomId = :chatRoomId ORDER BY createdAt DESC")
abstract fun observeSessionsForRoom(chatRoomId: String): Flow<List<ShareRefreshSession>>
@@ -62,6 +62,7 @@ import mobi.giza.compose.managers.ShareRefreshManager
import mobi.giza.compose.ui.view.state.GovernanceStatus
import mobi.giza.compose.ui.view.state.MemberActionOption
import mobi.giza.compose.managers.RotationHold
import mobi.giza.compose.ui.view.state.MemberActionBlocker
import mobi.giza.compose.ui.view.state.SharesSummary
import mobi.giza.compose.ui.view.state.RotationPreview
import mobi.giza.compose.database.model.types.ShareStanding
@@ -753,12 +754,33 @@ class DatabaseChatRepository(
changePending = engine.groupFor(localChatRoom.routingId) != null &&
!engine.gate.canPrepareLocalCommit(localChatRoom.routingId),
offeredAdmin = if (context.isKeyed) PromotionManager.unansweredOfferTargets(database, chatRoom.id) else emptySet(),
)
).let { if (it.isKeyed) withShares(localChatRoom, it) else it }
}
}
return MemberActionPolicy.options(context, rows)
}
/**
* [context] with what the room's shares say about its member rows: a rotation
* still under way, and whom it waits on, and who holds a live share.
* docs/admin-change-rotation.md, Phase 3.
*/
private suspend fun withShares(localChatRoom: LocalChatRoom, context: MemberActionContext): MemberActionContext {
val key = AdminGovernance.keyOf(database, localChatRoom.chatRoom.id) ?: return context
val holders = ShareGenerations.active(database, key).roster
.filter { it.standing == ShareStanding.LIVE }
.map { it.memberPublicKey }
.toSet()
val pending = AdminGovernance.adminChangeHold(database, localChatRoom)?.let { hold ->
val waitingOn = (hold as? RotationHold.Running)
?.let { database.shareRefreshDao().getSessionById(it.refreshId) }
?.let { ShareRefreshManager.progress(database, it)?.waitingOn }
.orEmpty()
MemberActionBlocker.RotationPending(waitingOn.toSet())
}
return context.copy(rotationPending = pending, shareHolders = holders)
}
override suspend fun promoteMember(localChatRoom: LocalChatRoom, memberPublicKey: HexKey) {
database.marmotOutboundDao().promote(localChatRoom, memberPublicKey)
}
@@ -145,11 +145,55 @@ object AdminGovernance {
return ShareRefreshManager.rotationPending(database, localChatRoom, key)
}
/** What a change waits on while the room's shares are being rotated. */
const val ROTATION_PENDING_REFUSAL = "The group's shares are still being rotated. Admins can change once the group has signed the new shares"
/**
* Whether [change] moves who holds a share of the room's key: it changes the
* admins -- every admin holds a share (R1), so a promotion enrolls one and a
* demotion rotates one away -- or removes a member who holds one of
* [holders]. Inviting or removing anyone else leaves the roster alone, and
* does not wait on a rotation (docs/admin-change-rotation.md, A6).
*/
fun touchesShares(change: mobi.giza.compose.nostr.frost.GovernanceChange, holders: Set<HexKey>): Boolean =
change.admins != null || change.removes.any { it in holders }
/**
* Why [change] must not be proposed in [localChatRoom] now, as far as the
* room's shares go, or null (docs/admin-change-rotation.md, Phase 3): a
* change that moves who holds a share waits while a rotation is pending
* ([adminChangeHold]), and one that takes a holder's share away is refused
* when the rotation it owes could not run (A12) -- before anybody signs it,
* since a change that lands with a rotation nobody can run leaves a
* non-admin holding a live share.
*/
suspend fun sharesRefusal(
database: GizaDatabase,
localChatRoom: mobi.giza.compose.database.model.intermdiate.LocalChatRoom,
change: mobi.giza.compose.nostr.frost.GovernanceChange,
currentAdmins: Set<HexKey>,
): String? {
val key = keyOf(database, localChatRoom.chatRoom.id) ?: return null
val shares = ShareGenerations.active(database, key)
val holders = shares.roster.filter { it.standing == mobi.giza.compose.database.model.types.ShareStanding.LIVE }.map { it.memberPublicKey }.toSet()
if (!touchesShares(change, holders)) return null
if (adminChangeHold(database, localChatRoom) != null) return ROTATION_PENDING_REFUSAL
val adminsAfter = (change.admins ?: currentAdmins) - change.removes
val missing = RoomAdmins.of(database, localChatRoom.chatRoom.id)?.missingFounders.orEmpty()
val retire = holders - adminsAfter - missing
// Only a change that itself takes a share away owes a rotation.
if (retire.none { it in change.removes || it in currentAdmins }) return null
return ShareRefreshManager.owedRotationRefusal(key, shares, retire)?.let {
"This would owe a rotation of the shares the group can't run: $it. Rotate the shares, or bring stale members back, first"
}
}
/**
* The key [chatRoomId] signs with, as this device holds it -- whether or not it
* can sign with it now: a member withheld from a rotation still follows it.
*/
private suspend fun keyOf(database: GizaDatabase, chatRoomId: String): mobi.giza.compose.database.model.DkgSession? =
suspend fun keyOf(database: GizaDatabase, chatRoomId: String): mobi.giza.compose.database.model.DkgSession? =
GroupKeyStateManager.keyStateFor(database, chatRoomId)?.dkgSessionId
?.let { database.dkgSessionDao().getSessionById(it) }
?.takeIf { it.stage == DkgRitualStage.COMPLETE }
@@ -18,6 +18,7 @@ import mobi.giza.compose.database.GizaDatabase
import mobi.giza.compose.database.model.ChatMessage
import mobi.giza.compose.database.model.GovernanceProposal
import mobi.giza.compose.database.model.GovernanceProposalStage
import mobi.giza.compose.database.model.types.ShareStanding
/**
* What a governed room's signed changes need after they land, taken by the device
@@ -39,7 +40,9 @@ object GovernanceFollowThrough {
database.governanceProposalDao().observeAll(),
database.marmotInnerEventDao().observeCountByKinds(listOf(PromotionEvents.OFFER, PromotionEvents.ACCEPT, PromotionEvents.HANDOVER, PromotionEvents.STEP_DOWN)),
database.groupSignedEventDao().observeByKind(GroupKeyStateEvent.KIND),
) { _, _, _ -> Unit }
// A rotation abandoned or failed releases what waited on it, with no key state filed.
database.shareRefreshDao().observeRunningCount(),
) { _, _, _, _ -> Unit }
.conflate()
.collect {
try {
@@ -64,6 +67,9 @@ object GovernanceFollowThrough {
PromotionManager.acceptedOffers(database, me).forEach { (offer, acceptance) ->
if (offer.id in failedOffers) return@forEach
val room = database.chatRoomDao().findChatRoomById(offer.chatRoomId) ?: return@forEach
// Waits while the shares are being rotated, rather than failing
// (docs/admin-change-rotation.md, A7): proposed on the pass after.
if (AdminGovernance.adminChangeHold(database, room) != null) return@forEach
runCatching { PromotionManager.propose(database, room, me, offer, acceptance) }.onFailure {
if (it is CancellationException) throw it
failedOffers += offer.id
@@ -129,7 +135,18 @@ object GovernanceFollowThrough {
val room = database.chatRoomDao().findChatRoomById(proposal.chatRoomId) ?: return
val me = keyPair.pubKey.toHexKey()
val privateKey = keyPair.privKey ?: return
val failure = runCatching { ShareRefreshManager.proposeWithout(database, room, me, privateKey, member) }.exceptionOrNull()
val failure = runCatching {
val rotation = ShareRefreshManager.proposeWithout(database, room, me, privateKey, member)
// A rotation already running is handed back. If it was proposed before
// the change and deals to the member, it is not the one owed: it would
// leave them a live share of the next generation
// (docs/admin-change-rotation.md, H1).
val id = ShareGenerations.at(database, database.dkgSessionDao().getSessionById(rotation.dkgSessionId)!!, rotation.baseGeneration)
?.signerIds?.get(member)
check(id == null || rotation.withheldStandings()[id] == ShareStanding.RETIRED) {
"a rotation that still deals to them was already running"
}
}.exceptionOrNull()
if (failure is CancellationException) throw failure
database.governanceProposalDao().upsert(proposal.copy(stage = GovernanceProposalStage.DONE, updatedAt = Clock.System.now()))
if (failure != null) {
@@ -125,6 +125,10 @@ object GovernanceManager {
val remaining = admins - prepared.change.removes
check(remaining.size >= floor) { "A group with a shared key needs at least $floor admins. Make someone else an admin first" }
}
// Admin changes and rotations take turns, and a change that owes a rotation
// has to owe one the group can run. docs/admin-change-rotation.md, Phase 3.
AdminGovernance.sharesRefusal(database, localChatRoom, prepared.change, live.currentAdminIdentitiesSet())
?.let { throw IllegalStateException(it) }
// The statement leads; anything signed with it -- a promotion's key state --
// is one decision by one quorum, so it is one batch.
@@ -46,6 +46,14 @@ data class MemberActionContext(
val changePending: Boolean = false,
/** Members this account has offered admin and who have not answered. */
val offeredAdmin: Set<HexKey> = emptySet(),
/**
* A rotation of the room's key still under way, which every change to who holds
* a share waits on, with whom it waits on; null when none is.
* docs/admin-change-rotation.md, Phase 3.
*/
val rotationPending: MemberActionBlocker.RotationPending? = null,
/** Who holds a live share of the room's key: their removal waits on a rotation too. */
val shareHolders: Set<HexKey> = emptySet(),
)
/**
@@ -84,6 +92,7 @@ object MemberActionPolicy {
// proposes, because a rotation's proposer has to keep a share. So the
// room's rules, the floor, and another admin with a leaf to ask.
context.governed && context.shareRefresh &&
context.rotationPending == null &&
me in context.admins &&
keepsFloor(context, me) &&
context.admins.any { it != me && it in context.members }
@@ -121,20 +130,22 @@ object MemberActionPolicy {
else -> null
}
val pending = listOfNotNull(MemberActionBlocker.ChangePending.takeIf { context.changePending })
// Every role change moves a share (R1); a removal does only for a holder (A6).
val rotating = listOfNotNull(context.rotationPending)
val role = if (isAdmin) {
room + actor + keyed + listOfNotNull(floor) + pending
room + actor + keyed + listOfNotNull(floor) + pending + rotating
} else {
room + actor + keyed + listOfNotNull(
MemberActionBlocker.NotInGroupYet.takeUnless { inGroup },
) + pending + listOfNotNull(
) + pending + rotating + listOfNotNull(
MemberActionBlocker.OfferPending.takeIf { member in context.offeredAdmin },
)
}
val removal = room + actor + listOfNotNull(
MemberActionBlocker.NotInGroupYet.takeUnless { inGroup },
floor,
) + pending
) + pending + rotating.takeIf { member in context.shareHolders }.orEmpty()
return listOf(MemberActionOption(roleAction, role), MemberActionOption(MemberAction.REMOVE_FROM_GROUP, removal))
}
@@ -125,6 +125,8 @@ object PromotionManager {
check(me in group.currentAdminIdentities()) { "Only an admin can make someone else one" }
require(target in AdminGovernance.members(group)) { "They are not in the group any more" }
if (target in group.currentAdminIdentities()) return ""
// An offer the group cannot act on until a rotation ends only asks them to wait.
check(AdminGovernance.adminChangeHold(database, localChatRoom) == null) { AdminGovernance.ROTATION_PENDING_REFUSAL }
val key = FrostSigningManager.completedKey(database, localChatRoom.chatRoom.id)
?: throw IllegalStateException("This device holds no share of the group's key")
check(ShareGenerations.active(database, key).generation >= 1) {
@@ -194,6 +196,7 @@ object PromotionManager {
?: throw MarmotMissingChatGroupException("No live group for ${localChatRoom.chatRoom.id}")
check(me in group.currentAdminIdentities()) { "You're not an admin of this group" }
check(AdminGovernance.stepDownProposer(group, me) != null) { "You're the only admin. Make someone else an admin first" }
check(AdminGovernance.adminChangeHold(database, localChatRoom) == null) { AdminGovernance.ROTATION_PENDING_REFUSAL }
val id = send(database, localChatRoom.chatRoom.id, me, PromotionEvents.STEP_DOWN, "", PromotionEvents.stepDownTags(localChatRoom.chatRoom.id))
announce(database, localChatRoom.chatRoom.id, me, ChatMessage.TYPE_ADMIN_OFFERED, "You asked to step down as admin. The group signs it next")
return id
@@ -224,6 +227,9 @@ object PromotionManager {
return@forEach
}
if (room.chatRoom.userPublicKey != me || AdminGovernance.stepDownProposer(group, requester) != me) return@forEach
// Kept, not used up, while the room's shares are being rotated: taken up by
// the first pass after the group signs the new ones (docs/admin-change-rotation.md, A7).
if (AdminGovernance.adminChangeHold(database, room) != null) return@forEach
val failure = runCatching { database.marmotOutboundDao().demote(room, requester) }.exceptionOrNull()
if (failure is kotlinx.coroutines.CancellationException) throw failure
@@ -143,6 +143,22 @@ object ShareRefreshManager {
private data class Plan(val recipients: List<Int>, val withheld: Map<Int, ShareStanding>, val refusal: String?)
/**
* Why the rotation a change would owe could not run, or null when it could
* (docs/admin-change-rotation.md, A12): every live holder of [shares] in
* [retire] withheld for good, every stale one withheld again, and the rest
* dealt to -- checked by the same [refusal] the rotation itself will meet. The
* admin floor counts admins; this counts recipients against every id not yet
* retired, so a share left live by an abandoned rotation makes the two differ.
*/
fun owedRotationRefusal(key: DkgSession, shares: ShareGenerations.Shares, retire: Set<HexKey>): String? {
val withheld = shares.roster
.filter { it.standing == ShareStanding.LIVE && it.memberPublicKey in retire }
.associate { it.participantId to ShareStanding.RETIRED }
val plan = plan(key, shares, userPublicKey = "", withheld)
return refusal(key, shares, plan.recipients, plan.withheld)
}
/** A refresh as it would be proposed, by member rather than by id. */
data class Preview(
val takingPart: List<HexKey>,
@@ -17,6 +17,7 @@ import androidx.compose.material.icons.filled.Key
import androidx.compose.material.icons.filled.Lock
import androidx.compose.material.icons.filled.Person
import androidx.compose.material.icons.filled.Schedule
import androidx.compose.material.icons.filled.Sync
import androidx.compose.material3.Button
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
@@ -68,6 +69,10 @@ import mobi.giza.compose.resources.step_down_as_admin
import mobi.giza.compose.resources.this_no_longer_applies
import mobi.giza.compose.resources.you_can_do_this_now
import mobi.giza.compose.resources.you_can_do_this_now_body
import mobi.giza.compose.resources.member_action_rotation_pending_title
import mobi.giza.compose.resources.member_action_rotation_pending_body
import mobi.giza.compose.resources.member_action_rotation_pending_waiting_body
import mobi.giza.compose.resources.see_the_rotation
import mobi.giza.compose.repository.ChatRepository
import mobi.giza.compose.repository.NostrRepository
import mobi.giza.compose.ui.composable.navigation.routes.ChatRoomDetailRoute
@@ -187,6 +192,14 @@ fun MemberActionUnavailableScreen(
}
}
// The rotation is on the group's screen, under Shares, with Abandon
// for one that has stalled (docs/admin-change-rotation.md, A10).
if (lead is MemberActionBlocker.RotationPending) {
Button(onClick = onNavigateBack) {
Text(stringResource(Res.string.see_the_rotation))
}
}
val rest = state.blockers.drop(1)
if (rest.isNotEmpty()) {
Column(verticalArrangement = Arrangement.spacedBy(MaterialTheme.spacing.itemGap)) {
@@ -270,6 +283,7 @@ private fun MemberActionBlocker.icon(): ImageVector = when (this) {
is MemberActionBlocker.BelowFloor -> Icons.Default.AdminPanelSettings
MemberActionBlocker.ChangePending,
MemberActionBlocker.OfferPending -> Icons.Default.Schedule
is MemberActionBlocker.RotationPending -> Icons.Default.Sync
}
@Composable
@@ -286,6 +300,7 @@ private fun MemberActionBlocker.title(memberName: String): String = when (this)
is MemberActionBlocker.BelowFloor -> stringResource(Res.string.member_action_below_floor_title, floor.toString())
MemberActionBlocker.ChangePending -> stringResource(Res.string.member_action_change_pending_title)
MemberActionBlocker.OfferPending -> stringResource(Res.string.member_action_offer_pending_title, memberName)
is MemberActionBlocker.RotationPending -> stringResource(Res.string.member_action_rotation_pending_title)
}
@Composable
@@ -302,6 +317,9 @@ private fun MemberActionBlocker.body(names: Map<HexKey, String>): String = when
is MemberActionBlocker.BelowFloor -> stringResource(Res.string.member_action_below_floor_body)
MemberActionBlocker.ChangePending -> stringResource(Res.string.member_action_change_pending_body)
MemberActionBlocker.OfferPending -> stringResource(Res.string.member_action_offer_pending_body)
is MemberActionBlocker.RotationPending ->
if (waitingOn.isEmpty()) stringResource(Res.string.member_action_rotation_pending_body)
else stringResource(Res.string.member_action_rotation_pending_waiting_body, waitingOn.namedBy(names))
}
/** The menu's word for [this], which is also this screen's title. */
@@ -77,6 +77,7 @@ class MemberActionUnavailableViewModel(
val named = option.blockers.flatMap { blocker ->
when (blocker) {
is MemberActionBlocker.NotAnAdmin -> blocker.admins
is MemberActionBlocker.RotationPending -> blocker.waitingOn
else -> emptySet()
}
}.toSet()
@@ -74,6 +74,13 @@ sealed interface MemberActionBlocker {
/** The member has already been offered admin, and has not answered. */
data object OfferPending : MemberActionBlocker
/**
* The group's shares are being rotated, until the group signs the new ones;
* a change to who holds a share waits for that (docs/admin-change-rotation.md,
* Phase 3). [waitingOn]: whom the rotation is waiting on, when it is still dealing.
*/
data class RotationPending(val waitingOn: Set<HexKey> = emptySet()) : MemberActionBlocker
}
/**
@@ -191,4 +191,27 @@ class MemberActionPolicyTest {
context.blockers(bob, MemberAction.REMOVE_FROM_GROUP),
)
}
// docs/admin-change-rotation.md, Phase 3
@Test
fun `a rotation under way holds every change of role, and the removal of a share holder only`() {
val rotating = MemberActionBlocker.RotationPending(waitingOn = setOf(carol))
val context = keyed(
admins = setOf(me, bob, carol, dana),
members = setOf(me, bob, carol, dana, gone),
).copy(rotationPending = rotating, shareHolders = setOf(me, bob, carol, dana))
assertEquals(listOf(rotating), context.blockers(bob, MemberAction.REMOVE_AS_ADMIN))
assertEquals(listOf(rotating), context.blockers(bob, MemberAction.REMOVE_FROM_GROUP))
assertEquals(listOf(rotating), context.blockers(gone, MemberAction.MAKE_ADMIN))
// Someone with no share leaves the roster alone: their removal does not wait.
assertTrue(context.blockers(gone, MemberAction.REMOVE_FROM_GROUP).isEmpty())
// Your own row lists nothing it cannot do.
assertNull(MemberActionPolicy.options(context, listOf(me))[me])
val settled = context.copy(rotationPending = null)
assertTrue(settled.blockers(bob, MemberAction.REMOVE_AS_ADMIN).isEmpty())
assertTrue(settled.option(me, MemberAction.STEP_DOWN)!!.isAvailable)
}
}
@@ -619,20 +619,78 @@ class GovernanceGateJvmTest {
}
}
/** Pinned before Phase 3 (H5): a step-down request taken up while a rotation runs is used up, whatever it meets. */
/** H5: a step-down request that arrives during a rotation waits for it, and is taken up after. */
@Test
fun `pinned -- a step-down request taken up during a rotation is used up`() = runBlocking {
fun `a step-down request waits through a rotation and is taken up once it ends`() = runBlocking {
governedRoom()
appIsAdmin()
roomKeyHeldBy(listOf(dana.hex, userHex))
rotationRunning()
val rotation = rotationRunning()
mobi.giza.compose.ExperimentalFeatures.shareRefreshOverride = true
try {
danaSays(PromotionEvents.STEP_DOWN, "", PromotionEvents.stepDownTags(roomId))
assertEquals(0, PromotionManager.followStepDowns(db, userHex))
assertEquals(1, db.marmotInnerEventDao().getByChatRoomAndKinds(roomId, listOf(PromotionEvents.STEP_DOWN)).size, "the request was used up")
assertTrue(lines(ChatMessage.TYPE_CHANGE_NOT_APPLIED).isEmpty())
// The rotation ends; the next pass takes the request up. This room is at its
// floor, so the demotion is refused there, out loud, and the request is used.
db.shareRefreshDao().upsert(rotation.copy(stage = mobi.giza.compose.database.model.types.ShareRefreshStage.FAILED))
PromotionManager.followStepDowns(db, userHex)
assertTrue(db.marmotInnerEventDao().getByChatRoomAndKinds(roomId, listOf(PromotionEvents.STEP_DOWN)).isEmpty(), "the request was kept")
assertTrue(db.marmotInnerEventDao().getByChatRoomAndKinds(roomId, listOf(PromotionEvents.STEP_DOWN)).isEmpty())
assertTrue(lines(ChatMessage.TYPE_CHANGE_NOT_APPLIED).any { "as they asked" in it.content })
} finally {
mobi.giza.compose.ExperimentalFeatures.shareRefreshOverride = null
}
}
/** H1, from the admin side: a demotion is not proposed while the shares are being rotated. */
@Test
fun `a demotion proposed while the shares are being rotated is refused, and nothing is signed`() = runBlocking {
governedRoom()
appIsAdmin()
roomKeyHeldBy(listOf(dana.hex, userHex))
rotationRunning()
val refused = assertFailsWith<IllegalStateException> {
GovernanceManager.propose(db, room(), userHex, thenRotateWithout = dana.hex, propose = ::demoteDana)
}
assertEquals(AdminGovernance.ROTATION_PENDING_REFUSAL, refused.message)
assertTrue(db.governanceProposalDao().getAll().isEmpty())
assertTrue(db.frostSigningSessionDao().getSessionsForChatRoom(roomId).isEmpty(), "a signature was asked for")
}
@Test
fun `nobody is offered admin, and nobody asks to step down, while the shares are being rotated`() = runBlocking {
governedRoom()
appIsAdmin()
erinAddedSigned()
roomKeyHeldBy(listOf(dana.hex, userHex))
rotationRunning()
mobi.giza.compose.ExperimentalFeatures.shareRefreshOverride = true
try {
assertEquals(AdminGovernance.ROTATION_PENDING_REFUSAL, assertFailsWith<IllegalStateException> { PromotionManager.offer(db, room(), userHex, erin.hex) }.message)
assertEquals(AdminGovernance.ROTATION_PENDING_REFUSAL, assertFailsWith<IllegalStateException> { PromotionManager.requestStepDown(db, room(), userHex) }.message)
assertTrue(db.marmotInnerEventDao().getByChatRoomAndKinds(roomId, listOf(PromotionEvents.OFFER, PromotionEvents.STEP_DOWN)).isEmpty())
// The member rows say why, with the share holders' removal held and nobody else's.
val options = chatRepository.memberActionOptions(room())
val rotating = options.getValue(dana.hex).first { it.action == mobi.giza.compose.ui.view.state.MemberAction.REMOVE_AS_ADMIN }.blockers
assertTrue(rotating.any { it is mobi.giza.compose.ui.view.state.MemberActionBlocker.RotationPending }, rotating.toString())
val erinRemoval = options.getValue(erin.hex).first { it.action == mobi.giza.compose.ui.view.state.MemberAction.REMOVE_FROM_GROUP }.blockers
assertTrue(erinRemoval.none { it is mobi.giza.compose.ui.view.state.MemberActionBlocker.RotationPending }, erinRemoval.toString())
} finally {
mobi.giza.compose.ExperimentalFeatures.shareRefreshOverride = null
}
}
/** A6: only a change that moves who holds a share waits on a rotation. */
@Test
fun `inviting or removing a member with no share does not touch the shares`() {
val holders = setOf(dana.hex, userHex)
assertFalse(AdminGovernance.touchesShares(GovernanceChange(removes = setOf(erin.hex)), holders))
assertFalse(AdminGovernance.touchesShares(GovernanceChange(adds = setOf(mobi.giza.compose.nostr.frost.AddedMember(erin.hex, "r"))), holders))
assertTrue(AdminGovernance.touchesShares(GovernanceChange(removes = setOf(dana.hex)), holders))
assertTrue(AdminGovernance.touchesShares(GovernanceChange(admins = setOf(userHex)), holders))
}
}
@@ -1514,12 +1514,14 @@ class ShareRefreshRitualJvmTest {
}
/**
* H1: a removal that lands while a rotation runs. The rotation it owes is handed
* the running one back -- which was proposed before the removal, deals to the
* removed member, and leaves them a live share of the new generation.
* H1: a removal that lands while a rotation runs is handed the running one, which
* was proposed before the removal and deals to the removed member. The freeze
* keeps that removal from being proposed (Phase 3); if one lands anyway, the
* rotation it owes is not marked done as if the running one were it.
*/
@Test
fun `pinned -- a removal during a rotation leaves the removed member a live share`() = runBlocking<Unit> {
fun `a removal's rotation is not taken for one already running that deals to them`() = runBlocking<Unit> {
mobi.giza.compose.ExperimentalFeatures.shareRefreshOverride = true
val group = Group(4, 2)
val all = devicesFor(group)
val (alice, _, _, dave) = all
@@ -1528,10 +1530,19 @@ class ShareRefreshRitualJvmTest {
val owed = ShareRefreshManager.proposeWithout(alice.db, alice.room, alice.publicKey, alice.privateKey, dave.publicKey)
assertEquals(running.id, owed.id, "the owed rotation was handed the running one")
approveAll(all, running.id)
assertEquals(1, alice.active().generation)
assertEquals(ShareStanding.LIVE, alice.active().roster.single { it.memberPublicKey == dave.publicKey }.standing)
val proposal = mobi.giza.compose.database.model.GovernanceProposal(
id = "d".repeat(64), chatRoomId = group.roomId, routingId = group.roomId, epoch = 1, frostSigningSessionId = "s",
commitEventId = "e".repeat(64), commitEventJson = "{}", priorStateHex = "", pendingStateHex = "",
stage = mobi.giza.compose.database.model.GovernanceProposalStage.APPLIED, thenRotateWithout = dave.publicKey,
)
alice.db.governanceProposalDao().upsert(proposal)
GovernanceFollowThrough.pass(alice.db, alice.keyPair)
assertEquals(mobi.giza.compose.database.model.GovernanceProposalStage.DONE, alice.db.governanceProposalDao().getById(proposal.id)!!.stage)
val said = alice.db.chatMessageDao().getChatMessagesByChatRoomId(group.roomId).map { it.chatMessage }
.filter { it.messageType == ChatMessage.TYPE_CHANGE_NOT_APPLIED }
assertTrue(said.any { "still deals to them" in it.content }, said.map { it.content }.toString())
}
/**
@@ -1689,6 +1700,58 @@ class ShareRefreshRitualJvmTest {
assertNull(AdminGovernance.adminChangeHold(alice.db, alice.room))
}
// ---- docs/admin-change-rotation.md, Phases 3 and 4 ---------------------------------------------------------------
/** H3: the rotation waits out a new admin's enrollment, and then deals to them. */
@Test
fun `a rotation after an enrollment deals to the new admin`() = runBlocking<Unit> {
mobi.giza.compose.ExperimentalFeatures.shareRefreshOverride = true
val (_, all) = rotatedOnce()
val alice = all[0]
val erinKeys = KeyPair()
val erin = stranger(alice.group, erinKeys)
bindNextId(all, erin.publicKey, ChillDkgRitualManager.deriveHostPublicKey(erinKeys.privKey!!).value.toHex())
assertFailsWith<IllegalStateException> { propose(alice) }
PromotionManager.takeHandover(erin.db, erin.room, erin.publicKey, erin.privateKey, handoverFrom(alice, erin.publicKey))
val everyone = all + erin
pump(everyone)
val refresh = propose(alice)
assertTrue(3 in refresh.recipientIdList(), "the new admin was left out")
pump(everyone)
approveAll(everyone, refresh.id)
everyone.forEach { device -> assertEquals(2, device.active().generation, "device ${device.index}") }
assertNotNull(erin.active().secretShare, "the new admin holds no share of the new generation")
}
/**
* A12: the admin floor counts admins, a rotation counts recipients against every
* id not yet retired. With one member stale and another's share left live by an
* abandoned rotation, retiring a third would leave no majority.
*/
@Test
fun `a removal is refused when the rotation it owes could not run`() = runBlocking<Unit> {
val group = Group(6, 3)
val all = devicesFor(group)
val carol = all[2]
val first = propose(all[0], mapOf(group.idOf[carol.index] to ShareStanding.STALE))
pump(all)
approveAll(all, first.id)
pump(all)
val alice = all[0]
val shares = alice.active()
assertEquals(1, shares.generation)
val (eve, dave) = all[4] to all[3]
// Eve's share was left live when her rotation was abandoned; Dave is being removed.
val refused = ShareRefreshManager.owedRotationRefusal(alice.key(), shares, retire = setOf(eve.publicKey, dave.publicKey))
assertNotNull(refused)
assertTrue("majority" in refused, refused)
// Dave alone would be fine.
assertNull(ShareRefreshManager.owedRotationRefusal(alice.key(), shares, retire = setOf(dave.publicKey)))
}
// ---- Phase 12: restore ---------------------------------------------------------------------------------------
/**