diff --git a/composeApp/src/commonMain/composeResources/values/strings.xml b/composeApp/src/commonMain/composeResources/values/strings.xml
index 65dc161c..bf1770b1 100644
--- a/composeApp/src/commonMain/composeResources/values/strings.xml
+++ b/composeApp/src/commonMain/composeResources/values/strings.xml
@@ -456,6 +456,9 @@
Re-issue every member's share without changing the group's key or this room.
Current share epoch: %1$s
Next share epoch: %1$s
+ Active share epoch: %1$s
+ Unchanged group key: %1$s
+ Share holders: %1$s
Refreshing does not erase old backups. If a threshold of old shares is compromised, make a new group key instead.
Every share holder must take part before the new shares can activate.
Commitments: %1$s of %2$s
diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/dao/ChatMessageDao.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/dao/ChatMessageDao.kt
index 32006323..4ffff0b8 100644
--- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/dao/ChatMessageDao.kt
+++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/dao/ChatMessageDao.kt
@@ -71,6 +71,12 @@ interface ChatMessageDao {
unresolvedTypes: Collection
): List
+ @Query(
+ "SELECT * FROM ChatMessage WHERE reEnrollmentSessionId = :sessionId " +
+ "AND messageType = :messageType AND senderPublicKey = :actor LIMIT 1"
+ )
+ suspend fun findReEnrollmentNotice(sessionId: String, messageType: String, actor: HexKey): ChatMessage?
+
@Upsert
suspend fun upsert(chatMessage: mobi.giza.compose.database.model.ChatMessage): Long
}
\ No newline at end of file
diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/model/ChatMessage.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/model/ChatMessage.kt
index bb2f5530..4cec6e2f 100644
--- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/model/ChatMessage.kt
+++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/model/ChatMessage.kt
@@ -334,6 +334,22 @@ data class ChatMessage(
val FROST_SETTLEMENTS = setOf(TYPE_FROST_COMPLETE, TYPE_FROST_FAILED)
/** Every signing line, for rendering them as system lines rather than bubbles. */
+ const val TYPE_REENROLLMENT_STARTED = "reEnrollmentStarted"
+ const val TYPE_REENROLLMENT_READY = "reEnrollmentReady"
+ const val TYPE_REENROLLMENT_ACTIVATING = "reEnrollmentActivating"
+ const val TYPE_REENROLLMENT_COMPLETE = "reEnrollmentComplete"
+ const val TYPE_REENROLLMENT_FAILED = "reEnrollmentFailed"
+
+ val REENROLLMENT_TYPES = setOf(
+ TYPE_REENROLLMENT_STARTED,
+ TYPE_REENROLLMENT_READY,
+ TYPE_REENROLLMENT_ACTIVATING,
+ TYPE_REENROLLMENT_COMPLETE,
+ TYPE_REENROLLMENT_FAILED,
+ )
+
+ val REENROLLMENT_AUTHORED_TYPES = setOf(TYPE_REENROLLMENT_STARTED, TYPE_REENROLLMENT_FAILED)
+
val FROST_TYPES = setOf(
TYPE_FROST_STARTED,
TYPE_FROST_NONCE,
diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/FrostReEnrollmentManager.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/FrostReEnrollmentManager.kt
index 5603cf0a..71aebce2 100644
--- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/FrostReEnrollmentManager.kt
+++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/FrostReEnrollmentManager.kt
@@ -20,11 +20,13 @@ import fr.acinq.bitcoin.crypto.frost.FrostRefresh
import fr.acinq.bitcoin.crypto.frost.RefreshCandidate
import fr.acinq.bitcoin.crypto.frost.RefreshDealerFault
import fr.acinq.bitcoin.utils.Either
+import fr.acinq.secp256k1.Secp256k1
import kotlin.time.Clock
import kotlin.time.Duration.Companion.minutes
import kotlin.time.Instant
import kotlinx.coroutines.CancellationException
import mobi.giza.compose.database.GizaDatabase
+import mobi.giza.compose.database.model.ChatMessage
import mobi.giza.compose.database.model.DkgSession
import mobi.giza.compose.database.model.FrostReEnrollmentMessage
import mobi.giza.compose.database.model.FrostReEnrollmentSession
@@ -80,7 +82,9 @@ object FrostReEnrollmentManager {
require(roomMembers.containsAll(participants)) { "Every share holder must be in the Marmot room" }
require(participants.size == key.participantCount) { "The share-holder roster does not match the ceremony" }
require(FrostSignerOrder.signerIdOf(database, key, userPublicKey) != null) { "This device is not a share holder" }
- require(key.publicShareList()?.size == key.participantCount) { "A complete public-share table is required" }
+ require(hasValidPublicShares(key)) {
+ "A validated current public-share table is required; repair it with current members before refreshing"
+ }
require(
database.frostSigningSessionDao().getSessionsForChatRoom(localChatRoom.chatRoom.id)
.none { it.dkgSessionId == key.id && it.stage != FrostSigningStage.COMPLETE && it.stage != FrostSigningStage.FAILED }
@@ -105,6 +109,7 @@ object FrostReEnrollmentManager {
joinApprovedAt = Clock.System.now(),
)
database.frostReEnrollmentDao().upsert(session)
+ announceStarted(database, session)
check(
broadcast(
database, localChatRoom, session, ReEnrollmentEvents.PROPOSAL, key.thresholdPublicKey.orEmpty(),
@@ -246,7 +251,9 @@ object FrostReEnrollmentManager {
sessionId: String,
) = database.frostReEnrollmentDao().getSessionById(sessionId)?.let { session ->
if (session.stage != ReEnrollmentStage.ACTIVATING) return@let null
- FrostSigningManager.proposeRefreshActivation(database, localChatRoom, userPublicKey, session)
+ val activation = FrostSigningManager.proposeRefreshActivation(database, localChatRoom, userPublicKey, session)
+ noteActivation(database, session)
+ activation
}
/** Validate and atomically apply a signed key-epoch state. */
@@ -264,7 +271,9 @@ object FrostReEnrollmentManager {
val candidateShares = session.candidatePublicShareList() ?: return null
val candidateSecret = session.candidateSecretShare ?: return null
val currentState = GroupKeyStateManager.keyStateFor(database, chatRoomId) ?: return null
- if (session.stage != ReEnrollmentStage.ACTIVATING) return null
+ if (session.stage != ReEnrollmentStage.ACTIVATING &&
+ !(session.stage == ReEnrollmentStage.FAILED && session.readyAt != null)
+ ) return null
if (key.shareEpoch != session.currentShareEpoch || currentState.shareEpoch != session.currentShareEpoch) return null
if (state.shareEpoch != session.nextShareEpoch || state.refreshSessionId != session.id) return null
if (state.refreshTranscriptHash != session.transcriptHash) return null
@@ -298,6 +307,10 @@ object FrostReEnrollmentManager {
)
database.frostReEnrollmentDao().scrubMessagesByKind(session.id, ReEnrollmentEvents.PRIVATE_EVALUATION)
database.marmotInnerEventDao().scrubContentByChatRoomAndKind(chatRoomId, ReEnrollmentEvents.PRIVATE_EVALUATION)
+ announce(
+ database, session, ChatMessage.TYPE_REENROLLMENT_COMPLETE,
+ "Share epoch ${session.nextShareEpoch} is active. The previous local share material was retired.",
+ )
}
}
return state
@@ -336,7 +349,7 @@ object FrostReEnrollmentManager {
if (nextEpoch != key.shareEpoch + 1 || threshold != key.threshold || members.size != key.participantCount) return null
if (!thresholdPublicKey.equals(key.thresholdPublicKey, ignoreCase = true)) return null
if (state.dkgSessionId != key.id || state.shareEpoch != key.shareEpoch || previousState.id != previousStateId) return null
- if (key.publicShareList()?.size != key.participantCount) return null
+ if (!hasValidPublicShares(key)) return null
val session = FrostReEnrollmentSession(
id = sessionId,
@@ -353,6 +366,7 @@ object FrostReEnrollmentManager {
dealerRandom = RandomInstance.bytes(32).toHex(),
)
database.frostReEnrollmentDao().upsert(session)
+ announceStarted(database, session)
replayStoredMessages(database, localChatRoom, session)
return session
}
@@ -508,7 +522,13 @@ object FrostReEnrollmentManager {
val ready = database.frostReEnrollmentDao().getMessagesByKind(session.id, ReEnrollmentEvents.READY)
if (ready.size < session.participantCount || ready.any { it.payload != session.transcriptHash }) return
- moveTo(database, session, ReEnrollmentStage.ACTIVATING)
+ val activating = moveTo(database, session, ReEnrollmentStage.ACTIVATING)
+ if (session.stage != ReEnrollmentStage.ACTIVATING && activating.stage == ReEnrollmentStage.ACTIVATING) {
+ announce(
+ database, session, ChatMessage.TYPE_REENROLLMENT_READY,
+ "All ${session.participantCount} members verified the same candidate for share epoch ${session.nextShareEpoch}.",
+ )
+ }
} catch (e: CancellationException) {
throw e
} catch (e: Throwable) {
@@ -521,6 +541,39 @@ object FrostReEnrollmentManager {
}
}
+ private suspend fun announceStarted(database: GizaDatabase, session: FrostReEnrollmentSession) = announce(
+ database, session, ChatMessage.TYPE_REENROLLMENT_STARTED,
+ "proposed refreshing every member's signing share without changing the group key.",
+ )
+
+ suspend fun noteActivation(database: GizaDatabase, session: FrostReEnrollmentSession) = announce(
+ database, session, ChatMessage.TYPE_REENROLLMENT_ACTIVATING,
+ "A quorum was asked to sign share epoch ${session.nextShareEpoch} into use.",
+ )
+
+ private suspend fun announce(
+ database: GizaDatabase,
+ session: FrostReEnrollmentSession,
+ messageType: String,
+ content: String,
+ actor: HexKey = session.coordinatorPublicKey,
+ ) {
+ if (database.chatMessageDao().findReEnrollmentNotice(session.id, messageType, actor) != null) return
+ database.chatMessageDao().upsert(
+ ChatMessage(
+ senderPublicKey = actor,
+ isUserMessage = actor == session.userPublicKey,
+ giftWrapPayloadId = null,
+ marmotGroupEventId = null,
+ marmotInnerEventId = null,
+ chatRoomId = session.chatRoomId,
+ content = content,
+ messageType = messageType,
+ reEnrollmentSessionId = session.id,
+ )
+ )
+ }
+
private suspend fun activeKey(database: GizaDatabase, session: FrostReEnrollmentSession): DkgSession =
database.dkgSessionDao().getSessionById(session.dkgSessionId)?.takeIf {
it.stage == DkgRitualStage.COMPLETE && it.shareEpoch == session.currentShareEpoch
@@ -571,6 +624,17 @@ object FrostReEnrollmentManager {
return Crypto.sha256(input.encodeToByteArray()).toHex()
}
+ fun hasValidPublicShares(key: DkgSession): Boolean {
+ val shares = key.publicShareList() ?: return false
+ if (shares.size != key.participantCount) return false
+ val thresholdPublicKey = key.thresholdPublicKey?.hexToByteArray() ?: return false
+ return runCatching {
+ Secp256k1.frostThresholdInfoValidate(
+ thresholdPublicKey, shares.map { it.value.toByteArray() }.toTypedArray(), key.threshold,
+ )
+ }.getOrDefault(false)
+ }
+
/** Hash a public-share table. This contains no secret material. */
fun publicSharesHash(publicShares: List): String =
Crypto.sha256((PUBLIC_SHARES_TAG + publicShares.joinToString(",") { it.value.toHex() }).encodeToByteArray()).toHex()
@@ -655,10 +719,15 @@ object FrostReEnrollmentManager {
stage = ReEnrollmentStage.FAILED,
failureReason = reason,
dealerRandom = null,
- candidateSecretShare = null,
+ candidateSecretShare = if (current.readyAt == null) null else current.candidateSecretShare,
)
}
database.frostReEnrollmentDao().scrubMessagesByKind(session.id, ReEnrollmentEvents.PRIVATE_EVALUATION)
+ announce(
+ database, current, ChatMessage.TYPE_REENROLLMENT_FAILED,
+ "abandoned the share refresh. The previous group key and active share epoch are unchanged.",
+ actor = current.userPublicKey,
+ )
broadcast(database, localChatRoom, current, ReEnrollmentEvents.FAILURE, reason)
}
diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/FrostSigningManager.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/FrostSigningManager.kt
index bbacd2e4..86f0cb94 100644
--- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/FrostSigningManager.kt
+++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/FrostSigningManager.kt
@@ -634,7 +634,8 @@ object FrostSigningManager {
if (innerEvent.kind != FrostSigningEvents.PROPOSAL_V2 ||
refresh.dkgSessionId != key.id || refresh.nextShareEpoch != proposalEpoch ||
refresh.candidateSecretShare == null || refresh.candidatePublicShareList() == null ||
- refresh.stage != mobi.giza.compose.database.model.types.ReEnrollmentStage.ACTIVATING
+ (refresh.stage != mobi.giza.compose.database.model.types.ReEnrollmentStage.ACTIVATING &&
+ !(refresh.stage == mobi.giza.compose.database.model.types.ReEnrollmentStage.FAILED && refresh.readyAt != null))
) {
logger.w("Signing proposal $sessionId does not have a valid activation candidate; dropping")
return null
@@ -741,6 +742,7 @@ object FrostSigningManager {
database.frostSigningSessionDao().upsert(session)
database.frostSigningSessionDao().upsertItems(itemsOver(sessionId, unsignedEvents))
announceStarted(database, session)
+ refresh?.let { FrostReEnrollmentManager.noteActivation(database, it) }
logger.i(
"Recorded signing session $sessionId over ${describe(unsignedEvents.size)} " +
@@ -1063,7 +1065,8 @@ object FrostSigningManager {
refresh.stage !in setOf(
mobi.giza.compose.database.model.types.ReEnrollmentStage.ACTIVATING,
mobi.giza.compose.database.model.types.ReEnrollmentStage.COMPLETE,
- )
+ ) && !(refresh.stage == mobi.giza.compose.database.model.types.ReEnrollmentStage.FAILED &&
+ refresh.readyAt != null)
)
) {
logger.i("Activation session $sessionId has no matching staged candidate; leaving it")
@@ -2266,7 +2269,8 @@ object FrostSigningManager {
refresh.stage !in setOf(
mobi.giza.compose.database.model.types.ReEnrollmentStage.ACTIVATING,
mobi.giza.compose.database.model.types.ReEnrollmentStage.COMPLETE,
- )
+ ) && !(refresh.stage == mobi.giza.compose.database.model.types.ReEnrollmentStage.FAILED &&
+ refresh.readyAt != null)
)
) {
logger.i("Activation session $sessionId has no staged candidate to resend")
diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/composable/ChatRoomMessagingScreen.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/composable/ChatRoomMessagingScreen.kt
index 45ac06e2..a4797b61 100644
--- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/composable/ChatRoomMessagingScreen.kt
+++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/composable/ChatRoomMessagingScreen.kt
@@ -49,6 +49,7 @@ import mobi.giza.compose.repository.NostrRepository
import mobi.giza.compose.ui.composable.navigation.routes.ChatRoomDetailRoute
import mobi.giza.compose.ui.composable.navigation.routes.DkgRitualRoute
import mobi.giza.compose.ui.composable.navigation.routes.ProposalListRoute
+import mobi.giza.compose.ui.composable.navigation.routes.ReEnrollmentRoute
import mobi.giza.compose.ui.composable.navigation.routes.proposalDestination
import mobi.giza.compose.ui.composable.navigation.routes.Route
import mobi.giza.compose.ui.composable.widgets.LoadingDataIndicator
@@ -196,6 +197,11 @@ fun ChatRoomMessagingScreen(
)
)
},
+ onOpenReEnrollment = { sessionId ->
+ onNavigateToRoute(
+ ReEnrollmentRoute(activeUserPublicKey, chatRoomId, sessionId)
+ )
+ },
// The notice has just counted the proposals
// waiting on this member and said so. Opening
// the room's whole signing history from it
diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/composable/ReEnrollmentScreen.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/composable/ReEnrollmentScreen.kt
index 3fc5cf0c..55710200 100644
--- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/composable/ReEnrollmentScreen.kt
+++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/composable/ReEnrollmentScreen.kt
@@ -21,6 +21,7 @@ import androidx.compose.material3.TopAppBar
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.style.TextOverflow
import androidx.lifecycle.viewmodel.compose.viewModel
import mobi.giza.compose.database.model.types.ReEnrollmentPurpose
import mobi.giza.compose.database.model.types.ReEnrollmentStage
@@ -29,6 +30,7 @@ import mobi.giza.compose.repository.ChatRepository
import mobi.giza.compose.repository.ReEnrollmentRepository
import mobi.giza.compose.resources.Res
import mobi.giza.compose.resources.abandon
+import mobi.giza.compose.resources.active_share_epoch
import mobi.giza.compose.resources.approve_share_repair
import mobi.giza.compose.resources.ask_again
import mobi.giza.compose.resources.commitments_received
@@ -44,6 +46,7 @@ import mobi.giza.compose.resources.refresh_backup_warning
import mobi.giza.compose.resources.refresh_complete
import mobi.giza.compose.resources.refresh_error
import mobi.giza.compose.resources.refresh_failed
+import mobi.giza.compose.resources.refresh_member_roster
import mobi.giza.compose.resources.refresh_pending_activation
import mobi.giza.compose.resources.refresh_shares_description
import mobi.giza.compose.resources.refresh_signing_shares
@@ -55,6 +58,7 @@ import mobi.giza.compose.resources.repair_helpers_responded
import mobi.giza.compose.resources.repair_public_table_verified
import mobi.giza.compose.resources.repair_share
import mobi.giza.compose.resources.refresh_stage
+import mobi.giza.compose.resources.refresh_unchanged_group_key
import mobi.giza.compose.resources.refresh_waiting_on_members
import mobi.giza.compose.ui.composable.navigation.routes.ReEnrollmentRoute
import mobi.giza.compose.ui.composable.navigation.routes.Route
@@ -134,11 +138,31 @@ fun ReEnrollmentScreen(
Text(stringResource(Res.string.refresh_shares_description))
Text(stringResource(Res.string.refresh_all_members_required))
}
+ state.thresholdPublicKey?.let { groupKey ->
+ Text(
+ stringResource(Res.string.refresh_unchanged_group_key, groupKey),
+ style = MaterialTheme.typography.bodySmall,
+ maxLines = 1,
+ overflow = TextOverflow.MiddleEllipsis,
+ )
+ }
+ Text(
+ stringResource(
+ Res.string.refresh_member_roster,
+ session.participantPublicKeySet().sorted().joinToString {
+ it.memberName(state.localChatRoom.localParticipants, session.userPublicKey)
+ },
+ )
+ )
Card(modifier = Modifier.fillMaxWidth()) {
Column(modifier = Modifier.padding(MaterialTheme.spacing.containerPadding)) {
- Text(stringResource(Res.string.current_share_epoch, session.currentShareEpoch))
- if (session.purpose != ReEnrollmentPurpose.REPAIR) {
- Text(stringResource(Res.string.next_share_epoch, session.nextShareEpoch))
+ if (session.stage == ReEnrollmentStage.COMPLETE) {
+ Text(stringResource(Res.string.active_share_epoch, session.nextShareEpoch))
+ } else {
+ Text(stringResource(Res.string.current_share_epoch, session.currentShareEpoch))
+ if (session.purpose != ReEnrollmentPurpose.REPAIR) {
+ Text(stringResource(Res.string.next_share_epoch, session.nextShareEpoch))
+ }
}
Text(stringResource(Res.string.of_members_will_be_needed_to_sign_with_this, session.threshold, session.participantCount))
Text(stringResource(Res.string.refresh_stage, session.stage.name))
diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/composable/widgets/chat/ChatTranscript.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/composable/widgets/chat/ChatTranscript.kt
index e70b510c..f704425b 100644
--- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/composable/widgets/chat/ChatTranscript.kt
+++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/composable/widgets/chat/ChatTranscript.kt
@@ -45,6 +45,7 @@ import androidx.compose.material.icons.filled.History
import androidx.compose.material.icons.filled.Groups
import androidx.compose.material.icons.filled.PanTool
import androidx.compose.material.icons.filled.PersonAdd
+import androidx.compose.material.icons.filled.Refresh
import androidx.compose.material.icons.filled.Upload
import androidx.compose.material.icons.filled.WorkspacePremium
import androidx.compose.material.icons.filled.Info
@@ -87,6 +88,7 @@ import mobi.giza.compose.resources.loading
import mobi.giza.compose.resources.no_chat_message_relays_were_found_for_this
import mobi.giza.compose.resources.private_to_you
import mobi.giza.compose.resources.review
+import mobi.giza.compose.resources.refresh_signing_shares
import mobi.giza.compose.resources.waiting_for_your_signature
import mobi.giza.compose.resources.you
import mobi.giza.compose.resources.private_to
@@ -121,6 +123,7 @@ fun ChatTranscript(
* and cannot say which one it meant.
*/
onOpenSigning: (sessionId: String?) -> Unit,
+ onOpenReEnrollment: (sessionId: String) -> Unit,
/** Opens the room's proposals, all of them, whatever their state. */
onOpenProposals: () -> Unit,
) {
@@ -369,6 +372,19 @@ fun ChatTranscript(
return@items
}
+ if (localChatMessage.chatMessage.messageType in ChatMessage.REENROLLMENT_TYPES) {
+ RitualNotice(
+ localChatMessage = localChatMessage,
+ isAnswered = true,
+ isSettled = true,
+ onClick = localChatMessage.chatMessage.reEnrollmentSessionId?.let { sessionId ->
+ { onOpenReEnrollment(sessionId) }
+ },
+ opens = stringResource(Res.string.refresh_signing_shares),
+ )
+ return@items
+ }
+
// Signing lines are the same kind of thing and get
// the same treatment -- nobody said them either --
// but they lead somewhere else, because what a
@@ -852,6 +868,12 @@ private fun RitualNotice(
ChatMessage.TYPE_FROST_RESENT -> Icons.Default.Campaign
ChatMessage.TYPE_FROST_APPROVAL_NEEDED -> Icons.Default.Draw
+ ChatMessage.TYPE_REENROLLMENT_STARTED,
+ ChatMessage.TYPE_REENROLLMENT_READY,
+ ChatMessage.TYPE_REENROLLMENT_ACTIVATING -> Icons.Default.Refresh
+ ChatMessage.TYPE_REENROLLMENT_COMPLETE -> Icons.Default.CheckCircle
+ ChatMessage.TYPE_REENROLLMENT_FAILED -> Icons.Default.ErrorOutline
+
ChatMessage.TYPE_CHRONICLE_REQUESTED -> Icons.Default.History
ChatMessage.TYPE_CHRONICLE_SENT -> Icons.Default.Upload
ChatMessage.TYPE_CHRONICLE_RECEIVED -> Icons.Default.Download
@@ -886,6 +908,7 @@ private fun RitualNotice(
val tint = when {
chatMessage.messageType == ChatMessage.TYPE_DKG_FAILED ||
chatMessage.messageType == ChatMessage.TYPE_FROST_FAILED ||
+ chatMessage.messageType == ChatMessage.TYPE_REENROLLMENT_FAILED ||
chatMessage.messageType == ChatMessage.TYPE_MEMBER_INVITE_FAILED ||
chatMessage.messageType == ChatMessage.TYPE_CHANGE_REJECTED ->
MaterialTheme.colorScheme.error
@@ -920,7 +943,8 @@ private fun RitualNotice(
// so it follows a rename and is not stuck on the "LOADING..."
// placeholder a member is given the moment they are first seen.
if (chatMessage.messageType in ChatMessage.DKG_AUTHORED_TYPES ||
- chatMessage.messageType in ChatMessage.FROST_AUTHORED_TYPES
+ chatMessage.messageType in ChatMessage.FROST_AUTHORED_TYPES ||
+ chatMessage.messageType in ChatMessage.REENROLLMENT_AUTHORED_TYPES
) {
withStyle(
SpanStyle(color = ProfileColor.fromPublicKey(chatMessage.senderPublicKey))
diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/view/model/ReEnrollmentViewModel.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/view/model/ReEnrollmentViewModel.kt
index 8bae2b6f..c7830a5d 100644
--- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/view/model/ReEnrollmentViewModel.kt
+++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/view/model/ReEnrollmentViewModel.kt
@@ -53,11 +53,14 @@ class ReEnrollmentViewModel(
uiState = ReEnrollmentUIState.Error("This group cannot refresh its shares")
return@launch
}
+ val thresholdPublicKey = chatRepository.groupKeyState(chatRoomId)?.thresholdPublicKey
combine(
reEnrollmentRepository.observeSessionById(sessionId),
reEnrollmentRepository.observeMessages(sessionId),
) { session, messages ->
- session?.let { ReEnrollmentUIState.Loaded(room, it, messages, reEnrollmentRepository.pendingApproval(it)) }
+ session?.let {
+ ReEnrollmentUIState.Loaded(room, it, messages, reEnrollmentRepository.pendingApproval(it), thresholdPublicKey)
+ }
}.collect { state -> state?.let { uiState = it } }
}
}
diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/view/state/ReEnrollmentUIState.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/view/state/ReEnrollmentUIState.kt
index 42748c32..a05f2879 100644
--- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/view/state/ReEnrollmentUIState.kt
+++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/view/state/ReEnrollmentUIState.kt
@@ -13,6 +13,7 @@ sealed interface ReEnrollmentUIState {
val session: FrostReEnrollmentSession,
val messages: List,
val pendingApproval: Boolean,
+ val thresholdPublicKey: String? = null,
) : ReEnrollmentUIState {
val commitments: Int get() = messages.count { it.kind == ReEnrollmentEvents.COMMITMENTS }
val evaluations: Int get() = messages.count {
diff --git a/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/FrostReEnrollmentManagerJvmTest.kt b/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/FrostReEnrollmentManagerJvmTest.kt
index 51fce045..d76beac2 100644
--- a/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/FrostReEnrollmentManagerJvmTest.kt
+++ b/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/FrostReEnrollmentManagerJvmTest.kt
@@ -12,6 +12,7 @@ import fr.acinq.bitcoin.crypto.frost.KeyMaterial
import kotlin.test.AfterTest
import kotlin.test.Test
import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
import kotlin.test.assertFalse
import kotlin.test.assertNotNull
import kotlin.test.assertNull
@@ -19,6 +20,7 @@ import kotlin.test.assertTrue
import kotlinx.coroutines.runBlocking
import mobi.giza.compose.database.GizaDatabase
import mobi.giza.compose.database.builder.getRoomDatabase
+import mobi.giza.compose.database.model.ChatMessage
import mobi.giza.compose.database.model.ChatRoom
import mobi.giza.compose.database.model.DkgParticipantMessage
import mobi.giza.compose.database.model.DkgSession
@@ -37,18 +39,18 @@ import mobi.giza.compose.nostr.frost.GroupKeyStateEvent
import mobi.giza.compose.nostr.frost.ReEnrollmentEvents
class FrostReEnrollmentManagerJvmTest {
- private val participants = 3
- private val threshold = 2
- private val keyMaterial: KeyMaterial = Frost.trustedDealerKeygen(
+ private var participants = 3
+ private var threshold = 2
+ private var keyMaterial: KeyMaterial = Frost.trustedDealerKeygen(
PrivateKey(ByteVector32("1c0ffee0000000000000000000000000000000000000000000000000000000a1")),
participants,
threshold,
)
- private val thresholdPublicKey = keyMaterial.thresholdPublicKey.value.toHex()
- private val roomId = SharedKeyDerivation.marmotGroupId(thresholdPublicKey)
+ private var thresholdPublicKey = keyMaterial.thresholdPublicKey.value.toHex()
+ private var roomId = SharedKeyDerivation.marmotGroupId(thresholdPublicKey)
private val ceremonyId = "ceremony".padEnd(64, '0')
- private val members = listOf("a", "b", "c").map { it.repeat(64) }
- private val hostKeys = listOf("2a", "2b", "2c").map { it.padEnd(66, '0') }
+ private var members = listOf("a", "b", "c").map { it.repeat(64) }
+ private var hostKeys = listOf("2a", "2b", "2c").map { it.padEnd(66, '0') }
private val devices = mutableListOf()
private val delivered = mutableSetOf()
@@ -141,8 +143,26 @@ class FrostReEnrollmentManagerJvmTest {
}
}
- private suspend fun openDevices(signerHostKeys: List = hostKeys) {
- devices += List(participants) { index -> Device(index, signerHostKeys).apply { open() } }
+ private suspend fun openDevices(
+ participantCount: Int = participants,
+ minimumSigners: Int = threshold,
+ signerHostKeys: List? = null,
+ ) {
+ require(devices.isEmpty())
+ participants = participantCount
+ threshold = minimumSigners
+ keyMaterial = Frost.trustedDealerKeygen(
+ PrivateKey(ByteVector32("1c0ffee0000000000000000000000000000000000000000000000000000000a1")),
+ participants,
+ threshold,
+ )
+ thresholdPublicKey = keyMaterial.thresholdPublicKey.value.toHex()
+ roomId = SharedKeyDerivation.marmotGroupId(thresholdPublicKey)
+ members = List(participants) { index -> ('a' + index).toString().repeat(64) }
+ hostKeys = List(participants) { index -> "2${'a' + index}".padEnd(66, '0') }
+ val orderedHostKeys = signerHostKeys ?: hostKeys
+ require(orderedHostKeys.size == participants)
+ devices += List(participants) { index -> Device(index, orderedHostKeys).apply { open() } }
}
private suspend fun pump(
@@ -189,6 +209,32 @@ class FrostReEnrollmentManagerJvmTest {
}
}
+ @Test
+ fun `an unavailable or invalid public table prevents any refresh message`() = runBlocking {
+ openDevices()
+ val coordinator = devices[0]
+ val key = coordinator.db.dkgSessionDao().getSessionById(ceremonyId)!!
+ coordinator.db.dkgSessionDao().upsert(key.copy(publicShares = null))
+ val missing = assertFailsWith {
+ FrostReEnrollmentManager.proposeReEnrollment(coordinator.db, coordinator.room, coordinator.member)
+ }
+ assertTrue(missing.message!!.contains("repair it with current members"))
+
+ val fabricated = Frost.trustedDealerKeygen(
+ PrivateKey(ByteVector32("8".repeat(64))), participants, threshold,
+ ).publicShares.joinToString(",") { it.value.toHex() }
+ coordinator.db.dkgSessionDao().upsert(key.copy(publicShares = fabricated))
+ assertFailsWith {
+ FrostReEnrollmentManager.proposeReEnrollment(coordinator.db, coordinator.room, coordinator.member)
+ }
+ assertTrue(
+ coordinator.db.marmotInnerEventDao().getByChatRoomAndKinds(
+ roomId,
+ listOf(ReEnrollmentEvents.PROPOSAL, ReEnrollmentEvents.COMMITMENTS, ReEnrollmentEvents.PRIVATE_EVALUATION),
+ ).isEmpty()
+ )
+ }
+
@Test
fun `all members reach activation with the same verified candidate`() = runBlocking {
openDevices()
@@ -222,8 +268,12 @@ class FrostReEnrollmentManagerJvmTest {
assertEquals(participants * (participants - 1), direct.distinctBy { it.id }.size)
}
- private suspend fun refreshAndActivate(signerHostKeys: List = hostKeys) {
- openDevices(signerHostKeys)
+ private suspend fun refreshAndActivate(
+ signerHostKeys: List? = null,
+ participantCount: Int = participants,
+ minimumSigners: Int = threshold,
+ ) {
+ openDevices(participantCount, minimumSigners, signerHostKeys)
devices[0].let { FrostReEnrollmentManager.proposeReEnrollment(it.db, it.room, it.member) }
pump { it.kind == ReEnrollmentEvents.PROPOSAL }
devices.drop(1).forEach { device ->
@@ -382,6 +432,200 @@ class FrostReEnrollmentManagerJvmTest {
}
}
+ @Test
+ fun `a signed activation takes precedence over a local failure`() = runBlocking {
+ openDevices()
+ devices[0].let { FrostReEnrollmentManager.proposeReEnrollment(it.db, it.room, it.member) }
+ pump { it.kind == ReEnrollmentEvents.PROPOSAL }
+ devices.drop(1).forEach { device ->
+ FrostReEnrollmentManager.approve(device.db, device.room, device.session()!!.id)
+ }
+ pump()
+ val activation = devices[0].let {
+ FrostReEnrollmentManager.proposeActivation(it.db, it.room, it.member, it.session()!!.id)
+ }!!
+ val target = devices[2]
+ target.receive(
+ MarmotInnerEvent(
+ id = "f".repeat(64),
+ publicKey = devices[0].member,
+ chatRoomId = roomId,
+ kind = ReEnrollmentEvents.FAILURE,
+ tags = ReEnrollmentEvents.assembleTags(activation.refreshSessionId!!),
+ content = "A local failure arrived before the signature",
+ createdAt = kotlin.time.Instant.fromEpochSeconds(1_700_000_100),
+ )
+ )
+ val failed = target.session()!!
+ assertEquals(ReEnrollmentStage.FAILED, failed.stage)
+ assertNotNull(failed.candidateSecretShare)
+ assertNotNull(failed.candidatePublicShares)
+ assertEquals(0, target.db.dkgSessionDao().getSessionById(ceremonyId)!!.shareEpoch)
+
+ pump { it.kind == FrostSigningEvents.PROPOSAL_V2 }
+ FrostSigningManager.approve(devices[1].db, devices[1].room, activation.id)
+ pump { it.kind in FrostSigningEvents.ALL }
+
+ devices.forEach { device ->
+ assertEquals(1, device.db.dkgSessionDao().getSessionById(ceremonyId)!!.shareEpoch)
+ assertEquals(ReEnrollmentStage.COMPLETE, device.session()!!.stage)
+ assertNull(device.session()!!.candidateSecretShare)
+ }
+ val signed = target.db.groupSignedEventDao().getByKind(ReEnrollmentEvents.KEY_EPOCH_STATE).single().toEvent()
+ assertTrue(Nip01Crypto.verify(signed.sig.hexToByteArray(), signed.id.hexToByteArray(), roomId.hexToByteArray()))
+ }
+
+ @Test
+ fun `activation retry keeps the candidate and uses fresh nonce seeds`() = runBlocking {
+ openDevices()
+ devices[0].let { FrostReEnrollmentManager.proposeReEnrollment(it.db, it.room, it.member) }
+ pump { it.kind == ReEnrollmentEvents.PROPOSAL }
+ devices.drop(1).forEach { device ->
+ FrostReEnrollmentManager.approve(device.db, device.room, device.session()!!.id)
+ }
+ pump()
+ val refreshId = devices[2].session()!!.id
+ val candidate = devices[2].session()!!
+ val first = devices[0].let {
+ FrostReEnrollmentManager.proposeActivation(it.db, it.room, it.member, refreshId)
+ }!!
+ pump { it.kind == FrostSigningEvents.PROPOSAL_V2 }
+ devices.drop(1).forEach { device -> FrostSigningManager.decline(device.db, device.room, first.id) }
+ pump()
+
+ devices.forEach { device ->
+ assertEquals(mobi.giza.compose.database.model.types.FrostSigningStage.FAILED,
+ device.db.frostSigningSessionDao().getSessionById(first.id)!!.stage)
+ }
+ assertEquals(candidate.candidateSecretShare, devices[2].session()!!.candidateSecretShare)
+ assertEquals(candidate.candidatePublicShares, devices[2].session()!!.candidatePublicShares)
+
+ val coordinator = devices[2]
+ val retry = FrostReEnrollmentManager.proposeActivation(coordinator.db, coordinator.room, coordinator.member, refreshId)!!
+ assertTrue(retry.id != first.id)
+ pump { it.kind == FrostSigningEvents.PROPOSAL_V2 }
+ devices.forEach { device ->
+ val original = device.db.frostSigningSessionDao().getItems(first.id).single().nonceRandom
+ val replacement = device.db.frostSigningSessionDao().getItems(retry.id).single().nonceRandom
+ assertTrue(original != replacement)
+ }
+ devices.filter { it.member != coordinator.member }.forEach { device ->
+ FrostSigningManager.approve(device.db, device.room, retry.id)
+ }
+ pump()
+
+ devices.forEach { device ->
+ assertEquals(1, device.db.dkgSessionDao().getSessionById(ceremonyId)!!.shareEpoch)
+ assertEquals(ReEnrollmentStage.COMPLETE, device.session()!!.stage)
+ assertNull(device.session()!!.candidateSecretShare)
+ }
+ val signed = coordinator.db.groupSignedEventDao().getByKind(ReEnrollmentEvents.KEY_EPOCH_STATE).single().toEvent()
+ assertTrue(Nip01Crypto.verify(signed.sig.hexToByteArray(), signed.id.hexToByteArray(), roomId.hexToByteArray()))
+ }
+
+ @Test
+ fun `a delayed activation signature activates from persisted state`() = runBlocking {
+ openDevices()
+ devices[0].let { FrostReEnrollmentManager.proposeReEnrollment(it.db, it.room, it.member) }
+ pump { it.kind == ReEnrollmentEvents.PROPOSAL }
+ devices.drop(1).forEach { device ->
+ FrostReEnrollmentManager.approve(device.db, device.room, device.session()!!.id)
+ }
+ pump()
+ val activation = devices[0].let {
+ FrostReEnrollmentManager.proposeActivation(it.db, it.room, it.member, it.session()!!.id)
+ }!!
+ pump { it.kind == FrostSigningEvents.PROPOSAL_V2 }
+ devices.drop(1).forEach { device -> FrostSigningManager.approve(device.db, device.room, activation.id) }
+ pump { it.kind != FrostSigningEvents.SIGNATURE }
+
+ val waiting = devices.filter { it.db.dkgSessionDao().getSessionById(ceremonyId)!!.shareEpoch == 0L }
+ assertTrue(waiting.isNotEmpty())
+ waiting.forEach { device ->
+ assertNotNull(device.session()!!.candidateSecretShare)
+ assertEquals(0, device.db.groupKeyStateDao().getByChatRoomId(roomId)!!.shareEpoch)
+ }
+ pump { it.kind == FrostSigningEvents.SIGNATURE }
+
+ devices.forEach { device ->
+ assertEquals(1, device.db.dkgSessionDao().getSessionById(ceremonyId)!!.shareEpoch)
+ assertEquals(1, device.db.groupKeyStateDao().getByChatRoomId(roomId)!!.shareEpoch)
+ assertNull(device.session()!!.candidateSecretShare)
+ }
+ }
+
+ @Test
+ fun `out-of-order messages replay from storage and duplicates are idempotent`() = runBlocking {
+ openDevices()
+ devices[0].let { FrostReEnrollmentManager.proposeReEnrollment(it.db, it.room, it.member) }
+ pump { it.kind != ReEnrollmentEvents.PROPOSAL }
+ devices.drop(1).forEach { assertNull(it.session()) }
+
+ delivered.clear()
+ pump { it.kind == ReEnrollmentEvents.PROPOSAL }
+ devices.drop(1).forEach { device ->
+ FrostReEnrollmentManager.approve(device.db, device.room, device.session()!!.id)
+ }
+ pump()
+
+ val staged = devices.map { it.session()!! }
+ assertEquals(List(participants) { ReEnrollmentStage.ACTIVATING }, staged.map { it.stage })
+ assertEquals(1, staged.map { it.transcriptHash }.toSet().size)
+ delivered.clear()
+ pump()
+ assertEquals(staged, devices.map { it.session()!! })
+ }
+
+ @Test
+ fun `a conflicting ready transcript cannot start activation`() = runBlocking {
+ openDevices()
+ devices[0].let { FrostReEnrollmentManager.proposeReEnrollment(it.db, it.room, it.member) }
+ pump { it.kind == ReEnrollmentEvents.PROPOSAL }
+ devices.drop(1).forEach { device ->
+ FrostReEnrollmentManager.approve(device.db, device.room, device.session()!!.id)
+ }
+ pump { it.kind != ReEnrollmentEvents.READY }
+
+ val target = devices[1]
+ val refresh = target.session()!!
+ val ready = devices[0].db.marmotInnerEventDao()
+ .getByChatRoomAndKinds(roomId, listOf(ReEnrollmentEvents.READY))
+ .single { ReEnrollmentEvents.parseSessionId(it.tags) == refresh.id }
+ target.receive(ready.copy(content = "00".repeat(32)))
+
+ assertEquals(ReEnrollmentStage.CANDIDATE_READY, target.session()!!.stage)
+ assertNull(FrostReEnrollmentManager.proposeActivation(target.db, target.room, target.member, refresh.id))
+ assertEquals(0, target.db.dkgSessionDao().getSessionById(ceremonyId)!!.shareEpoch)
+ }
+
+ @Test
+ fun `three of five members refresh and the last member can coordinate signing`() = runBlocking {
+ refreshAndActivate(participantCount = 5, minimumSigners = 3)
+ devices.forEach { device ->
+ assertEquals(1, device.db.dkgSessionDao().getSessionById(ceremonyId)!!.shareEpoch)
+ assertEquals(ReEnrollmentStage.COMPLETE, device.session()!!.stage)
+ }
+ val evaluations = devices.flatMap { device ->
+ device.db.marmotInnerEventDao().getByChatRoomAndKinds(roomId, listOf(ReEnrollmentEvents.PRIVATE_EVALUATION))
+ }.distinctBy { it.id }
+ assertEquals(participants * (participants - 1), evaluations.size)
+ assertTrue(evaluations.all { it.content.isEmpty() })
+
+ val coordinator = devices.last()
+ val after = FrostSigningManager.proposeSigning(
+ coordinator.db, coordinator.room, coordinator.member, 1, emptyArray(), "three of five refresh",
+ )
+ pump { it.kind == FrostSigningEvents.PROPOSAL_V2 }
+ devices.filter { it.member != coordinator.member }.forEach { device ->
+ FrostSigningManager.approve(device.db, device.room, after.id)
+ }
+ pump()
+ val signed = coordinator.db.groupSignedEventDao().getByKind(1).single {
+ it.content == "three of five refresh"
+ }.toEvent()
+ assertTrue(Nip01Crypto.verify(signed.sig.hexToByteArray(), signed.id.hexToByteArray(), roomId.hexToByteArray()))
+ }
+
@Test
fun `a resend names missing members and republishes the same private bytes`() = runBlocking {
openDevices()
@@ -467,6 +711,21 @@ class FrostReEnrollmentManagerJvmTest {
.getByChatRoomAndKinds(roomId, listOf(ReEnrollmentEvents.PRIVATE_EVALUATION))
.all { it.content.isEmpty() }
)
+ val notices = device.db.chatMessageDao().getChatMessagesByChatRoomId(roomId)
+ .map { it.chatMessage }
+ .filter { it.reEnrollmentSessionId == refresh.id }
+ assertEquals(
+ setOf(
+ ChatMessage.TYPE_REENROLLMENT_STARTED,
+ ChatMessage.TYPE_REENROLLMENT_READY,
+ ChatMessage.TYPE_REENROLLMENT_ACTIVATING,
+ ChatMessage.TYPE_REENROLLMENT_COMPLETE,
+ ),
+ notices.map { it.messageType }.toSet(),
+ )
+ assertEquals(notices.size, notices.map { it.messageType }.toSet().size)
+ assertTrue(notices.none { it.content.contains(key.secretShare!!) })
+ assertTrue(notices.none { it.content.contains(keyMaterial.secretShares[index].value.toHex()) })
}
val after = devices[0].let {
diff --git a/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/GroupFixtures.kt b/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/GroupFixtures.kt
index f1f439e3..c6b1a7c6 100644
--- a/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/GroupFixtures.kt
+++ b/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/GroupFixtures.kt
@@ -160,9 +160,9 @@ internal object GroupFixtures {
private fun signature(material: KeyMaterial, eventId: String): String =
signWith(material, SharedKeyDerivation.derive(thresholdKeyOf(material), path).cache, ByteVector(eventId.hexToByteArray())).toHex()
- /** A 2-of-3 FROST signature by [material]'s quorum over [message] under [cache] -- a leaf's, an address's, the room's. */
+ /** A threshold FROST signature by [material]'s quorum over [message] under [cache]. */
fun signWith(material: KeyMaterial, cache: TweakCache, message: ByteVector): ByteVector64 {
- val signerIds = listOf(0, 1)
+ val signerIds = (0 until material.threshold).toList()
val nonces = signerIds.map { signerId ->
SecretNonce.generate(
@@ -178,8 +178,8 @@ internal object GroupFixtures {
aggregatedNonce = IndividualNonce.aggregate(nonces.map { it.second }).right!!,
signerIds = signerIds.map { it.toUInt() },
signerPublicShares = signerIds.map { material.publicShares[it] },
- nParticipants = PARTICIPANTS,
- threshold = THRESHOLD,
+ nParticipants = material.nParticipants,
+ threshold = material.threshold,
tweakCache = cache,
message = message,
)