feat: a founding invite that never went out is finished (robust-group-admins, Phase 4)
MarmotGroupCreation.finishFoundingInvite invites the founders a room's founding invite never reached, in one commit, every key package first as at creation. It acts only on a room still at epoch 0: the founding invite is the commit that ends epoch 0, and leaving is a commit too, so a founder without a leaf there is one nobody ever invited -- never one who left. CeremonyFollowThrough takes it as step 4 once the room exists, on the coordinator's device; the repository exposes it by room for the detail screen, with the set it would invite. Also fixes what Phase 0 found. MarmotGroupCreation invited the founders through a room read before its routing id was recorded, so on the current profile the engine adopted a second copy of the group under the room id, and the copy at the real address still held only its creator: every later invite took the founding path, with no commit and nobody already in the room told. It now reads the room again first. RobustGroupAdminsJvmTest: a room left without its invite is finished and every founder joins as an admin, on both profiles; a room past its founding invites nobody; a later member on the current profile now gets a real commit. CeremonyFollowThroughJvmTest: step 4's outcomes. jvmTest 1249/1249, compileDebugKotlinAndroid, audits. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
4671a86a6d
commit
1dc94ad423
7 files changed
+340
-12
No files matched your search
+27
@@ -87,6 +87,33 @@ class DatabaseChatRepository(
|
||||
parentChatRoomId = parentChatRoomId,
|
||||
)
|
||||
|
||||
override suspend fun finishFoundingInvite(
|
||||
ceremony: DkgSession,
|
||||
ceremonyRoom: LocalChatRoom,
|
||||
): MarmotGroupCreation.FoundingInvite = MarmotGroupCreation.finishFoundingInvite(
|
||||
database = database,
|
||||
chatRepository = this,
|
||||
ceremony = ceremony,
|
||||
ceremonyRoom = ceremonyRoom,
|
||||
)
|
||||
|
||||
override suspend fun finishFoundingInvite(chatRoomId: String): MarmotGroupCreation.FoundingInvite {
|
||||
val (ceremony, ceremonyRoom) = FoundingAdmins.ceremonyOf(database, chatRoomId)
|
||||
?: return MarmotGroupCreation.FoundingInvite.NothingToDo
|
||||
return finishFoundingInvite(ceremony, ceremonyRoom)
|
||||
}
|
||||
|
||||
override suspend fun uninvitedFounders(localChatRoom: LocalChatRoom): Set<HexKey> = try {
|
||||
FoundingAdmins.ceremonyOf(database, localChatRoom.chatRoom.id)
|
||||
?.let { (ceremony, ceremonyRoom) ->
|
||||
MarmotGroupCreation.uninvitedFounders(database, localChatRoom, ceremony, ceremonyRoom)
|
||||
}
|
||||
.orEmpty()
|
||||
} catch (e: Throwable) {
|
||||
logger.e("Error reading who ${localChatRoom.chatRoom.id}'s founding invite missed", e)
|
||||
emptySet()
|
||||
}
|
||||
|
||||
override suspend fun followThroughCeremonies(keyPair: KeyPair) =
|
||||
CeremonyFollowThrough.observe(database = database, chatRepository = this, keyPair = keyPair)
|
||||
|
||||
|
||||
+25
-4
@@ -30,7 +30,9 @@ import mobi.giza.compose.repository.ChatRepository
|
||||
* 1. a subgroup's parent certifies the room the key derives -- proposed here, and
|
||||
* signed by the parent's own quorum, which stays their decision;
|
||||
* 2. the group signs what that room will sign with, its key state;
|
||||
* 3. the room is created and the members welcomed into it.
|
||||
* 3. the room is created and the members welcomed into it;
|
||||
* 4. a room whose founding invite never went out has it finished
|
||||
* (docs/robust-group-admins.md, Phase 4).
|
||||
*
|
||||
* None of the three proposals asks anybody anything: each is a request to the
|
||||
* group, and the coordinator agreed to make it when they opened the ceremony. So
|
||||
@@ -62,7 +64,7 @@ object CeremonyFollowThrough {
|
||||
|
||||
/** What one call to [takeNextStep] did. */
|
||||
sealed interface Step {
|
||||
/** Not this device's to do, or nothing left: not the coordinator, not finished, or the room exists. */
|
||||
/** Not this device's to do, or nothing left: not the coordinator, not finished, or the room exists with its founders. */
|
||||
data object NothingToDo : Step
|
||||
|
||||
/** Waiting on signatures somebody else gives. */
|
||||
@@ -74,6 +76,12 @@ object CeremonyFollowThrough {
|
||||
/** The room exists now. */
|
||||
data class Created(val chatRoomId: String) : Step
|
||||
|
||||
/**
|
||||
* The room existed without its founders, whose invite never went out, and
|
||||
* now they have been invited; [notAdded] could not be.
|
||||
*/
|
||||
data class Invited(val chatRoomId: String, val notAdded: List<HexKey>) : Step
|
||||
|
||||
/** The room cannot be created until these members' devices publish a key package. */
|
||||
data class BlockedOn(val missing: List<HexKey>) : Step
|
||||
|
||||
@@ -166,11 +174,24 @@ object CeremonyFollowThrough {
|
||||
val thresholdPublicKey = current.thresholdPublicKey ?: return@withLock Step.NothingToDo
|
||||
val roomId = SharedKeyDerivation.marmotGroupId(thresholdPublicKey)
|
||||
|
||||
if (database.chatRoomDao().findChatRoomById(roomId) != null) return@withLock Step.NothingToDo
|
||||
|
||||
val ceremonyRoom = database.chatRoomDao().findChatRoomById(current.chatRoomId)
|
||||
?: return@withLock Step.Stuck("The room ceremony ${current.id} ran in is gone")
|
||||
|
||||
// 4. The room exists: finish its founding invite if it never went out.
|
||||
// Only a room still at epoch 0 has anything to finish, so nobody who
|
||||
// left is ever invited back -- see `MarmotGroupCreation.uninvitedFounders`.
|
||||
if (database.chatRoomDao().findChatRoomById(roomId) != null) {
|
||||
return@withLock when (val invite = chatRepository.finishFoundingInvite(current, ceremonyRoom)) {
|
||||
MarmotGroupCreation.FoundingInvite.NothingToDo -> Step.NothingToDo
|
||||
is MarmotGroupCreation.FoundingInvite.Sent -> {
|
||||
logger.i("Ceremony ${current.id}: invited ${invite.invited.size} founder(s) to $roomId")
|
||||
Step.Invited(roomId, invite.notAdded)
|
||||
}
|
||||
is MarmotGroupCreation.FoundingInvite.BlockedOn -> Step.BlockedOn(invite.missing)
|
||||
is MarmotGroupCreation.FoundingInvite.Failed -> Step.Stuck(invite.reason)
|
||||
}
|
||||
}
|
||||
|
||||
val participants = ChillDkgRitualManager.participantsOf(current, ceremonyRoom)
|
||||
val parent = current.parentChatRoomId
|
||||
|
||||
|
||||
@@ -6,6 +6,7 @@ import com.vitorpamplona.quartz.nip01Core.core.HexKey
|
||||
import mobi.giza.compose.database.GizaDatabase
|
||||
import mobi.giza.compose.database.model.ChatMessage
|
||||
import mobi.giza.compose.database.model.DkgSession
|
||||
import mobi.giza.compose.database.model.intermdiate.LocalChatRoom
|
||||
import mobi.giza.compose.nostr.subgroup.SubgroupBirthCertificateEvent
|
||||
|
||||
/**
|
||||
@@ -94,6 +95,18 @@ object FoundingAdmins {
|
||||
return check
|
||||
}
|
||||
|
||||
/**
|
||||
* The ceremony that made [chatRoomId]'s key, as this device holds it, and the
|
||||
* room it ran in -- or null where this device holds no key state for the room,
|
||||
* no record of that ceremony, or no longer the room it ran in.
|
||||
*/
|
||||
suspend fun ceremonyOf(database: GizaDatabase, chatRoomId: String): Pair<DkgSession, LocalChatRoom>? {
|
||||
val state = database.groupKeyStateDao().getByChatRoomId(chatRoomId) ?: return null
|
||||
val ceremony = database.dkgSessionDao().getSessionById(state.dkgSessionId) ?: return null
|
||||
val ceremonyRoom = database.chatRoomDao().findChatRoomById(ceremony.chatRoomId) ?: return null
|
||||
return ceremony to ceremonyRoom
|
||||
}
|
||||
|
||||
/** The ceremony's participants, or null when this device holds no record of them. */
|
||||
private suspend fun foundersOf(database: GizaDatabase, ceremony: DkgSession?): Set<HexKey>? {
|
||||
ceremony ?: return null
|
||||
|
||||
+101
-1
@@ -4,6 +4,7 @@ import co.touchlab.kermit.Logger
|
||||
import mobi.giza.compose.nostr.MarmotProfile
|
||||
import com.vitorpamplona.quartz.nip01Core.core.HexKey
|
||||
import com.vitorpamplona.quartz.nip01Core.crypto.KeyPair
|
||||
import com.vitorpamplona.mls.group.MlsGroup
|
||||
import kotlinx.coroutines.async
|
||||
import kotlinx.coroutines.awaitAll
|
||||
import kotlinx.coroutines.coroutineScope
|
||||
@@ -11,6 +12,7 @@ import kotlinx.coroutines.flow.filterNotNull
|
||||
import kotlinx.coroutines.flow.first
|
||||
import kotlinx.coroutines.withTimeoutOrNull
|
||||
import mobi.giza.compose.database.GizaDatabase
|
||||
import mobi.giza.compose.database.model.Participant
|
||||
import mobi.giza.compose.database.model.DkgSession
|
||||
import mobi.giza.compose.database.model.MarmotKeyPackage
|
||||
import mobi.giza.compose.database.model.intermdiate.LocalChatRoom
|
||||
@@ -177,8 +179,16 @@ object MarmotGroupCreation {
|
||||
// there is a row to file it against.
|
||||
GroupKeyStateManager.adopt(database, groupId)
|
||||
|
||||
// Read again now the routing is on file. The row above predates it, and a
|
||||
// room with no routing row is addressed by its own id -- so on the current
|
||||
// profile the invite went to a second copy of the group the engine adopted
|
||||
// under the room id, and the copy at the real address still held only its
|
||||
// creator. Every later invite then took the founding path: no commit, and
|
||||
// nobody already in the room told. docs/robust-group-admins.md, Phase 4.
|
||||
val routedRoom = chatRepository.getChatRoomByIdentifier(groupId) ?: localChatRoom
|
||||
|
||||
val notAdded = runCatching {
|
||||
chatRepository.addMembers(localChatRoom = localChatRoom, peers = addable)
|
||||
chatRepository.addMembers(localChatRoom = routedRoom, peers = addable)
|
||||
}.onFailure {
|
||||
logger.e("Failed to add members to $groupId", it)
|
||||
}.getOrElse { addable.map { (publicKey, _) -> publicKey } }
|
||||
@@ -257,6 +267,96 @@ object MarmotGroupCreation {
|
||||
)
|
||||
}
|
||||
|
||||
/** What [finishFoundingInvite] did. */
|
||||
sealed interface FoundingInvite {
|
||||
/** Every founding member holds a leaf, or the room is past its founding. */
|
||||
data object NothingToDo : FoundingInvite
|
||||
|
||||
/** The founders who were missing were invited; [notAdded] could not be. */
|
||||
data class Sent(val chatRoomId: String, val invited: List<HexKey>, val notAdded: List<HexKey>) : FoundingInvite
|
||||
|
||||
/** Some founders have no published key package, so nobody was invited. */
|
||||
data class BlockedOn(val missing: List<HexKey>) : FoundingInvite
|
||||
|
||||
data class Failed(val reason: String) : FoundingInvite
|
||||
}
|
||||
|
||||
/**
|
||||
* The founding members of [room] its founding invite never reached: listed as
|
||||
* admins, holding no leaf, in a room nothing has been committed to since it was
|
||||
* made.
|
||||
*
|
||||
* Only at epoch 0. A room is created at epoch 0 and its founding invite is the
|
||||
* commit that leaves it -- so a room still there is one whose invite failed
|
||||
* outright, and nobody in it has left or been removed, because either would
|
||||
* have been a commit. Past epoch 0 a founder without a leaf might be one who
|
||||
* left, and inviting them back is not this function's to decide
|
||||
* (docs/robust-group-admins.md, Out of scope).
|
||||
*
|
||||
* A device holds a room at epoch 0 only if it made it: everybody else's copy
|
||||
* comes from a Welcome, which is already past the founding commit.
|
||||
*/
|
||||
suspend fun uninvitedFounders(
|
||||
database: GizaDatabase,
|
||||
room: LocalChatRoom,
|
||||
ceremony: DkgSession,
|
||||
ceremonyRoom: LocalChatRoom,
|
||||
): Set<HexKey> {
|
||||
val group = liveGroupOf(database, room) ?: return emptySet()
|
||||
if (group.epoch != 0L) return emptySet()
|
||||
|
||||
val holdingLeaves = Participant.fromMlsGroup(group, room.chatRoom.id, null).map { it.participantPublicKey }.toSet()
|
||||
return ChillDkgRitualManager.participantsOf(ceremony, ceremonyRoom) - holdingLeaves
|
||||
}
|
||||
|
||||
/**
|
||||
* Invites the founding members [room]'s founding invite never reached -- see
|
||||
* [uninvitedFounders] -- in one commit, as [create] would have.
|
||||
*
|
||||
* Every key package first, as at creation: a founder who cannot be invited yet
|
||||
* holds the rest back rather than leaving the room to a second, partial
|
||||
* founding. docs/robust-group-admins.md, Phase 4.
|
||||
*/
|
||||
suspend fun finishFoundingInvite(
|
||||
database: GizaDatabase,
|
||||
chatRepository: ChatRepository,
|
||||
ceremony: DkgSession,
|
||||
ceremonyRoom: LocalChatRoom,
|
||||
keyPackageLookupTimeout: Long = KEY_PACKAGE_LOOKUP_TIMEOUT,
|
||||
): FoundingInvite {
|
||||
val thresholdPublicKey = ceremony.thresholdPublicKey ?: return FoundingInvite.NothingToDo
|
||||
val groupId = SharedKeyDerivation.marmotGroupId(thresholdPublicKey)
|
||||
val room = chatRepository.getChatRoomByIdentifier(groupId) ?: return FoundingInvite.NothingToDo
|
||||
|
||||
val uninvited = uninvitedFounders(database, room, ceremony, ceremonyRoom)
|
||||
if (uninvited.isEmpty()) return FoundingInvite.NothingToDo
|
||||
|
||||
val keyPackages = keyPackagesFor(chatRepository, uninvited.toList(), keyPackageLookupTimeout, room.chatRoom.marmotProfile())
|
||||
val missing = keyPackages.filter { it.second == null }.map { it.first }
|
||||
if (missing.isNotEmpty()) {
|
||||
logger.w("Not finishing $groupId's founding invite: no key package for $missing")
|
||||
return FoundingInvite.BlockedOn(missing)
|
||||
}
|
||||
val addable = keyPackages.mapNotNull { (publicKey, keyPackage) -> keyPackage?.let { publicKey to it } }
|
||||
|
||||
val notAdded = runCatching {
|
||||
chatRepository.addMembers(localChatRoom = room, peers = addable)
|
||||
}.onFailure {
|
||||
logger.e("Failed to finish $groupId's founding invite", it)
|
||||
}.getOrElse { return FoundingInvite.Failed(it.message ?: "Couldn't invite them. Please try again.") }
|
||||
|
||||
flagAdmins(database, groupId)
|
||||
logger.i("Finished $groupId's founding invite: ${addable.size - notAdded.size} invited, ${notAdded.size} not")
|
||||
return FoundingInvite.Sent(groupId, addable.map { it.first }, notAdded)
|
||||
}
|
||||
|
||||
/** The room's live group: the row's on the legacy profile, the engine's on the current one. */
|
||||
private suspend fun liveGroupOf(database: GizaDatabase, room: LocalChatRoom): MlsGroup? =
|
||||
when (room.chatRoom.marmotProfile()) {
|
||||
MarmotProfile.LEGACY -> room.chatRoom.toMlsGroup()
|
||||
MarmotProfile.CURRENT -> database.marmotEngine.groupFor(room.routingId)
|
||||
}
|
||||
|
||||
/**
|
||||
* Writes `adminAt` on the rows of the members this room was created with as
|
||||
* admins.
|
||||
|
||||
@@ -224,6 +224,19 @@ interface ChatRepository {
|
||||
parentChatRoomId: HexKey? = null,
|
||||
): MarmotGroupCreation.Outcome
|
||||
|
||||
/**
|
||||
* Invites the founding members [ceremony]'s room never reached, when its
|
||||
* founding invite never went out. See `MarmotGroupCreation.finishFoundingInvite`
|
||||
* and docs/robust-group-admins.md, Phase 4.
|
||||
*/
|
||||
suspend fun finishFoundingInvite(ceremony: DkgSession, ceremonyRoom: LocalChatRoom): MarmotGroupCreation.FoundingInvite
|
||||
|
||||
/** [finishFoundingInvite] for the room [chatRoomId], through the ceremony its key state names. */
|
||||
suspend fun finishFoundingInvite(chatRoomId: String): MarmotGroupCreation.FoundingInvite
|
||||
|
||||
/** The founders [localChatRoom]'s founding invite never reached; empty when there are none to reach. */
|
||||
suspend fun uninvitedFounders(localChatRoom: LocalChatRoom): Set<HexKey>
|
||||
|
||||
/**
|
||||
* Takes every key ceremony [keyPair] coordinated from a key to a working room,
|
||||
* until cancelled: asks the group to sign its key state (a subgroup's parent to
|
||||
@@ -468,6 +481,14 @@ interface ChatRepository {
|
||||
|
||||
override suspend fun followThroughCeremonies(keyPair: KeyPair) = Unit
|
||||
|
||||
override suspend fun finishFoundingInvite(ceremony: DkgSession, ceremonyRoom: LocalChatRoom) =
|
||||
MarmotGroupCreation.FoundingInvite.NothingToDo
|
||||
|
||||
override suspend fun finishFoundingInvite(chatRoomId: String) =
|
||||
MarmotGroupCreation.FoundingInvite.NothingToDo
|
||||
|
||||
override suspend fun uninvitedFounders(localChatRoom: LocalChatRoom): Set<HexKey> = emptySet()
|
||||
|
||||
|
||||
override suspend fun sendChatMessage(
|
||||
text: String,
|
||||
|
||||
+25
@@ -50,6 +50,7 @@ class CeremonyFollowThroughJvmTest {
|
||||
/** The room creations asked for, and what the next one answers. */
|
||||
private val created = mutableListOf<Pair<String, Set<HexKey>>>()
|
||||
private var outcome: (String) -> MarmotGroupCreation.Outcome = { MarmotGroupCreation.Outcome.Failed("unset") }
|
||||
private var foundingInvite: MarmotGroupCreation.FoundingInvite = MarmotGroupCreation.FoundingInvite.NothingToDo
|
||||
|
||||
private val chatRepository = object : ChatRepository by ChatRepository.NO_OP_CHAT_REPOSITORY {
|
||||
override suspend fun createMarmotGroup(
|
||||
@@ -63,6 +64,8 @@ class CeremonyFollowThroughJvmTest {
|
||||
created += groupId to adminPublicKeys
|
||||
return outcome(groupId)
|
||||
}
|
||||
|
||||
override suspend fun finishFoundingInvite(ceremony: DkgSession, ceremonyRoom: LocalChatRoom) = foundingInvite
|
||||
}
|
||||
|
||||
private val material = keyMaterial("5eed0000000000000000000000000000000000000000000000000000000000e5")
|
||||
@@ -203,6 +206,28 @@ class CeremonyFollowThroughJvmTest {
|
||||
assertTrue(created.isEmpty())
|
||||
}
|
||||
|
||||
/** docs/robust-group-admins.md, Phase 4: a room that exists is asked whether its founding invite went out. */
|
||||
@Test
|
||||
fun `a room whose founding invite never went out has it finished`(): Unit = runBlocking {
|
||||
val session = finishedCeremony()
|
||||
signKeyState(session)
|
||||
GroupFixtures.seedRoom(db, roomOf(material))
|
||||
foundingInvite = MarmotGroupCreation.FoundingInvite.Sent(roomOf(material), invited = listOf(alice, bob), notAdded = listOf(bob))
|
||||
|
||||
assertEquals(CeremonyFollowThrough.Step.Invited(roomOf(material), listOf(bob)), next(session))
|
||||
assertTrue(created.isEmpty(), "and no second room")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a founding invite waiting on key packages says on whom`(): Unit = runBlocking {
|
||||
val session = finishedCeremony()
|
||||
signKeyState(session)
|
||||
GroupFixtures.seedRoom(db, roomOf(material))
|
||||
foundingInvite = MarmotGroupCreation.FoundingInvite.BlockedOn(listOf(alice))
|
||||
|
||||
assertEquals(CeremonyFollowThrough.Step.BlockedOn(listOf(alice)), next(session))
|
||||
}
|
||||
|
||||
/**
|
||||
* A subgroup's room needs its parent's certificate before its key state can
|
||||
* even be proposed, so that is asked for first -- and then the parent's
|
||||
|
||||
+128
-7
@@ -26,6 +26,12 @@ import kotlinx.coroutines.runBlocking
|
||||
import mobi.giza.compose.database.GizaDatabase
|
||||
import mobi.giza.compose.database.builder.getRoomDatabase
|
||||
import mobi.giza.compose.database.model.MarmotKeyPackage
|
||||
import mobi.giza.compose.nostr.Relays
|
||||
import mobi.giza.compose.extensions.toHex
|
||||
import mobi.giza.compose.database.model.types.DkgRitualStage
|
||||
import mobi.giza.compose.database.model.intermdiate.LocalChatRoom
|
||||
import mobi.giza.compose.database.model.DkgSession
|
||||
import mobi.giza.compose.database.model.ChatRoom
|
||||
import mobi.giza.compose.database.model.types.DkgApprovalStep
|
||||
import mobi.giza.compose.database.repository.DatabaseChatRepository
|
||||
import mobi.giza.compose.database.repository.DatabaseMarmotRepository
|
||||
@@ -84,7 +90,8 @@ class RobustGroupAdminsJvmTest {
|
||||
override fun toString() = publicKey.take(8)
|
||||
}
|
||||
|
||||
private val roomId = SharedKeyDerivation.marmotGroupId("02" + KeyPair().pubKey.toHexKey())
|
||||
private val foundingThresholdPublicKey = "02" + KeyPair().pubKey.toHexKey()
|
||||
private val roomId = SharedKeyDerivation.marmotGroupId(foundingThresholdPublicKey)
|
||||
|
||||
/**
|
||||
* Three phones; the first creates the admin room with all three as its admins,
|
||||
@@ -118,7 +125,7 @@ class RobustGroupAdminsJvmTest {
|
||||
}
|
||||
|
||||
/** Hands [to] the Welcome [from] queued for it, wrapped as a relay would carry it. */
|
||||
private suspend fun welcome(from: Phone, to: Phone) {
|
||||
private suspend fun welcome(from: Phone, to: Phone, roomId: String = this.roomId) {
|
||||
val payload = from.db.giftWrapPayloadDao().getAllGiftWrapUnsigned()
|
||||
.filter { it.kind == WelcomeEvent.KIND }
|
||||
.single { payload -> payload.tags.any { it.size > 1 && it[1] == to.keyPackage.id } }
|
||||
@@ -192,13 +199,14 @@ class RobustGroupAdminsJvmTest {
|
||||
/**
|
||||
* The boundary docs/robust-group-admins.md, D1 draws: founding, not present.
|
||||
*
|
||||
* Legacy only until Phase 4. On the current profile `MarmotGroupCreation` invites
|
||||
* the founders through a room read before its routing id was recorded, so the
|
||||
* engine's group at the real address still holds only the creator, and a later
|
||||
* invite takes the founding path -- no commit, and nobody else told.
|
||||
* On both profiles since Phase 4. Before it, `MarmotGroupCreation` invited the
|
||||
* founders on the current profile through a room read before its routing id was
|
||||
* recorded, so the engine's group at the real address still held only the
|
||||
* creator, and this later invite took the founding path -- no commit, and
|
||||
* nobody else told.
|
||||
*/
|
||||
@Test
|
||||
fun `a member added after the founding is not an admin`() = onEveryProfile(listOf(MarmotProfile.LEGACY)) { profile, phones ->
|
||||
fun `a member added after the founding is not an admin`() = onEveryProfile { profile, phones ->
|
||||
val founders = phones.map { it.publicKey }.toSet()
|
||||
val creator = phones.first()
|
||||
|
||||
@@ -219,6 +227,119 @@ class RobustGroupAdminsJvmTest {
|
||||
}
|
||||
}
|
||||
|
||||
// ---- The founding invite: docs/robust-group-admins.md, Phase 4 -------------
|
||||
|
||||
private val ceremonyRoomId = "ce1e".repeat(16)
|
||||
|
||||
/** The ceremony [phones] ran, as [owner]'s device holds it: everyone in it, and its key [roomId]'s. */
|
||||
private suspend fun ceremonyOn(owner: Phone, phones: List<Phone>, thresholdPublicKey: HexKey): Pair<DkgSession, LocalChatRoom> {
|
||||
owner.db.chatRoomDao().upsert(
|
||||
ChatRoom(id = ceremonyRoomId, userPublicKey = owner.publicKey, subject = "Ekklesia", description = null, mlsGroupState = null)
|
||||
)
|
||||
val session = DkgSession(
|
||||
id = "the-ceremony",
|
||||
chatRoomId = ceremonyRoomId,
|
||||
coordinatorPublicKey = owner.publicKey,
|
||||
userPublicKey = owner.publicKey,
|
||||
threshold = 2,
|
||||
participantCount = phones.size,
|
||||
participantPublicKeys = DkgSession.formatParticipants(phones.map { it.publicKey }.toSet()),
|
||||
subject = "Ekklesia",
|
||||
stage = DkgRitualStage.COMPLETE,
|
||||
hostPublicKey = owner.publicKey,
|
||||
round1Random = "aa".repeat(32),
|
||||
round2AuxRandom = "bb".repeat(32),
|
||||
thresholdPublicKey = thresholdPublicKey,
|
||||
secretShare = "cc".repeat(32),
|
||||
)
|
||||
owner.db.dkgSessionDao().upsert(session)
|
||||
return session to assertNotNull(owner.db.chatRoomDao().findChatRoomById(ceremonyRoomId))
|
||||
}
|
||||
|
||||
/**
|
||||
* A room whose founding invite never went out: made, with every founder in
|
||||
* its policy, and nobody but its creator in its tree -- what `create` leaves
|
||||
* when `addMembers` throws.
|
||||
*/
|
||||
private suspend fun roomWithoutItsInvite(profile: MarmotProfile, phones: List<Phone>, roomId: String) {
|
||||
val creator = phones.first()
|
||||
val created = MarmotGroupFactory.create(
|
||||
creator = creator.keyPair,
|
||||
roomId = roomId,
|
||||
name = "#Ekklesia",
|
||||
description = SharedKeyDerivation.describe("Admins of Ekklesia."),
|
||||
adminPublicKeys = phones.map { it.publicKey },
|
||||
relays = Relays.DefaultDMRelayList.map { it.url },
|
||||
profile = profile,
|
||||
)
|
||||
assertNotNull(
|
||||
creator.chatRepository.getOrCreateChatRoom(
|
||||
chatRoomId = roomId,
|
||||
activeUserPublicKey = creator.publicKey,
|
||||
relayHint = null,
|
||||
defaultSubject = "#Ekklesia",
|
||||
description = null,
|
||||
mlsGroupState = created.group.saveState().encodeTls().toHex(),
|
||||
)
|
||||
)
|
||||
creator.chatRepository.recordMarmotRouting(chatRoomId = roomId, routingId = created.routingId)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a founding invite that never went out is finished, and every founder is an admin`(): Unit = runBlocking {
|
||||
listOf(MarmotProfile.LEGACY, MarmotProfile.CURRENT).forEach { profile ->
|
||||
val phones = List(3) { Phone(profile) }
|
||||
try {
|
||||
phones.forEach { it.ready() }
|
||||
phones.forEach { phone -> phones.forEach { MarmotStandIn.seedProfile(phone.db, it.publicKey) } }
|
||||
val creator = phones.first()
|
||||
phones.drop(1).forEach { creator.db.marmotKeyPackageDao().upsert(it.keyPackage) }
|
||||
|
||||
val thresholdPublicKey = "02" + KeyPair().pubKey.toHexKey()
|
||||
val roomId = SharedKeyDerivation.marmotGroupId(thresholdPublicKey)
|
||||
roomWithoutItsInvite(profile, phones, roomId)
|
||||
val (session, ceremonyRoom) = ceremonyOn(creator, phones, thresholdPublicKey)
|
||||
|
||||
val invite = MarmotGroupCreation.finishFoundingInvite(
|
||||
creator.db, creator.chatRepository, session, ceremonyRoom, keyPackageLookupTimeout = 2_000L,
|
||||
)
|
||||
val sent = assertIs<MarmotGroupCreation.FoundingInvite.Sent>(invite, "($profile)")
|
||||
assertEquals(phones.drop(1).map { it.publicKey }.toSet(), sent.invited.toSet(), "($profile)")
|
||||
assertTrue(sent.notAdded.isEmpty(), "($profile)")
|
||||
|
||||
assertEquals(
|
||||
MarmotGroupCreation.FoundingInvite.NothingToDo,
|
||||
MarmotGroupCreation.finishFoundingInvite(creator.db, creator.chatRepository, session, ceremonyRoom, 2_000L),
|
||||
"and a second run invites nobody ($profile)",
|
||||
)
|
||||
|
||||
phones.drop(1).forEach { welcome(from = creator, to = it, roomId = roomId) }
|
||||
val founders = phones.map { it.publicKey }.toSet()
|
||||
phones.forEach { phone ->
|
||||
val room = assertNotNull(phone.db.chatRoomDao().findChatRoomById(roomId), "$phone has no room ($profile)")
|
||||
val group = assertNotNull(room.chatRoom.toMlsGroup(), "$phone holds no group ($profile)")
|
||||
assertEquals(founders, group.currentAdminIdentities(), "$phone's admin policy ($profile)")
|
||||
assertTrue(group.isLocalAdmin(), "$phone is not an admin ($profile)")
|
||||
}
|
||||
} finally {
|
||||
phones.forEach { it.close() }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** Past epoch 0 a founder without a leaf may be one who left; that is not this step's to undo. */
|
||||
@Test
|
||||
fun `a room past its founding invites nobody`() = onEveryProfile { profile, phones ->
|
||||
val creator = phones.first()
|
||||
val (session, ceremonyRoom) = ceremonyOn(creator, phones, foundingThresholdPublicKey)
|
||||
|
||||
assertEquals(
|
||||
MarmotGroupCreation.FoundingInvite.NothingToDo,
|
||||
MarmotGroupCreation.finishFoundingInvite(creator.db, creator.chatRepository, session, ceremonyRoom, 2_000L),
|
||||
"($profile)",
|
||||
)
|
||||
}
|
||||
|
||||
// ---- The ceremony ------------------------------------------------------------
|
||||
|
||||
@Test
|
||||
|
||||
Reference in new issue
Block a user