diff --git a/composeApp/src/commonMain/composeResources/values/strings.xml b/composeApp/src/commonMain/composeResources/values/strings.xml index 12f1e60d..925f98f3 100644 --- a/composeApp/src/commonMain/composeResources/values/strings.xml +++ b/composeApp/src/commonMain/composeResources/values/strings.xml @@ -581,6 +581,10 @@ A relay hasn't accepted the last change to this group yet. This clears by itself. %1$s has already been asked They've been offered admin and haven't answered yet. + The group's shares are being rotated + Admins can change once the group has signed the new shares. This clears by itself. + Waiting on %1$s. Admins can change once the group has signed the new shares. + See the rotation Also in the way You can do this now Nothing stands in the way any more. Go back to the group to do it. diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/dao/ShareRefreshDao.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/dao/ShareRefreshDao.kt index bb4d1fee..f540657a 100644 --- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/dao/ShareRefreshDao.kt +++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/dao/ShareRefreshDao.kt @@ -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 + /** 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 + @Query("SELECT * FROM ShareRefreshSession WHERE chatRoomId = :chatRoomId ORDER BY createdAt DESC") abstract fun observeSessionsForRoom(chatRoomId: String): Flow> diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/repository/DatabaseChatRepository.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/repository/DatabaseChatRepository.kt index 883b5ce9..d910e73d 100644 --- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/repository/DatabaseChatRepository.kt +++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/repository/DatabaseChatRepository.kt @@ -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) } diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/AdminGovernance.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/AdminGovernance.kt index 0a4ecc68..62b6c25d 100644 --- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/AdminGovernance.kt +++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/AdminGovernance.kt @@ -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): 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, + ): 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 } diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/GovernanceFollowThrough.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/GovernanceFollowThrough.kt index f832f01f..1dc91853 100644 --- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/GovernanceFollowThrough.kt +++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/GovernanceFollowThrough.kt @@ -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) { diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/GovernanceManager.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/GovernanceManager.kt index 0fa0f5d8..556edf4d 100644 --- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/GovernanceManager.kt +++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/GovernanceManager.kt @@ -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. diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/MemberActionPolicy.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/MemberActionPolicy.kt index fab025b6..2b20daf1 100644 --- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/MemberActionPolicy.kt +++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/MemberActionPolicy.kt @@ -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 = 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 = 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)) } diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/PromotionManager.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/PromotionManager.kt index 91b3a6c0..3dc136af 100644 --- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/PromotionManager.kt +++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/PromotionManager.kt @@ -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 diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/ShareRefreshManager.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/ShareRefreshManager.kt index a5c78bd6..f82e67c2 100644 --- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/ShareRefreshManager.kt +++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/ShareRefreshManager.kt @@ -143,6 +143,22 @@ object ShareRefreshManager { private data class Plan(val recipients: List, val withheld: Map, 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): 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, diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/composable/MemberActionUnavailableScreen.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/composable/MemberActionUnavailableScreen.kt index fa192f97..8562b84c 100644 --- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/composable/MemberActionUnavailableScreen.kt +++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/composable/MemberActionUnavailableScreen.kt @@ -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): 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. */ diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/view/model/MemberActionUnavailableViewModel.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/view/model/MemberActionUnavailableViewModel.kt index 5fe0d886..b5b11b48 100644 --- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/view/model/MemberActionUnavailableViewModel.kt +++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/view/model/MemberActionUnavailableViewModel.kt @@ -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() diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/view/state/MemberAction.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/view/state/MemberAction.kt index f49dfe71..489708d5 100644 --- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/view/state/MemberAction.kt +++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/view/state/MemberAction.kt @@ -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 = emptySet()) : MemberActionBlocker } /** diff --git a/composeApp/src/commonTest/kotlin/mobi/giza/compose/managers/MemberActionPolicyTest.kt b/composeApp/src/commonTest/kotlin/mobi/giza/compose/managers/MemberActionPolicyTest.kt index e846203d..e7040436 100644 --- a/composeApp/src/commonTest/kotlin/mobi/giza/compose/managers/MemberActionPolicyTest.kt +++ b/composeApp/src/commonTest/kotlin/mobi/giza/compose/managers/MemberActionPolicyTest.kt @@ -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) + } } diff --git a/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/GovernanceGateJvmTest.kt b/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/GovernanceGateJvmTest.kt index 3629c3f2..c7a17a62 100644 --- a/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/GovernanceGateJvmTest.kt +++ b/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/GovernanceGateJvmTest.kt @@ -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 { + 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 { PromotionManager.offer(db, room(), userHex, erin.hex) }.message) + assertEquals(AdminGovernance.ROTATION_PENDING_REFUSAL, assertFailsWith { 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)) + } } diff --git a/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/ShareRefreshRitualJvmTest.kt b/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/ShareRefreshRitualJvmTest.kt index 1351d17b..df3a0364 100644 --- a/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/ShareRefreshRitualJvmTest.kt +++ b/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/ShareRefreshRitualJvmTest.kt @@ -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 { + fun `a removal's rotation is not taken for one already running that deals to them`() = runBlocking { + 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 { + 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 { 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 { + 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 --------------------------------------------------------------------------------------- /**