Merge branch 'claude/signing-session-resend-plan-563745' into curated
Resending a FROST signing session: the proposer repeats what it wrote, and the repeat names the members it has heard nothing from so their own devices repeat what they wrote. docs/frost-session-resend.md has the account. The failure it recovers is in docs/mls-skipped-keys.md and is otherwise terminal and silent -- a group event that decrypted to nothing because MLS had moved its ratchet past the generation it arrived at, leaving a session waiting forever on a member who never knew. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
commit
f9cfc2ea59
23 files changed
+8326
-13
No files matched your search
File diff suppressed because it is too large.
Load diff
@@ -196,6 +196,11 @@
|
||||
<string name="propose_translation">Propose translation</string>
|
||||
<string name="publish_new_key_package">Publish new key package</string>
|
||||
<string name="re_broadcast">Re-broadcast</string>
|
||||
<string name="asked_again">Asked the members who have not answered to take another look</string>
|
||||
<string name="everyone_has_answered_this_session">Everyone has answered. There is nobody left to ask.</string>
|
||||
<string name="one_member_has_not_answered">One member has not answered. They may never have received it.</string>
|
||||
<string name="members_have_not_answered">%1$s members have not answered. They may never have received it.</string>
|
||||
<string name="asked_again_recently">Asked again just now. You can ask again in a few minutes.</string>
|
||||
<string name="read_to_the_end_of_the_list_to_sign">Read to the end of the list to sign.</string>
|
||||
<string name="recovery_phrase">Recovery phrase</string>
|
||||
<string name="ready_to_sign">Ready to sign</string>
|
||||
|
||||
@@ -187,7 +187,7 @@ val GENESIS_AT = Instant.fromEpochMilliseconds(1231006505000L)
|
||||
UnsignedNostrEvent::class,
|
||||
Zap::class
|
||||
],
|
||||
version = 24,
|
||||
version = 25,
|
||||
autoMigrations = [
|
||||
// v2 only adds the DkgSession/DkgParticipantMessage tables, so Room can
|
||||
// generate the migration itself — nothing existing changes shape.
|
||||
@@ -362,6 +362,12 @@ val GENESIS_AT = Instant.fromEpochMilliseconds(1231006505000L)
|
||||
// an obligation forgotten at a crash is a replacement commit at the next
|
||||
// start, which forks the group against whoever took the first one.
|
||||
AutoMigration(from = 23, to = 24),
|
||||
// v25 adds FrostSigningSession.resentAt: when the coordinator last
|
||||
// re-published a signing session for the members it had heard nothing
|
||||
// from (docs/frost-session-resend.md, Phase 2). Nullable and nothing is
|
||||
// backfilled -- a session that has never been resent reads null, which
|
||||
// is what every session before the column was.
|
||||
AutoMigration(from = 24, to = 25),
|
||||
]
|
||||
)
|
||||
@ConstructedBy(CurareDatabaseConstructor::class)
|
||||
|
||||
+11
@@ -91,6 +91,17 @@ interface FrostSigningSessionDao {
|
||||
@Query("SELECT * FROM FrostSignerMessage WHERE sessionId = :sessionId ORDER BY createdAt ASC")
|
||||
fun observeMessages(sessionId: String): Flow<List<FrostSignerMessage>>
|
||||
|
||||
/**
|
||||
* Every message a session has received, of every kind.
|
||||
*
|
||||
* What a resend reads to work out who has said nothing at all: a member with
|
||||
* any row here has answered -- offered a nonce, signed their part, or
|
||||
* refused -- and is not somebody to knock on the door of. See
|
||||
* `FrostSigningManager.silentMembers`.
|
||||
*/
|
||||
@Query("SELECT * FROM FrostSignerMessage WHERE sessionId = :sessionId ORDER BY createdAt ASC")
|
||||
suspend fun getMessagesForSession(sessionId: String): List<FrostSignerMessage>
|
||||
|
||||
@Query("SELECT COUNT(*) FROM FrostSignerMessage WHERE sessionId = :sessionId AND kind = :kind")
|
||||
suspend fun countMessagesByKind(sessionId: String, kind: Kind): Int
|
||||
|
||||
|
||||
@@ -53,6 +53,15 @@ interface GiftWrapPayloadDao {
|
||||
@Upsert
|
||||
suspend fun upsert(giftWrapPayload: GiftWrapPayload)
|
||||
|
||||
/**
|
||||
* One row by its id. The same job as `MarmotInnerEventDao.getById`, for the
|
||||
* other transport: an id is a hash over `created_at` to the second, so a
|
||||
* re-publish inside that second collides with the copy it is repeating and
|
||||
* an upsert would un-send it.
|
||||
*/
|
||||
@Query("SELECT * FROM GiftWrapPayload WHERE id = :id")
|
||||
suspend fun getById(id: String): GiftWrapPayload?
|
||||
|
||||
@Insert
|
||||
suspend fun insert(giftWrapPayload: GiftWrapPayload)
|
||||
}
|
||||
+15
@@ -37,6 +37,21 @@ interface MarmotInnerEventDao {
|
||||
@Upsert
|
||||
suspend fun upsert(marmotInnerEvent: MarmotInnerEvent)
|
||||
|
||||
/**
|
||||
* One row by its id, for a caller that has to know whether an id is taken
|
||||
* before it writes one.
|
||||
*
|
||||
* An outbound row's id is a hash over the fields the rumor will be assembled
|
||||
* from, `created_at` among them and stored to the second -- so re-publishing
|
||||
* the same message inside the same second as the first copy computes the
|
||||
* same id. Upserting it would put an already-sent row back on the queue with
|
||||
* `marmotGroupEventId` cleared, which double-sends it and loses its mapping
|
||||
* to the group event it became. `FrostSigningManager.broadcast` checks here
|
||||
* first.
|
||||
*/
|
||||
@Query("SELECT * FROM MarmotInnerEvent WHERE id = :id")
|
||||
suspend fun getById(id: String): MarmotInnerEvent?
|
||||
|
||||
/**
|
||||
* A room's inner events of the given kinds, oldest first.
|
||||
*
|
||||
|
||||
@@ -291,6 +291,19 @@ data class ChatMessage(
|
||||
*/
|
||||
const val TYPE_FROST_DECLINED = "frostDeclined"
|
||||
|
||||
/**
|
||||
* The coordinator re-published a session for the members it had heard
|
||||
* nothing from.
|
||||
*
|
||||
* Its own type rather than a step, because nothing moved: somebody
|
||||
* knocked. A session can be left waiting on a member whose copy of the
|
||||
* proposal never arrived -- MLS dropped the generation, or a
|
||||
* disappearing-message group expired it off the relay -- and a resend is
|
||||
* the only thing that reaches them. The line exists so a second knock
|
||||
* reads as a second knock. See docs/frost-session-resend.md.
|
||||
*/
|
||||
const val TYPE_FROST_RESENT = "frostResent"
|
||||
|
||||
/** Addressed to the reader rather than said by anyone -- see [DKG_REQUEST_TYPES]. */
|
||||
const val TYPE_FROST_APPROVAL_NEEDED = "frostApprovalNeeded"
|
||||
|
||||
@@ -337,6 +350,7 @@ data class ChatMessage(
|
||||
TYPE_FROST_COMPLETE,
|
||||
TYPE_FROST_FAILED,
|
||||
TYPE_FROST_DECLINED,
|
||||
TYPE_FROST_RESENT,
|
||||
TYPE_FROST_APPROVAL_NEEDED,
|
||||
)
|
||||
|
||||
@@ -354,6 +368,7 @@ data class ChatMessage(
|
||||
TYPE_FROST_SIGNATURE,
|
||||
TYPE_FROST_FAILED,
|
||||
TYPE_FROST_DECLINED,
|
||||
TYPE_FROST_RESENT,
|
||||
)
|
||||
|
||||
val DKG_AUTHORED_TYPES = setOf(
|
||||
|
||||
+15
@@ -152,6 +152,21 @@ data class FrostSigningSession(
|
||||
/** Whether the chat line asking for that approval has been written. */
|
||||
val approvalRequestedAt: Instant? = null,
|
||||
|
||||
/**
|
||||
* When the coordinator last re-published this session, or null if never.
|
||||
*
|
||||
* Two jobs, and the second one is not cosmetic. It is the cooldown -- a
|
||||
* resend is a publish, and a control that publishes on every tap fills a
|
||||
* room with duplicates. And it keeps a second resend out of the same second
|
||||
* as the first, where an outbound row's primary key is a hash over
|
||||
* `createdAt` and a collision would replace a sent row with an unsent one;
|
||||
* see `FrostSigningManager.broadcast`.
|
||||
*
|
||||
* Only ever written on the coordinator's own row. Null is what every
|
||||
* session predating the column reads back as, which is what they all were.
|
||||
*/
|
||||
val resentAt: Instant? = null,
|
||||
|
||||
override val createdAt: Instant = Clock.System.now(),
|
||||
override val updatedAt: Instant = createdAt,
|
||||
override val savedAt: Instant = createdAt,
|
||||
|
||||
+14
@@ -114,6 +114,20 @@ class DatabaseFrostSigningRepository(
|
||||
null
|
||||
}
|
||||
|
||||
override suspend fun resend(localChatRoom: LocalChatRoom, sessionId: String): Boolean = try {
|
||||
FrostSigningManager.resend(
|
||||
database = database,
|
||||
localChatRoom = localChatRoom,
|
||||
sessionId = sessionId
|
||||
)
|
||||
} catch (e: Throwable) {
|
||||
// False rather than rethrown, for the reason `approve` swallows: a
|
||||
// resend is a repair, and a repair that takes the screen down with it is
|
||||
// worse than one that did not happen.
|
||||
logger.e("Error resending signing session $sessionId", e)
|
||||
false
|
||||
}
|
||||
|
||||
override suspend fun approve(localChatRoom: LocalChatRoom, sessionId: String) {
|
||||
try {
|
||||
FrostSigningManager.approve(
|
||||
|
||||
+411
-10
@@ -20,7 +20,9 @@ import fr.acinq.bitcoin.crypto.frost.SecretNonce
|
||||
import fr.acinq.bitcoin.crypto.frost.Session
|
||||
import fr.acinq.bitcoin.utils.Either
|
||||
import kotlin.time.Clock
|
||||
import kotlin.time.Duration
|
||||
import kotlin.time.Instant
|
||||
import kotlin.time.Duration.Companion.minutes
|
||||
import kotlinx.coroutines.CancellationException
|
||||
import to.curare.compose.database.CurareDatabase
|
||||
import to.curare.compose.database.model.ChatMessage
|
||||
@@ -152,6 +154,39 @@ object FrostSigningManager {
|
||||
*/
|
||||
const val MAX_BATCH_SIZE: Int = 64
|
||||
|
||||
/**
|
||||
* How many seconds [broadcast] will step forward looking for an unused
|
||||
* outbound row id before giving up and publishing nothing.
|
||||
*
|
||||
* Only a repeat can collide at all -- a first publish differs from every
|
||||
* stored row in its content or its kind -- so this is the number of times
|
||||
* the same message can be re-published within one second. Four is past
|
||||
* anything a person pressing a button can do, and the cooldown on
|
||||
* `FrostSigningSession.resentAt` keeps it far from the limit.
|
||||
*/
|
||||
private const val MAX_ID_SEARCH: Int = 4
|
||||
|
||||
/**
|
||||
* How long after a resend the coordinator may send another.
|
||||
*
|
||||
* A resend is a publish. Without a floor under it a control that repeats a
|
||||
* 64-event proposal becomes a control that fills a room with them, and two
|
||||
* taps inside one second collide on the outbound row id -- see [broadcast].
|
||||
* Long enough that a second knock means a person decided to knock again,
|
||||
* short enough to be useful while somebody is watching the screen.
|
||||
*/
|
||||
val RESEND_COOLDOWN: Duration = 5.minutes
|
||||
|
||||
/**
|
||||
* The kinds a member authors for a session, and so the ones [republishOwn]
|
||||
* may repeat. Everything else on the session is the coordinator's.
|
||||
*/
|
||||
private val OWN_KINDS: List<Kind> = listOf(
|
||||
FrostSigningEvents.NONCE,
|
||||
FrostSigningEvents.PARTIAL_SIGNATURE,
|
||||
FrostSigningEvents.DECLINE
|
||||
)
|
||||
|
||||
/**
|
||||
* Opens a signing session, making this device the coordinator.
|
||||
*
|
||||
@@ -357,6 +392,22 @@ object FrostSigningManager {
|
||||
return
|
||||
}
|
||||
|
||||
// A resent proposal can carry the coordinator saying it has heard nothing
|
||||
// from this device. If it has, this device says it again -- the same
|
||||
// bytes, under its own key, because nobody else can send them for it.
|
||||
//
|
||||
// Ahead of [record] and [advance] so that a nonce lost on its way to the
|
||||
// coordinator goes out on the same pass that learns it was lost. Only
|
||||
// from the coordinator, and only messages already on file: see
|
||||
// [republishOwn].
|
||||
if (innerEvent.kind == FrostSigningEvents.PROPOSAL &&
|
||||
innerEvent.pubKey == session.coordinatorPublicKey &&
|
||||
FrostSigningEvents.parseSilentMembers(innerEvent.tags)
|
||||
?.contains(session.userPublicKey) == true
|
||||
) {
|
||||
republishOwn(database, localChatRoom, session)
|
||||
}
|
||||
|
||||
if (!record(database, session, innerEvent)) return
|
||||
|
||||
advance(database, localChatRoom, session.id)
|
||||
@@ -1816,6 +1867,260 @@ object FrostSigningManager {
|
||||
* because the local copy is not just a copy: filing it is what may end the
|
||||
* session, and [recordDecline] is the one place that decides.
|
||||
*/
|
||||
/**
|
||||
* Re-publishes what this device wrote for a session, for the members it has
|
||||
* heard nothing from. Returns whether anything went out.
|
||||
*
|
||||
* A member can be left with nothing at all for a session they would have
|
||||
* agreed to. Several ways, and only some of them heal on their own: a group
|
||||
* event that decrypted to nothing because MLS had moved its ratchet past the
|
||||
* generation it arrived at, which is terminal at the receiver and invisible
|
||||
* to the sender (`docs/mls-skipped-keys.md`); a disappearing-message group
|
||||
* whose kind:445 expired off the relay before they synced; a member added to
|
||||
* the room after the proposal, holding a share from an earlier ceremony. In
|
||||
* each of them the session sits in [FrostSigningStage.COLLECTING_NONCES]
|
||||
* until somebody gives up, and the member it was waiting on never knew.
|
||||
*
|
||||
* A resend repairs all three because a resent message is a *new* message:
|
||||
* new `created_at`, new id, encrypted at a generation the receiver has not
|
||||
* passed, carrying a fresh expiry.
|
||||
*
|
||||
* ### Only this device's own messages, and only the coordinator's
|
||||
*
|
||||
* What goes out is the proposal, the signer set and the signature -- the
|
||||
* three the coordinator authors. A member's nonce, partial signature or
|
||||
* refusal is not resent and cannot be: [record] files a signer's message
|
||||
* under the inner event's own `pubKey`, so a relayed copy would be filed
|
||||
* under the relayer, and for a refusal that is a way to manufacture one.
|
||||
* Nor is there a need. A nonce and a partial signature are read by nobody
|
||||
* but the coordinator -- [orderedNonces] and [orderedPartialSignatures] are
|
||||
* both called under `isCoordinator` -- and the coordinator already holds
|
||||
* them, which is how it knows who is quiet. What the resend does for a
|
||||
* silent member instead is name them, in `FrostSilentMembersTag`, so their
|
||||
* own device republishes what it already said. See [republishOwn].
|
||||
*
|
||||
* Coordinator-only, and that is correctness rather than etiquette.
|
||||
* [acceptProposal] takes `coordinatorPublicKey` from the proposal's author,
|
||||
* so a non-coordinator resending it to a member with no session row would
|
||||
* have that member believe the resender coordinates -- and then drop the
|
||||
* real coordinator's signer set through [isFromCoordinator].
|
||||
*
|
||||
* ### The minimum the stage requires
|
||||
*
|
||||
* | stage | what goes out |
|
||||
* |---|---|
|
||||
* | [FrostSigningStage.COLLECTING_NONCES] | the proposal |
|
||||
* | [FrostSigningStage.COLLECTING_PARTIAL_SIGNATURES] | the proposal, then the signer set |
|
||||
* | [FrostSigningStage.COMPLETE] | the proposal, then the signature |
|
||||
* | [FrostSigningStage.FAILED] | nothing -- refused |
|
||||
*
|
||||
* The proposal goes in every case because a device with no session row can
|
||||
* apply nothing else: a signer set naming ids it has no items for, and a
|
||||
* signature over events it has never seen, are both dropped.
|
||||
* [FrostSigningStage.COMPLETE] is worth repeating rather than skipping --
|
||||
* a member who never received the signature never ran [complete], so the
|
||||
* signed events were never applied to their store.
|
||||
*
|
||||
* Two and not three, deliberately. Publishing in bursts is what the
|
||||
* skipped-keys bug feeds on, and a recovery for it that re-creates it is no
|
||||
* recovery. `MlsGroupCache` covers a burst decrypted in one sync, which is
|
||||
* what makes [proposeSigningBatch]'s own two-message burst work; this stays
|
||||
* inside the same budget.
|
||||
*
|
||||
* A failed session is refused rather than repaired. Its items' nonce seeds
|
||||
* have been published against an aggregate already, so the retry is a fresh
|
||||
* proposal and never this one again -- which is what [fail] tells the group.
|
||||
*/
|
||||
suspend fun resend(
|
||||
database: CurareDatabase,
|
||||
localChatRoom: LocalChatRoom,
|
||||
sessionId: String
|
||||
): Boolean {
|
||||
val session = database.frostSigningSessionDao().getSessionById(sessionId) ?: return false
|
||||
|
||||
if (!session.isCoordinator()) {
|
||||
logger.i("Session $sessionId was not proposed by this device; it is not ours to resend")
|
||||
return false
|
||||
}
|
||||
|
||||
if (session.stage == FrostSigningStage.FAILED) {
|
||||
logger.i("Session $sessionId was abandoned; nothing to resend. Propose afresh instead")
|
||||
return false
|
||||
}
|
||||
|
||||
val items = database.frostSigningSessionDao().getItems(sessionId)
|
||||
if (items.isEmpty()) {
|
||||
logger.w("Session $sessionId holds no items; nothing to resend")
|
||||
return false
|
||||
}
|
||||
|
||||
val now = Clock.System.now()
|
||||
session.resentAt?.let { last ->
|
||||
if (now - last < RESEND_COOLDOWN) {
|
||||
logger.i("Session $sessionId was resent less than $RESEND_COOLDOWN ago; not again yet")
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
val silent = silentMembers(database, session)
|
||||
if (silent.isEmpty()) {
|
||||
logger.i("Session $sessionId has heard from every share holder; nothing to resend")
|
||||
return false
|
||||
}
|
||||
|
||||
val unsigned = items.mapNotNull { Event.fromJsonOrNull(it.unsignedEventJson) }
|
||||
if (unsigned.size != items.size) {
|
||||
// Refused rather than shortened. A proposal that quietly lost an
|
||||
// event would have every signer's contribution rejected for being
|
||||
// the wrong length, which is a stall with nothing to blame.
|
||||
logger.w(
|
||||
"Session $sessionId: only ${unsigned.size} of ${items.size} stored events could " +
|
||||
"be read; not resending a proposal that is missing one"
|
||||
)
|
||||
return false
|
||||
}
|
||||
|
||||
logger.i(
|
||||
"Resending session $sessionId at ${session.stage} to ${silent.size} member(s) " +
|
||||
"(${silent.joinToString { it.take(8) }})"
|
||||
)
|
||||
|
||||
// The proposal first, so a device that has nothing has somewhere to file
|
||||
// what follows it.
|
||||
broadcast(
|
||||
database = database,
|
||||
localChatRoom = localChatRoom,
|
||||
session = session,
|
||||
kind = FrostSigningEvents.PROPOSAL,
|
||||
content = FrostSigningEvents.encodeProposal(unsigned),
|
||||
includeKey = true,
|
||||
silentMembers = silent.toList(),
|
||||
recipients = silent
|
||||
)
|
||||
|
||||
when (session.stage) {
|
||||
FrostSigningStage.COLLECTING_PARTIAL_SIGNATURES -> {
|
||||
val chosen = session.signerIdList()
|
||||
val aggregated = items.map { it.aggregatedNonce }
|
||||
if (chosen != null && aggregated.all { it != null }) {
|
||||
broadcast(
|
||||
database = database,
|
||||
localChatRoom = localChatRoom,
|
||||
session = session,
|
||||
kind = FrostSigningEvents.SIGNER_SET,
|
||||
content = joinPayload(aggregated.map { it!! }),
|
||||
signerIds = chosen,
|
||||
recipients = silent
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
FrostSigningStage.COMPLETE -> {
|
||||
val signatures = items.map { it.signature }
|
||||
if (signatures.all { it != null }) {
|
||||
broadcast(
|
||||
database = database,
|
||||
localChatRoom = localChatRoom,
|
||||
session = session,
|
||||
kind = FrostSigningEvents.SIGNATURE,
|
||||
content = joinPayload(signatures.map { it!! }),
|
||||
recipients = silent
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
FrostSigningStage.COLLECTING_NONCES, FrostSigningStage.FAILED -> Unit
|
||||
}
|
||||
|
||||
update(database, session) { it.copy(resentAt = now) }
|
||||
announceResent(database, session, silent.size)
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
/**
|
||||
* The share holders this session has heard nothing at all from.
|
||||
*
|
||||
* Off the ceremony rather than off the room, like [recordDecline]'s own
|
||||
* count and `FrostSigningUIState.Loaded.members`: a room can hold members
|
||||
* added after its key was made who hold no share, and a subgroup's ceremony
|
||||
* room is the parent, which holds everybody the subgroup is not. A door that
|
||||
* cannot answer is not one to knock on.
|
||||
*
|
||||
* A member who declined is not silent. They answered, and the session is
|
||||
* counting their refusal; knocking again would be asking a question they
|
||||
* have already closed.
|
||||
*/
|
||||
private suspend fun silentMembers(
|
||||
database: CurareDatabase,
|
||||
session: FrostSigningSession
|
||||
): Set<HexKey> {
|
||||
val key = database.dkgSessionDao().getSessionById(session.dkgSessionId) ?: return emptySet()
|
||||
val holders = signerIds(database, key).keys
|
||||
|
||||
val heardFrom = database.frostSigningSessionDao()
|
||||
.getMessagesForSession(session.id)
|
||||
.map { it.signerPublicKey }
|
||||
.toSet()
|
||||
|
||||
return holders - heardFrom - session.userPublicKey
|
||||
}
|
||||
|
||||
/**
|
||||
* Re-publishes the messages *this* device authored for a session, because
|
||||
* the coordinator says it never received them.
|
||||
*
|
||||
* The other half of a resend, and the only half that can repair a signal
|
||||
* lost on its way *to* the coordinator. [advance] republishes a message it
|
||||
* has no local copy of; a device that published its nonce and recorded it
|
||||
* has a copy, so it will never send that nonce again however long the
|
||||
* coordinator waits. This is how it learns to.
|
||||
*
|
||||
* The stored bytes, never regenerated. They are byte-identical either way --
|
||||
* `SecretNonce.generate` is deterministic in the seed and the message, and
|
||||
* an item's message cannot change -- so this cannot produce a second nonce
|
||||
* for one message, which is the thing the whole design is arranged to make
|
||||
* impossible. Reading the row just avoids k native key generations to arrive
|
||||
* at the same answer.
|
||||
*
|
||||
* **It publishes nothing new.** Only messages already on file go out, so a
|
||||
* device whose owner has not decided sends nothing and falls through to
|
||||
* [advance], which does what it always does: write the approval request and
|
||||
* wait on a person. A message from the coordinator must never be able to
|
||||
* talk a device into putting its share behind events its owner has not
|
||||
* agreed to -- that is [acceptProposal]'s "publishes nothing" rule, and the
|
||||
* gate enforcing it is untouched.
|
||||
*
|
||||
* Caller checks that the request came from the coordinator. A member who
|
||||
* could name another member as silent could make them publish on demand --
|
||||
* the same bytes they already sent, so nothing on the wire changes, but it
|
||||
* is not a trigger to leave lying around.
|
||||
*/
|
||||
private suspend fun republishOwn(
|
||||
database: CurareDatabase,
|
||||
localChatRoom: LocalChatRoom,
|
||||
session: FrostSigningSession
|
||||
) {
|
||||
val own = OWN_KINDS.mapNotNull { kind -> ownMessage(database, session, kind) }
|
||||
if (own.isEmpty()) return
|
||||
|
||||
logger.i(
|
||||
"Session ${session.id}: the coordinator has not heard from this device; " +
|
||||
"republishing ${own.size} message(s) it already sent"
|
||||
)
|
||||
|
||||
own.forEach { message ->
|
||||
broadcast(
|
||||
database = database,
|
||||
localChatRoom = localChatRoom,
|
||||
session = session,
|
||||
kind = message.kind,
|
||||
content = message.payload,
|
||||
recipients = setOf(session.coordinatorPublicKey)
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
private suspend fun publishDecline(
|
||||
database: CurareDatabase,
|
||||
localChatRoom: LocalChatRoom,
|
||||
@@ -1839,6 +2144,34 @@ object FrostSigningManager {
|
||||
)
|
||||
}
|
||||
|
||||
/**
|
||||
* The line saying the coordinator knocked again.
|
||||
*
|
||||
* Its own type rather than another step: nothing moved, somebody asked. The
|
||||
* ladder should show that the knock happened so that a second one reads as a
|
||||
* second one -- which `FrostSigningSession.resentAt` makes true, since it is
|
||||
* what stops a tap from writing a line without publishing anything.
|
||||
*
|
||||
* Counted rather than named. Who is quiet is on the screen above this line,
|
||||
* member by member, and a transcript line listing four pubkeys is a line
|
||||
* nobody reads.
|
||||
*/
|
||||
private suspend fun announceResent(
|
||||
database: CurareDatabase,
|
||||
session: FrostSigningSession,
|
||||
silent: Int
|
||||
) {
|
||||
announce(
|
||||
database = database,
|
||||
session = session,
|
||||
messageType = ChatMessage.TYPE_FROST_RESENT,
|
||||
content = "asked " +
|
||||
(if (silent == 1) "the member" else "the $silent members") +
|
||||
" who have not answered to take another look.",
|
||||
actor = session.coordinatorPublicKey
|
||||
)
|
||||
}
|
||||
|
||||
private suspend fun announceStarted(database: CurareDatabase, session: FrostSigningSession) {
|
||||
val count = database.frostSigningSessionDao().countItems(session.id)
|
||||
|
||||
@@ -1979,6 +2312,10 @@ object FrostSigningManager {
|
||||
* has no local copy of. A crash between the two therefore costs a duplicate
|
||||
* broadcast — which every receiver folds away — rather than a message the
|
||||
* group waits on forever.
|
||||
*
|
||||
* Which cuts both ways, so a [broadcast] that queued nothing records
|
||||
* nothing: the local copy is the thing that stops the next pass from trying
|
||||
* again.
|
||||
*/
|
||||
private suspend fun publishOwn(
|
||||
database: CurareDatabase,
|
||||
@@ -1987,7 +2324,11 @@ object FrostSigningManager {
|
||||
kind: Kind,
|
||||
content: String
|
||||
) {
|
||||
broadcast(database, localChatRoom, session, kind, content)
|
||||
// Nothing is recorded if nothing was queued. The local copy is what stops
|
||||
// [advance] from publishing this again, so writing one for a message that
|
||||
// did not go out would be a message the group waits on forever -- the
|
||||
// opposite of the trade this order is for.
|
||||
if (!broadcast(database, localChatRoom, session, kind, content)) return
|
||||
|
||||
val known = ownMessage(database, session, kind) != null
|
||||
|
||||
@@ -2033,12 +2374,15 @@ object FrostSigningManager {
|
||||
kind: Kind,
|
||||
content: String,
|
||||
includeKey: Boolean = false,
|
||||
signerIds: List<Int>? = null
|
||||
) {
|
||||
signerIds: List<Int>? = null,
|
||||
silentMembers: List<HexKey>? = null,
|
||||
recipients: Set<HexKey>? = null
|
||||
): Boolean {
|
||||
val sessionTags = FrostSigningEvents.assembleTags(
|
||||
sessionId = session.id,
|
||||
dkgSessionId = if (includeKey) session.dkgSessionId else null,
|
||||
signerIds = signerIds
|
||||
signerIds = signerIds,
|
||||
silentMembers = silentMembers
|
||||
)
|
||||
|
||||
// No MLS state is what marks a room NIP-17 -- the same reading
|
||||
@@ -2049,20 +2393,55 @@ object FrostSigningManager {
|
||||
val tags = if (isMarmotRoom) {
|
||||
sessionTags
|
||||
} else {
|
||||
recipientTags(localChatRoom, session.userPublicKey) + sessionTags
|
||||
recipientTags(localChatRoom, session.userPublicKey, recipients) + sessionTags
|
||||
}
|
||||
|
||||
val createdAt = Clock.System.now().epochSeconds
|
||||
|
||||
// The rumor id the outbound pipeline will recompute from these same
|
||||
// fields when it assembles the event to encrypt, on either transport.
|
||||
val id = EventHasher.hashId(
|
||||
// fields when it assembles the event to encrypt, on either transport --
|
||||
// and with it the second this message claims to have been written in,
|
||||
// because that second is one of the fields.
|
||||
//
|
||||
// Which is why this is a search and not an assignment. `created_at` is
|
||||
// stored to the second, so a message re-published inside the same second
|
||||
// as the copy it repeats hashes to the same id; upserting that would put
|
||||
// an already-sent row back on the outbound queue with its
|
||||
// `marmotGroupEventId` cleared -- sending the message twice and losing
|
||||
// the row's mapping to the group event it became. So an id already in
|
||||
// the store is stepped past rather than written over. One second of drift
|
||||
// per collision is nothing a protocol message reads, and no caller
|
||||
// publishes faster than [MAX_ID_SEARCH] identical messages a second.
|
||||
var createdAt = Clock.System.now().epochSeconds
|
||||
var id = EventHasher.hashId(
|
||||
pubKey = session.userPublicKey,
|
||||
createdAt = createdAt,
|
||||
tags = tags,
|
||||
content = content,
|
||||
kind = kind
|
||||
)
|
||||
var attempts = 0
|
||||
|
||||
while (attempts < MAX_ID_SEARCH && isQueued(database, isMarmotRoom, id)) {
|
||||
createdAt += 1
|
||||
id = EventHasher.hashId(
|
||||
pubKey = session.userPublicKey,
|
||||
createdAt = createdAt,
|
||||
tags = tags,
|
||||
content = content,
|
||||
kind = kind
|
||||
)
|
||||
attempts += 1
|
||||
}
|
||||
|
||||
// Refused rather than written over. The row this would replace is a
|
||||
// message this device has already queued or sent, and clearing its
|
||||
// mapping is strictly worse than not repeating it.
|
||||
if (attempts >= MAX_ID_SEARCH) {
|
||||
logger.w(
|
||||
"Session ${session.id}: kind $kind already queued at every second tried; " +
|
||||
"not publishing it again"
|
||||
)
|
||||
return false
|
||||
}
|
||||
|
||||
if (isMarmotRoom) {
|
||||
database.marmotInnerEventDao().upsert(
|
||||
@@ -2089,6 +2468,19 @@ object FrostSigningManager {
|
||||
)
|
||||
)
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
/** Whether this id is already an outbound row on the room's transport. */
|
||||
private suspend fun isQueued(
|
||||
database: CurareDatabase,
|
||||
isMarmotRoom: Boolean,
|
||||
id: HexKey
|
||||
): Boolean = if (isMarmotRoom) {
|
||||
database.marmotInnerEventDao().getById(id) != null
|
||||
} else {
|
||||
database.giftWrapPayloadDao().getById(id) != null
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -2098,13 +2490,22 @@ object FrostSigningManager {
|
||||
* per recipient and this device already has its own copy -- `publishOwn`
|
||||
* records it locally. Deduplicated by member, since `localParticipants` is a
|
||||
* row list and a room can carry the same person twice.
|
||||
*
|
||||
* [only] narrows it, for a resend: a wrap is sealed per recipient, so
|
||||
* repeating a message for the two members who missed it costs two wraps
|
||||
* rather than the room's worth. Null means everybody, which is what every
|
||||
* first-time publish wants -- and a narrowing that matched nobody is read as
|
||||
* null rather than as a message addressed to no one, since an untagged
|
||||
* NIP-17 payload reaches nobody at all.
|
||||
*/
|
||||
private fun recipientTags(
|
||||
localChatRoom: LocalChatRoom,
|
||||
senderPublicKey: HexKey
|
||||
senderPublicKey: HexKey,
|
||||
only: Set<HexKey>? = null
|
||||
): Array<Array<String>> = localChatRoom.localParticipants
|
||||
.distinctBy { it.participant.participantPublicKey }
|
||||
.filter { it.participant.participantPublicKey != senderPublicKey }
|
||||
.filter { only.isNullOrEmpty() || it.participant.participantPublicKey in only }
|
||||
.map { localParticipant ->
|
||||
PTag.assemble(
|
||||
localParticipant.participant.participantPublicKey,
|
||||
|
||||
+17
-1
@@ -1,12 +1,14 @@
|
||||
package to.curare.compose.nostr.frost
|
||||
|
||||
import com.vitorpamplona.quartz.nip01Core.core.Event
|
||||
import com.vitorpamplona.quartz.nip01Core.core.HexKey
|
||||
import com.vitorpamplona.quartz.nip01Core.core.Kind
|
||||
import kotlinx.serialization.json.jsonArray
|
||||
import to.curare.compose.network.serialization.CommonJson
|
||||
import to.curare.compose.nostr.frost.tags.FrostKeyTag
|
||||
import to.curare.compose.nostr.frost.tags.FrostSessionIdTag
|
||||
import to.curare.compose.nostr.frost.tags.FrostSignerIdsTag
|
||||
import to.curare.compose.nostr.frost.tags.FrostSilentMembersTag
|
||||
|
||||
/**
|
||||
* The nostr kinds a FROST signing session is carried on.
|
||||
@@ -121,15 +123,22 @@ object FrostSigningEvents {
|
||||
/**
|
||||
* Tags for a signing message. The session id is on every kind so a message
|
||||
* from an abandoned attempt can be dropped rather than mixed in.
|
||||
*
|
||||
* [silentMembers] rides a resent proposal and nothing else. It is additive
|
||||
* in the only sense that matters: a build that does not know the tag ignores
|
||||
* it and accepts the proposal it is attached to, which is the half of a
|
||||
* resend that fixes the common case anyway. See [FrostSilentMembersTag].
|
||||
*/
|
||||
fun assembleTags(
|
||||
sessionId: String,
|
||||
dkgSessionId: String? = null,
|
||||
signerIds: List<Int>? = null
|
||||
signerIds: List<Int>? = null,
|
||||
silentMembers: List<HexKey>? = null
|
||||
): Array<Array<String>> = buildList {
|
||||
add(FrostSessionIdTag.assemble(sessionId))
|
||||
dkgSessionId?.let { add(FrostKeyTag.assemble(it)) }
|
||||
signerIds?.let { add(FrostSignerIdsTag.assemble(it)) }
|
||||
silentMembers?.takeIf { it.isNotEmpty() }?.let { add(FrostSilentMembersTag.assemble(it)) }
|
||||
}.toTypedArray()
|
||||
|
||||
fun parseSessionId(tags: Array<Array<String>>): String? =
|
||||
@@ -141,6 +150,13 @@ object FrostSigningEvents {
|
||||
fun parseSignerIds(tags: Array<Array<String>>): List<Int>? =
|
||||
tags.firstNotNullOfOrNull(FrostSignerIdsTag::parse)?.signerIds
|
||||
|
||||
/**
|
||||
* Who the coordinator says it has not heard from, or null on any proposal
|
||||
* that is not a resend.
|
||||
*/
|
||||
fun parseSilentMembers(tags: Array<Array<String>>): List<HexKey>? =
|
||||
tags.firstNotNullOfOrNull(FrostSilentMembersTag::parse)?.members
|
||||
|
||||
/**
|
||||
* The unsigned events of a proposal, as its content.
|
||||
*
|
||||
|
||||
+74
@@ -0,0 +1,74 @@
|
||||
package to.curare.compose.nostr.frost.tags
|
||||
|
||||
import com.vitorpamplona.quartz.nip01Core.core.HexKey
|
||||
import com.vitorpamplona.quartz.nip01Core.core.has
|
||||
import com.vitorpamplona.quartz.utils.ensure
|
||||
|
||||
/**
|
||||
* The share holders a coordinator has heard nothing from, carried on a resent
|
||||
* proposal.
|
||||
*
|
||||
* A proposer can resend what the proposer wrote, and nothing else: a nonce or a
|
||||
* refusal relayed by somebody else is filed under the relayer -- see
|
||||
* `FrostSigningManager.record`, which keys a signer's message on the inner
|
||||
* event's own `pubKey` -- and for a refusal that is a way to manufacture one.
|
||||
* So the resend names the quiet members instead, and their own devices
|
||||
* republish what they already said, under the keys that said it.
|
||||
*
|
||||
* It names rather than counts because a count cannot be acted on. A device
|
||||
* reading this tag is asking one question -- am I in it -- and the answer has
|
||||
* to be about them specifically.
|
||||
*
|
||||
* Only the coordinator's tag is honoured, and only to republish messages that
|
||||
* are already on file. Nothing here can talk a device into publishing a nonce
|
||||
* its owner has not approved; that gate is `advance`'s, and this does not reach
|
||||
* it. See `FrostSigningManager.republishOwn`.
|
||||
*
|
||||
* Carrying it leaks nothing. On Marmot every nonce is a group event the whole
|
||||
* room received, and on NIP-17 every member is p-tagged on every message, so
|
||||
* who has spoken is not a secret this could give away.
|
||||
*/
|
||||
class FrostSilentMembersTag(
|
||||
val members: List<HexKey>,
|
||||
) {
|
||||
fun toTagArray() = assemble(members = members)
|
||||
|
||||
companion object {
|
||||
const val TAG_NAME = "frost_silent"
|
||||
|
||||
/** The length of a nostr public key in hex, which is what this list holds. */
|
||||
private const val KEY_LENGTH = 64
|
||||
|
||||
/**
|
||||
* All or nothing, like [FrostSignerIdsTag]: a list naming the wrong
|
||||
* people is worse than no list. One unreadable entry means the whole tag
|
||||
* is dropped -- and the resend then simply nudges nobody, which is the
|
||||
* same as a build that does not write the tag at all.
|
||||
*/
|
||||
fun parse(tag: Array<String>): FrostSilentMembersTag? {
|
||||
ensure(tag.has(1)) { return null }
|
||||
ensure(tag[0] == TAG_NAME) { return null }
|
||||
|
||||
val members = tag[1].split(",").map { entry ->
|
||||
entry.trim().lowercase().takeIf { it.isHexKey() } ?: return null
|
||||
}
|
||||
if (members.isEmpty()) return null
|
||||
|
||||
return FrostSilentMembersTag(members = members)
|
||||
}
|
||||
|
||||
/**
|
||||
* Lowercased, because a pubkey is compared against
|
||||
* `FrostSigningSession.userPublicKey` by string equality and a tag that
|
||||
* shouted would name nobody.
|
||||
*/
|
||||
fun assemble(members: List<HexKey>): Array<String> =
|
||||
arrayOf(TAG_NAME, members.joinToString(",") { it.lowercase() })
|
||||
|
||||
fun assemble(frostSilentMembersTag: FrostSilentMembersTag) =
|
||||
assemble(members = frostSilentMembersTag.members)
|
||||
|
||||
private fun String.isHexKey(): Boolean =
|
||||
length == KEY_LENGTH && all { it in '0'..'9' || it in 'a'..'f' }
|
||||
}
|
||||
}
|
||||
+29
@@ -126,6 +126,30 @@ interface FrostSigningRepository {
|
||||
dependents: (lead: Event) -> List<EventTemplate<*>>
|
||||
): FrostSigningSession?
|
||||
|
||||
/**
|
||||
* Re-publishes the messages this device wrote for a session, for the members
|
||||
* it has heard nothing from.
|
||||
*
|
||||
* For a session left waiting on a member who has nothing to answer with: a
|
||||
* group event that decrypted to nothing because MLS had moved past the
|
||||
* generation it arrived at, a disappearing-message group that expired it off
|
||||
* the relay, a member added to the room after the proposal was made. A
|
||||
* resent message is a new message, so it is readable where the first one was
|
||||
* not.
|
||||
*
|
||||
* **The coordinator's own messages, and nobody else's.** A member's nonce is
|
||||
* read by nobody but the coordinator, who already has it -- which is how it
|
||||
* knows who is quiet -- so there is nothing of theirs to repeat. And a
|
||||
* message relayed by somebody else would be filed under the relayer, which
|
||||
* for a refusal is a way to manufacture one. What the resend does for a
|
||||
* silent member is name them, so their own device republishes what it
|
||||
* already said.
|
||||
*
|
||||
* Returns false when there was nothing to do: not this device's session,
|
||||
* already abandoned, nobody quiet, or inside the cooldown.
|
||||
*/
|
||||
suspend fun resend(localChatRoom: LocalChatRoom, sessionId: String): Boolean
|
||||
|
||||
/** Agrees to sign, letting the session publish this device's part and run on. */
|
||||
suspend fun approve(localChatRoom: LocalChatRoom, sessionId: String)
|
||||
|
||||
@@ -189,6 +213,11 @@ interface FrostSigningRepository {
|
||||
dependents: (lead: Event) -> List<EventTemplate<*>>
|
||||
): FrostSigningSession? = null
|
||||
|
||||
override suspend fun resend(
|
||||
localChatRoom: LocalChatRoom,
|
||||
sessionId: String
|
||||
): Boolean = false
|
||||
|
||||
override suspend fun approve(localChatRoom: LocalChatRoom, sessionId: String) = Unit
|
||||
|
||||
override suspend fun decline(localChatRoom: LocalChatRoom, sessionId: String) = Unit
|
||||
|
||||
+67
@@ -13,6 +13,7 @@ import androidx.compose.foundation.rememberScrollState
|
||||
import androidx.compose.foundation.verticalScroll
|
||||
import androidx.compose.material.icons.Icons
|
||||
import androidx.compose.material.icons.filled.Block
|
||||
import androidx.compose.material.icons.filled.Campaign
|
||||
import androidx.compose.material.icons.filled.CheckCircle
|
||||
import androidx.compose.material.icons.filled.Draw
|
||||
import androidx.compose.material.icons.filled.ErrorOutline
|
||||
@@ -34,6 +35,7 @@ import androidx.compose.material3.TextButton
|
||||
import androidx.compose.material3.TopAppBar
|
||||
import androidx.compose.runtime.Composable
|
||||
import androidx.compose.runtime.LaunchedEffect
|
||||
import androidx.compose.runtime.rememberCoroutineScope
|
||||
import androidx.compose.ui.Alignment
|
||||
import androidx.compose.ui.Modifier
|
||||
import androidx.compose.ui.text.style.TextAlign
|
||||
@@ -58,7 +60,13 @@ import to.curare.compose.ui.theme.spacing
|
||||
import to.curare.compose.ui.composable.widgets.Decorative
|
||||
import curare.composeapp.generated.resources.Res
|
||||
import org.jetbrains.compose.resources.stringResource
|
||||
import curare.composeapp.generated.resources.ask_again
|
||||
import curare.composeapp.generated.resources.asked_again
|
||||
import curare.composeapp.generated.resources.asked_again_recently
|
||||
import curare.composeapp.generated.resources.declined_to_sign
|
||||
import curare.composeapp.generated.resources.everyone_has_answered_this_session
|
||||
import curare.composeapp.generated.resources.members_have_not_answered
|
||||
import curare.composeapp.generated.resources.one_member_has_not_answered
|
||||
import curare.composeapp.generated.resources.don_t_sign
|
||||
import curare.composeapp.generated.resources.has_not_taken_part_yet
|
||||
import curare.composeapp.generated.resources.members
|
||||
@@ -70,6 +78,7 @@ import curare.composeapp.generated.resources.signed_their_part
|
||||
import curare.composeapp.generated.resources.events_signed_together
|
||||
import androidx.compose.material3.SnackbarHost
|
||||
import to.curare.compose.ui.composable.widgets.LocalSnackbarHostState
|
||||
import to.curare.compose.ui.composable.widgets.rememberNotifier
|
||||
import to.curare.compose.ui.composable.widgets.NavigateBackButton
|
||||
import to.curare.compose.ui.theme.readableContent
|
||||
import to.curare.compose.ui.theme.ConformancePreviews
|
||||
@@ -115,6 +124,13 @@ fun FrostSigningScreen(
|
||||
}
|
||||
}
|
||||
|
||||
// Both of these are composable and an onClick lambda is not, so they are
|
||||
// read here rather than in the handler. The notifier takes the caller's
|
||||
// scope on purpose -- see rememberNotifier.
|
||||
val notify = rememberNotifier(rememberCoroutineScope())
|
||||
val askedAgain = stringResource(Res.string.asked_again)
|
||||
val everyoneAnswered = stringResource(Res.string.everyone_has_answered_this_session)
|
||||
|
||||
Scaffold(
|
||||
snackbarHost = { SnackbarHost(LocalSnackbarHostState.current) },
|
||||
topBar = {
|
||||
@@ -261,6 +277,57 @@ fun FrostSigningScreen(
|
||||
}
|
||||
}
|
||||
|
||||
// The coordinator's knock, under the list of doors it is for.
|
||||
//
|
||||
// A session can wait forever on a member whose copy of the
|
||||
// proposal never arrived -- MLS dropped the generation it came
|
||||
// in at, or a disappearing-message group expired it off the
|
||||
// relay -- and neither heals on its own. Repeating the proposal
|
||||
// is the only thing that reaches them, and it also names them,
|
||||
// so that a member whose own answer went missing on the way
|
||||
// here says it again.
|
||||
if (state.canResend) {
|
||||
HorizontalDivider()
|
||||
|
||||
Text(
|
||||
text = if (state.silent.size == 1) {
|
||||
stringResource(Res.string.one_member_has_not_answered)
|
||||
} else {
|
||||
stringResource(
|
||||
Res.string.members_have_not_answered,
|
||||
state.silent.size
|
||||
)
|
||||
},
|
||||
style = MaterialTheme.typography.bodySmall
|
||||
)
|
||||
|
||||
// Disabled rather than hidden while the cooldown runs. A
|
||||
// control that vanishes after a tap reads as one that
|
||||
// failed, and what happened is that it worked.
|
||||
val waiting = state.resendAvailableAt != null
|
||||
|
||||
if (waiting) {
|
||||
Text(
|
||||
text = stringResource(Res.string.asked_again_recently),
|
||||
style = MaterialTheme.typography.bodySmall,
|
||||
color = MaterialTheme.colorScheme.onSurfaceVariant
|
||||
)
|
||||
}
|
||||
|
||||
Button(
|
||||
enabled = !waiting && !frostSigningViewModel.isActionPending.value,
|
||||
onClick = {
|
||||
frostSigningViewModel.resend { sent ->
|
||||
notify(if (sent) askedAgain else everyoneAnswered)
|
||||
}
|
||||
}
|
||||
) {
|
||||
Icon(Icons.Default.Campaign, contentDescription = Decorative)
|
||||
Spacer(modifier = Modifier.width(MaterialTheme.spacing.space125))
|
||||
Text(stringResource(Res.string.ask_again))
|
||||
}
|
||||
}
|
||||
|
||||
// Asked rather than re-derived: the manager owns when a session
|
||||
// is still waiting on its owner, and a second copy of that rule
|
||||
// here is a second copy to keep in step.
|
||||
|
||||
+5
@@ -33,6 +33,7 @@ import androidx.compose.material.icons.filled.CheckCircle
|
||||
import androidx.compose.material.icons.filled.ChevronRight
|
||||
import androidx.compose.material.icons.filled.ErrorOutline
|
||||
import androidx.compose.material.icons.filled.CallMerge
|
||||
import androidx.compose.material.icons.filled.Campaign
|
||||
import androidx.compose.material.icons.filled.FactCheck
|
||||
import androidx.compose.material.icons.filled.Draw
|
||||
import androidx.compose.material.icons.filled.Download
|
||||
@@ -825,6 +826,10 @@ private fun RitualNotice(
|
||||
// A refusal the session survived. Quiet on purpose: it is not an error,
|
||||
// and the one that ends a session is written as a failure instead.
|
||||
ChatMessage.TYPE_FROST_DECLINED -> Icons.Default.Block
|
||||
// Nothing moved; somebody knocked. Its own icon rather than the
|
||||
// proposal's, so that a resend does not read as a second proposal --
|
||||
// which is the one thing a session must never have.
|
||||
ChatMessage.TYPE_FROST_RESENT -> Icons.Default.Campaign
|
||||
ChatMessage.TYPE_FROST_APPROVAL_NEEDED -> Icons.Default.Draw
|
||||
|
||||
ChatMessage.TYPE_CHRONICLE_REQUESTED -> Icons.Default.History
|
||||
|
||||
+29
@@ -133,6 +133,35 @@ class FrostSigningViewModel(
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Asks the members this session has heard nothing from to take another look.
|
||||
*
|
||||
* Unlike [approve] and [decline] this does not navigate away: the point of
|
||||
* pressing it is to go on watching whether anybody answers, and the screen
|
||||
* is the only place that says who has. [onResult] is handed whether anything
|
||||
* actually went out, so the caller can say which happened -- a resend inside
|
||||
* the cooldown, or one where everybody has since answered, publishes nothing
|
||||
* and should not claim to have.
|
||||
*/
|
||||
fun resend(onResult: (sent: Boolean) -> Unit) {
|
||||
val state = frostSigningUIState as? FrostSigningUIState.Loaded ?: return
|
||||
val sessionId = state.session?.id ?: return
|
||||
|
||||
if (isActionPending.value) return
|
||||
isActionPending.value = true
|
||||
|
||||
viewModelScope.launch(Dispatchers.IO) {
|
||||
val sent = frostSigningRepository.resend(
|
||||
localChatRoom = state.localChatRoom,
|
||||
sessionId = sessionId
|
||||
)
|
||||
|
||||
isActionPending.value = false
|
||||
|
||||
viewModelScope.launch(Dispatchers.Main) { onResult.invoke(sent) }
|
||||
}
|
||||
}
|
||||
|
||||
fun decline(onDone: () -> Unit) {
|
||||
val state = frostSigningUIState as? FrostSigningUIState.Loaded ?: return
|
||||
val sessionId = state.session?.id ?: return
|
||||
|
||||
+50
@@ -1,11 +1,15 @@
|
||||
package to.curare.compose.ui.view.state
|
||||
|
||||
import com.vitorpamplona.quartz.nip01Core.core.HexKey
|
||||
import kotlin.time.Clock
|
||||
import kotlin.time.Instant
|
||||
import to.curare.compose.database.model.FrostSigningItem
|
||||
import to.curare.compose.database.model.FrostSigningSession
|
||||
import to.curare.compose.database.model.Participant
|
||||
import to.curare.compose.database.model.intermdiate.LocalChatRoom
|
||||
import to.curare.compose.database.model.intermdiate.LocalParticipant
|
||||
import to.curare.compose.database.model.types.FrostSigningStage
|
||||
import to.curare.compose.managers.FrostSigningManager
|
||||
|
||||
sealed interface FrostSigningUIState {
|
||||
data class Loaded(
|
||||
@@ -76,6 +80,52 @@ sealed interface FrostSigningUIState {
|
||||
|
||||
return inRoom + elsewhere
|
||||
}
|
||||
|
||||
/**
|
||||
* The share holders this session has heard nothing at all from.
|
||||
*
|
||||
* Whose door to knock on, as a set rather than as a list of rows: it is
|
||||
* what decides whether there is anything to knock about. A member who
|
||||
* refused is not here -- they answered, and asking again would be asking
|
||||
* a question they have closed.
|
||||
*
|
||||
* Derived rather than collected. Everything it is made of is already on
|
||||
* this state, and a second flow for it would be a second thing that can
|
||||
* disagree with the rows the screen draws.
|
||||
*/
|
||||
val silent: Set<HexKey> get() =
|
||||
shareHolders - offeredNonce - signed - declined - localChatRoom.chatRoom.userPublicKey
|
||||
|
||||
/**
|
||||
* Whether this device may ask the quiet members to take another look.
|
||||
*
|
||||
* The coordinator's, and nobody else's: `acceptProposal` takes a
|
||||
* session's coordinator from the author of the proposal that opened it,
|
||||
* so a resend from anybody else would have a member who was missing the
|
||||
* session believe the resender coordinates -- and then drop the real
|
||||
* coordinator's signer set. See `FrostSigningManager.resend`.
|
||||
*
|
||||
* An abandoned session is not resent either. Its nonce seeds have been
|
||||
* published against an aggregate already, so the retry is a fresh
|
||||
* proposal, which is what the status line says.
|
||||
*
|
||||
* The cooldown is deliberately not read here. A control that vanishes
|
||||
* after a tap reads as one that failed, so the section stays and the
|
||||
* button inside it is what goes quiet -- see [resendAvailableAt].
|
||||
*/
|
||||
val canResend: Boolean get() {
|
||||
val session = session ?: return false
|
||||
|
||||
return session.isCoordinator() &&
|
||||
session.stage != FrostSigningStage.FAILED &&
|
||||
items.isNotEmpty() &&
|
||||
silent.isNotEmpty()
|
||||
}
|
||||
|
||||
/** When the next resend may go out, or null when one may go out now. */
|
||||
val resendAvailableAt: Instant? get() = session?.resentAt
|
||||
?.plus(FrostSigningManager.RESEND_COOLDOWN)
|
||||
?.takeIf { it > Clock.System.now() }
|
||||
}
|
||||
|
||||
data class Error(
|
||||
|
||||
+109
@@ -0,0 +1,109 @@
|
||||
package to.curare.compose.nostr.frost
|
||||
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertNull
|
||||
import kotlin.test.assertTrue
|
||||
import to.curare.compose.nostr.frost.tags.FrostSilentMembersTag
|
||||
|
||||
/**
|
||||
* The tag a resent proposal carries, and what a reader makes of a bad one.
|
||||
*
|
||||
* It names the members a coordinator has heard nothing from, and a device reads
|
||||
* it to decide whether to republish its own messages. So the thing worth
|
||||
* testing is not the happy round trip but the failure: a list that named the
|
||||
* wrong people would have the wrong device speak, and a tag that is dropped
|
||||
* nudges nobody -- which is exactly what a build predating the tag does, and so
|
||||
* the safe way to fail.
|
||||
*/
|
||||
class FrostSilentMembersTagTest {
|
||||
private val alice = "a".repeat(64)
|
||||
private val bob = "b".repeat(64)
|
||||
|
||||
@Test
|
||||
fun `a list of members round trips in order`() {
|
||||
val assembled = FrostSilentMembersTag.assemble(listOf(alice, bob))
|
||||
|
||||
val parsed = FrostSilentMembersTag.parse(assembled)
|
||||
|
||||
assertEquals(listOf(alice, bob), parsed?.members)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `one member round trips`() {
|
||||
val parsed = FrostSilentMembersTag.parse(FrostSilentMembersTag.assemble(listOf(alice)))
|
||||
|
||||
assertEquals(listOf(alice), parsed?.members)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `an uppercase key is lowercased, because it is compared by string equality`() {
|
||||
// userPublicKey on a session is lowercase hex, and `contains` on the
|
||||
// parsed list is how a device decides whether it is being asked to
|
||||
// speak. A tag that shouted would name nobody.
|
||||
val assembled = FrostSilentMembersTag.assemble(listOf(alice.uppercase()))
|
||||
|
||||
assertEquals(listOf(alice), FrostSilentMembersTag.parse(assembled)?.members)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `one unreadable entry drops the whole tag`() {
|
||||
// All or nothing, like FrostSignerIdsTag. Keeping the readable half
|
||||
// would be nudging a subset the coordinator never chose.
|
||||
assertNull(FrostSilentMembersTag.parse(arrayOf(FrostSilentMembersTag.TAG_NAME, "$alice,nonsense")))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a key of the wrong length is not a key`() {
|
||||
assertNull(FrostSilentMembersTag.parse(arrayOf(FrostSilentMembersTag.TAG_NAME, "ab")))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `an empty list is not a tag`() {
|
||||
assertNull(FrostSilentMembersTag.parse(arrayOf(FrostSilentMembersTag.TAG_NAME, "")))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a tag of another name is not this one`() {
|
||||
assertNull(FrostSilentMembersTag.parse(arrayOf("p", alice)))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a tag with no value is not this one`() {
|
||||
assertNull(FrostSilentMembersTag.parse(arrayOf(FrostSilentMembersTag.TAG_NAME)))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `assembleTags carries the silent members and parses them back`() {
|
||||
val tags = FrostSigningEvents.assembleTags(
|
||||
sessionId = "session".padEnd(64, '0'),
|
||||
silentMembers = listOf(bob)
|
||||
)
|
||||
|
||||
assertEquals(listOf(bob), FrostSigningEvents.parseSilentMembers(tags))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `assembleTags writes no tag when nobody is silent`() {
|
||||
// An empty list is not a resend that nudges nobody, it is a resend with
|
||||
// nothing to say -- and an empty tag would parse to null anyway, so
|
||||
// writing one would only put a lie on the wire.
|
||||
val tags = FrostSigningEvents.assembleTags(
|
||||
sessionId = "session".padEnd(64, '0'),
|
||||
silentMembers = emptyList()
|
||||
)
|
||||
|
||||
assertTrue(tags.none { it[0] == FrostSilentMembersTag.TAG_NAME })
|
||||
assertNull(FrostSigningEvents.parseSilentMembers(tags))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `an ordinary proposal's tags name nobody`() {
|
||||
val tags = FrostSigningEvents.assembleTags(
|
||||
sessionId = "session".padEnd(64, '0'),
|
||||
dkgSessionId = "ceremony".padEnd(64, '0')
|
||||
)
|
||||
|
||||
assertNull(FrostSigningEvents.parseSilentMembers(tags))
|
||||
}
|
||||
}
|
||||
+203
@@ -0,0 +1,203 @@
|
||||
package to.curare.compose.ui.view.state
|
||||
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertFalse
|
||||
import kotlin.test.assertNotNull
|
||||
import kotlin.test.assertNull
|
||||
import kotlin.test.assertTrue
|
||||
import kotlin.time.Clock
|
||||
import to.curare.compose.database.model.ChatRoom
|
||||
import to.curare.compose.database.model.FrostSigningItem
|
||||
import to.curare.compose.database.model.FrostSigningSession
|
||||
import to.curare.compose.database.model.Participant
|
||||
import to.curare.compose.database.model.intermdiate.LocalChatRoom
|
||||
import to.curare.compose.database.model.intermdiate.LocalParticipant
|
||||
import to.curare.compose.database.model.types.FrostSigningStage
|
||||
import to.curare.compose.managers.FrostSigningManager
|
||||
|
||||
/**
|
||||
* When the signing screen offers to ask the quiet members again, and who it
|
||||
* counts as quiet.
|
||||
*
|
||||
* Both are derived on the state rather than collected, because everything they
|
||||
* are made of is already there -- the share holders, who offered a nonce, who
|
||||
* signed, who refused. A second flow for either would be a second thing that
|
||||
* can disagree with the rows drawn right above the button.
|
||||
*
|
||||
* The limits are what this pins. The offer is the coordinator's and nobody
|
||||
* else's: `acceptProposal` takes a session's coordinator from the author of the
|
||||
* proposal that opened it, so a resend from anybody else would have a member who
|
||||
* was missing the session believe the resender coordinates -- and then drop the
|
||||
* real coordinator's signer set.
|
||||
*/
|
||||
class FrostSigningResendStateTest {
|
||||
private val roomId = "11".repeat(32)
|
||||
|
||||
private val alice = "a".repeat(64)
|
||||
private val bob = "b".repeat(64)
|
||||
private val carol = "c".repeat(64)
|
||||
|
||||
private val holders = setOf(alice, bob, carol)
|
||||
|
||||
private fun room(owner: String) = LocalChatRoom(
|
||||
chatRoom = ChatRoom(
|
||||
id = roomId,
|
||||
userPublicKey = owner,
|
||||
subject = "#Ekklesia",
|
||||
description = null,
|
||||
mlsGroupState = null,
|
||||
),
|
||||
localParticipants = holders.sorted().map { publicKey ->
|
||||
LocalParticipant(
|
||||
participant = Participant(
|
||||
participantPublicKey = publicKey,
|
||||
chatRoomId = roomId,
|
||||
relayHint = null,
|
||||
),
|
||||
profile = null,
|
||||
)
|
||||
},
|
||||
)
|
||||
|
||||
private fun session(
|
||||
owner: String = alice,
|
||||
coordinator: String = alice,
|
||||
stage: FrostSigningStage = FrostSigningStage.COLLECTING_NONCES,
|
||||
resentAt: kotlin.time.Instant? = null,
|
||||
) = FrostSigningSession(
|
||||
id = "s".repeat(64),
|
||||
chatRoomId = roomId,
|
||||
coordinatorPublicKey = coordinator,
|
||||
userPublicKey = owner,
|
||||
dkgSessionId = "ceremony".padEnd(64, '0'),
|
||||
threshold = 2,
|
||||
participantCount = 3,
|
||||
signerId = 0,
|
||||
resentAt = resentAt,
|
||||
stage = stage,
|
||||
)
|
||||
|
||||
private val item = FrostSigningItem(
|
||||
sessionId = "s".repeat(64),
|
||||
itemIndex = 0,
|
||||
unsignedEventJson = "{}",
|
||||
eventId = "e".repeat(64),
|
||||
nonceRandom = "f".repeat(64),
|
||||
)
|
||||
|
||||
private fun loaded(
|
||||
owner: String = alice,
|
||||
coordinator: String = alice,
|
||||
stage: FrostSigningStage = FrostSigningStage.COLLECTING_NONCES,
|
||||
resentAt: kotlin.time.Instant? = null,
|
||||
offeredNonce: Set<String> = emptySet(),
|
||||
signed: Set<String> = emptySet(),
|
||||
declined: Set<String> = emptySet(),
|
||||
items: List<FrostSigningItem> = listOf(item),
|
||||
) = FrostSigningUIState.Loaded(
|
||||
localChatRoom = room(owner),
|
||||
session = session(owner, coordinator, stage, resentAt),
|
||||
items = items,
|
||||
shareHolders = holders,
|
||||
offeredNonce = offeredNonce,
|
||||
signed = signed,
|
||||
declined = declined,
|
||||
)
|
||||
|
||||
@Test
|
||||
fun `the quiet members are the share holders nobody has heard from`() {
|
||||
val state = loaded(offeredNonce = setOf(bob))
|
||||
|
||||
// Alice is this device: her own answer is not something to knock about.
|
||||
assertEquals(setOf(carol), state.silent)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a member who refused is not quiet`() {
|
||||
// They answered. Asking again would be asking a question they closed.
|
||||
assertEquals(setOf(carol), loaded(declined = setOf(bob)).silent)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a member who signed their part is not quiet`() {
|
||||
assertEquals(setOf(carol), loaded(signed = setOf(bob)).silent)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a session nobody has answered is quiet in everybody but its proposer`() {
|
||||
assertEquals(setOf(bob, carol), loaded().silent)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `the coordinator is offered the resend`() {
|
||||
assertTrue(loaded().canResend)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a member who did not propose is not offered it`() {
|
||||
// Correctness rather than etiquette -- see the class note.
|
||||
assertFalse(loaded(owner = bob, coordinator = alice).canResend)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a session everybody has answered has nothing to resend`() {
|
||||
val state = loaded(offeredNonce = setOf(bob), declined = setOf(carol))
|
||||
|
||||
assertTrue(state.silent.isEmpty())
|
||||
assertFalse(state.canResend)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `an abandoned session is not resent`() {
|
||||
// Its items' nonce seeds have been published against an aggregate
|
||||
// already. The retry is a fresh proposal, never this one again.
|
||||
assertFalse(loaded(stage = FrostSigningStage.FAILED).canResend)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a signed session can still be resent`() {
|
||||
// A member who never received the signature never applied the events.
|
||||
assertTrue(loaded(stage = FrostSigningStage.COMPLETE).canResend)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a session with no items yet is not resent`() {
|
||||
assertFalse(loaded(items = emptyList()).canResend)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a session not yet collected offers nothing`() {
|
||||
val state = FrostSigningUIState.Loaded(localChatRoom = room(alice))
|
||||
|
||||
assertFalse(state.canResend)
|
||||
assertNull(state.resendAvailableAt)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a session never resent may be resent now`() {
|
||||
assertNull(loaded().resendAvailableAt)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a session just resent says when it may go again`() {
|
||||
val now = Clock.System.now()
|
||||
val state = loaded(resentAt = now)
|
||||
|
||||
// Read by the screen to disable the button rather than hide the section:
|
||||
// a control that vanishes after a tap reads as one that failed.
|
||||
val availableAt = state.resendAvailableAt
|
||||
assertNotNull(availableAt)
|
||||
assertEquals(now + FrostSigningManager.RESEND_COOLDOWN, availableAt)
|
||||
assertTrue(state.canResend, "the offer stands; it is the button that goes quiet")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a session resent long ago may be resent again`() {
|
||||
val state = loaded(
|
||||
resentAt = Clock.System.now() - FrostSigningManager.RESEND_COOLDOWN * 2
|
||||
)
|
||||
|
||||
assertNull(state.resendAvailableAt)
|
||||
}
|
||||
}
|
||||
+772
@@ -0,0 +1,772 @@
|
||||
package to.curare.compose.managers
|
||||
|
||||
import androidx.room3.Room
|
||||
import com.vitorpamplona.quartz.nip01Core.core.Event
|
||||
import com.vitorpamplona.quartz.nip01Core.core.HexKey
|
||||
import com.vitorpamplona.quartz.nip01Core.core.Kind
|
||||
import fr.acinq.bitcoin.ByteVector32
|
||||
import fr.acinq.bitcoin.PrivateKey
|
||||
import fr.acinq.bitcoin.crypto.frost.Frost
|
||||
import fr.acinq.bitcoin.crypto.frost.KeyMaterial
|
||||
import kotlin.test.AfterTest
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertFalse
|
||||
import kotlin.test.assertNotNull
|
||||
import kotlin.test.assertNull
|
||||
import kotlin.test.assertTrue
|
||||
import kotlin.time.Clock
|
||||
import kotlinx.coroutines.runBlocking
|
||||
import to.curare.compose.database.CurareDatabase
|
||||
import to.curare.compose.database.builder.getRoomDatabase
|
||||
import to.curare.compose.database.model.ChatMessage
|
||||
import to.curare.compose.database.model.ChatRoom
|
||||
import to.curare.compose.database.model.DkgParticipantMessage
|
||||
import to.curare.compose.database.model.DkgSession
|
||||
import to.curare.compose.database.model.FrostSignerMessage
|
||||
import to.curare.compose.database.model.FrostSigningItem
|
||||
import to.curare.compose.database.model.FrostSigningSession
|
||||
import to.curare.compose.database.model.GiftWrapPayload
|
||||
import to.curare.compose.database.model.NostrEvent
|
||||
import to.curare.compose.database.model.Participant
|
||||
import to.curare.compose.database.model.Profile
|
||||
import to.curare.compose.database.model.intermdiate.LocalChatRoom
|
||||
import to.curare.compose.database.model.intermdiate.LocalParticipant
|
||||
import to.curare.compose.database.model.types.DkgRitualStage
|
||||
import to.curare.compose.database.model.types.FrostSigningStage
|
||||
import to.curare.compose.extensions.toHex
|
||||
import to.curare.compose.nostr.dkg.DkgRitualEvents
|
||||
import to.curare.compose.nostr.frost.FrostSigningEvents
|
||||
|
||||
/**
|
||||
* What a resend does, against a real database and the real manager.
|
||||
*
|
||||
* A session can be left waiting forever on a member who would have agreed,
|
||||
* because the message asking them never arrived -- MLS moved its ratchet past
|
||||
* the generation it came in at (`docs/mls-skipped-keys.md`), or a
|
||||
* disappearing-message group expired it off the relay. Neither heals on its own
|
||||
* and neither is visible to the sender.
|
||||
*
|
||||
* Two halves, and the second is the one worth testing hardest. The coordinator
|
||||
* repeats what the coordinator wrote; a member named as silent repeats what
|
||||
* *they* wrote, because a relayed copy would be filed under the relayer. The
|
||||
* tests below are mostly about the limits of that: the same bytes and not new
|
||||
* ones, nothing at all from a device whose owner has not decided, and nothing
|
||||
* from a nudge that did not come from the coordinator.
|
||||
*/
|
||||
class FrostSigningResendJvmTest {
|
||||
private val participants = 3
|
||||
private val threshold = 2
|
||||
|
||||
/** Stands in for a completed ceremony; the test is about resending, not the DKG. */
|
||||
private val keyMaterial: KeyMaterial = Frost.trustedDealerKeygen(
|
||||
thresholdSecretKey = PrivateKey(
|
||||
ByteVector32("1c0ffee0000000000000000000000000000000000000000000000000000000a1")
|
||||
),
|
||||
nParticipants = participants,
|
||||
threshold = threshold
|
||||
)
|
||||
|
||||
private val thresholdPublicKey = keyMaterial.thresholdPublicKey.value.toHex()
|
||||
|
||||
/** The admin room: the group's key walked to the admin path, which is its id. */
|
||||
private val 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 val alice = members[0]
|
||||
private val bob = members[1]
|
||||
private val carol = members[2]
|
||||
|
||||
private lateinit var db: CurareDatabase
|
||||
private lateinit var room: LocalChatRoom
|
||||
|
||||
@AfterTest
|
||||
fun closeDatabase() {
|
||||
if (::db.isInitialized) db.close()
|
||||
}
|
||||
|
||||
/**
|
||||
* One member's device: a room it can sign in, and their share to sign with.
|
||||
*
|
||||
* The room carries its roster, unlike the decline test's, because this one
|
||||
* is about who a message is addressed to: the room here is NIP-17 -- no MLS
|
||||
* state -- so a payload is sealed per p-tag, and narrowing a resend to the
|
||||
* quiet members is visible only if there is somebody to leave out.
|
||||
*/
|
||||
private suspend fun openDevice(owner: HexKey = alice) {
|
||||
db = getRoomDatabase(Room.inMemoryDatabaseBuilder<CurareDatabase>())
|
||||
|
||||
val index = members.indexOf(owner)
|
||||
|
||||
val nostrEventId = "e$owner".take(64)
|
||||
db.nostrEventDao().upsert(
|
||||
NostrEvent(
|
||||
id = nostrEventId,
|
||||
pubKey = owner,
|
||||
kind = 0,
|
||||
tags = emptyArray(),
|
||||
content = "{}",
|
||||
sig = "0".repeat(128)
|
||||
)
|
||||
)
|
||||
db.profileDao().upsert(Profile(publicKey = owner, nostrEventId = nostrEventId))
|
||||
|
||||
val chatRoom = ChatRoom(
|
||||
id = roomId,
|
||||
userPublicKey = owner,
|
||||
subject = "#Ekklesia",
|
||||
description = SharedKeyDerivation.describe("Admins of the group."),
|
||||
mlsGroupState = null
|
||||
)
|
||||
db.chatRoomDao().upsert(chatRoom)
|
||||
|
||||
db.dkgSessionDao().upsert(
|
||||
DkgSession(
|
||||
id = ceremonyId,
|
||||
chatRoomId = roomId,
|
||||
coordinatorPublicKey = alice,
|
||||
userPublicKey = owner,
|
||||
threshold = threshold,
|
||||
participantCount = participants,
|
||||
stage = DkgRitualStage.COMPLETE,
|
||||
hostPublicKey = hostKeys[index],
|
||||
round1Random = "1".repeat(64),
|
||||
round2AuxRandom = "2".repeat(64),
|
||||
thresholdPublicKey = thresholdPublicKey,
|
||||
secretShare = keyMaterial.secretShares[index].value.toHex(),
|
||||
publicShares = keyMaterial.publicShares.joinToString(",") { it.value.toHex() }
|
||||
)
|
||||
)
|
||||
|
||||
members.forEachIndexed { i, member ->
|
||||
db.dkgSessionDao().upsert(
|
||||
DkgParticipantMessage(
|
||||
sessionId = ceremonyId,
|
||||
participantPublicKey = member,
|
||||
kind = DkgRitualEvents.HOST_KEY,
|
||||
payload = hostKeys[i]
|
||||
)
|
||||
)
|
||||
}
|
||||
|
||||
room = LocalChatRoom(
|
||||
chatRoom = chatRoom,
|
||||
localParticipants = members.map { member ->
|
||||
LocalParticipant(
|
||||
Participant(
|
||||
participantPublicKey = member,
|
||||
chatRoomId = roomId,
|
||||
relayHint = null
|
||||
),
|
||||
null
|
||||
)
|
||||
}
|
||||
)
|
||||
}
|
||||
|
||||
/** Alice proposes, which makes her device the coordinator and agrees on her behalf. */
|
||||
private suspend fun propose(): FrostSigningSession = FrostSigningManager.proposeSigning(
|
||||
database = db,
|
||||
localChatRoom = room,
|
||||
userPublicKey = alice,
|
||||
kind = 1,
|
||||
tags = arrayOf(),
|
||||
content = "Something for the group to say"
|
||||
)
|
||||
|
||||
/**
|
||||
* A session as it sits on a member's device once Alice's proposal has
|
||||
* arrived: recorded, awaiting the owner's answer, and nothing published.
|
||||
*
|
||||
* The item carries a real unsigned event rather than `{}`, because a resend
|
||||
* refuses to repeat a proposal whose stored events will not parse -- a
|
||||
* proposal that quietly lost one would have every signer's contribution
|
||||
* rejected for being the wrong length.
|
||||
*/
|
||||
private suspend fun proposalArrivedAt(owner: HexKey): FrostSigningSession {
|
||||
val session = FrostSigningSession(
|
||||
id = "s".repeat(64),
|
||||
chatRoomId = roomId,
|
||||
coordinatorPublicKey = alice,
|
||||
userPublicKey = owner,
|
||||
dkgSessionId = ceremonyId,
|
||||
threshold = threshold,
|
||||
participantCount = participants,
|
||||
signerId = members.indexOf(owner),
|
||||
derivationPath = SharedKeyDerivation.formatPath(SharedKeyDerivation.MARMOT_ADMIN_GROUP_PATH)
|
||||
)
|
||||
db.frostSigningSessionDao().upsert(session)
|
||||
db.frostSigningSessionDao().upsertItems(
|
||||
listOf(
|
||||
FrostSigningItem(
|
||||
sessionId = session.id,
|
||||
itemIndex = 0,
|
||||
unsignedEventJson = unsignedEvent().toJson(),
|
||||
eventId = unsignedEvent().id,
|
||||
nonceRandom = "f".repeat(64)
|
||||
)
|
||||
)
|
||||
)
|
||||
return session
|
||||
}
|
||||
|
||||
/** The one event these sessions sign, as the room's own key would author it. */
|
||||
private fun unsignedEvent(): Event = Event(
|
||||
id = "e".repeat(64),
|
||||
pubKey = roomId,
|
||||
createdAt = 1_700_000_000L,
|
||||
kind = 1,
|
||||
tags = arrayOf(),
|
||||
content = "Something for the group to say",
|
||||
sig = ""
|
||||
)
|
||||
|
||||
/**
|
||||
* One signing message, as the inbound path would hand it over.
|
||||
*
|
||||
* [silent] is what a resent proposal carries: the members the coordinator
|
||||
* says it has heard nothing from.
|
||||
*/
|
||||
private suspend fun receive(
|
||||
sessionId: String,
|
||||
kind: Kind,
|
||||
member: HexKey,
|
||||
content: String = "",
|
||||
silent: List<HexKey>? = null,
|
||||
includeKey: Boolean = false
|
||||
) {
|
||||
FrostSigningManager.processSigningPayload(
|
||||
database = db,
|
||||
localChatRoom = room,
|
||||
innerEvent = Event(
|
||||
id = "$kind$member$content$silent".hashCode().toUInt().toString(16).padStart(64, '0'),
|
||||
pubKey = member,
|
||||
createdAt = Clock.System.now().epochSeconds,
|
||||
kind = kind,
|
||||
tags = FrostSigningEvents.assembleTags(
|
||||
sessionId = sessionId,
|
||||
dkgSessionId = if (includeKey) ceremonyId else null,
|
||||
silentMembers = silent
|
||||
),
|
||||
content = content,
|
||||
sig = ""
|
||||
),
|
||||
userPublicKey = room.chatRoom.userPublicKey
|
||||
)
|
||||
}
|
||||
|
||||
private suspend fun resend(sessionId: String) =
|
||||
FrostSigningManager.resend(database = db, localChatRoom = room, sessionId = sessionId)
|
||||
|
||||
private suspend fun session(id: String) = db.frostSigningSessionDao().getSessionById(id)!!
|
||||
|
||||
private suspend fun transcript(type: String) = db.chatMessageDao()
|
||||
.getChatMessagesByChatRoomId(roomId)
|
||||
.map { it.chatMessage }
|
||||
.filter { it.messageType == type }
|
||||
|
||||
/** What this device has queued for the group, of one kind. The room is NIP-17 here. */
|
||||
private suspend fun queued(kind: Kind) = db.giftWrapPayloadDao()
|
||||
.getByChatRoomAndKinds(roomId, listOf(kind))
|
||||
.filter { it.publicKey == room.chatRoom.userPublicKey }
|
||||
|
||||
private fun pTags(tags: Array<Array<String>>): Set<HexKey> =
|
||||
tags.filter { it[0] == "p" }.map { it[1] }.toSet()
|
||||
|
||||
/**
|
||||
* The row [publish] added to the queue, found by id rather than by time.
|
||||
*
|
||||
* `createdAt` is stored to the second, so a resend and the publish it
|
||||
* repeats routinely share one -- picking "the newest" is a coin toss
|
||||
* between them, and the coin came up wrong often enough to be worth not
|
||||
* tossing.
|
||||
*/
|
||||
private suspend fun queuedBy(kind: Kind, publish: suspend () -> Unit): GiftWrapPayload {
|
||||
val before = queued(kind).map { it.id }.toSet()
|
||||
publish()
|
||||
val after = queued(kind).filter { it.id !in before }
|
||||
assertEquals(1, after.size, "expected exactly one new queued row of kind $kind")
|
||||
return after.single()
|
||||
}
|
||||
|
||||
// ---- the coordinator's half -------------------------------------------
|
||||
|
||||
@Test
|
||||
fun `a resend repeats the proposal and names who has not answered`() = runBlocking {
|
||||
openDevice()
|
||||
val session = propose()
|
||||
|
||||
// Alice proposed, so her nonce is on file. Nobody else has said anything.
|
||||
assertEquals(1, queued(FrostSigningEvents.PROPOSAL).size)
|
||||
|
||||
val resent = queuedBy(FrostSigningEvents.PROPOSAL) { assertTrue(resend(session.id)) }
|
||||
|
||||
assertEquals(
|
||||
2,
|
||||
queued(FrostSigningEvents.PROPOSAL).size,
|
||||
"the resend is a second proposal, not an edit of the first"
|
||||
)
|
||||
|
||||
assertEquals(
|
||||
setOf(bob, carol),
|
||||
FrostSigningEvents.parseSilentMembers(resent.tags)?.toSet(),
|
||||
"both members who have said nothing are named"
|
||||
)
|
||||
|
||||
// The proposer is never in the silent set: it is their own session.
|
||||
assertFalse(alice in FrostSigningEvents.parseSilentMembers(resent.tags)!!)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a resend carries the key, so a device with no session can open one`() = runBlocking {
|
||||
openDevice()
|
||||
val session = propose()
|
||||
|
||||
val resent = queuedBy(FrostSigningEvents.PROPOSAL) { assertTrue(resend(session.id)) }
|
||||
|
||||
// Without this a receiver that never saw the first proposal drops the
|
||||
// second: `acceptProposal` refuses a proposal that names no key.
|
||||
assertEquals(ceremonyId, FrostSigningEvents.parseKey(resent.tags))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a resend repeats the same events, not new ones`() = runBlocking {
|
||||
openDevice()
|
||||
val session = propose()
|
||||
val signing = db.frostSigningSessionDao().getItems(session.id).map { it.eventId }
|
||||
|
||||
val resent = queuedBy(FrostSigningEvents.PROPOSAL) { assertTrue(resend(session.id)) }
|
||||
val proposed = FrostSigningEvents.decodeProposal(resent.content)
|
||||
|
||||
// The load-bearing one. A resend that proposed different events under the
|
||||
// same session id would be asking for two signatures out of one secret
|
||||
// nonce, which `acceptProposal` refuses -- so it would be a resend that
|
||||
// repairs nothing while looking like it worked.
|
||||
assertEquals(signing, proposed?.map { it.id })
|
||||
assertEquals(signing, db.frostSigningSessionDao().getItems(session.id).map { it.eventId })
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a resend is narrowed to the members it is for`() = runBlocking {
|
||||
openDevice()
|
||||
val session = propose()
|
||||
|
||||
val first = queued(FrostSigningEvents.PROPOSAL).single()
|
||||
|
||||
// Bob answers; Carol does not. A refusal rather than a nonce, because
|
||||
// Alice already holds her own: a second nonce reaches the threshold and
|
||||
// sends her off to aggregate, which this test has nothing valid to give
|
||||
// her. One refusal in a 2-of-3 group leaves the session open.
|
||||
receive(session.id, FrostSigningEvents.DECLINE, bob, "Declined to sign")
|
||||
assertEquals(FrostSigningStage.COLLECTING_NONCES, session(session.id).stage)
|
||||
|
||||
val resent = queuedBy(FrostSigningEvents.PROPOSAL) { assertTrue(resend(session.id)) }
|
||||
|
||||
// A NIP-17 payload is sealed once per p-tag, so repeating a message for
|
||||
// the one member who missed it should cost one wrap and not the room's
|
||||
// worth. The first proposal named everybody; this one names Carol.
|
||||
assertEquals(setOf(carol), pTags(resent.tags))
|
||||
assertEquals(setOf(bob, carol), pTags(first.tags))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a member who declined is not silent`() = runBlocking {
|
||||
openDevice()
|
||||
val session = propose()
|
||||
|
||||
receive(session.id, FrostSigningEvents.DECLINE, bob, "Declined to sign")
|
||||
|
||||
val resent = queuedBy(FrostSigningEvents.PROPOSAL) { assertTrue(resend(session.id)) }
|
||||
|
||||
// Bob answered. Knocking again would be asking a question he has closed.
|
||||
assertEquals(setOf(carol), FrostSigningEvents.parseSilentMembers(resent.tags)?.toSet())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a resend with nobody silent does nothing`() = runBlocking {
|
||||
openDevice()
|
||||
val session = propose()
|
||||
|
||||
// Bob refuses, and Carol's nonce is written straight to the message table
|
||||
// rather than delivered: a second nonce reaching Alice would send her off
|
||||
// to aggregate it, and this test has no valid nonce to give her. What is
|
||||
// being checked is who counts as silent, which is read from these rows.
|
||||
receive(session.id, FrostSigningEvents.DECLINE, bob, "Declined to sign")
|
||||
db.frostSigningSessionDao().upsert(
|
||||
FrostSignerMessage(
|
||||
sessionId = session.id,
|
||||
signerPublicKey = carol,
|
||||
kind = FrostSigningEvents.NONCE,
|
||||
payload = "c".repeat(132)
|
||||
)
|
||||
)
|
||||
|
||||
assertFalse(resend(session.id))
|
||||
assertEquals(1, queued(FrostSigningEvents.PROPOSAL).size)
|
||||
assertTrue(transcript(ChatMessage.TYPE_FROST_RESENT).isEmpty())
|
||||
assertNull(session(session.id).resentAt)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `only the device that proposed may resend`() = runBlocking {
|
||||
openDevice(bob)
|
||||
val session = proposalArrivedAt(bob)
|
||||
|
||||
assertFalse(resend(session.id))
|
||||
assertTrue(queued(FrostSigningEvents.PROPOSAL).isEmpty())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `an abandoned session is not resent`() = runBlocking {
|
||||
openDevice()
|
||||
val session = propose()
|
||||
|
||||
receive(session.id, FrostSigningEvents.FAILURE, bob, "Something went wrong")
|
||||
assertEquals(FrostSigningStage.FAILED, session(session.id).stage)
|
||||
|
||||
// Its items' nonce seeds have been published against an aggregate
|
||||
// already. The retry is a fresh proposal, never this one again.
|
||||
assertFalse(resend(session.id))
|
||||
assertEquals(1, queued(FrostSigningEvents.PROPOSAL).size)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `the cooldown stops a second resend`() = runBlocking {
|
||||
openDevice()
|
||||
val session = propose()
|
||||
|
||||
assertTrue(resend(session.id))
|
||||
val resentAt = session(session.id).resentAt
|
||||
assertNotNull(resentAt)
|
||||
|
||||
assertFalse(resend(session.id), "a second tap inside the cooldown publishes nothing")
|
||||
assertEquals(2, queued(FrostSigningEvents.PROPOSAL).size)
|
||||
assertEquals(1, transcript(ChatMessage.TYPE_FROST_RESENT).size)
|
||||
assertEquals(resentAt, session(session.id).resentAt)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a resend past the cooldown goes out again`() = runBlocking {
|
||||
openDevice()
|
||||
val session = propose()
|
||||
|
||||
assertTrue(resend(session.id))
|
||||
|
||||
// Wound back rather than waited out: the cooldown is minutes.
|
||||
db.frostSigningSessionDao().upsert(
|
||||
session(session.id).copy(
|
||||
resentAt = Clock.System.now() - FrostSigningManager.RESEND_COOLDOWN * 2
|
||||
)
|
||||
)
|
||||
|
||||
assertTrue(resend(session.id))
|
||||
assertEquals(3, queued(FrostSigningEvents.PROPOSAL).size)
|
||||
assertEquals(2, transcript(ChatMessage.TYPE_FROST_RESENT).size)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `two resends in the same second do not collide`() = runBlocking {
|
||||
openDevice()
|
||||
val session = propose()
|
||||
|
||||
assertTrue(resend(session.id))
|
||||
db.frostSigningSessionDao().upsert(session(session.id).copy(resentAt = null))
|
||||
assertTrue(resend(session.id))
|
||||
|
||||
val proposals = queued(FrostSigningEvents.PROPOSAL)
|
||||
|
||||
// An outbound row's id is a hash over its `created_at`, which is stored
|
||||
// to the second. Two identical publishes inside one second would hash
|
||||
// the same, and the upsert would put the already-sent row back on the
|
||||
// queue with its mapping cleared -- double-sending it and losing the
|
||||
// group event it became. So the second steps a second forward instead.
|
||||
assertEquals(3, proposals.size)
|
||||
assertEquals(3, proposals.map { it.id }.toSet().size, "three rows, three ids")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a resend writes one line in the transcript`() = runBlocking {
|
||||
openDevice()
|
||||
val session = propose()
|
||||
|
||||
assertTrue(resend(session.id))
|
||||
|
||||
val lines = transcript(ChatMessage.TYPE_FROST_RESENT)
|
||||
assertEquals(1, lines.size)
|
||||
assertEquals(alice, lines.single().senderPublicKey)
|
||||
assertTrue(lines.single().content.contains("2 members"))
|
||||
}
|
||||
|
||||
// ---- the member's half ------------------------------------------------
|
||||
|
||||
@Test
|
||||
fun `a member named as silent republishes the nonce they already sent`() = runBlocking {
|
||||
openDevice(bob)
|
||||
val session = proposalArrivedAt(bob)
|
||||
|
||||
FrostSigningManager.approve(database = db, localChatRoom = room, sessionId = session.id)
|
||||
|
||||
val first = queued(FrostSigningEvents.NONCE)
|
||||
assertEquals(1, first.size)
|
||||
|
||||
// Alice never got it, and says so.
|
||||
val resent = queuedBy(FrostSigningEvents.NONCE) {
|
||||
receive(session.id, FrostSigningEvents.PROPOSAL, alice, proposalContent(), silent = listOf(bob))
|
||||
}
|
||||
|
||||
assertEquals(2, queued(FrostSigningEvents.NONCE).size, "the nonce goes out a second time")
|
||||
|
||||
// The load-bearing assertion in this file. Two different nonces for one
|
||||
// message against two aggregates is how a secret share is extracted, so
|
||||
// a republish has to be the same bytes and not a fresh nonce.
|
||||
assertEquals(first.single().content, resent.content, "the same bytes, not a new nonce")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a republished nonce goes only to the coordinator`() = runBlocking {
|
||||
openDevice(bob)
|
||||
val session = proposalArrivedAt(bob)
|
||||
|
||||
FrostSigningManager.approve(database = db, localChatRoom = room, sessionId = session.id)
|
||||
|
||||
val resent = queuedBy(FrostSigningEvents.NONCE) {
|
||||
receive(session.id, FrostSigningEvents.PROPOSAL, alice, proposalContent(), silent = listOf(bob))
|
||||
}
|
||||
|
||||
// A nonce is read by nobody but the coordinator -- `orderedNonces` is
|
||||
// called under `isCoordinator` -- so repeating it for the room would be
|
||||
// two wraps spent telling people who do not look.
|
||||
assertEquals(setOf(alice), pTags(resent.tags))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a member named as silent who has not decided publishes nothing`() = runBlocking {
|
||||
openDevice(bob)
|
||||
val session = proposalArrivedAt(bob)
|
||||
|
||||
assertTrue(queued(FrostSigningEvents.NONCE).isEmpty())
|
||||
|
||||
receive(session.id, FrostSigningEvents.PROPOSAL, alice, proposalContent(), silent = listOf(bob))
|
||||
|
||||
// The strongest limit here. A message from the coordinator must never be
|
||||
// able to put this device's share behind events its owner has not agreed
|
||||
// to; the session is still waiting on a person, and says so.
|
||||
assertTrue(queued(FrostSigningEvents.NONCE).isEmpty())
|
||||
assertNull(session(session.id).signApprovedAt)
|
||||
assertTrue(
|
||||
FrostSigningManager.isAwaitingApproval(
|
||||
session(session.id),
|
||||
db.frostSigningSessionDao().getItems(session.id)
|
||||
)
|
||||
)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a member named as silent republishes the refusal they already sent`() = runBlocking {
|
||||
openDevice(bob)
|
||||
val session = proposalArrivedAt(bob)
|
||||
|
||||
FrostSigningManager.decline(database = db, localChatRoom = room, sessionId = session.id)
|
||||
val first = queued(FrostSigningEvents.DECLINE)
|
||||
assertEquals(1, first.size)
|
||||
|
||||
val resent = queuedBy(FrostSigningEvents.DECLINE) {
|
||||
receive(session.id, FrostSigningEvents.PROPOSAL, alice, proposalContent(), silent = listOf(bob))
|
||||
}
|
||||
|
||||
assertEquals(2, queued(FrostSigningEvents.DECLINE).size)
|
||||
assertEquals(first.single().content, resent.content)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a member not named stays quiet`() = runBlocking {
|
||||
openDevice(bob)
|
||||
val session = proposalArrivedAt(bob)
|
||||
|
||||
FrostSigningManager.approve(database = db, localChatRoom = room, sessionId = session.id)
|
||||
assertEquals(1, queued(FrostSigningEvents.NONCE).size)
|
||||
|
||||
receive(session.id, FrostSigningEvents.PROPOSAL, alice, proposalContent(), silent = listOf(carol))
|
||||
|
||||
assertEquals(1, queued(FrostSigningEvents.NONCE).size)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a nudge from somebody who is not the coordinator is ignored`() = runBlocking {
|
||||
openDevice(bob)
|
||||
val session = proposalArrivedAt(bob)
|
||||
|
||||
FrostSigningManager.approve(database = db, localChatRoom = room, sessionId = session.id)
|
||||
assertEquals(1, queued(FrostSigningEvents.NONCE).size)
|
||||
|
||||
// Carol naming Bob as silent. The bytes Bob would send are ones he has
|
||||
// already sent, so nothing on the wire changes -- but a publish anybody
|
||||
// in the room can trigger is not a thing to leave lying around.
|
||||
receive(session.id, FrostSigningEvents.PROPOSAL, carol, proposalContent(), silent = listOf(bob))
|
||||
|
||||
assertEquals(1, queued(FrostSigningEvents.NONCE).size)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a resent proposal for a session already held changes nothing about it`() = runBlocking {
|
||||
openDevice(bob)
|
||||
val session = proposalArrivedAt(bob)
|
||||
val before = db.frostSigningSessionDao().getItems(session.id)
|
||||
|
||||
receive(session.id, FrostSigningEvents.PROPOSAL, alice, proposalContent(), silent = listOf(bob))
|
||||
|
||||
val after = db.frostSigningSessionDao().getItems(session.id)
|
||||
assertEquals(before.map { it.eventId }, after.map { it.eventId })
|
||||
assertEquals(before.map { it.nonceRandom }, after.map { it.nonceRandom })
|
||||
// `acceptProposal` returns the session it already holds before it
|
||||
// announces anything, so a resend writes no second "asked the group"
|
||||
// line -- and this device's session was written straight to the row,
|
||||
// so there is no first one either.
|
||||
assertTrue(transcript(ChatMessage.TYPE_FROST_STARTED).isEmpty())
|
||||
}
|
||||
|
||||
/** What a resent proposal carries: the events of [proposalArrivedAt]'s session. */
|
||||
private fun proposalContent(): String =
|
||||
FrostSigningEvents.encodeProposal(listOf(unsignedEvent()))
|
||||
|
||||
// ---- the case the feature exists for ----------------------------------
|
||||
|
||||
/**
|
||||
* A real resent proposal, taken off a coordinator device and handed to a
|
||||
* member's.
|
||||
*
|
||||
* Two databases rather than a hand-written row, because this is the one test
|
||||
* that goes through [FrostSigningManager.acceptProposal] from the outside. An
|
||||
* event's id is rebuilt from its own fields under the author the *receiver*
|
||||
* resolves -- the room's key at the room's derivation path, never the
|
||||
* proposer's word for it -- and a proposal whose id does not survive that is
|
||||
* dropped. A fabricated event cannot pass it, which is the point of the
|
||||
* check, so the proposal has to be one a coordinator really made.
|
||||
*
|
||||
* Returns the session id and the resent proposal's content, with [db] and
|
||||
* [room] left pointing at [owner]'s freshly opened device.
|
||||
*/
|
||||
private suspend fun resentProposalFor(owner: HexKey): Pair<String, String> {
|
||||
openDevice(alice)
|
||||
val session = propose()
|
||||
val resent = queuedBy(FrostSigningEvents.PROPOSAL) {
|
||||
assertTrue(FrostSigningManager.resend(db, room, session.id))
|
||||
}
|
||||
val content = resent.content
|
||||
db.close()
|
||||
|
||||
openDevice(owner)
|
||||
return session.id to content
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a resend opens the session on a device that never saw the proposal`() = runBlocking {
|
||||
val (sessionId, content) = resentProposalFor(bob)
|
||||
|
||||
// The case the whole feature exists for. Bob's copy of the first
|
||||
// proposal decrypted to nothing -- MLS had moved its ratchet past the
|
||||
// generation it arrived at, which is terminal and which the sender
|
||||
// cannot see (docs/mls-skipped-keys.md). He has no session at all.
|
||||
assertNull(db.frostSigningSessionDao().getSessionById(sessionId))
|
||||
|
||||
receive(sessionId, FrostSigningEvents.PROPOSAL, alice, content, silent = listOf(bob), includeKey = true)
|
||||
|
||||
val session = db.frostSigningSessionDao().getSessionById(sessionId)
|
||||
assertNotNull(session, "the resent proposal opens the session Bob was missing")
|
||||
assertEquals(alice, session.coordinatorPublicKey)
|
||||
assertEquals(bob, session.userPublicKey)
|
||||
assertEquals(1, db.frostSigningSessionDao().getItems(sessionId).size)
|
||||
|
||||
// And he is asked, rather than signed for. A relay delivering an event
|
||||
// to a phone in a pocket must not be enough to make a signature happen.
|
||||
assertTrue(
|
||||
FrostSigningManager.isAwaitingApproval(
|
||||
session,
|
||||
db.frostSigningSessionDao().getItems(sessionId)
|
||||
)
|
||||
)
|
||||
assertTrue(queued(FrostSigningEvents.NONCE).isEmpty())
|
||||
assertEquals(1, transcript(ChatMessage.TYPE_FROST_APPROVAL_NEEDED).size)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `being named as silent does not sign for a device that has just learned of the session`() =
|
||||
runBlocking {
|
||||
val (sessionId, content) = resentProposalFor(bob)
|
||||
|
||||
receive(sessionId, FrostSigningEvents.PROPOSAL, alice, content, silent = listOf(bob), includeKey = true)
|
||||
|
||||
// Named *and* new. There is nothing of Bob's on file to republish,
|
||||
// so the nudge finds nothing -- and must not reach for the nonce it
|
||||
// could generate instead.
|
||||
assertTrue(queued(FrostSigningEvents.NONCE).isEmpty())
|
||||
assertTrue(queued(FrostSigningEvents.DECLINE).isEmpty())
|
||||
assertNull(db.frostSigningSessionDao().getSessionById(sessionId)!!.signApprovedAt)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a resent proposal delivered twice opens one session`() = runBlocking {
|
||||
val (sessionId, content) = resentProposalFor(bob)
|
||||
|
||||
receive(sessionId, FrostSigningEvents.PROPOSAL, alice, content, silent = listOf(bob), includeKey = true)
|
||||
val items = db.frostSigningSessionDao().getItems(sessionId)
|
||||
|
||||
// Relays redeliver, and a resend makes duplicates routine rather than
|
||||
// exceptional. A second copy must not mint new nonce seeds: that is one
|
||||
// secret nonce replaced under a message that has not changed, which is
|
||||
// the stall the write-once rule exists to prevent.
|
||||
receive(sessionId, FrostSigningEvents.PROPOSAL, alice, content, silent = listOf(bob), includeKey = true)
|
||||
|
||||
val after = db.frostSigningSessionDao().getItems(sessionId)
|
||||
assertEquals(items.map { it.nonceRandom }, after.map { it.nonceRandom })
|
||||
assertEquals(items.map { it.eventId }, after.map { it.eventId })
|
||||
assertEquals(1, transcript(ChatMessage.TYPE_FROST_STARTED).size)
|
||||
assertEquals(1, transcript(ChatMessage.TYPE_FROST_APPROVAL_NEEDED).size)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a republished refusal is counted once`() = runBlocking {
|
||||
openDevice()
|
||||
val session = propose()
|
||||
|
||||
// What the coordinator sees when a nudged member says their refusal
|
||||
// again: the same message twice. Counting it twice would abandon a
|
||||
// 2-of-3 session on one member's single no.
|
||||
receive(session.id, FrostSigningEvents.DECLINE, bob, "Declined to sign")
|
||||
receive(session.id, FrostSigningEvents.DECLINE, bob, "Declined to sign")
|
||||
|
||||
assertEquals(FrostSigningStage.COLLECTING_NONCES, session(session.id).stage)
|
||||
assertEquals(1, transcript(ChatMessage.TYPE_FROST_DECLINED).size)
|
||||
assertEquals(
|
||||
1,
|
||||
db.frostSigningSessionDao()
|
||||
.getMessagesByKind(session.id, FrostSigningEvents.DECLINE)
|
||||
.size
|
||||
)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a session the group has already signed can still be resent`() = runBlocking {
|
||||
openDevice()
|
||||
val session = propose()
|
||||
|
||||
// A member who never received the signature never applied the events.
|
||||
// Repeating it is the only thing that gets their store right, so COMPLETE
|
||||
// is worth resending rather than treated as finished business.
|
||||
db.frostSigningSessionDao().upsert(
|
||||
session(session.id).copy(stage = FrostSigningStage.COMPLETE)
|
||||
)
|
||||
db.frostSigningSessionDao().upsertItems(
|
||||
db.frostSigningSessionDao().getItems(session.id).map {
|
||||
it.copy(signature = "d".repeat(128))
|
||||
}
|
||||
)
|
||||
|
||||
assertTrue(resend(session.id))
|
||||
assertEquals(1, queued(FrostSigningEvents.SIGNATURE).size)
|
||||
assertEquals(2, queued(FrostSigningEvents.PROPOSAL).size)
|
||||
}
|
||||
}
|
||||
@@ -10,6 +10,7 @@ silent, or a decision that looked arbitrary and was not.
|
||||
| [shared-key-derivation.md](./shared-key-derivation.md) | deriving further keys from the group's threshold key with FROST tweaks — why not BIP32, why no chain code, and the one rule that must not be broken |
|
||||
| [subgroups.md](./subgroups.md) | a group making another group — the four ceremonies, what the parent's signature actually covers, and why the child's key is fresh rather than derived |
|
||||
| [frost-batch-signing.md](./frost-batch-signing.md) | signing several events in one ceremony — why one nonce can never cover two messages, and the phased schema, wire and UI work that follows from it |
|
||||
| [frost-session-resend.md](./frost-session-resend.md) | asking the members who never got a signing proposal to look again — why a proposer can repeat only what it wrote, why a member's availability signal needs no repeating, and the one half that has to come from the silent member's own device |
|
||||
| [marmot-membership.md](./marmot-membership.md) | how members join an MLS group, and the epoch race that makes a missing member look like a successful invite |
|
||||
| [member-chronicle.md](./member-chronicle.md) | handing a member added after the work was done the group's signed record — why the events are not on the wire at all, and why the room's id is enough to verify them |
|
||||
| [marmot-direct-messages.md](./marmot-direct-messages.md) | a one-to-one message inside a group as a stock NIP-59 gift wrap — what its MIP-03 carve-out costs, why the sender cannot read their own, and the one query that would broadcast it |
|
||||
@@ -27,6 +28,8 @@ silent, or a decision that looked arbitrary and was not.
|
||||
Start with the ceremony if you are new to this area; the Marmot notes all assume it.
|
||||
Read the skipped-keys note before debugging any "the other device never got it"
|
||||
report — it is silent, and it looks like every other kind of delivery failure. The
|
||||
resend note is the recovery for it on a signing session, and says which delivery
|
||||
failures a resend repairs and which heal on their own. The
|
||||
sync note stands alone, and the dead-code inventory reads as a follow-up to it. The
|
||||
batch-signing note is a phased plan that has been built: read it after the
|
||||
derivation note, whose one rule is the same one it is built around. The member
|
||||
|
||||
@@ -0,0 +1,616 @@
|
||||
# Resending a signing session
|
||||
|
||||
A proposer can ask the group to sign something and never hear back from a member
|
||||
who would have agreed, because the message asking them never arrived. Today there
|
||||
is nothing to do about it. The session sits in `COLLECTING_NONCES` until somebody
|
||||
abandons it and proposes afresh, and the member it was waiting on never knew they
|
||||
were being waited on.
|
||||
|
||||
This is the plan for a resend: the proposer re-publishing what they authored for a
|
||||
session, and — the half that is not obvious — the silent member republishing what
|
||||
*they* authored, because the proposer cannot do it for them and must not be able to.
|
||||
|
||||
Read [`docs/mls-skipped-keys.md`](mls-skipped-keys.md) first. It documents the
|
||||
failure that makes this necessary and ends with the sentence this plan is a reply
|
||||
to: *"nothing asks the sender to resend."*
|
||||
|
||||
## The problem
|
||||
|
||||
"Missed it" is five different things, and only some of them are a resend's business.
|
||||
|
||||
| why a member has nothing | does a resend help? |
|
||||
|---|---|
|
||||
| offline, and the relay still holds the kind:445 | no — ordinary sync catches up |
|
||||
| **MLS skipped keys**: the group event decrypted to nothing | **yes, and nothing else does** |
|
||||
| NIP-40 expiration: a disappearing-message group dropped it off the relay | **yes, and nothing else does** |
|
||||
| the member's read relays never had it | **yes** |
|
||||
| the member was not in the room when it was sent | **yes** |
|
||||
| the session already failed | no — `fail` already says "it is safe to ask again" |
|
||||
|
||||
The second row is the one that forces the feature. From the skipped-keys doc:
|
||||
|
||||
> the key is derived from a ratchet that has moved past it and cannot be
|
||||
> recovered
|
||||
|
||||
Terminal at the receiver, invisible to the sender, and the doc's own worked
|
||||
example is this exact flow — a FROST proposal lost to it, leaving the proposer's
|
||||
nonce filed against a session that will never exist. `MlsGroupCache` narrows the
|
||||
window; it does not close it, and a restart or another writer reopens it.
|
||||
|
||||
A resend fixes it because a resent message is a *new* application message at a
|
||||
*new* generation. The old generation's key is gone; the new one is derivable. The
|
||||
same is true of the expiration case: a fresh event carries a fresh expiry.
|
||||
|
||||
## What is safe to resend, and what is not
|
||||
|
||||
Every kind in a session has a direction, and the direction decides whether a
|
||||
resend is even meaningful.
|
||||
|
||||
| kind | author | who must actually receive it | proposer can resend? |
|
||||
|---|---|---|---|
|
||||
| 30320 `PROPOSAL` | proposer | every share holder | **yes** |
|
||||
| 30321 `NONCE` | a signer | **only the coordinator** | no, and not needed |
|
||||
| 30322 `SIGNER_SET` | coordinator | the chosen signers | **yes** |
|
||||
| 30323 `PARTIAL_SIGNATURE` | a signer | **only the coordinator** | no, and not needed |
|
||||
| 30324 `SIGNATURE` | coordinator | every share holder | **yes** |
|
||||
| 30325 `FAILURE` | anyone | everyone | n/a — the session is over |
|
||||
| 30330 `DECLINE` | a share holder | every share holder, for the count | no — see below |
|
||||
|
||||
The third column is read off the code, not guessed. `orderedNonces` and
|
||||
`orderedPartialSignatures` are both called under `session.isCoordinator()`;
|
||||
nothing else in `advance` reads another member's nonce or partial. A non-coordinator
|
||||
device uses other members' nonces for exactly one thing — the "Ready to sign" row
|
||||
in `FrostSigningUIState.offeredNonce` — which is cosmetic.
|
||||
|
||||
**So the parenthetical in the request is the right answer.** A nonce is a signal only
|
||||
the proposer needs, and the proposer already has it, which is how they know the
|
||||
member is not silent. There is nothing to resend.
|
||||
|
||||
### Receiver-side idempotence already holds
|
||||
|
||||
A resend is only cheap because every arm of `record` is already write-once. This is
|
||||
an audit of the gates, not a wish list; each one is a line that exists today.
|
||||
|
||||
- `PROPOSAL` → `acceptProposal` finds the session, compares the proposed ids against
|
||||
the stored `FrostSigningItem.eventId`s, finds them equal, returns the existing
|
||||
session. No write, no log line.
|
||||
- `SIGNER_SET` → `isFromCoordinator`, then `if (current(database, session).signerIds != null) return true`.
|
||||
- `SIGNATURE` → `if (isSigned(database, session)) return true`.
|
||||
- `NONCE` / `PARTIAL_SIGNATURE` → upsert keyed on `(sessionId, signerPublicKey, kind)`;
|
||||
`known` is true, so no second transcript line.
|
||||
- `DECLINE` → `recordDecline` recomputes a `toSet()` count; `fail` has its own
|
||||
already-settled guard.
|
||||
|
||||
`publishOwn` already states the policy this plan generalises:
|
||||
|
||||
> A crash between the two therefore costs a duplicate broadcast — which every
|
||||
> receiver folds away
|
||||
|
||||
**No protocol change is required for the proposer to resend its own messages.** That
|
||||
is the whole of Phase 2.
|
||||
|
||||
### Why the proposer cannot resend another member's message
|
||||
|
||||
Three reasons, in increasing order of seriousness.
|
||||
|
||||
**It would be filed under the wrong author.** `record` writes
|
||||
`FrostSignerMessage(signerPublicKey = innerEvent.pubKey, …)`. A forwarded copy is
|
||||
authored by the forwarder, so a nonce the proposer relayed on Bob's behalf is filed
|
||||
as the *proposer's* nonce, overwriting their own. On Marmot there is no way around
|
||||
this: MIP-03 rejects an inner event whose `pubKey` is not the MLS sender's identity,
|
||||
and `docs/marmot-direct-messages.md` describes the single carve-out that exists and
|
||||
why it is narrow.
|
||||
|
||||
**For a decline it is a forgery primitive.** `recordDecline` counts distinct
|
||||
`signerPublicKey`s against `declinesThatAbandon()`. A proposer who could relay a
|
||||
decline under their own key would be able to manufacture refusals; in an n-of-n
|
||||
group one is enough to abandon a session nobody refused. Forwarding would have to
|
||||
carry a signature over the original, verified before counting — a new envelope kind,
|
||||
new verification code, and a new way to get it wrong, to deliver a message that
|
||||
nobody but the coordinator needed in the first place.
|
||||
|
||||
**For the proposal it is already load-bearing.** `acceptProposal` sets
|
||||
`coordinatorPublicKey = innerEvent.pubKey` for a session it has never seen. A
|
||||
non-coordinator who resends the proposal to a member with no session row makes that
|
||||
member believe the *resender* coordinates — and that member will then drop the real
|
||||
coordinator's signer set through `isFromCoordinator`. **Resend is coordinator-only,
|
||||
and the restriction is correctness rather than etiquette.** (A member could already
|
||||
mint a proposal under someone else's session id today; resend does not widen that,
|
||||
but it must not make it a routine code path either.)
|
||||
|
||||
## The half the request is actually about
|
||||
|
||||
The request asks whether the proposer needs to resend a member's availability
|
||||
signal. It does not, but there is a real gap hiding behind the question, and it is
|
||||
the mirror image:
|
||||
|
||||
> A nonce lost on the way to the proposer is a permanent stall, and no device will
|
||||
> ever republish it.
|
||||
|
||||
`advance` republishes a message it has **no local copy of** — `if (ownNonces == null)`.
|
||||
Bob's device, having published and recorded its nonce, will never send it again,
|
||||
however long the proposer waits. The member who can fix it is Bob, and Bob has no
|
||||
way to know.
|
||||
|
||||
So the resend has two halves:
|
||||
|
||||
1. the proposer republishes what the proposer authored (Phase 2), and
|
||||
2. the resent proposal **names the members the proposer has not heard from**, and a
|
||||
named device republishes what *it* authored (Phase 3).
|
||||
|
||||
Half 2 is what the request is reaching for, reached from the only side that can
|
||||
author the message. It needs no forwarding, no new envelope and no signature
|
||||
checking, because every message still travels under the key that made it.
|
||||
|
||||
## Phase 1 — a tag for the silent set
|
||||
|
||||
`FrostSilentMembersTag`, in `nostr/frost/tags/`, following `FrostSignerIdsTag`
|
||||
exactly: a `TAG_NAME` const, `parse`/`assemble`, and all-or-nothing parsing because
|
||||
a partially-read list is a list naming the wrong people.
|
||||
|
||||
```kotlin
|
||||
const val TAG_NAME = "frost_silent"
|
||||
```
|
||||
|
||||
Hex pubkeys, comma separated, in `tag[1]`. An entry that is not 64 hex characters
|
||||
invalidates the whole tag.
|
||||
|
||||
`FrostSigningEvents.assembleTags` grows a fourth optional parameter:
|
||||
|
||||
```kotlin
|
||||
fun assembleTags(
|
||||
sessionId: String,
|
||||
dkgSessionId: String? = null,
|
||||
signerIds: List<Int>? = null,
|
||||
silentMembers: List<HexKey>? = null
|
||||
): Array<Array<String>>
|
||||
```
|
||||
|
||||
and a `parseSilentMembers` beside the other three parsers. `broadcast` gains a
|
||||
matching optional parameter and passes it through.
|
||||
|
||||
**Why a tag on the proposal rather than a kind of its own.** A bare nudge reaches a
|
||||
device with no session to apply it to and is dropped —
|
||||
`getSessionById` returns null and `processSigningPayload` logs *"leaving it stored"*.
|
||||
That is exactly the device we are trying to reach. The member who is silent is
|
||||
overwhelmingly silent *because* they never got the proposal, so the nudge and the
|
||||
thing they are missing have to travel in one message or the common case is not
|
||||
fixed. See the appendix for the kind-30331 version and why it loses.
|
||||
|
||||
**It is invisible to the id check.** `acceptProposal` rebuilds the signed events from
|
||||
`innerEvent.content`; the carrier's tags are not part of any id. Adding a tag cannot
|
||||
change what a signer is putting their share behind.
|
||||
|
||||
**It leaks nothing.** On Marmot every nonce is a group event the room already saw;
|
||||
on NIP-17 every member is p-tagged on every message. Who has signalled is not a
|
||||
secret the tag gives away.
|
||||
|
||||
**The silent set comes off the ceremony, not the room.** `signerIds(database, key).keys`
|
||||
minus everyone with any `FrostSignerMessage` for the session — the same source
|
||||
`recordDecline` counts against and `observeShareHolders` draws. The room's roster is
|
||||
wrong twice over, for the reasons `FrostSigningUIState.Loaded.members` already gives:
|
||||
it can hold members added after the key was made, and a subgroup's ceremony room is
|
||||
the parent.
|
||||
|
||||
## Phase 2 — the proposer resends what it authored
|
||||
|
||||
```kotlin
|
||||
suspend fun resend(
|
||||
database: CurareDatabase,
|
||||
localChatRoom: LocalChatRoom,
|
||||
sessionId: String
|
||||
): Boolean
|
||||
```
|
||||
|
||||
Returns whether anything went out, so the caller can say so.
|
||||
|
||||
**Refused unless it is this device's session to resend.** `session.isCoordinator()`,
|
||||
for the `acceptProposal` reason above. Refused for `FAILED` — nothing can be
|
||||
resent into a dead session and `fail` already tells the group to ask again — and
|
||||
refused for a session whose items are empty.
|
||||
|
||||
**It sends the minimum the stage requires**, which is at most two events:
|
||||
|
||||
| stage | what goes out |
|
||||
|---|---|
|
||||
| `COLLECTING_NONCES` | the proposal |
|
||||
| `COLLECTING_PARTIAL_SIGNATURES` | the proposal, then the signer set |
|
||||
| `COMPLETE` | the proposal, then the signature |
|
||||
| `FAILED` | refused |
|
||||
|
||||
The proposal goes in every case because a device with no session row cannot apply
|
||||
anything else: a signer set naming ids it has no items for, or a signature over
|
||||
events it has never seen, are both dropped. `COMPLETE` is worth resending rather
|
||||
than skipping — a member who never received the signature never ran `complete`, so
|
||||
the signed events were never applied to their local store.
|
||||
|
||||
The proposal's content is `FrostSigningEvents.encodeProposal` over the stored
|
||||
items' `unsignedEventJson`. Re-serialising is safe: the receiver compares rebuilt
|
||||
ids, and an id is over the canonical form, so any JSON with the same fields hashes
|
||||
the same. A batch of one must still go out as a bare object — `encodeProposal`
|
||||
guarantees it, and `decodeProposal` dispatching on a leading `[` is why it matters.
|
||||
|
||||
### Two hazards worth naming before writing the code
|
||||
|
||||
**The id collision.** `broadcast` derives the queue row's primary key from
|
||||
`EventHasher.hashId(pubKey, createdAt, tags, content, kind)` with `createdAt` in
|
||||
whole seconds. A resend whose content, tags and second all match the original
|
||||
produces the **same id**, and `@Upsert` then replaces the sent row with an
|
||||
unsent one: `marmotGroupEventId` goes back to null, the already-delivered event is
|
||||
queued a second time, and its mapping to the group event it became is lost. The
|
||||
cooldown in Phase 4 makes this improbable; it must not be the only defence.
|
||||
`broadcast` should refuse to overwrite a row whose `marmotGroupEventId` is already
|
||||
set, and the resend path should carry `createdAt` forward a second at a time until
|
||||
the id is unused. Worth a test of its own.
|
||||
|
||||
**The burst.** Resending two events back-to-back recreates precisely the condition
|
||||
the skipped-keys bug needs. `MlsGroupCache` covers a burst decrypted in one sync,
|
||||
which is what makes `proposeSigningBatch`'s own two-message burst work today, so
|
||||
the mitigation is the existing one — send in protocol order, in one pass, and do not
|
||||
add a third event. It is the strongest argument for the stage table above being a
|
||||
minimum rather than "send everything".
|
||||
|
||||
### Transport
|
||||
|
||||
`broadcast` already knows the difference and needs no new branch for Marmot: one
|
||||
group event reaches everybody, and every receiver folds the duplicate away, which
|
||||
is cheaper than one message per silent member and tells the room nothing it does not
|
||||
already know.
|
||||
|
||||
NIP-17 is the opposite — `recipientTags` seals one wrap per recipient — so there the
|
||||
resend narrows to the silent set plus the chosen signers, which is a real saving in
|
||||
a room where one member out of nine is quiet. This is the first signature a group
|
||||
makes, on gift wraps, per `GroupKeyStateManager.propose`.
|
||||
|
||||
## Phase 3 — a named member republishes what it authored
|
||||
|
||||
In `processSigningPayload`, after the session is in hand and before `advance`:
|
||||
|
||||
```kotlin
|
||||
if (FrostSigningEvents.parseSilentMembers(innerEvent.tags)
|
||||
?.contains(session.userPublicKey) == true &&
|
||||
isFromCoordinator(session, innerEvent)
|
||||
) {
|
||||
republishOwn(database, localChatRoom, session)
|
||||
}
|
||||
```
|
||||
|
||||
`republishOwn` re-broadcasts this device's own stored `FrostSignerMessage` rows for
|
||||
`NONCE`, `PARTIAL_SIGNATURE` and `DECLINE` — **the stored bytes, never regenerated**.
|
||||
They are byte-identical by construction, so they cannot produce a second aggregate,
|
||||
and reading the row avoids k native `SecretNonce.generate` calls to arrive at the
|
||||
same answer.
|
||||
|
||||
Three constraints, each of which is a rule that already exists somewhere else:
|
||||
|
||||
**Only from the coordinator.** A member who could name another member as silent could
|
||||
make them republish on demand. It changes nothing on the wire — the bytes are the
|
||||
same ones already sent — but it is a publish anybody could trigger, and that is not
|
||||
a thing to leave lying around.
|
||||
|
||||
**Nothing new is published.** `republishOwn` sends only what is already on file. A
|
||||
device with no `FrostSignerMessage` of its own sends nothing and falls through to
|
||||
`advance`, which does what it has always done: ask whether the owner has decided,
|
||||
and if they have not, write the approval request and stop. **A message from the
|
||||
proposer must never be able to talk a device into publishing a nonce its owner has
|
||||
not approved** — that is `acceptProposal`'s "Publishes nothing" rule, and the gate
|
||||
that enforces it is `advance`'s `if (session.signApprovedAt == null)`, untouched.
|
||||
|
||||
**Once per delivery.** A redelivered resend has the same inner-event id and is
|
||||
deduplicated upstream; a *second* resend from the proposer is a new id and will
|
||||
republish again, which costs a duplicate everybody folds away. The Phase 4 cooldown
|
||||
bounds how often that can happen.
|
||||
|
||||
### What this fixes, concretely
|
||||
|
||||
- Bob approved, published a nonce, and the proposer never got it. Bob is named,
|
||||
republishes the same bytes, and the proposer's `orderedNonces` finds a quorum.
|
||||
- Bob approved and his device died before `publishOwn` queued anything. Today the
|
||||
resent proposal alone already fixes this, because `acceptProposal` → `record` →
|
||||
`advance` re-enters the `ownNonces == null` branch. Worth knowing: part of the
|
||||
fix is free.
|
||||
- Bob declined and the refusal was lost. He republishes it, and every device's count
|
||||
converges on the same arithmetic instead of waiting on a member who has answered.
|
||||
- Bob never saw the proposal at all. He sees it now, and `announceApprovalNeeded`
|
||||
puts the request in his transcript.
|
||||
|
||||
## Phase 4 — schema 24 → 25: `resentAt`
|
||||
|
||||
*Landed with Phase 2 rather than after it: `resend` needs the column for its
|
||||
cooldown, and writing it twice to keep the phases apart would have been
|
||||
ceremony.*
|
||||
|
||||
A nullable `Instant?` on `FrostSigningSession`, written by `resend`:
|
||||
|
||||
```kotlin
|
||||
/**
|
||||
* When the coordinator last re-published this session, or null if never.
|
||||
*
|
||||
* Two jobs. It is the cooldown -- a resend is a publish, and a button that
|
||||
* publishes on every tap is a button that fills a room with duplicates. And it
|
||||
* keeps a second resend from landing in the same second as the first, where the
|
||||
* queue row's id is a hash over `createdAt` and a collision un-sends the
|
||||
* message it collides with.
|
||||
*/
|
||||
val resentAt: Instant? = null
|
||||
```
|
||||
|
||||
`AutoMigration(from = 24, to = 25)` with the comment the others carry, and the
|
||||
generated `composeApp/schemas/25.json` committed. Nothing is backfilled: a session
|
||||
that has never been resent reads null, which is what every session before the column
|
||||
was.
|
||||
|
||||
A cooldown of five minutes, as a `const` on the manager beside `MAX_BATCH_SIZE`,
|
||||
with the reasoning on it. `resend` returns false inside the window rather than
|
||||
throwing; the screen disables the button and says when it may be used again.
|
||||
|
||||
The alternative — deriving the last resend from the `TYPE_FROST_RESENT` transcript
|
||||
row — needs no migration but makes the manager read the chat table to decide a
|
||||
protocol question, and makes a user-deletable row load-bearing. The column is
|
||||
cheaper than that.
|
||||
|
||||
## Phase 5 — the transcript
|
||||
|
||||
`ChatMessage.TYPE_FROST_RESENT = "frostResent"`, added to the frost block and to
|
||||
`FROST_TYPES` (whatever the rendering set is called where `TYPE_FROST_DECLINED`
|
||||
appears), with the house comment explaining why it is its own type: it is not a
|
||||
protocol step, it is the proposer knocking, and the ladder should show that the
|
||||
knock happened so a second one is visibly a second one.
|
||||
|
||||
The line is the `announce` shape the other frost lines use, with the actor as the
|
||||
coordinator:
|
||||
|
||||
> asked the 2 members who have not answered to take another look.
|
||||
|
||||
Named rather than counted when there are few, for the reason `FrostSigningScreen`
|
||||
already gives — *"1 of 2" does not tell anyone whose door to knock on*. Written
|
||||
once per resend, which `resentAt` makes true.
|
||||
|
||||
A resent message must **not** write a second step line. That is already how it
|
||||
works: `announceStep` is called from `publishOwn` and `record` only when `known` is
|
||||
false, and `resend` calls `broadcast` directly rather than `publishOwn` — which is
|
||||
also why `resend` must not be routed through `publishOwn`, whose whole job is to
|
||||
record a local copy that already exists.
|
||||
|
||||
## Phase 6 — repository and view model
|
||||
|
||||
`FrostSigningRepository` grows one method, documented with the directionality that
|
||||
makes it one method rather than two:
|
||||
|
||||
```kotlin
|
||||
/**
|
||||
* Re-publishes the messages this device authored for a session, for the members
|
||||
* it has not heard from.
|
||||
*
|
||||
* Coordinator only, and a resend of *this device's* messages only. A member's
|
||||
* nonce is read by nobody but the coordinator, who already has it; and a message
|
||||
* relayed by somebody else would be filed under the relayer, which for a refusal
|
||||
* is a way to manufacture one. What the resend does for a silent member is name
|
||||
* them, so their own device republishes what it already said.
|
||||
*
|
||||
* Returns false when there was nothing to do: not the coordinator, already
|
||||
* failed, nobody silent, or inside the cooldown.
|
||||
*/
|
||||
suspend fun resend(localChatRoom: LocalChatRoom, sessionId: String): Boolean
|
||||
```
|
||||
|
||||
`NO_OP_FROST_SIGNING_REPOSITORY` returns false. `DatabaseFrostSigningRepository`
|
||||
delegates to the manager, as its other methods do.
|
||||
|
||||
`FrostSigningUIState.Loaded` gains two derived values rather than two fields:
|
||||
|
||||
```kotlin
|
||||
/** Share holders this session has heard nothing from. Whose door to knock on. */
|
||||
val silent: Set<HexKey> get() = shareHolders - offeredNonce - signed - declined
|
||||
|
||||
/** Whether this device may knock: it proposed, the session is open, somebody is quiet. */
|
||||
val canResend: Boolean get() = …
|
||||
```
|
||||
|
||||
`silent` is already computable from what the view model collects — `offeredNonce`,
|
||||
`signed`, `declined` and `shareHolders` are all there — so the screen needs no new
|
||||
flow. `FrostSigningViewModel` gains a `resend(onDone:)` on the `approve`/`decline`
|
||||
pattern, guarded by the same `isActionPending`.
|
||||
|
||||
## Phase 7 — UI
|
||||
|
||||
The affordance belongs on `FrostSigningScreen`, below the member list and above the
|
||||
approval block, in a section the coordinator alone sees. The member list is already
|
||||
the screen's answer to "whose door to knock on"; this is the knock, and it goes
|
||||
where the doors are.
|
||||
|
||||
```kotlin
|
||||
if (state.canResend) {
|
||||
HorizontalDivider()
|
||||
|
||||
Text(
|
||||
text = stringResource(Res.string.these_members_have_not_answered),
|
||||
style = MaterialTheme.typography.bodySmall
|
||||
)
|
||||
|
||||
Button(
|
||||
enabled = !frostSigningViewModel.isActionPending.value,
|
||||
onClick = { frostSigningViewModel.resend { notify(resent) } }
|
||||
) {
|
||||
Icon(Icons.Default.Send, contentDescription = Decorative)
|
||||
Spacer(modifier = Modifier.width(MaterialTheme.spacing.space125))
|
||||
Text(stringResource(Res.string.ask_again))
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Per `CLAUDE.md`, and each of these is enforced by `./gradlew :composeApp:m3Audit`:
|
||||
|
||||
- strings in `composeApp/src/commonMain/composeResources/values/strings.xml`, in
|
||||
**sentence case**: `asked_again`, `one_member_has_not_answered`,
|
||||
`members_have_not_answered`, `asked_again_recently`,
|
||||
`everyone_has_answered_this_session`. The count interpolates as `%1$s`, which
|
||||
is what the catalogue's other counted strings use. `ask_again` was already
|
||||
there for re-querying a list's relays and means exactly this, so it is reused
|
||||
rather than duplicated — two keys with one label is how a translator comes to
|
||||
pick two different words for one idea.
|
||||
- spacing from `MaterialTheme.spacing`; no `.dp` literal in a spacing position.
|
||||
- the icon is beside its label, so `contentDescription = Decorative` — decided, not
|
||||
`null`.
|
||||
- the outcome goes through `rememberNotifier(rememberCoroutineScope())`, with the
|
||||
`stringResource` read **above** the handler, since `onClick` is not composable.
|
||||
- no new state branch: the screen keeps its four, and this sits inside `Loaded`.
|
||||
|
||||
`ProposalListScreen` gets nothing. A resend is a decision about one session made
|
||||
while looking at who has answered, and the list shows neither.
|
||||
|
||||
Within the cooldown the button is disabled with a supporting line saying so, rather
|
||||
than hidden — a control that vanishes after a tap reads as a control that failed.
|
||||
|
||||
## Phase 8 — the tests
|
||||
|
||||
`FrostSigningResendJvmTest`, on `FrostSigningDeclineJvmTest`'s harness: a 2-of-3
|
||||
`Frost.trustedDealerKeygen`, a room at `SharedKeyDerivation.marmotGroupId`, and its
|
||||
`openDevice` / `propose` / `proposalArrivedAt` / `receive` / `queued(kind)` helpers.
|
||||
That test is already a two-device simulation over one real database, which is what
|
||||
this needs.
|
||||
|
||||
The properties, each one a thing that would otherwise be found in a group:
|
||||
|
||||
1. **A resend reaches a device that missed the proposal.** Propose on Alice, never
|
||||
deliver, resend, deliver the resent proposal to Bob: Bob has a session and an
|
||||
approval request. This is the skipped-keys case.
|
||||
2. **A resend is idempotent on a device that has the session.** Deliver the proposal,
|
||||
approve, then deliver the resend: the item ids are unchanged, no second
|
||||
transcript line, no second nonce row, and `signerIds` unchanged once set.
|
||||
3. **A named member republishes their nonce.** Bob approves, his nonce is dropped,
|
||||
the proposer resends naming Bob, and Bob's device queues the **same payload** a
|
||||
second time. Assert byte equality against the first — a different nonce for the
|
||||
same message against two aggregates is the share extraction the whole design
|
||||
forbids.
|
||||
4. **A named member who has not decided publishes nothing.** The strongest test here.
|
||||
Bob is named without having approved: nothing is queued, and
|
||||
`isAwaitingApproval` is still true.
|
||||
5. **A named member republishes their refusal**, and counts converge.
|
||||
6. **A non-coordinator cannot resend**, and a resend tag from a non-coordinator is
|
||||
ignored.
|
||||
7. **A resend of a `FAILED` session is refused**, and nothing is queued.
|
||||
8. **Two resends in the same second do not collide.** Two ids, both rows unsent, the
|
||||
first not reverted. The hazard from Phase 2.
|
||||
9. **The cooldown holds**: the second call inside the window returns false and queues
|
||||
nothing.
|
||||
|
||||
A pure `commonTest` for `FrostSilentMembersTag` round-tripping, beside
|
||||
`FrostProposalCodecTest`: an empty list, a malformed entry invalidating the whole
|
||||
tag, and an unknown tag surviving `assembleTags`/`parse` untouched.
|
||||
|
||||
Then the project's two gates:
|
||||
|
||||
```bash
|
||||
./gradlew :composeApp:m3Audit
|
||||
```
|
||||
|
||||
```bash
|
||||
./gradlew :composeApp:compileDebugKotlinAndroid :composeApp:jvmTest
|
||||
```
|
||||
|
||||
One unrelated 5-second-timeout failure per full `jvmTest` run is a known flake;
|
||||
re-run the suite alone before investigating.
|
||||
|
||||
## Rollout and compatibility
|
||||
|
||||
Nothing here is a wire break, and that is by design.
|
||||
|
||||
**A build predating this plan receiving a resent proposal** reads an unknown
|
||||
`frost_silent` tag, ignores it, and runs `acceptProposal` — which either creates the
|
||||
session it was missing or returns the one it has. **The half that matters works on
|
||||
old builds without a change.** Only the republish-when-named half needs both ends.
|
||||
|
||||
**A build predating this plan receiving a resent signer set or signature** applies
|
||||
them if it was missing them and hits its own write-once gate if it was not. Both
|
||||
behaviours are today's.
|
||||
|
||||
**An old coordinator** never resends, which is today's behaviour exactly.
|
||||
|
||||
The one ordering constraint: Phase 1's tag must ship no later than Phase 2, because
|
||||
a resent proposal with no silent tag is a resend whose second half silently does
|
||||
nothing. Phases 4 through 7 can land after, and Phase 8's tests should land with the
|
||||
phase they test rather than at the end.
|
||||
|
||||
### What landing it turned up
|
||||
|
||||
Two things worth recording, both of them in `broadcast` and neither of them about
|
||||
resend as such.
|
||||
|
||||
**The id collision was real, and the guard needed a second half.** `broadcast`
|
||||
now steps past a taken id rather than upserting over it, and returns whether it
|
||||
queued anything. That return is load-bearing: `publishOwn` writes the local copy
|
||||
that stops [advance] from publishing a message again, so a `broadcast` that
|
||||
queued nothing must record nothing, or the group waits forever on a message that
|
||||
never went out. The comment on `publishOwn` had the trade written down in one
|
||||
direction only.
|
||||
|
||||
**Narrowing is a `recipientTags` change, not a `broadcast` branch.** On NIP-17 a
|
||||
resend names the quiet members and the signers; on Marmot the parameter is
|
||||
ignored, because a group event is encrypted to the group and names nobody. One
|
||||
optional argument covers both, which is the shape `broadcast` already had for
|
||||
the transports.
|
||||
|
||||
## What this does not do
|
||||
|
||||
- **It does not retry automatically.** See the appendix.
|
||||
- **It does not resend another member's message**, and cannot be extended to without
|
||||
a signed forwarding envelope. The appendix says why that is not worth building.
|
||||
- **It does not recover a failed session.** A retry is a new batch, always:
|
||||
`proposeSigningBatch`'s own notes say why, and `itemsOver` mints fresh nonce seeds
|
||||
so a retry is a new session by construction.
|
||||
- **It does not change the quorum arithmetic.** A resend publishes nothing new and
|
||||
counts nothing twice; `declinesThatAbandon` is untouched.
|
||||
- **It does not help a member who holds no share.** They were never in the session.
|
||||
`signerIds(database, key)` is the list, for the reason
|
||||
`FrostSigningUIState.Loaded.members` gives.
|
||||
- **It does not fix the skipped-keys bug.** It is a recovery for it, driven by a
|
||||
person who noticed. The fix is in quartz, and `docs/mls-skipped-keys.md` has it.
|
||||
|
||||
## Appendix — what was considered and rejected
|
||||
|
||||
**A resend kind of its own (30331).** Cleaner to read, and it could nudge without
|
||||
re-sending a proposal carrying up to `MAX_BATCH_SIZE` events. It loses on the common
|
||||
case: a bare nudge arriving at a device with no session for it is dropped —
|
||||
`getSessionById` returns null, `processSigningPayload` logs *"leaving it stored"* —
|
||||
and that device is the one we are trying to reach. It would also be unrouted by any
|
||||
build predating it, since `ALL` is what the inbound path dispatches on, which is the
|
||||
same degradation the decline kind at 30330 documents. If the proposal's size ever
|
||||
becomes the binding cost, the nudge can be added *alongside* the resent proposal
|
||||
rather than instead of it.
|
||||
|
||||
**Forwarding another member's message in a signed envelope.** Technically possible:
|
||||
wrap the original event, verify the inner signature before `record` files it under
|
||||
the inner author. Rejected on cost against benefit. It is new verification code on
|
||||
the path that decides whether a refusal counts — see the forgery note above — and it
|
||||
exists to deliver nonces and partial signatures that nobody but the coordinator ever
|
||||
needed. The coordinator already has them. Naming the silent member and letting their
|
||||
own device speak costs one tag.
|
||||
|
||||
**Automatic resend on a timer.** A background publisher that fires on a stalled
|
||||
session. Rejected: it publishes without anybody deciding to, it would write a
|
||||
transcript line per tick in a room whose protocol lines are deliberately one per
|
||||
step, and every amplification bug in the app's history has been something that
|
||||
published on a schedule. A person noticing a stalled session and knocking is the
|
||||
same shape as everything else on this screen. The cooldown column would make a timer
|
||||
straightforward to add later if a group asks for it.
|
||||
|
||||
**A Marmot direct message per silent member.** `MarmotInnerEvent` has
|
||||
`directMessageRecipientPublicKey` and it would work. Rejected twice over: it is m
|
||||
events where one does, and per `docs/marmot-direct-messages.md` every member of the
|
||||
group sees that a private message was sent and to whom — so a nudge would read as a
|
||||
side channel in a room where the nudge is public information anyway.
|
||||
|
||||
**Narrowing the Marmot resend to the silent set.** There is no narrowing to do: a
|
||||
group event is encrypted to the group and names nobody, which is the point
|
||||
`broadcast` makes about why its p-tags are not cosmetic. Narrowing is real on
|
||||
NIP-17, where a wrap is sealed per recipient, and Phase 2 does it there.
|
||||
|
||||
**Resetting the queue row instead of writing a new one.** `@Upsert` of a
|
||||
`MarmotInnerEvent` with `marmotGroupEventId = null` puts an already-sent row back on
|
||||
the outbound queue, which looks like a free resend. Rejected: it destroys the row's
|
||||
mapping to the group event it became, which the transcript and
|
||||
`MarmotPublishObligation` both read, and it re-sends the *old* ciphertext's plaintext
|
||||
at an id that no longer describes a new event. A resend is a new message with a new
|
||||
`created_at`, which is also what makes it decryptable at a generation the receiver
|
||||
has not passed.
|
||||
@@ -85,7 +85,14 @@ back afterwards. So the sequence is
|
||||
4. the exception is swallowed, the event yields no `ApplicationMessage`
|
||||
|
||||
Step 3 is terminal. The key is derived from a ratchet that has moved past it and
|
||||
cannot be recovered, and nothing asks the sender to resend.
|
||||
cannot be recovered.
|
||||
|
||||
Nothing *asked* the sender to resend, either, which is a second gap and a
|
||||
narrower one. A FROST signing session now has a resend: the proposer repeats what
|
||||
it wrote, and the repeat names the members it has heard nothing from so their own
|
||||
devices repeat what they wrote. See
|
||||
[frost-session-resend.md](./frost-session-resend.md). It is a recovery driven by
|
||||
somebody noticing, not a fix — the fix is below, and it is in quartz.
|
||||
|
||||
Verified against the published artifact rather than a checkout:
|
||||
`quartz-1.14.0-sources.jar`, `commonMain/com/vitorpamplona/quartz/marmot/mls/schedule/SecretTree.kt`.
|
||||
@@ -195,6 +202,13 @@ It is not the fix, and it is worth being precise about what it leaves broken:
|
||||
- **Nothing helps a long reorder.** A message the relay holds back until after a
|
||||
restart or an outbound send is gone.
|
||||
|
||||
A message lost this way is gone for good, but it is not necessarily
|
||||
unrecoverable: a *new* message carrying the same payload is encrypted at a
|
||||
generation the receiver has not passed, so it decrypts normally. That is the
|
||||
whole mechanism behind
|
||||
[frost-session-resend.md](./frost-session-resend.md), and the same move would
|
||||
work for any other flow in the table above that someone can be asked to repeat.
|
||||
|
||||
The staleness check is what keeps the cache from being *worse* than no cache: a
|
||||
group that has been overtaken by another writer is never carried on with, so the
|
||||
fallback is always the old behaviour rather than a diverged ratchet.
|
||||
Reference in new issue
Block a user