diff --git a/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/screen/loggedIn/chats/feed/ChatMessageActionSheet.kt b/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/screen/loggedIn/chats/feed/ChatMessageActionSheet.kt index ae7da2c626..42db67fdba 100644 --- a/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/screen/loggedIn/chats/feed/ChatMessageActionSheet.kt +++ b/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/screen/loggedIn/chats/feed/ChatMessageActionSheet.kt @@ -44,6 +44,7 @@ import androidx.compose.runtime.Composable import androidx.compose.runtime.Immutable import androidx.compose.runtime.getValue import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.produceState import androidx.compose.runtime.remember import androidx.compose.runtime.setValue import androidx.compose.ui.Alignment @@ -92,6 +93,7 @@ import com.vitorpamplona.amethyst.commons.ui.note.elements.NoteActionHandlers import com.vitorpamplona.amethyst.commons.ui.note.elements.ShareOptionsBottomSheet import com.vitorpamplona.amethyst.commons.ui.note.elements.noteActionSections import com.vitorpamplona.amethyst.commons.ui.note.elements.observeBookmarksFollowsAndAccount +import com.vitorpamplona.amethyst.commons.ui.screen.loggedIn.chats.publicChannels.concord.ConcordExpiringPinDialog import com.vitorpamplona.amethyst.commons.ui.screen.loggedIn.report.ReportNoteDialog import com.vitorpamplona.amethyst.commons.ui.screen.loggedIn.wallet.OnchainZapSendDialog import com.vitorpamplona.amethyst.commons.ui.screen.loggedIn.wallet.navigateToReloadMint @@ -108,12 +110,15 @@ import com.vitorpamplona.amethyst.ui.note.ZapAmountChoiceGrid import com.vitorpamplona.amethyst.ui.note.observeZapRailCapability import com.vitorpamplona.amethyst.ui.note.payViaIntentOrManualSplit import com.vitorpamplona.quartz.buzz.stream.StreamMessageV2Event +import com.vitorpamplona.quartz.concord.cord03Channels.ConcordDisappearing import com.vitorpamplona.quartz.nip01Core.core.Event import com.vitorpamplona.quartz.nip22Comments.CommentEvent import com.vitorpamplona.quartz.nipC7Chats.ChatEvent import kotlinx.collections.immutable.ImmutableList import kotlinx.collections.immutable.toImmutableList import kotlinx.collections.immutable.toImmutableSet +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.withContext import kotlin.uuid.ExperimentalUuidApi // null amount = open the on-chain dialog with no prefill. @@ -379,16 +384,37 @@ fun ChatMessageActionSheet( // Concord (CORD-04 §7): pin/unpin into the channel's Pin List. Only offered to a // PIN_MESSAGES holder who can write the Control Plane (null otherwise). - val concordPinned = remember(note) { accountViewModel.account.concord.concordPinState(note) } + // Read off the main thread: it verifies the channel's whole Pin List. + val concordPinState by produceState(null, note) { + value = withContext(Dispatchers.Default) { accountViewModel.account.concord.concordPinState(note) } + } + val concordPinned = concordPinState if (concordPinned != null && !note.isDraft()) { + var confirmExpiringPin by remember(note) { mutableStateOf(false) } SectionDivider() TileRow { val label = if (concordPinned) Res.string.relay_group_unpin_message else Res.string.relay_group_pin_message ActionTile(MaterialSymbols.PushPin, stringRes(label)) { - accountViewModel.toggleConcordPin(note) - onDismiss() + // Pinning a disappearing message (CORD-08) keeps its words past the timer: ask first. + val expires = note.event?.let { ConcordDisappearing.expirationOf(it) } != null + if (!concordPinned && expires) { + confirmExpiringPin = true + } else { + accountViewModel.toggleConcordPin(note) + onDismiss() + } } } + if (confirmExpiringPin) { + ConcordExpiringPinDialog( + onConfirm = { + confirmExpiringPin = false + accountViewModel.toggleConcordPin(note) + onDismiss() + }, + onDismiss = { confirmExpiringPin = false }, + ) + } } } } diff --git a/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/screen/loggedIn/chats/publicChannels/concord/ConcordChannelScreen.kt b/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/screen/loggedIn/chats/publicChannels/concord/ConcordChannelScreen.kt index 3f41b23ed2..fa5531418e 100644 --- a/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/screen/loggedIn/chats/publicChannels/concord/ConcordChannelScreen.kt +++ b/amethyst/src/main/java/com/vitorpamplona/amethyst/ui/screen/loggedIn/chats/publicChannels/concord/ConcordChannelScreen.kt @@ -88,7 +88,6 @@ import com.vitorpamplona.amethyst.commons.ui.insets.imePaddingSafe import com.vitorpamplona.amethyst.commons.ui.navigation.navs.INav import com.vitorpamplona.amethyst.commons.ui.note.creators.userSuggestions.ShowUserSuggestionList import com.vitorpamplona.amethyst.commons.ui.screen.loggedIn.chats.feed.types.concordTimerText -import com.vitorpamplona.amethyst.commons.ui.screen.loggedIn.chats.publicChannels.concord.ConcordPinDuties import com.vitorpamplona.amethyst.commons.ui.screen.loggedIn.chats.publicChannels.concord.ConcordPinnedButton import com.vitorpamplona.amethyst.commons.ui.screen.loggedIn.chats.publicChannels.concord.ConcordPinnedMessagesSheet import com.vitorpamplona.amethyst.commons.ui.screen.loggedIn.chats.publicChannels.concord.datasource.ConcordChannelSubscription @@ -186,10 +185,9 @@ fun ConcordChannelScreen( newMessageModel.init(accountViewModel) newMessageModel.load(communityId, channelId) - // CORD-04 §7 Pins: the header's entry point, the sheet it opens, the jump it requests, and the - // delayed duty writes (deletion omission / Edit refresh) a PIN_MESSAGES holder owes. + // CORD-04 §7 Pins: the header's entry point, the sheet it opens and the jump it requests. The + // delayed duty writes a PIN_MESSAGES holder owes run from the account (scheduleConcordPinDuties). val pins by rememberConcordChannelPins(communityId, channelId, accountViewModel) - ConcordPinDuties(communityId, channelId, pins, accountViewModel) var showPins by remember { mutableStateOf(false) } val jumpToNoteId = remember { mutableStateOf(null) } pins?.let { current -> @@ -199,6 +197,7 @@ fun ConcordChannelScreen( channelId = channelId, pins = current, accountViewModel = accountViewModel, + nav = nav, onJumpToMessage = { jumpToNoteId.value = it }, onDismiss = { showPins = false }, ) @@ -208,7 +207,7 @@ fun ConcordChannelScreen( Scaffold( topBar = { TopAppBar( - actions = { ConcordPinnedButton(pins) { showPins = true } }, + actions = { ConcordPinnedButton(communityId, pins, accountViewModel) { showPins = true } }, title = { Column { Text(channel.toBestDisplayName(), maxLines = 1) @@ -332,7 +331,11 @@ private fun ConcordTimerIndicator( communityId: String, accountViewModel: AccountViewModel, ) { - val session = remember(communityId) { accountViewModel.account.concordSessions.sessionFor(communityId) } ?: return + // Re-resolved on every session-set change: the session may not exist yet at first composition, and + // a Refounding replaces it (a captured one would keep reading the dead epoch's fold). + val sessions = accountViewModel.account.concordSessions + val revision by sessions.revision.collectAsStateWithLifecycle() + val session = remember(communityId, revision) { sessions.sessionFor(communityId) } ?: return val state by session.state.collectAsStateWithLifecycle() val secs = state?.metadata?.messageExpirationSecs() ?: return Text( diff --git a/cli/README.md b/cli/README.md index 6c6453ae35..c08bea8c4d 100644 --- a/cli/README.md +++ b/cli/README.md @@ -677,6 +677,10 @@ also carried on-relay as the encrypted, fragmented kind:33302 Community List | `amy concord list` | List joined Concord communities. | | `amy concord import` | Fetch + decrypt this account's Community List — the kind:33302 fragments plus the retired kind:13302 (carries heldRoots, CORD-06). | | `amy concord channels COMMUNITY` | List a community's channels; `readable` is false for a private channel whose key this account does not hold (CORD-03 §1). | +| `amy concord channel create COMMUNITY NAME [--private [--role NAME]]` | Create a channel (MANAGE_CHANNELS). `--private` gives it its own independent key at channel epoch 0 (stored before anything publishes) plus a bit-less access Role scoped to it (CORD-04 §2, default name = the channel's); nobody holds that Role yet — `concord grant` it to let members read. | +| `amy concord channel privatize COMMUNITY CHANNEL [--role NAME]` | Convert a Public channel to Private (CORD-03 §2): a fresh key at the next channel epoch — floored at the highest channel rotation found on the wire, refused (`inconclusive`) past 32 — plus an access Role, then the flag. Protects the future only. | +| `amy concord channel publicize COMMUNITY CHANNEL` | Convert a Private channel back to Public (flag only); the held key stays so the private era keeps reading. | +| `amy concord channel rekey COMMUNITY CHANNEL` | Rotate a Private channel's key (CORD-06 §1-2) to exactly the members its Roles entitle today plus us: 72-byte scope-bound blobs at the channel-rekey address, `vac` on every chunk. Needs MANAGE_CHANNELS and outranking every cut role holder; the key is reserved in `concord.json` so a re-run re-delivers the same one. | | `amy concord send COMMUNITY CHANNEL TEXT` | Post a message (CHANNEL = `general`\|name\|id). A private channel posts on its own key's plane; without a held key it fails with `no_channel_key` instead of falling back to the community-wide plane. | | `amy concord read COMMUNITY CHANNEL [--limit N] [--epoch N] [--root HEX]` | Read a channel's messages (default 50); `--epoch`/`--root` read a prior epoch's plane (public channels; a private channel reads its held key's plane). Banned members' messages are left out and counted in `hidden_banned`. | | `amy concord invite COMMUNITY [--base URL]` | Mint + publish a shareable invite link (at most 3 bootstrap relays ride in the fragment, CORD-05 §3; the bundle names this account as creator), then publish this account's Invite Registry (`vsk 8`, CORD-05 §5) listing its live link signers — expired links pruned. Output adds `registry_published`, `public` and `live_invite_links`. | @@ -686,15 +690,16 @@ also carried on-relay as the encrypted, fragmented kind:33302 Community List | `amy concord decline WRAP-ID` | Discard a Direct Invite; its wrap id is remembered in `concord-invites.json` so it never resurfaces. | | `amy concord revoke COMMUNITY TOKEN\|URL` | Retire a link you minted: publishes a `vsk=9` tombstone at its coordinate, records it in your Invite List, then republishes your Invite Registry without it. When it was the community's last live link the output carries `privatized: true` / `refound_required: true`: the community is Private now, and `concord refound COMMUNITY --privatize` rotates its keys (CORD-05 §2). | | `amy concord join URL` | Redeem an invite link, save the community, and publish a Guestbook Join echoing the link's attribution (CORD-05 §1/§6). | -| `amy concord rekey [COMMUNITY]` | Follow a Refounding we were re-keyed for. Honors only a BAN-holding rotator whose `vac` cites a Grant our fold has synced (the owner cites none); racing rotations converge on the lowest root (CORD-06 §3). | +| `amy concord rekey [COMMUNITY]` | Follow a Refounding we were re-keyed for. Honors only a BAN-holding rotator whose `vac` cites a Grant our fold has synced (the owner cites none); racing rotations converge on the lowest root (CORD-06 §3). Then follows every held private channel's own rotations (`channel_rekeys`): a complete, honored rotation off the key we hold is adopted; one from a rotator who outranks us that leaves us out drops the key and records the cut, so no older key comes back. | | `amy concord recover [COMMUNITY] [--rejoin]` | Report whether a Refounding left us behind (our joined-through link resolves to a higher epoch). A bundle never moves the base on its own (CORD-06 §2); `--rejoin` explicitly re-accepts the link. Ban-gated, fails closed. | -| `amy concord refound COMMUNITY --remove U[,U…]` / `--privatize` | CORD-06 Refounding. Aborts unless the whole Control Plane folds; publishes the rekey chunks first (each confirmed), the compacted plane after; reserves its keys so a re-run resumes with the same root; refused for a dissolved community. `--privatize` removes nobody: it converts a Public community to Private (owed once its last live invite link is revoked). | +| `amy concord refound COMMUNITY --remove U[,U…]` / `--privatize` | CORD-06 Refounding. Aborts unless the whole Control Plane folds; publishes the rekey chunks first (each confirmed), the compacted plane after, then rotates every held private channel to its entitled kept set, sealed under the prior root (`channels_rotated`); reserves its keys so a re-run resumes with the same root; refused for a dissolved community. `--privatize` removes nobody: it converts a Public community to Private (owed once its last live invite link is revoked). | | `amy concord roles COMMUNITY` | List live roles + the current banlist (CORD-04), plus the community's mode from the folded Invite Registries (CORD-05 §5): `public` (true while any live invite link exists), `live_invite_links`, and `invite_registries` (links per creator). | | `amy concord role COMMUNITY NAME POSITION PERM…` | Define a role (perms by name, e.g. `BAN KICK`; also `MANAGE_ROLES`, `MANAGE_CHANNELS`, `MANAGE_METADATA`, `MANAGE_MESSAGES`, `CREATE_INVITE`, `VIEW_AUDIT_LOG`, `MENTION_EVERYONE`, `PIN_MESSAGES`). | -| `amy concord grant COMMUNITY USER ROLE-ID` | Grant a role to a member. | +| `amy concord grant COMMUNITY USER ROLE-ID` | Grant a role to a member. Private-channel keys follow the Grant (CORD-03/06): every channel it opens to a member is vended to them by Direct Invite carrying only those channels (`channel_keys_vended`); every channel it closes is rotated (`channels_rotated`, or `channels_not_rotated` with the reason). Only keys this account holds can move (`channels_not_held`). | | `amy concord ban COMMUNITY USER` / `unban COMMUNITY USER` | Ban / unban a member. A ban reports `public` and `refound_required`: a Public ban is the Banlist alone, while a ban from a Private community owes a Refounding (`concord refound COMMUNITY --remove USER`, CORD-06 §3). | -| `amy concord pins COMMUNITY CHANNEL` | The channel's Pin List (CORD-04 §7), every entry verified from its proof bundle; entries the author deleted are listed under `deleted`, `edited`/`stale_edit` flag revisions, and `sealed_unavailable` means the list is sealed under a key this account never held (unreadable, not empty). | -| `amy concord pin COMMUNITY CHANNEL RUMOR_ID` / `unpin COMMUNITY CHANNEL RUMOR_ID` | Pin / unpin a message (PIN_MESSAGES or owner, plus the control write key). Pinning reopens the message's wrap to prove it with its original seal; a private channel's list is sealed under its current key. Refused (`list_unavailable`, `too_many_pins`, `too_large`, …) rather than published when the list is unreadable or a cap would break. | +| `amy concord kick COMMUNITY USER` | Cooperative Kick (CORD-04 §6): strips the member's roles first (when you may — MANAGE_ROLES + outrank), then publishes the Guestbook KICK (kind 3309) citing your Grant. Needs KICK and a strict outrank. Reports `roles_stripped`; changes no key — the member can rejoin, and a compliant client leaves on its own. | +| `amy concord pins COMMUNITY CHANNEL` | The channel's Pin List (CORD-04 §7), every entry verified from its proof bundle; entries the author deleted are listed under `deleted`, `edited`/`stale_edit` flag revisions, and `sealed_unavailable` means the list is sealed under a key this account never held (unreadable, not empty). Expired (CORD-08) pinned messages are hidden like deleted ones. | +| `amy concord pin COMMUNITY CHANNEL RUMOR_ID [--force]` / `unpin COMMUNITY CHANNEL RUMOR_ID` | Pin / unpin a message (PIN_MESSAGES or owner, plus the control write key). A disappearing message (one carrying a CORD-08 `expiration`) is refused with `expiring_message` unless `--force`: the pin would keep its words past the timer. Pinning reopens the message's wrap to prove it with its original seal; a private channel's list is sealed under its current key. Refused (`list_unavailable`, `too_many_pins`, `too_large`, …) rather than published when the list is unreadable or a cap would break. | | `amy concord dissolve COMMUNITY --yes` | Owner only, irreversible: publish the `eid`-bound dissolution tombstone that seals the community read-only (CORD-02 §9). | | `amy concord timer COMMUNITY [off\|SECONDS\|1d\|1w\|30d\|90d\|1y]` | CORD-08 disappearing messages. No value: print the folded timer (`0` = off). With one: publish the metadata edition (MANAGE_METADATA) and a kind-1740 notice into every channel whose key we hold. While a timer is set, `send` signs a NIP-40 `expiration` into the rumor and repeats it on the wrap; `read` drops expired messages. | diff --git a/cli/src/main/kotlin/com/vitorpamplona/amethyst/cli/commands/ConcordCommands.kt b/cli/src/main/kotlin/com/vitorpamplona/amethyst/cli/commands/ConcordCommands.kt index 8d7dcf5b34..9b936c5ae9 100644 --- a/cli/src/main/kotlin/com/vitorpamplona/amethyst/cli/commands/ConcordCommands.kt +++ b/cli/src/main/kotlin/com/vitorpamplona/amethyst/cli/commands/ConcordCommands.kt @@ -44,6 +44,7 @@ import com.vitorpamplona.quartz.concord.cord02Community.ConcordDissolution import com.vitorpamplona.quartz.concord.cord02Community.ConcordListFragmentSet import com.vitorpamplona.quartz.concord.cord02Community.HeldRoot import com.vitorpamplona.quartz.concord.cord02Community.PrivateChannelKey +import com.vitorpamplona.quartz.concord.cord03Channels.ConcordChannelKeyring import com.vitorpamplona.quartz.concord.cord04Roles.AuthorityResolver import com.vitorpamplona.quartz.concord.cord04Roles.ConcordLimits import com.vitorpamplona.quartz.concord.cord04Roles.ControlEdition @@ -53,6 +54,7 @@ import com.vitorpamplona.quartz.concord.cord05Invites.ConcordInviteListDocument import com.vitorpamplona.quartz.concord.cord05Invites.ConcordInviteListEntry import com.vitorpamplona.quartz.concord.cord05Invites.ConcordInviteListEvent import com.vitorpamplona.quartz.concord.cord05Invites.ConcordInviteListTombstone +import com.vitorpamplona.quartz.concord.cord05Invites.ConcordInviteVend import com.vitorpamplona.quartz.concord.cord05Invites.InviteBundleStatus import com.vitorpamplona.quartz.concord.cord06Rekey.ReceivedRefounding import com.vitorpamplona.quartz.concord.crypto.ControlPlaneKeys @@ -79,6 +81,15 @@ object ConcordCommands { | concord import fetch + decrypt this account's kind:33302 | community list (carries heldRoots, CORD-06) | concord channels COMMUNITY list a community's channels + | concord channel create COMMUNITY NAME create a channel (MANAGE_CHANNELS); --private + | [--private [--role NAME]] gives it its own key at channel epoch 0 plus a + | bit-less access Role (default: the channel name); + | grant that Role to let members read it + | concord channel privatize COMMUNITY CHANNEL convert a Public channel to Private: a fresh key + | [--role NAME] at the next channel epoch + an access Role + | concord channel publicize COMMUNITY CHANNEL convert a Private channel back to Public (flag only) + | concord channel rekey COMMUNITY CHANNEL rotate a Private channel's key to exactly the + | members its Roles entitle today (CORD-06) | concord send COMMUNITY CHANNEL TEXT post a message (CHANNEL = general|name|id) | concord read COMMUNITY CHANNEL [--limit N] read a channel's messages (default 50); | [--epoch N] [--root HEX] --epoch/--root read a prior epoch's plane @@ -96,7 +107,9 @@ object ConcordCommands { | it in your invite list so it stays retired | concord join URL redeem an invite link and save the community | concord rekey [COMMUNITY] follow a Refounding we were re-keyed for: - | open our blob and adopt the new epoch + | open our blob and adopt the new epoch; then + | follow each held private channel's rotations + | (adopt the new key, or drop it when cut) | concord recover [COMMUNITY] [--rejoin] re-resolve the joined-through invite link and | report whether a Refounding left us behind; | --rejoin re-accepts that link (a bundle never @@ -106,8 +119,12 @@ object ConcordCommands { | and public: true/false + live invite links | from the folded registries (CORD-05 §5) | concord role COMMUNITY NAME POSITION PERM… define a role (perms by name, e.g. BAN KICK) - | concord grant COMMUNITY USER ROLE-ID grant a role to a member + | concord grant COMMUNITY USER ROLE-ID grant a role to a member; the private channels it + | opens are vended by Direct Invite, the ones it + | closes are rotated (CORD-03/06) | concord ban COMMUNITY USER ban a member + | concord kick COMMUNITY USER cooperative kick (CORD-04 §6): strip the member's + | roles, then the Guestbook KICK; re-joinable | concord pins COMMUNITY CHANNEL the channel's verified Pin List (CORD-04 §7) | concord pin COMMUNITY CHANNEL RUMOR_ID pin a message (PIN_MESSAGES); proves it with | its original seal, capped at 25 / 32 KiB @@ -133,7 +150,7 @@ object ConcordCommands { route( "concord", tail, - "concord ", + "concord ", help = USAGE, routes = mapOf( @@ -141,6 +158,7 @@ object ConcordCommands { "list" to { rest -> list(dataDir, rest) }, "import" to { rest -> import(dataDir, rest) }, "channels" to { rest -> ConcordChannelCommands.channels(dataDir, rest) }, + "channel" to { rest -> ConcordPrivateChannelCommands.channel(dataDir, rest) }, "send" to { rest -> ConcordChannelCommands.send(dataDir, rest) }, "read" to { rest -> ConcordChannelCommands.read(dataDir, rest) }, "invite" to { rest -> invite(dataDir, rest) }, @@ -155,6 +173,7 @@ object ConcordCommands { "role" to { rest -> ConcordModCommands.defineRole(dataDir, rest) }, "grant" to { rest -> ConcordModCommands.grant(dataDir, rest) }, "ban" to { rest -> ConcordModCommands.ban(dataDir, rest) }, + "kick" to { rest -> ConcordModCommands.kick(dataDir, rest) }, "unban" to { rest -> ConcordModCommands.unban(dataDir, rest) }, "pins" to { rest -> ConcordPinCommands.pins(dataDir, rest) }, "pin" to { rest -> ConcordPinCommands.pin(dataDir, rest) }, @@ -729,9 +748,12 @@ object ConcordCommands { 0 } is DirectInviteAcceptPlan.CatchUp -> { - val held = heldSc!! - store.upsert(storedFrom(held, plan.entry)) - val added = plan.entry.privateChannels.filter { pc -> held.privateChannels.none { it.channelId.equals(pc.channelId, ignoreCase = true) && it.epoch == pc.epoch } } + // Re-applied to the record as stored NOW (the fold above took a while), never the + // snapshot the plan was computed from. + val held = store.load().firstOrNull { it.communityId == heldSc!!.communityId } ?: heldSc!! + val adopted = ConcordInviteVend.adoptCatchUp(entryFor(held), opened.invite, plan.channelIds) ?: plan.entry + store.upsert(storedFrom(held, adopted)) + val added = adopted.privateChannels.filter { pc -> held.privateChannels.none { it.channelId.equals(pc.channelId, ignoreCase = true) && it.epoch == pc.epoch } } Output.emit(done(mapOf("joined" to true, "catch_up" to true, "channels" to added.map { mapOf("id" to it.channelId, "name" to it.name, "epoch" to it.epoch) }))) 0 } @@ -840,7 +862,9 @@ object ConcordCommands { } /** The quartz list entry a [StoredCommunity] describes — the shape every commons helper takes. */ - fun entryFor(sc: StoredCommunity) = + fun entryFor(sc: StoredCommunity) = sc.channelCuts.entries.fold(entryShape(sc)) { entry, (id, epoch) -> ConcordChannelKeyring.withCut(entry, id, epoch) } + + private fun entryShape(sc: StoredCommunity) = ConcordCommunityListEntry( id = sc.communityId, owner = sc.owner, @@ -870,6 +894,7 @@ object ConcordCommands { name = entry.name.ifBlank { sc.name }, inviteRef = entry.inviteRef ?: sc.inviteRef, privateChannels = entry.privateChannels.filter { it.key.isNotBlank() }.map { StoredPrivateChannel(it.channelId, it.key, it.epoch, it.name) }, + channelCuts = ConcordChannelKeyring.cutsOf(entry), ) /** @@ -1048,7 +1073,15 @@ object ConcordCommands { store.upsert(storedFrom(sc, adopted).copy(pendingRefounding = null)) results += mapOf("community_id" to sc.communityId, "name" to sc.name, "rekeyed" to true, "from_epoch" to sc.rootEpoch, "root_epoch" to received.newEpoch, "rotator" to received.rotator) } - Output.emit(mapOf("communities" to results)) + // Then every held Private Channel's own rotations (CORD-06 §2), off the records as stored + // now — a base adoption above may have moved the root they are sealed under. + val channelResults = mutableListOf>() + for (id in targets.map { it.communityId }) { + val fresh = store.load().firstOrNull { it.communityId == id } ?: continue + if (fresh.privateChannels.isEmpty() || isDissolved(ctx, fresh)) continue + channelResults += ConcordPrivateChannelCommands.drainChannelRekeys(ctx, store, fresh) + } + Output.emit(mapOf("communities" to results, "channel_rekeys" to channelResults)) return 0 } } diff --git a/cli/src/main/kotlin/com/vitorpamplona/amethyst/cli/commands/ConcordModCommands.kt b/cli/src/main/kotlin/com/vitorpamplona/amethyst/cli/commands/ConcordModCommands.kt index c8d9f65c3b..8ad23dcd11 100644 --- a/cli/src/main/kotlin/com/vitorpamplona/amethyst/cli/commands/ConcordModCommands.kt +++ b/cli/src/main/kotlin/com/vitorpamplona/amethyst/cli/commands/ConcordModCommands.kt @@ -29,10 +29,13 @@ import com.vitorpamplona.amethyst.cli.stores.StoredCommunity import com.vitorpamplona.amethyst.cli.stores.StoredPendingRefounding import com.vitorpamplona.amethyst.commons.actions.ConcordActions import com.vitorpamplona.amethyst.commons.actions.ConcordModeration +import com.vitorpamplona.amethyst.commons.actions.ConcordPrivateChannels import com.vitorpamplona.amethyst.commons.actions.ConcordReceive import com.vitorpamplona.quartz.concord.cord02Community.ConcordCommunityState import com.vitorpamplona.quartz.concord.cord02Community.ConcordDissolution +import com.vitorpamplona.quartz.concord.cord03Channels.ConcordChannelKeyring import com.vitorpamplona.quartz.concord.cord03Channels.ConcordDisappearing +import com.vitorpamplona.quartz.concord.cord04Roles.AuthorityResolver import com.vitorpamplona.quartz.concord.cord04Roles.ConcordLimits import com.vitorpamplona.quartz.concord.cord04Roles.ConcordPermissions import com.vitorpamplona.quartz.concord.cord04Roles.ControlEdition @@ -41,6 +44,7 @@ import com.vitorpamplona.quartz.concord.cord04Roles.RoleEntity import com.vitorpamplona.quartz.concord.cord05Invites.ConcordInviteListDocument import com.vitorpamplona.quartz.concord.cord05Invites.ConcordInviteRegistry import com.vitorpamplona.quartz.concord.cord05Invites.InviteBundleStatus +import com.vitorpamplona.quartz.concord.cord06Rekey.ConcordChannelRekey import com.vitorpamplona.quartz.concord.cord06Rekey.ConcordRefounding import com.vitorpamplona.quartz.concord.cord06Rekey.IncompleteControlPlaneException import com.vitorpamplona.quartz.concord.cord06Rekey.PendingRefounding @@ -204,7 +208,11 @@ object ConcordModCommands { ) val ack = ctx.publish(wrap, ConcordCommands.relaysFor(ctx, sc)) RawEventSupport.publishGuard(ack, wrap.id)?.let { return it } - Output.emit(mapOf("member" to member, "roles" to listOf(roleId)) + RawEventSupport.ackFields(ack)) + // Role-gated channel keys follow the Grant (CORD-03/06): vend what it opened, rotate what it closed. + val before = AuthorityResolver.resolve(editions, sc.communityId.hexToByteArray(), sc.owner) + val after = editions + ConcordActions.controlEditions(listOf(wrap), cp) + val access = ConcordPrivateChannelCommands.reconcileAccess(ctx, ConcordStore(dataDir.concordFile), loaded.community, before, after) + Output.emit(mapOf("member" to member, "roles" to listOf(roleId)) + access + RawEventSupport.ackFields(ack)) return 0 } } @@ -318,6 +326,61 @@ object ConcordModCommands { } } + /** + * Kicks a member: `kick ` (CORD-04 §6, the Cooperative Kick). Role Removal + * first — an empty Grant when the target holds roles and we may strip them (MANAGE_ROLES + + * outrank, and the control_root to publish it; best-effort) — then the Guestbook directive + * (kind 3309) citing our Grant. Needs KICK and a strict outrank of the target. + */ + suspend fun kick( + dataDir: DataDir, + rest: Array, + ): Int { + val args = Args(rest) + val handle = args.positional(0, "community") + val userRef = args.positional(1, "user") + args.rejectUnknown() + val store = ConcordStore(dataDir.concordFile) + val sc = store.find(handle) ?: return ConcordCommands.notFound(handle) + + Context.open(dataDir).use { ctx -> + ctx.prepare() + val member = ctx.requireUserHex(userRef) + val loaded = load(ctx, sc, dataDir) + val (cp, editions) = loaded + val cid = sc.communityId.hexToByteArray() + val me = ctx.signer.pubKey + val authority = AuthorityResolver.resolve(editions, cid, sc.owner) + if (!authority.canActOn(me, member, ConcordPermissions.KICK)) { + return Output.error("forbidden", "kicking $member takes KICK and a strict outrank in '$handle' (CORD-04 §6)") + } + val relays = ConcordCommands.relaysFor(ctx, sc) + + // Strip first, so the target's rank is gone before the departure lands. + var chain = editions + var access: Map = emptyMap() + val strip = authority.rolesOf(member).isNotEmpty() && cp.canWrite && authority.canActOn(me, member, ConcordPermissions.MANAGE_ROLES) + if (strip) { + val stripWrap = ConcordModeration.grant(ctx.signer, cp, cid, member, emptyList(), editions, TimeUtils.now(), owner = sc.owner) + if (ctx.publish(stripWrap, relays).values.any { it.accepted }) { + chain = editions + ConcordActions.controlEditions(listOf(stripWrap), cp) + access = ConcordPrivateChannelCommands.reconcileAccess(ctx, store, loaded.community, authority, chain) + } else { + System.err.println("[concord] the role strip for $member was not accepted by any relay; kicking anyway") + } + } + + val gb = ConcordActions.guestbookPlane(sc.root.hexToByteArray(), cid, sc.rootEpoch) + ctx.registerConcordStreamKeys(relays, listOf(gb.secretKey)) + val citation = AuthorityResolver.resolve(chain, cid, sc.owner).citationFor(me) + val wrap = ConcordActions.buildGuestbookKick(ctx.signer, gb, member, citation, TimeUtils.now()) + val ack = ctx.publish(wrap, relays) + RawEventSupport.publishGuard(ack, wrap.id)?.let { return it } + Output.emit(mapOf("member" to member, "kicked" to true, "roles_stripped" to (chain !== editions)) + access + RawEventSupport.ackFields(ack)) + return 0 + } + } + /** Unbans a member: `unban `. */ suspend fun unban( dataDir: DataDir, @@ -544,11 +607,33 @@ object ConcordModCommands { } val compactionFailures = build.controlWraps.count { wrap -> ctx.publish(wrap, relays).values.none { it.accepted } } + // 4b. Rotate every held Private Channel (CORD-06 §3), each to its OWN entitled set among + // the kept members, sealed under the PRIOR root so a base-fork loser can still open + // it. One that no relay takes keeps its key and is reported: resumable, not atomic. + val afterBans = ConcordCommunityState.fold(chain, sc.communityId.hexToByteArray(), sc.owner) + val kept = recipients.mapTo(HashSet()) { it.lowercase() } + var withChannels = ConcordCommands.entryFor(loaded.community) + val channelsRotated = mutableListOf() + val channelsNotRotated = mutableListOf() + for (held in withChannels.privateChannels) { + val id = held.channelId.lowercase() + if (id !in afterBans.privateChannelIds || ConcordChannelKeyring.heldKey(withChannels, id) == null) continue + val keep = ConcordPrivateChannels.keepSet(afterBans.authority, id, me).filterTo(HashSet()) { it in kept || it == me.lowercase() } + val newKey = ConcordChannelRekey.mintKey() + val wraps = ConcordPrivateChannels.buildRotation(ctx.signer, priorRoot, held, newKey, keep, TimeUtils.now(), citation) + if (wraps.all { wrap -> ctx.publish(wrap, relays).values.any { it.accepted } }) { + withChannels = ConcordChannelKeyring.withRotatedKey(withChannels, id, newKey.toHexKey(), held.epoch + 1) ?: withChannels + channelsRotated += id + } else { + channelsNotRotated += id + } + } + // 5. Adopt the new epoch ourselves — the same pure rewrite Amethyst uses, banking the // epoch we are leaving for the anti-rollback floor — and drop the reservation. val adopted = ConcordReceive.withAdoptedRoot( - ConcordCommands.entryFor(loaded.community), + withChannels, keys.newRoot, build.newEpoch, build.newControlKeys.address.hexToByteArray(), @@ -606,6 +691,8 @@ object ConcordModCommands { "rekey_wraps" to build.rekeyWraps.size, "compaction_failures" to compactionFailures, "invites_refreshed" to refreshed, + "channels_rotated" to channelsRotated, + "channels_not_rotated" to channelsNotRotated, ), ) return 0 diff --git a/cli/src/main/kotlin/com/vitorpamplona/amethyst/cli/commands/ConcordPinCommands.kt b/cli/src/main/kotlin/com/vitorpamplona/amethyst/cli/commands/ConcordPinCommands.kt index bbbf4e946c..a1581ecd21 100644 --- a/cli/src/main/kotlin/com/vitorpamplona/amethyst/cli/commands/ConcordPinCommands.kt +++ b/cli/src/main/kotlin/com/vitorpamplona/amethyst/cli/commands/ConcordPinCommands.kt @@ -35,10 +35,12 @@ import com.vitorpamplona.amethyst.commons.actions.ConcordPinOutcome import com.vitorpamplona.amethyst.commons.actions.ConcordPinWrite import com.vitorpamplona.amethyst.commons.actions.ConcordPinning import com.vitorpamplona.quartz.concord.cord02Community.ConcordCommunityState +import com.vitorpamplona.quartz.concord.cord03Channels.ConcordDisappearing import com.vitorpamplona.quartz.concord.cord04Roles.ConcordPermissions import com.vitorpamplona.quartz.concord.cord04Roles.ControlEdition import com.vitorpamplona.quartz.nip01Core.core.Event import com.vitorpamplona.quartz.nip01Core.core.hexToByteArray +import com.vitorpamplona.quartz.nip40Expiration.isExpirationBefore import com.vitorpamplona.quartz.utils.TimeUtils /** @@ -91,7 +93,8 @@ object ConcordPinCommands { ?.key ?.conversationKey }, - isKilled = view.evidence::isKilled, + // CORD-08 §3: an expired message never shows, pinned or not (the proof stays valid, the rumor says it is gone). + isKilled = { view.evidence.isKilled(it) || it.tags.isExpirationBefore(TimeUtils.now()) }, newestEdit = view.evidence::newestEdit, ) } @@ -168,6 +171,7 @@ object ConcordPinCommands { val handle = args.positional(0, "community") val channelRef = args.positional(1, "channel") val rumorId = args.positional(2, "rumor_id").lowercase() + val force = pin && args.bool("force") args.rejectUnknown() if (!HEX64.matches(rumorId)) return Output.error("bad_args", "RUMOR_ID must be a 64-char hex rumor id") val stored = ConcordStore(dataDir.concordFile).find(handle) ?: return ConcordCommands.notFound(handle) @@ -202,9 +206,14 @@ object ConcordPinCommands { if (pin) { val refused = ConcordPinning.refusal(pinCtx) val source = if (refused == null) ConcordPinning.sourceFrom(view.wraps, view.planes, rumorId) else null + val expiresAt = source?.let { ConcordDisappearing.expirationOf(it.opened.rumor) } when { refused != null -> ConcordPinWrite(refused) source == null -> ConcordPinWrite(ConcordPinOutcome.MESSAGE_UNAVAILABLE) + // A pin carries the message's words in its proof: pinning a disappearing message + // makes it outlive its timer (CORD-08), so that takes an explicit --force. + expiresAt != null && !force -> + return Output.error("expiring_message", "that message disappears at $expiresAt (CORD-08) and a pin would keep its words past the timer; pass --force to pin it anyway") else -> ConcordPinning.pin(pinCtx, source, TimeUtils.now()) } } else { diff --git a/cli/src/main/kotlin/com/vitorpamplona/amethyst/cli/commands/ConcordPrivateChannelCommands.kt b/cli/src/main/kotlin/com/vitorpamplona/amethyst/cli/commands/ConcordPrivateChannelCommands.kt new file mode 100644 index 0000000000..06c1e7152d --- /dev/null +++ b/cli/src/main/kotlin/com/vitorpamplona/amethyst/cli/commands/ConcordPrivateChannelCommands.kt @@ -0,0 +1,409 @@ +/* + * Copyright (c) 2025 Vitor Pamplona + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the + * Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR + * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ +package com.vitorpamplona.amethyst.cli.commands + +import com.vitorpamplona.amethyst.cli.Args +import com.vitorpamplona.amethyst.cli.Context +import com.vitorpamplona.amethyst.cli.DataDir +import com.vitorpamplona.amethyst.cli.Output +import com.vitorpamplona.amethyst.cli.stores.ConcordStore +import com.vitorpamplona.amethyst.cli.stores.StoredCommunity +import com.vitorpamplona.amethyst.commons.actions.ConcordActions +import com.vitorpamplona.amethyst.commons.actions.ConcordModeration +import com.vitorpamplona.amethyst.commons.actions.ConcordPrivateChannels +import com.vitorpamplona.amethyst.commons.actions.ConcordReceive +import com.vitorpamplona.amethyst.commons.model.ConcordDirectInviteDraft +import com.vitorpamplona.quartz.concord.cord02Community.ConcordCommunityState +import com.vitorpamplona.quartz.concord.cord02Community.PrivateChannelKey +import com.vitorpamplona.quartz.concord.cord03Channels.ConcordChannelKeyring +import com.vitorpamplona.quartz.concord.cord04Roles.AuthorityResolver +import com.vitorpamplona.quartz.concord.cord04Roles.ChannelEntity +import com.vitorpamplona.quartz.concord.cord04Roles.ConcordPermissions +import com.vitorpamplona.quartz.concord.cord04Roles.ControlEdition +import com.vitorpamplona.quartz.concord.cord05Invites.ConcordInviteVend +import com.vitorpamplona.quartz.concord.cord06Rekey.ChannelRekeyOutcome +import com.vitorpamplona.quartz.concord.cord06Rekey.ConcordChannelRekey +import com.vitorpamplona.quartz.marmot.RecipientRelayFetcher +import com.vitorpamplona.quartz.nip01Core.core.Event +import com.vitorpamplona.quartz.nip01Core.core.HexKey +import com.vitorpamplona.quartz.nip01Core.core.hexToByteArray +import com.vitorpamplona.quartz.nip01Core.core.toHexKey +import com.vitorpamplona.quartz.utils.RandomInstance +import com.vitorpamplona.quartz.utils.TimeUtils + +/** + * `amy concord channel create|privatize|publicize|rekey` — Private Channels (CORD-03 §1-2, + * CORD-06 §1-2). Thin assembly over [ConcordPrivateChannels] (commons); the decisions — the key + * epoch, the access Role, who a rotation keeps, whether a received rotation is honored — are all + * shared with Amethyst. Like every amy verb that holds secrets, keys live in the local store only + * (amy does not republish the Community List). + */ +object ConcordPrivateChannelCommands { + /** How many channel epochs `privatize` probes for earlier rotations (Armada MAX_PROBED_CHANNEL_EPOCH). */ + private const val MAX_PROBED_CHANNEL_EPOCH = 32L + + suspend fun channel( + dataDir: DataDir, + tail: Array, + ): Int = + route( + "concord channel", + tail, + "concord channel ", + routes = + mapOf( + "create" to { rest -> create(dataDir, rest) }, + "privatize" to { rest -> privatize(dataDir, rest) }, + "publicize" to { rest -> publicize(dataDir, rest) }, + "rekey" to { rest -> rekey(dataDir, rest) }, + ), + ) + + /** Publishes [wraps] in order to [sc]'s relays; the first one no relay takes stops the run. */ + private suspend fun publishAll( + ctx: Context, + sc: StoredCommunity, + wraps: List, + ): Int? { + val relays = ConcordCommands.relaysFor(ctx, sc) + for (wrap in wraps) { + val ack = ctx.publish(wrap, relays) + RawEventSupport.publishGuard(ack, wrap.id)?.let { return it } + } + return null + } + + private fun canManageChannels( + authority: AuthorityResolver, + me: HexKey, + ): Boolean = authority.isOwner(me) || authority.hasPermission(me, ConcordPermissions.MANAGE_CHANNELS) + + private fun forbidden(): Int = Output.error("forbidden", "this needs the Manage-channels permission (CORD-03 §2); readers would drop the edition") + + /** Stores [sc] with the Private Channel [key] (refused when it would not move the channel forward). */ + private fun storeKey( + store: ConcordStore, + sc: StoredCommunity, + key: PrivateChannelKey, + ): Boolean { + val fresh = store.load().firstOrNull { it.communityId == sc.communityId } ?: sc + val next = ConcordChannelKeyring.withChannelKey(ConcordCommands.entryFor(fresh), key) ?: return false + store.upsert(ConcordCommands.storedFrom(fresh, next)) + return true + } + + /** `concord channel create COMMUNITY NAME [--private [--role NAME]]`. */ + private suspend fun create( + dataDir: DataDir, + rest: Array, + ): Int { + val args = Args(rest) + val handle = args.positional(0, "community") + val name = args.positional(1, "name") + val private = args.bool("private") + val roleName = args.flag("role") + args.rejectUnknown() + if (!ChannelEntity(name = name.trim()).hasValidName()) return Output.error("bad_args", "a channel name must be 1..${ChannelEntity.NAME_MAX_BYTES} UTF-8 bytes").let { 2 } + if (roleName != null && !private) return Output.error("bad_args", "--role names a Private channel's access Role; add --private").let { 2 } + val store = ConcordStore(dataDir.concordFile) + val sc = store.find(handle) ?: return ConcordCommands.notFound(handle) + + Context.open(dataDir).use { ctx -> + ctx.prepare() + val loaded = ConcordModCommands.load(ctx, sc, dataDir) + val (cp, editions) = loaded + ConcordModCommands.writeGuard(cp)?.let { return it } + val authority = AuthorityResolver.resolve(editions, sc.communityId.hexToByteArray(), sc.owner) + if (!canManageChannels(authority, ctx.signer.pubKey)) return forbidden() + + if (!private) { + val channelId = RandomInstance.bytes(32) + val wrap = ConcordModeration.defineChannel(ctx.signer, cp, sc.communityId.hexToByteArray(), channelId, ChannelEntity(name = name.trim()), editions, TimeUtils.now(), owner = sc.owner) + publishAll(ctx, sc, listOf(wrap))?.let { return it } + Output.emit(mapOf("channel_id" to channelId.toHexKey(), "name" to name.trim(), "private" to false)) + return 0 + } + + val build = + ConcordPrivateChannels.create(ctx.signer, cp, sc.communityId.hexToByteArray(), name, roleName, editions, authority, sc.owner, TimeUtils.now()) + ?: return Output.error("forbidden", "no rank to mint this channel's access Role from") + // The key goes into the store BEFORE the editions publish: otherwise a crash orphans the only copy. + if (!storeKey(store, loaded.community, build.key)) return Output.error("conflict", "could not store the new channel key") + publishAll(ctx, sc, build.wraps)?.let { return it } + Output.emit( + mapOf( + "channel_id" to build.channelIdHex, + "name" to name.trim(), + "private" to true, + "channel_epoch" to build.key.epoch, + "access_role_id" to build.roleIdHex, + ), + ) + return 0 + } + } + + /** `concord channel privatize COMMUNITY CHANNEL [--role NAME]`. */ + private suspend fun privatize( + dataDir: DataDir, + rest: Array, + ): Int { + val args = Args(rest) + val handle = args.positional(0, "community") + val channelRef = args.positional(1, "channel") + val roleName = args.flag("role") + args.rejectUnknown() + val store = ConcordStore(dataDir.concordFile) + val sc = store.find(handle) ?: return ConcordCommands.notFound(handle) + + Context.open(dataDir).use { ctx -> + ctx.prepare() + val channelId = ConcordChannelCommands.resolve(ctx, sc, channelRef) ?: return Output.error("not_found", "no channel '$channelRef'") + val loaded = ConcordModCommands.load(ctx, sc, dataDir) + val (cp, editions) = loaded + ConcordModCommands.writeGuard(cp)?.let { return it } + val state = ConcordCommunityState.fold(editions, sc.communityId.hexToByteArray(), sc.owner) + if (!canManageChannels(state.authority, ctx.signer.pubKey)) return forbidden() + val standing = state.channels[channelId]?.definition ?: return Output.error("not_found", "channel '$channelRef' is not in the folded Control Plane") + if (standing.private) return Output.error("already_private", "channel '$channelRef' is already private") + + // The next channel epoch must climb past every generation ever used — including ones this + // account never held — so probe the rekey addresses the roots derive (CORD-03 §2). + val entry = ConcordCommands.entryFor(loaded.community) + val window = HashMap() + for (root in (listOf(entry.root) + entry.heldRoots.map { it.key }).distinct()) { + for (epoch in 1L..MAX_PROBED_CHANNEL_EPOCH) window[ConcordChannelRekey.address(root.hexToByteArray(), channelId.hexToByteArray(), epoch).publicKeyHex] = epoch + } + val relays = ConcordCommands.relaysFor(ctx, sc) + val seen = ctx.drain(relays.associateWith { listOf(ConcordActions.planeFilterFor(window.keys.toList())) }).map { it.second } + val floor = seen.mapNotNull { window[it.pubKey] }.maxOrNull() ?: 0 + if (floor >= MAX_PROBED_CHANNEL_EPOCH) return Output.error("inconclusive", "this channel has rotated at least $MAX_PROBED_CHANNEL_EPOCH times; its next epoch can't be established safely") + + val build = + ConcordPrivateChannels.privatize(ctx.signer, cp, entry, channelId, standing, roleName, editions, state.authority, TimeUtils.now(), floor) + ?: return Output.error("forbidden", "no rank to mint this channel's access Role from") + if (!storeKey(store, loaded.community, build.key)) return Output.error("conflict", "could not store the new channel key") + publishAll(ctx, sc, build.wraps)?.let { return it } + Output.emit(mapOf("channel_id" to channelId, "private" to true, "channel_epoch" to build.key.epoch, "access_role_id" to build.roleIdHex)) + return 0 + } + } + + /** `concord channel publicize COMMUNITY CHANNEL`. */ + private suspend fun publicize( + dataDir: DataDir, + rest: Array, + ): Int { + val args = Args(rest) + val handle = args.positional(0, "community") + val channelRef = args.positional(1, "channel") + args.rejectUnknown() + val sc = ConcordStore(dataDir.concordFile).find(handle) ?: return ConcordCommands.notFound(handle) + + Context.open(dataDir).use { ctx -> + ctx.prepare() + val channelId = ConcordChannelCommands.resolve(ctx, sc, channelRef) ?: return Output.error("not_found", "no channel '$channelRef'") + val (cp, editions) = ConcordModCommands.load(ctx, sc, dataDir) + ConcordModCommands.writeGuard(cp)?.let { return it } + val state = ConcordCommunityState.fold(editions, sc.communityId.hexToByteArray(), sc.owner) + if (!canManageChannels(state.authority, ctx.signer.pubKey)) return forbidden() + val standing = state.channels[channelId]?.definition ?: return Output.error("not_found", "channel '$channelRef' is not in the folded Control Plane") + val wrap = + ConcordPrivateChannels.publicize(ctx.signer, cp, sc.communityId.hexToByteArray(), channelId, standing, editions, sc.owner, TimeUtils.now()) + ?: return Output.error("already_public", "channel '$channelRef' is not private") + publishAll(ctx, sc, listOf(wrap))?.let { return it } + Output.emit(mapOf("channel_id" to channelId, "private" to false)) + return 0 + } + } + + /** `concord channel rekey COMMUNITY CHANNEL` — rotate to exactly the members entitled today. */ + private suspend fun rekey( + dataDir: DataDir, + rest: Array, + ): Int { + val args = Args(rest) + val handle = args.positional(0, "community") + val channelRef = args.positional(1, "channel") + args.rejectUnknown() + val store = ConcordStore(dataDir.concordFile) + val sc = store.find(handle) ?: return ConcordCommands.notFound(handle) + + Context.open(dataDir).use { ctx -> + ctx.prepare() + if (ConcordCommands.isDissolved(ctx, sc)) return Output.error("dissolved", "community '$handle' has been dissolved (CORD-02 §9)") + val channelId = ConcordChannelCommands.resolve(ctx, sc, channelRef) ?: return Output.error("not_found", "no channel '$channelRef'") + val loaded = ConcordModCommands.load(ctx, sc, dataDir) + val authority = AuthorityResolver.resolve(loaded.editions, sc.communityId.hexToByteArray(), sc.owner) + // The known role holders a rotation to the entitled set leaves out; a roleless member ranks + // last, so any MANAGE_CHANNELS holder outranks them and they need no check. + val keep = ConcordPrivateChannels.keepSet(authority, channelId, ctx.signer.pubKey) + val cut = (authority.roleHolders() + authority.owner()).filterTo(HashSet()) { it !in keep } + return rotate(ctx, store, loaded.community, channelId, authority, loaded.editions, cut) + } + } + + /** A rotation's result: [error] (code to message) when refused or unpublished, else what landed. */ + internal class Rotation( + val error: Pair? = null, + val newEpoch: Long = 0, + val kept: Int = 0, + val chunks: Int = 0, + ) + + /** [rotateSilently] with its outcome emitted as the command's JSON line. */ + internal suspend fun rotate( + ctx: Context, + store: ConcordStore, + sc: StoredCommunity, + channelId: HexKey, + authority: AuthorityResolver, + editions: List, + cut: Set, + ): Int { + val r = rotateSilently(ctx, store, sc, channelId, authority, editions, cut) + r.error?.let { (code, message) -> return Output.error(code, message) } + Output.emit(mapOf("channel_id" to channelId, "rekeyed" to true, "channel_epoch" to r.newEpoch, "kept" to r.kept, "chunks" to r.chunks)) + return 0 + } + + /** + * Rotates [channelId] to its entitled set (CORD-06 §1-2), cutting [cut]: authority checked, the + * key reserved in the store before anything publishes (a retry re-delivers the same key), every + * chunk accepted by a relay before the new key is adopted locally. Prints nothing. + */ + internal suspend fun rotateSilently( + ctx: Context, + store: ConcordStore, + sc: StoredCommunity, + channelId: HexKey, + authority: AuthorityResolver, + editions: List, + cut: Set, + ): Rotation { + val me = ctx.signer.pubKey + val entry = ConcordCommands.entryFor(sc) + val held = ConcordChannelKeyring.heldKey(entry, channelId) ?: return Rotation("no_channel_key" to "this account holds no key for channel $channelId, so it cannot rotate it") + if (!ConcordPrivateChannels.canRotate(authority, me, cut)) { + return Rotation("forbidden" to "rotating needs the Manage-channels permission and outranking every member it cuts (CORD-06 §3)") + } + val citation = ConcordReceive.rotationCitation(entry, editions, me) + if (citation == null && !authority.isOwner(me)) return Rotation("forbidden" to "no Grant of ours to cite; nobody would honor this rotation (CORD-06 §3)") + + val newEpoch = held.epoch + 1 + val reservation = "${held.channelId.lowercase()}:$newEpoch:${ConcordChannelRekey.prevCommit(held.epoch, held.key.hexToByteArray())}" + val newKeyHex = sc.pendingChannelRotations[reservation] ?: ConcordChannelRekey.mintKey().toHexKey() + store.upsert(sc.copy(pendingChannelRotations = sc.pendingChannelRotations + (reservation to newKeyHex))) + + val keep = ConcordPrivateChannels.keepSet(authority, channelId, me) + val wraps = ConcordPrivateChannels.buildRotation(ctx.signer, sc.root.hexToByteArray(), held, newKeyHex.hexToByteArray(), keep, TimeUtils.now(), citation) + val relays = ConcordCommands.relaysFor(ctx, sc) + for (wrap in wraps) { + if (ctx.publish(wrap, relays).values.none { it.accepted }) { + return Rotation("rejected" to "no relay accepted chunk ${wrap.id} of the rotation; re-running re-delivers the same key") + } + } + + // Adopt at once: the rotator must never keep writing under the severed key. + val fresh = store.load().firstOrNull { it.communityId == sc.communityId } ?: sc + val next = ConcordChannelKeyring.withRotatedKey(ConcordCommands.entryFor(fresh), channelId, newKeyHex, newEpoch) + if (next != null) store.upsert(ConcordCommands.storedFrom(fresh, next).copy(pendingChannelRotations = fresh.pendingChannelRotations - reservation)) + return Rotation(newEpoch = newEpoch, kept = keep.size, chunks = wraps.size) + } + + /** + * Follows every held Private Channel's rotations for [sc] (CORD-06 §2): drains the watched + * channel-rekey addresses, adopts a key carried off the one we hold, or drops the channel (and + * records the cut) when a rotation from someone who outranks us left us out. Returns one result + * per channel acted on. + */ + internal suspend fun drainChannelRekeys( + ctx: Context, + store: ConcordStore, + sc: StoredCommunity, + ): List> { + val entry = ConcordCommands.entryFor(sc) + val keys = ConcordPrivateChannels.watchKeys(entry) + if (keys.isEmpty()) return emptyList() + val relays = ConcordCommands.relaysFor(ctx, sc) + ctx.registerConcordStreamKeys(relays, keys.values.map { it.secretKey }) + val wraps = ctx.drain(relays.associateWith { listOf(ConcordActions.planeFilterFor(keys.keys.toList())) }, pendingOnAuthRequired = true).map { it.second } + if (wraps.isEmpty()) return emptyList() + val loaded = ConcordModCommands.load(ctx, sc) + val authority = AuthorityResolver.resolve(loaded.editions, sc.communityId.hexToByteArray(), sc.owner) + val outcomes = ConcordPrivateChannels.receive(entry, wraps, loaded.editions, authority, ctx.signer) + if (outcomes.isEmpty()) return emptyList() + val fresh = store.load().firstOrNull { it.communityId == sc.communityId } ?: sc + val next = ConcordPrivateChannels.applyOutcome(ConcordCommands.entryFor(fresh), outcomes, entry.privateChannels.associate { it.channelId.lowercase() to it.epoch }) + if (next != null) store.upsert(ConcordCommands.storedFrom(fresh, next)) + return outcomes.map { (id, outcome) -> + when (outcome) { + is ChannelRekeyOutcome.Adopted -> mapOf("community_id" to sc.communityId, "channel_id" to id, "adopted" to true, "channel_epoch" to outcome.epoch) + is ChannelRekeyOutcome.Removed -> mapOf("community_id" to sc.communityId, "channel_id" to id, "removed" to true, "channel_epoch" to outcome.epoch) + ChannelRekeyOutcome.None -> mapOf("community_id" to sc.communityId, "channel_id" to id) + } + } + } + + /** + * After a Grant: vends every Private Channel it opened to its member by Direct Invite (only those + * channels), and rotates every one it closed (CORD-03/06; Armada `handleToggleRole`). Returns what + * it did, for the grant command's output. + */ + internal suspend fun reconcileAccess( + ctx: Context, + store: ConcordStore, + sc: StoredCommunity, + before: AuthorityResolver, + afterEditions: List, + ): Map { + val state = ConcordCommunityState.fold(afterEditions, sc.communityId.hexToByteArray(), sc.owner) + val me = ctx.signer.pubKey.lowercase() + val entry = ConcordCommands.entryFor(sc) + val changes = ConcordInviteVend.accessChanges(before, state.authority, state.privateChannelIds) + val vended = mutableListOf>() + val rotated = mutableListOf() + val unrotated = mutableListOf>() + val unheld = mutableListOf() + val byMember = HashMap>() + for (change in changes) { + if (ConcordChannelKeyring.heldKey(entry, change.channelIdHex) == null) { + unheld += change.channelIdHex + continue + } + for (m in change.gained - me) byMember.getOrPut(m) { HashSet() }.add(change.channelIdHex) + val cut = change.lost - me + if (cut.isNotEmpty()) { + val fresh = store.load().firstOrNull { it.communityId == sc.communityId } ?: sc + val r = rotateSilently(ctx, store, fresh, change.channelIdHex, state.authority, afterEditions, cut) + if (r.error == null) rotated += change.channelIdHex else unrotated += mapOf("channel_id" to change.channelIdHex, "reason" to r.error.second) + } + } + for ((member, channels) in byMember) { + val draft = ConcordActions.draftDirectInvite(entry, state, me, member, onlyChannelIds = channels) as? ConcordDirectInviteDraft.Ready ?: continue + val wrap = ConcordActions.buildDirectInvite(ctx.signer, member, draft.invite) + val lists = ctx.cachedRelayListsOf(member) ?: RecipientRelayFetcher.fetchRelayLists(ctx.client, member, ctx.bootstrapRelays()) + val ack = ctx.publish(wrap, ConcordActions.directInviteDeliveryRelays(lists)) + vended += mapOf("member" to member, "channels" to draft.invite.channels.map { it.id }, "delivered" to ack.values.any { it.accepted }) + } + return mapOf("channel_keys_vended" to vended, "channels_rotated" to rotated, "channels_not_rotated" to unrotated, "channels_not_held" to unheld) + } +} diff --git a/cli/src/main/kotlin/com/vitorpamplona/amethyst/cli/stores/ConcordInviteInboxStore.kt b/cli/src/main/kotlin/com/vitorpamplona/amethyst/cli/stores/ConcordInviteInboxStore.kt index b9ec3a7116..41fbd498c2 100644 --- a/cli/src/main/kotlin/com/vitorpamplona/amethyst/cli/stores/ConcordInviteInboxStore.kt +++ b/cli/src/main/kotlin/com/vitorpamplona/amethyst/cli/stores/ConcordInviteInboxStore.kt @@ -23,6 +23,7 @@ package com.vitorpamplona.amethyst.cli.stores import com.fasterxml.jackson.module.kotlin.readValue import com.vitorpamplona.amethyst.cli.Output import com.vitorpamplona.amethyst.cli.SecureFileIO +import com.vitorpamplona.amethyst.commons.model.concord.ConcordDirectInviteInbox import java.io.File /** amy's bookkeeping for Concord Direct Invites (CORD-05 §6): the wrap ids the user declined. */ @@ -50,6 +51,8 @@ class ConcordInviteInboxStore( fun decline(wrapId: String) { val current = load() if (wrapId in current.declined) return - SecureFileIO.writeTextAtomic(file, Output.mapper.writeValueAsString(current.copy(declined = current.declined + wrapId))) + // Bounded like the app's store: the newest declines are kept, a long-expired one is not worth a line. + val next = (current.declined + wrapId).takeLast(ConcordDirectInviteInbox.DECLINED_CAP) + SecureFileIO.writeTextAtomic(file, Output.mapper.writeValueAsString(current.copy(declined = next))) } } diff --git a/cli/src/main/kotlin/com/vitorpamplona/amethyst/cli/stores/ConcordStore.kt b/cli/src/main/kotlin/com/vitorpamplona/amethyst/cli/stores/ConcordStore.kt index cbfc24fd48..225bf928e8 100644 --- a/cli/src/main/kotlin/com/vitorpamplona/amethyst/cli/stores/ConcordStore.kt +++ b/cli/src/main/kotlin/com/vitorpamplona/amethyst/cli/stores/ConcordStore.kt @@ -57,6 +57,13 @@ data class StoredCommunity( // A private channel is read and written ONLY on the plane its own key derives; without one it // is unreadable and `send` refuses rather than fall back to the root-derived plane. val privateChannels: List = emptyList(), + // Per Private Channel, the channel epoch whose rotation cut this account out (CORD-06 §2; the + // reference client's `channel_cuts`): a key below it is never adopted again from a bundle. + val channelCuts: Map = emptyMap(), + // Channel keys reserved for a Private Channel rotation this account started but has not yet + // adopted, keyed "channelId:newEpoch:prevcommit" (CORD-06): a retried `channel rekey` must + // re-deliver the SAME key, never a sibling that splits the members at one epoch. + val pendingChannelRotations: Map = emptyMap(), // Keys reserved for a Refounding this account started but has not yet adopted (CORD-06 §3): a // retried `refound` must re-deliver the SAME root, never mint a sibling that splits the members. val pendingRefounding: StoredPendingRefounding? = null, diff --git a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/actions/ConcordActions.kt b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/actions/ConcordActions.kt index 265fdf5e87..d458ba1c2e 100644 --- a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/actions/ConcordActions.kt +++ b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/actions/ConcordActions.kt @@ -33,8 +33,8 @@ import com.vitorpamplona.quartz.concord.cord02Community.ImagePointer import com.vitorpamplona.quartz.concord.cord02Community.NewConcordCommunity import com.vitorpamplona.quartz.concord.cord02Community.PrivateChannelKey import com.vitorpamplona.quartz.concord.cord03Channels.ChannelChat +import com.vitorpamplona.quartz.concord.cord03Channels.ConcordChannelKeyring import com.vitorpamplona.quartz.concord.cord03Channels.ConcordChannelKeys -import com.vitorpamplona.quartz.concord.cord03Channels.ConcordChatEditEvent import com.vitorpamplona.quartz.concord.cord03Channels.ConcordDisappearing import com.vitorpamplona.quartz.concord.cord04Roles.AuthorityCitation import com.vitorpamplona.quartz.concord.cord04Roles.AuthorityResolver @@ -212,24 +212,30 @@ object ConcordActions { /** * The older Chat Planes of a channel this account can still read, beside [currentChannelPlane]: - * - Public: its plane under every held prior root ([historicalChannelPlanes]), plus the - * private-era plane when a channel key is held (a channel that was Private before); - * - Private: none. Only the channel-key planes are its own; the root-derived plane is readable - * by every member, so showing it would present public content as private (Armada - * `channelsView`). With no priors kept per channel key, that leaves nothing. + * - Public: its plane under every held prior root ([historicalChannelPlanes]), plus every + * private-era plane a channel key is held for (a channel that was Private before); + * - Private: the planes of the older channel keys the entry still carries (its `seed` and a + * peer's `priors`, [ConcordChannelKeyring.historicalKeys]) — history across a channel rekey. + * Never the root-derived plane: every member reads that one, so showing it would present + * public content as private (Armada `channelsView`). */ fun historicalChannelPlanes( entry: ConcordCommunityListEntry, channelIdHex: HexKey, isPrivate: Boolean, ): List { - if (isPrivate) return emptyList() + val channelId = channelIdHex.hexToByteArray() + val olderKeys = + ConcordChannelKeyring.historicalKeys(entry, channelIdHex).map { old -> + ChannelPlane(channelIdHex, old.epoch, ConcordChannelKeys.privateChannel(old.key.hexToByteArray(), channelId, old.epoch)) + } + if (isPrivate) return olderKeys val rootEras = historicalChannelPlanes(entry.heldRoots, listOf(channelIdHex)) val privateEra = heldPrivateChannelKey(entry, channelIdHex)?.let { held -> - ChannelPlane(channelIdHex, held.epoch, ConcordChannelKeys.privateChannel(held.key.hexToByteArray(), channelIdHex.hexToByteArray(), held.epoch)) + ChannelPlane(channelIdHex, held.epoch, ConcordChannelKeys.privateChannel(held.key.hexToByteArray(), channelId, held.epoch)) } - return rootEras + listOfNotNull(privateEra) + return rootEras + listOfNotNull(privateEra) + olderKeys } /** @@ -500,6 +506,11 @@ object ConcordActions { * Builds an encrypted-seal **edit** wrap (kind-3302 [ChannelChat.edit] of [target]) on the * [channel] plane. [newText] replaces [target]'s content on receivers that apply the edit overlay; * only the original author's edits take effect, so restrict callers to their own messages. + * + * The Edit carries [expiration] verbatim — by default [target]'s own NIP-40 deadline, and none + * when [target] has none — never `now + timer`: an Edit stamped with a fresh deadline would + * outlive (or cut short) the message it revises, so the revised words could survive the message + * the timer already erased (CORD-08 §2; the reference client keeps `expirationOf(original)`). */ suspend fun buildChannelEdit( authorSigner: NostrSigner, @@ -510,9 +521,10 @@ object ConcordActions { newText: String, createdAt: Long, extraTags: Array> = emptyArray(), - timerSecs: Long? = null, + expiration: Long? = ConcordDisappearing.expirationOf(target), ): Event { - val rumor = ChannelChat.edit(authorSigner.pubKey, channelId, epoch, target.id, newText, createdAt, withTimer(extraTags, ConcordChatEditEvent.KIND, createdAt, timerSecs)) + val tags = ConcordDisappearing.withExpiration(extraTags.filterNot { it.isNotEmpty() && it[0] == "expiration" }.toTypedArray(), expiration) + val rumor = ChannelChat.edit(authorSigner.pubKey, channelId, epoch, target.id, newText, createdAt, tags) return wrapChat(rumor, channel, authorSigner) } @@ -616,14 +628,16 @@ object ConcordActions { /** * [openChannelRumor] without the CORD-08 expiry refusal, for a caller that must tell an expired * rumor apart from garbage — the session, which purges an expired rumor's wrap instead of merely - * skipping it. Such a caller owns the refusal. + * skipping it. Such a caller owns the refusal. [kinds] widens the gate to + * [ChannelChat.PLANE_KINDS] for a caller that routes the WebXDC signal apart from chat rows. */ fun openChannelRumorAnyExpiry( wrap: Event, channel: GroupKey, channelId: HexKey, epoch: Long, - ): Event? = ConcordStreamEnvelope.openOrNull(wrap, channel)?.let { ChannelChat.acceptOpened(it, channelId, epoch) } + kinds: Set = ChannelChat.CHAT_KINDS, + ): Event? = ConcordStreamEnvelope.openOrNull(wrap, channel)?.let { ChannelChat.acceptOpened(it, channelId, epoch, kinds) } // ---- invites -------------------------------------------------------------- @@ -676,6 +690,7 @@ object ConcordActions { expiresAtMs: Long? = null, name: String = entry.name, icon: ImagePointer? = null, + onlyChannelIds: Set? = null, ): CommunityInvite = CommunityInvite( communityId = entry.id, @@ -684,7 +699,12 @@ object ConcordActions { communityRoot = entry.root, rootEpoch = entry.rootEpoch, controlPk = entry.controlPk, - channels = ConcordInviteVend.toInviteChannels(ConcordInviteVend.vendableChannels(entry.privateChannels, authority, recipient)), + channels = + ConcordInviteVend.toInviteChannels( + ConcordInviteVend + .vendableChannels(entry.privateChannels, authority, recipient) + .filter { onlyChannelIds == null || it.channelId.lowercase() in onlyChannelIds }, + ), relays = entry.relays.take(ConcordInviteBundle.MAX_COMMUNITY_RELAYS), name = name.ifBlank { entry.name }, icon = icon, @@ -705,6 +725,7 @@ object ConcordActions { sender: HexKey, recipient: HexKey, expiresAtMs: Long? = null, + onlyChannelIds: Set? = null, ): ConcordDirectInviteDraft { val to = recipient.lowercase() if (!HEX64.matches(to)) return ConcordDirectInviteDraft.Refused(ConcordDirectInviteSendResult.INVALID_RECIPIENT) @@ -719,6 +740,7 @@ object ConcordActions { expiresAtMs = expiresAtMs, name = state.metadata?.name ?: entry.name, icon = state.metadata?.icon, + onlyChannelIds = onlyChannelIds?.mapTo(HashSet()) { it.lowercase() }, ), ) } @@ -879,11 +901,31 @@ object ConcordActions { return ConcordStreamEnvelope.wrap(rumor, guestbook, memberSigner, encrypted = true, createdAt = createdAt) } - /** Opens the guestbook [wraps] into their live membership set (joins minus later leaves). */ + /** + * Builds an authorized Guestbook KICK (kind 3309) wrap naming [target], citing [citation] — the + * actor's own Grant head (`vac`, CORD-04 §5), null only for the owner. A Kick is the *second* + * layer of a removal: the caller strips the target's roles first (CORD-04 §6). + */ + suspend fun buildGuestbookKick( + actorSigner: NostrSigner, + guestbook: GroupKey, + target: HexKey, + citation: AuthorityCitation?, + createdAt: Long, + ): Event { + val rumor = Guestbook.kick(actorSigner.pubKey, target.lowercase(), createdAt, citation = citation) + return ConcordStreamEnvelope.wrap(rumor, guestbook, actorSigner, encrypted = true, createdAt = createdAt) + } + + /** + * Opens the guestbook [wraps] into their live membership set: joins minus later leaves and later + * Kicks honored against [authority] (none is honored without it). + */ fun guestbookMembers( wraps: List, guestbook: GroupKey, - ): Set = projectGuestbook(wraps.mapNotNull { guestbookEntry(it, guestbook) }) + authority: AuthorityResolver? = null, + ): Set = projectGuestbook(wraps.mapNotNull { guestbookEntry(it, guestbook) }, authority) /** * Opens a single guestbook [wrap] into its entry, or null when it doesn't belong to @@ -898,17 +940,26 @@ object ConcordActions { fun guestbookEntry( wrap: Event, guestbook: GroupKey, - ): GuestbookEntry? = ConcordStreamEnvelope.openOrNull(wrap, guestbook)?.rumor?.let { Guestbook.parse(it) } + ): GuestbookEntry? = + ConcordStreamEnvelope + .openOrNull(wrap, guestbook) + // The Guestbook's seals MUST be encrypted (CORD-02 §5); a plaintext one is Control-only. + ?.takeIf { it.sealKind == ConcordStreamEnvelope.KIND_SEAL_ENCRYPTED } + ?.rumor + ?.let { Guestbook.parse(it) } - /** Last-writer-wins projection of already-opened [entries] down to the JOINed member set. */ - fun projectGuestbook(entries: Collection): Set { - val latest = HashMap() - for (entry in entries) { - val prev = latest[entry.member.lowercase()] - if (prev == null || entry.createdAt > prev.createdAt) latest[entry.member.lowercase()] = entry - } - return latest.values.filter { it.action == GuestbookAction.JOIN }.mapTo(HashSet()) { it.member.lowercase() } - } + /** + * The CORD-02 §5 coalesce of already-opened [entries] (latest motion per npub, Kicks honored + * against [authority]) down to the JOINed member set. + */ + fun projectGuestbook( + entries: Collection, + authority: AuthorityResolver? = null, + nowMs: Long = TimeUtils.nowMillis(), + ): Set = joinedMembers(Guestbook.coalesce(entries, nowMs, authority)) + + /** The npubs whose coalesced Guestbook state ([Guestbook.coalesce]) is a Join. */ + fun joinedMembers(coalesced: Map): Set = coalesced.filterValues { it.action == GuestbookAction.JOIN }.keys // ---- refounding / rekey (CORD-06) ---------------------------------------- diff --git a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/actions/ConcordModeration.kt b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/actions/ConcordModeration.kt index f7112d9b7e..a47da15d01 100644 --- a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/actions/ConcordModeration.kt +++ b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/actions/ConcordModeration.kt @@ -32,6 +32,7 @@ import com.vitorpamplona.quartz.concord.cord04Roles.ControlEdition import com.vitorpamplona.quartz.concord.cord04Roles.ControlEditionBuilder import com.vitorpamplona.quartz.concord.cord04Roles.ControlEntityKind import com.vitorpamplona.quartz.concord.cord04Roles.ControlRootWrap +import com.vitorpamplona.quartz.concord.cord04Roles.EntityFloor import com.vitorpamplona.quartz.concord.cord04Roles.GrantEntity import com.vitorpamplona.quartz.concord.cord04Roles.MetadataEntity import com.vitorpamplona.quartz.concord.cord04Roles.RoleEntity @@ -98,7 +99,8 @@ object ConcordModeration { communityId: ByteArray, entityId: ByteArray, owner: HexKey, - ): ControlEdition? = ConcordCommunityState.authorizedHeads(current, communityId, owner)[entityId.toHexKey()]?.known + floors: Map = emptyMap(), + ): ControlEdition? = ConcordCommunityState.authorizedHeads(current, communityId, owner, floors)[entityId.toHexKey()]?.known /** version/prevHash to chain onto the current head of [entityId], or a genesis at version 1 (CORD-04 §1). */ private fun versioning(head: ControlEdition?): Pair = if (head != null) (head.version + 1) to head.hash else 1L to null @@ -140,8 +142,9 @@ object ConcordModeration { createdAt: Long, citation: AuthorityCitation?, owner: HexKey, + floors: Map = emptyMap(), ): Event { - val head = headOf(current, communityId, entityId, owner) + val head = headOf(current, communityId, entityId, owner, floors) val content = ConcordJson.encodePreserving(serializer, value, head?.content) return wrap(actor, controlPlane, communityId, kind, entityId, head, content, current, createdAt, citation, owner) } @@ -207,7 +210,8 @@ object ConcordModeration { createdAt: Long, citation: AuthorityCitation? = null, owner: HexKey, - ): Event = editMetadata(actor, controlPlane, communityId, standing.withMessageExpiration(secs), current, createdAt, citation, owner) + floors: Map = emptyMap(), + ): Event = editMetadata(actor, controlPlane, communityId, standing.withMessageExpiration(secs), current, createdAt, citation, owner, floors) /** * Replaces the community metadata (name / icon / description / relays). The @@ -224,10 +228,11 @@ object ConcordModeration { createdAt: Long, citation: AuthorityCitation? = null, owner: HexKey, + floors: Map = emptyMap(), ): Event { require(ConcordLimits.nameFits(metadata.name)) { "community name exceeds ${ConcordLimits.NAME_MAX_BYTES} bytes" } require(ConcordLimits.descriptionFits(metadata.description)) { "description exceeds ${ConcordLimits.DESCRIPTION_MAX_BYTES} bytes" } - return edit(actor, controlPlane, communityId, ControlEntityKind.METADATA, communityId, MetadataEntity.serializer(), metadata, current, createdAt, citation, owner) + return edit(actor, controlPlane, communityId, ControlEntityKind.METADATA, communityId, MetadataEntity.serializer(), metadata, current, createdAt, citation, owner, floors) } /** @@ -390,9 +395,12 @@ object ConcordModeration { createdAt: Long, citation: AuthorityCitation? = null, owner: HexKey, + floors: Map = emptyMap(), ): Event { val entityId = ConcordInviteRegistry.coordinate(communityId, actor.pubKey) - val head = headOf(current, communityId, entityId, owner) + // Floor-aware: after a Refounding the honored head may be the prior epoch's (the anti-rollback + // floor), and chaining onto the current epoch's editions alone would fork below it. + val head = headOf(current, communityId, entityId, owner, floors) return wrap(actor, controlPlane, communityId, ControlEntityKind.INVITE_REGISTRY, entityId, head, ConcordInviteRegistry.encode(linkSigners), current, createdAt, citation, owner) } diff --git a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/actions/ConcordPinnedRumor.kt b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/actions/ConcordPinnedRumor.kt new file mode 100644 index 0000000000..d86a4a492b --- /dev/null +++ b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/actions/ConcordPinnedRumor.kt @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2025 Vitor Pamplona + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the + * Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR + * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ +package com.vitorpamplona.amethyst.commons.actions + +import com.vitorpamplona.quartz.nip01Core.core.Event + +/** + * This pin as the rumor the chat feed would render (CORD-04 §7): the recomputed id, author, kind and + * the original's tags — so its NIP-92 `imeta` attachments, encrypted ones included, come along — with + * the newest words this client can show ([ConcordPinnedMessage.content]). Unsigned: a rumor never is. + * A pin proves its message without this account ever having held it, so this is the only source of + * the attachment keys for such a pin. + */ +fun ConcordPinnedMessage.toRumor(): Event = Event(pin.rumorId, pin.author, pin.createdAt, pin.kind, pin.tags, content, "") diff --git a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/actions/ConcordPinning.kt b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/actions/ConcordPinning.kt index 9f9bf8b85d..e167d1cb7c 100644 --- a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/actions/ConcordPinning.kt +++ b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/actions/ConcordPinning.kt @@ -37,6 +37,7 @@ import com.vitorpamplona.quartz.nip01Core.core.HexKey import com.vitorpamplona.quartz.nip01Core.core.hexToByteArray import com.vitorpamplona.quartz.nip01Core.core.toHexKey import com.vitorpamplona.quartz.nip01Core.signers.NostrSigner +import com.vitorpamplona.quartz.nip40Expiration.ExpirationTag import com.vitorpamplona.quartz.utils.sha256.sha256 import kotlinx.serialization.json.JsonObject import kotlin.random.Random @@ -92,6 +93,11 @@ class ConcordChannelPins( val sealedForm: Boolean, /** Entries that failed verification and were dropped alone. */ val invalidEntries: Int, + /** + * False while the Control Plane has not been swept whole yet: [head] is whatever the partial fold + * holds, so an empty list may only mean "not served yet". No edition may be built from it (§7). + */ + val complete: Boolean = true, ) { val count: Int get() = pins.size @@ -100,8 +106,20 @@ class ConcordChannelPins( /** True when the head owes keyless readers a republish: an erased entry, or a newer Edit to attach. */ val owesRepublish: Boolean get() = killed.isNotEmpty() || pins.any { it.newerEdit != null } + /** Every rumor id the list carries, shown or erased — what a delete or an Edit must name to change this read. */ + val rumorIds: Set by lazy { (alive + killed).mapTo(HashSet()) { it.rumorId } } + + /** + * The soonest NIP-40 deadline (unix seconds) after [now] among the shown pins, or null: when this + * read goes stale, since an expired message leaves the list (CORD-08 §3). + */ + fun nextExpiry(now: Long): Long? = alive.mapNotNull { pin -> pin.tags.firstNotNullOfOrNull(ExpirationTag::parse) }.filter { it > now }.minOrNull() + companion object { - fun none(channelIdHex: HexKey) = ConcordChannelPins(channelIdHex, null, emptyList(), emptyList(), emptyList(), sealedUnavailable = false, violating = false, sealedForm = false, invalidEntries = 0) + fun none( + channelIdHex: HexKey, + complete: Boolean = true, + ) = ConcordChannelPins(channelIdHex, null, emptyList(), emptyList(), emptyList(), sealedUnavailable = false, violating = false, sealedForm = false, invalidEntries = 0, complete = complete) } } @@ -136,6 +154,38 @@ class ConcordPinVerifier( } return verdict } + + private val lists = LinkedHashMap() + + /** List parses (and sealed-form decrypts) actually performed (cache misses) — for tests. */ + var listReads: Int = 0 + private set + + /** + * [head]'s content read as a Pin List, memoized by the head's rumor id: an edition's bytes never + * change, so re-reading the pins on every trigger (a fold, a delete landing, an expiry) parses and + * decrypts the list once. A read that found the list sealed under a key not held is not cached, + * so the key arriving later (a Private Channel key delivered on grant) opens it. + */ + fun readList( + head: ControlEdition, + unsealKey: (epoch: Long) -> ByteArray?, + ): ConcordPins.PinListRead { + lock.withLock { lists[head.rumorId] }?.let { return it } + val read = ConcordPins.read(head.content, unsealKey) + lock.withLock { + listReads++ + if (!read.sealedUnavailable) { + lists[head.rumorId] = read + while (lists.size > MAX_LISTS) lists.remove(lists.keys.first()) + } + } + return read + } + + companion object { + private const val MAX_LISTS = 64 + } } /** The proof material for pinning one opened message: its original seal and the plane key of its epoch. */ @@ -214,6 +264,9 @@ enum class ConcordPinOutcome { UNVERIFIABLE, TOO_MANY_PINS, TOO_LARGE, + + /** The edition was built but no relay acknowledged it, so it may not have landed. */ + NOT_CONFIRMED, } class ConcordPinWrite( @@ -283,9 +336,10 @@ object ConcordPinning { verifier: ConcordPinVerifier = ConcordPinVerifier(), isKilled: (VerifiedPin) -> Boolean = { false }, newestEdit: (VerifiedPin) -> ConcordLocalEdit? = { null }, + complete: Boolean = true, ): ConcordChannelPins { - if (head == null) return ConcordChannelPins.none(channelIdHex) - val read = ConcordPins.read(head.content, unsealKey) + if (head == null) return ConcordChannelPins.none(channelIdHex, complete) + val read = verifier.readList(head, unsealKey) val alive = ArrayList() val killed = ArrayList() var invalid = 0 @@ -314,11 +368,23 @@ object ConcordPinning { pins = shown, sealedUnavailable = read.sealedUnavailable, violating = read.violating, - sealedForm = ConcordPins.isSealedForm(head.content), + sealedForm = read.sealedForm, invalidEntries = invalid, + complete = complete, ) } + /** + * [pins]' shown entries a reader displays: an entry by a [isBanned] author (the community declines + * to show a banned member's posts, CORD-04 §4) or by someone the reader [isHidden]s (mutes or + * blocks) is left out. Display only — the list itself, and every write built from it, is untouched. + */ + fun visible( + pins: ConcordChannelPins, + isBanned: (HexKey) -> Boolean, + isHidden: (HexKey) -> Boolean, + ): List = pins.pins.filterNot { isBanned(it.author) || isHidden(it.author) } + /** True when [edit] is newer than whatever Edit [pin]'s proof already carries. */ private fun isNewer( edit: ConcordLocalEdit, @@ -363,6 +429,9 @@ object ConcordPinning { when { !ctx.authorized -> ConcordPinOutcome.NOT_AUTHORIZED !ctx.controlPlane.canWrite -> ConcordPinOutcome.NO_WRITE_KEY + // §7: never write from a list the fold was not served — a partial fold's head (or its + // absence) is not the list a replace-entire edition would overwrite. + !ctx.pins.complete -> ConcordPinOutcome.NOT_FOLDED // §7: a writer MUST NOT build an edition from a list it could not read. ctx.pins.sealedUnavailable -> ConcordPinOutcome.LIST_UNAVAILABLE ctx.channelIsPrivate && ctx.currentPlane == null -> ConcordPinOutcome.NO_CHANNEL_KEY diff --git a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/actions/ConcordPrivateChannels.kt b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/actions/ConcordPrivateChannels.kt new file mode 100644 index 0000000000..7cdd4bd189 --- /dev/null +++ b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/actions/ConcordPrivateChannels.kt @@ -0,0 +1,387 @@ +/* + * Copyright (c) 2025 Vitor Pamplona + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the + * Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR + * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ +package com.vitorpamplona.amethyst.commons.actions + +import com.vitorpamplona.quartz.concord.cord02Community.ConcordCommunityListEntry +import com.vitorpamplona.quartz.concord.cord02Community.PrivateChannelKey +import com.vitorpamplona.quartz.concord.cord03Channels.ConcordChannelKeyring +import com.vitorpamplona.quartz.concord.cord04Roles.AuthorityCitation +import com.vitorpamplona.quartz.concord.cord04Roles.AuthorityResolver +import com.vitorpamplona.quartz.concord.cord04Roles.ChannelEntity +import com.vitorpamplona.quartz.concord.cord04Roles.ConcordLimits +import com.vitorpamplona.quartz.concord.cord04Roles.ConcordPermissions +import com.vitorpamplona.quartz.concord.cord04Roles.ControlEdition +import com.vitorpamplona.quartz.concord.cord04Roles.RoleEntity +import com.vitorpamplona.quartz.concord.cord04Roles.RoleScope +import com.vitorpamplona.quartz.concord.cord05Invites.ConcordInviteVend +import com.vitorpamplona.quartz.concord.cord06Rekey.ChannelRekeyOutcome +import com.vitorpamplona.quartz.concord.cord06Rekey.ChannelRotation +import com.vitorpamplona.quartz.concord.cord06Rekey.ConcordChannelRekey +import com.vitorpamplona.quartz.concord.cord06Rekey.ConcordRefounding +import com.vitorpamplona.quartz.concord.cord06Rekey.ConcordRotationAuthority +import com.vitorpamplona.quartz.concord.crypto.ControlPlaneKeys +import com.vitorpamplona.quartz.concord.crypto.GroupKey +import com.vitorpamplona.quartz.nip01Core.core.Event +import com.vitorpamplona.quartz.nip01Core.core.HexKey +import com.vitorpamplona.quartz.nip01Core.core.hexToByteArray +import com.vitorpamplona.quartz.nip01Core.core.toHexKey +import com.vitorpamplona.quartz.nip01Core.signers.NostrSigner +import com.vitorpamplona.quartz.utils.RandomInstance + +/** + * A Private Channel just minted or privatised (CORD-03 §2): its [channelIdHex], the independent + * [key] to store in the Community List **before** [wraps] publish (a lost List write would orphan + * the only copy), the access Role minted beside it ([roleIdHex]), and the Control editions to + * publish in order — the Role first (an orphan Role is inert), then the channel edition. + */ +class PrivateChannelBuild( + val channelIdHex: HexKey, + val key: PrivateChannelKey, + val roleIdHex: HexKey, + val wraps: List, +) + +/** + * Private Channels end to end (CORD-03 §1-2, CORD-04 §2, CORD-05 §6, CORD-06 §1-3) as pure + * builders and decisions, shared by the app and `amy`. The network and the Community List write + * stay with the caller. + * + * Who may read a Private Channel is its Roles: a Role scoped `{kind:"channel", channel_id}` IS its + * access list ([ConcordInviteVend.isEntitled]). Read access is enforced by key possession alone, so + * this decides who a key is delivered TO (a Direct Invite on grant) and who a rotation keeps (a + * channel rekey on revoke). Pinned to Armada's `channelAccess.ts`, `useCommunityActions` + * (`createChannel`, `privatiseChannel`, `publiciseChannel`) and `useRekey` (`useChannelRekey`, + * `useChannelRekeyWatch`). + */ +object ConcordPrivateChannels { + /** + * The position a new access Role takes (Armada `accessRolePosition`): the bottom of the roster, + * never above what [actor] may mint (the owner mints from 1, anyone else strictly below their + * own rank), so a grantee is never promoted by being let into a channel. Null when [actor] holds + * no rank to mint from. + */ + fun accessRolePosition( + authority: AuthorityResolver?, + actor: HexKey, + owner: HexKey, + ): Long? { + val ceiling = + if (actor.equals(owner, ignoreCase = true)) { + 1L + } else { + (authority?.rank(actor) ?: return null) + 1 + } + val lowest = + authority + ?.roles() + ?.values + ?.filterNot { it.deleted } + ?.maxOfOrNull { it.position } ?: 0L + return maxOf(ceiling, lowest + 1) + } + + /** [name] cut to the protocol's 64-byte cap on a character boundary (Armada slices the same way). */ + private fun fitName(name: String): String { + var out = name + while (!ConcordLimits.nameFits(out)) out = out.dropLast(1) + return out + } + + /** The bit-less access Role scoped to [channelIdHex] (CORD-04 §2): read access is the key, never a bit. */ + fun accessRole( + name: String, + channelIdHex: HexKey, + position: Long, + ): RoleEntity = + RoleEntity( + name = fitName(name), + position = position, + permissions = "0", + scope = RoleScope(kind = "channel", channelId = channelIdHex.lowercase()), + ) + + /** + * A new channel (CORD-03 §2): a random `channel_id`, and for a Private one an independent key + * at channel epoch 0 plus its access Role (Armada `createChannel`: a born-private channel is + * epoch 0; the first *privatisation* of a public channel is epoch 1). Returns null when the + * name is invalid or the actor has no rank to mint the Role from. + */ + suspend fun create( + actor: NostrSigner, + cp: ControlPlaneKeys, + communityId: ByteArray, + name: String, + accessRoleName: String?, + current: List, + authority: AuthorityResolver?, + owner: HexKey, + createdAt: Long, + ): PrivateChannelBuild? { + val channel = ChannelEntity(name = name.trim(), private = true) + if (!channel.hasValidName()) return null + val position = accessRolePosition(authority, actor.pubKey, owner) ?: return null + val channelId = RandomInstance.bytes(32) + val channelIdHex = channelId.toHexKey() + val roleId = RandomInstance.bytes(32) + val role = accessRole(accessRoleName?.trim()?.ifBlank { null } ?: channel.name, channelIdHex, position) + val roleWrap = ConcordModeration.defineRole(actor, cp, communityId, roleId, role, current, createdAt, owner = owner) + val channelWrap = ConcordModeration.defineChannel(actor, cp, communityId, channelId, channel, current, createdAt, owner = owner) + return PrivateChannelBuild( + channelIdHex = channelIdHex, + key = PrivateChannelKey(channelIdHex, ConcordChannelRekey.mintKey().toHexKey(), 0, channel.name), + roleIdHex = roleId.toHexKey(), + wraps = listOf(roleWrap, channelWrap), + ) + } + + /** + * Converts the Public channel [channelIdHex] to Private (CORD-03 §2): a fresh independent key at + * the NEXT channel epoch ([ConcordChannelKeyring.nextChannelEpoch], floored at [observedFloor], + * the highest channel rotation seen on the wire), a new access Role, and the channel edition + * flipping `private` on — every other field of [standing] carried through. Protects the future + * only: the public era stays readable to every member. Null when the actor can't mint the Role. + */ + suspend fun privatize( + actor: NostrSigner, + cp: ControlPlaneKeys, + entry: ConcordCommunityListEntry, + channelIdHex: HexKey, + standing: ChannelEntity, + accessRoleName: String?, + current: List, + authority: AuthorityResolver?, + createdAt: Long, + observedFloor: Long = 0, + ): PrivateChannelBuild? { + if (standing.private || standing.deleted) return null + val position = accessRolePosition(authority, actor.pubKey, entry.owner) ?: return null + val communityId = entry.id.hexToByteArray() + val roleId = RandomInstance.bytes(32) + val role = accessRole(accessRoleName?.trim()?.ifBlank { null } ?: standing.name, channelIdHex, position) + val roleWrap = ConcordModeration.defineRole(actor, cp, communityId, roleId, role, current, createdAt, owner = entry.owner) + val channelWrap = ConcordModeration.defineChannel(actor, cp, communityId, channelIdHex.hexToByteArray(), standing.copy(private = true), current, createdAt, owner = entry.owner) + val epoch = ConcordChannelKeyring.nextChannelEpoch(entry, channelIdHex, observedFloor) + return PrivateChannelBuild( + channelIdHex = channelIdHex.lowercase(), + key = PrivateChannelKey(channelIdHex.lowercase(), ConcordChannelRekey.mintKey().toHexKey(), epoch, standing.name), + roleIdHex = roleId.toHexKey(), + wraps = listOf(roleWrap, channelWrap), + ) + } + + /** + * Converts the Private channel [channelIdHex] back to Public (CORD-03 §2): the flag only. The + * channel derives from the `community_root` from here on; the held key stays in the List so its + * holders keep reading the private era, which a later joiner never can. Null when it is not + * private. + */ + suspend fun publicize( + actor: NostrSigner, + cp: ControlPlaneKeys, + communityId: ByteArray, + channelIdHex: HexKey, + standing: ChannelEntity, + current: List, + owner: HexKey, + createdAt: Long, + ): Event? { + if (!standing.private || standing.deleted) return null + return ConcordModeration.defineChannel(actor, cp, communityId, channelIdHex.hexToByteArray(), standing.copy(private = false), current, createdAt, owner = owner) + } + + // ---- channel rotations (CORD-06 §1-2) ------------------------------------- + + /** + * Whether [actor] may launch a single-channel Rekey cutting [removed] (CORD-06 §3 Authority): + * `MANAGE_CHANNELS` (or `BAN`, a Refounding's) and strictly outranking every removed target. + * The owner may always; the owner is never a valid target. + */ + fun canRotate( + authority: AuthorityResolver, + actor: HexKey, + removed: Collection, + bit: Int = ConcordPermissions.MANAGE_CHANNELS, + ): Boolean { + if (authority.isOwner(actor)) return true + if (!authority.hasPermission(actor, bit)) return false + return removed.all { it.equals(actor, ignoreCase = true) || authority.canActOn(actor, it, bit) } + } + + /** + * The members a rotation of [channelIdHex] keeps (Armada `handleRotateChannelKey`): exactly + * those entitled today ([ConcordInviteVend.entitledMembers]) plus the [rotator], who must keep + * every key or nobody could rotate the channel next time. + */ + fun keepSet( + authority: AuthorityResolver, + channelIdHex: HexKey, + rotator: HexKey, + ): Set = ConcordInviteVend.entitledMembers(authority, channelIdHex) + rotator.lowercase() + + /** + * The wraps of one rotation of [held] to [newKey] for [keep], sealed under [sealingRoot] (the + * current root for a single-channel Rekey, the PRIOR root inside a Refounding — CORD-06 §3), and + * citing [authority] on every chunk. + */ + suspend fun buildRotation( + rotator: NostrSigner, + sealingRoot: ByteArray, + held: PrivateChannelKey, + newKey: ByteArray, + keep: Collection, + createdAt: Long, + authority: AuthorityCitation?, + ): List = + ConcordChannelRekey.build( + rotatorSigner = rotator, + sealingRoot = sealingRoot, + channelId = held.channelId.hexToByteArray(), + heldKey = held.key.hexToByteArray(), + heldEpoch = held.epoch, + newKey = newKey, + recipients = keep + rotator.pubKey, + createdAt = createdAt, + authority = authority, + ) + + /** The roots a member watches channel rekeys under: the current one and the canonical prior one (CORD-06 §3). */ + fun watchRoots(entry: ConcordCommunityListEntry): List { + val prior = ConcordRefounding.canonicalHeldRoots(entry.heldRoots).filter { it.epoch == entry.rootEpoch - 1 } + return (listOf(entry.root) + prior.map { it.key }).distinct().map { it.hexToByteArray() } + } + + /** + * Every channel-rekey address this entry should watch (CORD-06 §2): per held Private Channel, + * the next [ConcordChannelRekey.LOOKAHEAD] channel epochs past the held one, under each of + * [watchRoots]. Address hex → key. + */ + fun watchKeys(entry: ConcordCommunityListEntry): Map { + val out = LinkedHashMap() + val roots = watchRoots(entry) + for (held in entry.privateChannels) { + if (ConcordChannelKeyring.heldKey(entry, held.channelId) == null) continue + val channelId = held.channelId.hexToByteArray() + for (root in roots) { + for (ahead in 1..ConcordChannelRekey.LOOKAHEAD) { + val key = ConcordChannelRekey.address(root, channelId, held.epoch + ahead) + out[key.publicKeyHex] = key + } + } + } + return out + } + + /** + * Whether a received channel rotation's Rotator may be honored (CORD-06 §3 Authority): the owner, + * or a non-banned holder of `MANAGE_CHANNELS` (a single-channel Rekey) or `BAN` (a Refounding's + * channel rekeys), whose `vac` cites a Grant our fold has synced. Key possession is never + * authority. + */ + fun isHonoredRotation( + entry: ConcordCommunityListEntry, + editions: Collection, + authority: AuthorityResolver, + rotation: ChannelRotation, + ): Boolean { + val rotator = rotation.rotator + if (!authority.isOwner(rotator)) { + if (authority.isBanned(rotator)) return false + if (!authority.hasPermission(rotator, ConcordPermissions.MANAGE_CHANNELS) && !authority.hasPermission(rotator, ConcordPermissions.BAN)) return false + } + val heads = ConcordRotationAuthority.headsOf(editions, entry.id, entry.owner) + return ConcordRotationAuthority.citationSatisfied(entry.id, rotator, entry.owner, rotation.authority, heads) + } + + /** Whether [rotator] strictly outranks [me] — only such a Rotator's omission is a cut (CORD-06 §3). */ + fun outranks( + authority: AuthorityResolver, + rotator: HexKey, + me: HexKey, + ): Boolean { + if (authority.isOwner(me)) return false + val theirs = authority.rank(rotator) ?: return false + val mine = authority.rank(me) ?: Long.MAX_VALUE + return theirs < mine + } + + /** + * What the buffered channel-rekey [wraps] mean for each Private Channel [entry] holds a key for + * (CORD-06 §2), per channel id: an adoption moves that channel's key forward, a cut drops it and + * records `channel_cuts`. Channels with nothing to do are omitted. The caller applies the result + * inside its List write ([applyOutcome]). + */ + suspend fun receive( + entry: ConcordCommunityListEntry, + wraps: Collection, + editions: Collection, + authority: AuthorityResolver, + recipient: NostrSigner, + ): Map { + if (wraps.isEmpty()) return emptyMap() + val keys = watchKeys(entry) + val me = recipient.pubKey + val joinedAtSecs = entry.addedAt / 1000 + val out = LinkedHashMap() + for (held in entry.privateChannels) { + if (ConcordChannelKeyring.heldKey(entry, held.channelId) == null) continue + val id = held.channelId.lowercase() + val rotations = ConcordChannelRekey.rotations(wraps, keys, id) + if (rotations.isEmpty()) continue + val outcome = + ConcordChannelRekey.walk( + rotations = rotations, + channelIdHex = id, + heldKey = held.key.hexToByteArray(), + heldEpoch = held.epoch, + recipientSigner = recipient, + joinedAtSecs = joinedAtSecs, + honored = { isHonoredRotation(entry, editions, authority, it) }, + outranksMe = { outranks(authority, it, me) }, + ) + if (outcome !is ChannelRekeyOutcome.None) out[id] = outcome + } + return out + } + + /** + * [current] with [outcomes] applied — only where the channel is still at the epoch the outcome + * was computed from ([fromEpochs]), so a write racing another adoption never rolls a key back — + * or null when nothing changed. + */ + fun applyOutcome( + current: ConcordCommunityListEntry, + outcomes: Map, + fromEpochs: Map, + ): ConcordCommunityListEntry? { + var next = current + for ((id, outcome) in outcomes) { + val held = ConcordChannelKeyring.heldKey(next, id) ?: continue + if (held.epoch != fromEpochs[id]) continue + next = + when (outcome) { + is ChannelRekeyOutcome.Adopted -> ConcordChannelKeyring.withRotatedKey(next, id, outcome.key.toHexKey(), outcome.epoch) ?: next + is ChannelRekeyOutcome.Removed -> ConcordChannelKeyring.withoutChannel(next, id, outcome.epoch) + ChannelRekeyOutcome.None -> next + } + } + return if (next === current) null else next + } +} diff --git a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/actions/ConcordSubscriptionPlanner.kt b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/actions/ConcordSubscriptionPlanner.kt index fb32df16ba..4dc513b1d7 100644 --- a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/actions/ConcordSubscriptionPlanner.kt +++ b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/actions/ConcordSubscriptionPlanner.kt @@ -96,7 +96,8 @@ object ConcordSubscriptionPlanner { * The off-channel planes every joined community subscribes to upfront (known * from the entry alone): the Guestbook Plane (membership motions) and the * next-epoch base-rekey address (so an inbound Refounding is received live, - * CORD-06), and the dissolution tombstone address (CORD-02 §9). All are kind-1059 + * CORD-06), the dissolution tombstone address (CORD-02 §9), and every held Private Channel's + * next channel-rekey addresses (CORD-06 §2). All are kind-1059 * wraps authored by their derived stream address. */ fun auxiliaryPlaneSubs(entries: List): List = @@ -114,7 +115,10 @@ object ConcordSubscriptionPlanner { ConcordPlaneSub(channelId = null, pubKeyHex = dissolved.publicKeyHex, relays = relays), // The current epoch's own rekey address, so a racing sibling can heal us (CORD-06 §3). sibling?.let { ConcordPlaneSub(channelId = null, pubKeyHex = it.publicKeyHex, relays = relays) }, - ) + ) + + // Each held Private Channel's next channel-rekey addresses (CORD-06 §2), so a rotation + // that moves the key forward — or cuts us — is received live. + ConcordPrivateChannels.watchKeys(e).keys.map { ConcordPlaneSub(channelId = null, pubKeyHex = it, relays = relays) } } /** diff --git a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/Account.kt b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/Account.kt index 7c17764ec3..97c8f612e6 100644 --- a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/Account.kt +++ b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/Account.kt @@ -190,6 +190,7 @@ import com.vitorpamplona.quartz.buzz.threading.buzzThreadReply import com.vitorpamplona.quartz.buzz.threading.buzzThreadRoot import com.vitorpamplona.quartz.concord.cord03Channels.ChannelChat import com.vitorpamplona.quartz.concord.cord03Channels.ConcordChannelId +import com.vitorpamplona.quartz.concord.cord03Channels.ConcordChatEditEvent import com.vitorpamplona.quartz.concord.cord03Channels.ConcordDisappearing import com.vitorpamplona.quartz.concord.cord03Channels.ConcordTimerNoticeEvent import com.vitorpamplona.quartz.experimental.bounties.BountyAddValueEvent @@ -360,6 +361,7 @@ import com.vitorpamplona.quartz.utils.containsAny import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.DelicateCoroutinesApi import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.FlowPreview import kotlinx.coroutines.IO import kotlinx.coroutines.delay import kotlinx.coroutines.flow.MutableStateFlow @@ -367,7 +369,10 @@ import kotlinx.coroutines.flow.SharingStarted import kotlinx.coroutines.flow.StateFlow import kotlinx.coroutines.flow.collectLatest import kotlinx.coroutines.flow.debounce +import kotlinx.coroutines.flow.filter import kotlinx.coroutines.flow.flowOn +import kotlinx.coroutines.flow.map +import kotlinx.coroutines.flow.merge import kotlinx.coroutines.flow.sample import kotlinx.coroutines.flow.stateIn import kotlinx.coroutines.launch @@ -378,6 +383,9 @@ import kotlin.coroutines.cancellation.CancellationException import com.vitorpamplona.quartz.experimental.nip95.header.thumbhash as nip95thumbhash import com.vitorpamplona.quartz.experimental.profileGallery.thumbhash as galleryThumbhash +/** How long past a disappearing message's deadline the sweep waits, to purge nearby deadlines in one pass (CORD-08). */ +private const val CONCORD_EXPIRY_COALESCE_MS = 2_000L + @OptIn(DelicateCoroutinesApi::class) @Stable class Account( @@ -760,6 +768,8 @@ class Account( val expired = concordSessions.sweepExpired(now) for (rumors in expired.values) { for (gone in rumors) { + // Its attachments' decryption keys go with it: a cached key would keep the blob readable. + gone.attachmentUrls.forEach { encryptionKeyCache.remove(it) } cache.getNoteIfExists(gone.rumorId)?.let { note -> note.detachFromChildren() cache.pruner.unlinkAndRemove(note) @@ -800,7 +810,7 @@ class Account( * decrypts the blob transparently on fetch (keyed by URL) — the same path NIP-17 encrypted media * uses. Runs for both inbound wraps and our own local echo, so a sent image renders immediately. */ - private fun registerConcordEncryptedImages(rumor: Event) { + internal fun registerConcordEncryptedImages(rumor: Event) { val images = ChannelChat.encryptedImagesOf(rumor) if (images.isEmpty()) return images.forEach { img -> @@ -4185,19 +4195,44 @@ class Account( // A promotion to staff delivers the Control Plane write key inside the Grant // itself (CORD-04 §3), so the fold that seats the role is also when it arrives. runCatching { concord.drainConcordStaffGrants() }.onFailure { Log.w("Concord", "staff grant drain failed", it) } + // A Private Channel rotation lands on its channel-rekey address (CORD-06 §2): adopt the new + // key, or drop the channel when it cut us. + runCatching { concord.drainConcordChannelRekeys() }.onFailure { Log.w("Concord", "channel rekey drain failed", it) } + // A Grant folding late turns a parked catch-up invite into one we adopt without a click. + runCatching { concord.drainConcordCatchUps() }.onFailure { Log.w("Concord", "catch-up drain failed", it) } + // An honored Kick naming us (CORD-04 §6): leave the community locally and say so. + runCatching { concord.drainConcordKicks() }.onFailure { Log.w("Concord", "kick drain failed", it) } // A rotation we were *excluded* from produces no rekey to drain, so it can only be // found by re-resolving the invite link we joined through. Rate-limited internally. runCatching { concord.recoverStrandedConcordCommunities() }.onFailure { Log.w("Concord", "stranded recovery failed", it) } } } + // CORD-04 §7: a PIN_MESSAGES holder owes keyless readers the deletion omission and the Edit + // refresh whether or not the channel is open, so the delayed pin duties run from the account — + // on every structural tick (a new Pin List head, a fold) and whenever a delete or an Edit lands. + // The scheduler itself waits 3–15 s, keeps one duty per channel and one attempt per debt. + scope.launch { + @OptIn(FlowPreview::class) + merge( + concordSessions.revision.map { }, + cache.live.newEventBundles + .filter { notes -> notes.any { it.event is DeletionRequestEvent || it.event is ConcordChatEditEvent } } + .map { }, + ).sample(1000).collect { + runCatching { concord.scheduleConcordPinDuties(scope) }.onFailure { Log.w("Concord", "pin duty scheduling failed", it) } + } + } + // CORD-08 §3: purge disappearing Concord messages when they expire. Sleeps until the earliest // deadline any joined community holds and never wakes while nothing carries one, so a // community without a timer costs nothing. A new earlier deadline restarts the wait. scope.launch(Dispatchers.IO) { concordSessions.nextExpiry.collectLatest { at -> if (at == null) return@collectLatest - val waitMs = (at - TimeUtils.now()) * 1000 + // Coalesced: sleep a little past the deadline and sweep everything due by then, so a + // burst of messages sent seconds apart expires in one pass instead of one sweep each. + val waitMs = (at - TimeUtils.now()) * 1000 + CONCORD_EXPIRY_COALESCE_MS if (waitMs > 0) delay(waitMs) runCatching { sweepExpiredConcordMessages() }.onFailure { Log.w("Concord", "expired-message sweep failed", it) } } diff --git a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/AccountConcordActions.kt b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/AccountConcordActions.kt index 1c9dad080e..d54fdaf135 100644 --- a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/AccountConcordActions.kt +++ b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/AccountConcordActions.kt @@ -27,9 +27,12 @@ import com.vitorpamplona.amethyst.commons.actions.ConcordModeration import com.vitorpamplona.amethyst.commons.actions.ConcordPinContext import com.vitorpamplona.amethyst.commons.actions.ConcordPinOutcome import com.vitorpamplona.amethyst.commons.actions.ConcordPinWrite +import com.vitorpamplona.amethyst.commons.actions.ConcordPinnedMessage import com.vitorpamplona.amethyst.commons.actions.ConcordPinning +import com.vitorpamplona.amethyst.commons.actions.ConcordPrivateChannels import com.vitorpamplona.amethyst.commons.actions.ConcordReceive import com.vitorpamplona.amethyst.commons.actions.ConcordSubscriptionPlanner +import com.vitorpamplona.amethyst.commons.actions.toRumor import com.vitorpamplona.amethyst.commons.defaults.DefaultDmIndexerRelays import com.vitorpamplona.amethyst.commons.model.ConcordInviteResult import com.vitorpamplona.amethyst.commons.model.Note @@ -39,6 +42,8 @@ import com.vitorpamplona.amethyst.commons.model.concord.ConcordChannelListState import com.vitorpamplona.amethyst.commons.model.concord.ConcordCommunitySession import com.vitorpamplona.amethyst.commons.model.concord.ConcordDirectInviteInbox import com.vitorpamplona.amethyst.commons.model.concord.ConcordDirectInviteView +import com.vitorpamplona.amethyst.commons.model.concord.ConcordKickNotice +import com.vitorpamplona.amethyst.commons.model.concord.ConcordPinDutyScheduler import com.vitorpamplona.amethyst.commons.model.concord.DirectInviteAcceptPlan import com.vitorpamplona.amethyst.commons.model.concordChannelLastReadRoute import com.vitorpamplona.amethyst.commons.util.ConcurrentSet @@ -53,12 +58,17 @@ import com.vitorpamplona.quartz.concord.cord02Community.ConcordListTooLargeExcep import com.vitorpamplona.quartz.concord.cord02Community.HeldRoot import com.vitorpamplona.quartz.concord.cord02Community.ImagePointer import com.vitorpamplona.quartz.concord.cord03Channels.ChannelChat +import com.vitorpamplona.quartz.concord.cord03Channels.ConcordChannelKeyring import com.vitorpamplona.quartz.concord.cord03Channels.ConcordChatEditEvent +import com.vitorpamplona.quartz.concord.cord03Channels.ConcordDisappearing import com.vitorpamplona.quartz.concord.cord03Channels.concordEpoch +import com.vitorpamplona.quartz.concord.cord04Roles.AuthorityCitation +import com.vitorpamplona.quartz.concord.cord04Roles.AuthorityCitations import com.vitorpamplona.quartz.concord.cord04Roles.AuthorityResolver import com.vitorpamplona.quartz.concord.cord04Roles.ChannelEntity import com.vitorpamplona.quartz.concord.cord04Roles.ConcordLimits import com.vitorpamplona.quartz.concord.cord04Roles.ConcordPermissions +import com.vitorpamplona.quartz.concord.cord04Roles.ControlEdition import com.vitorpamplona.quartz.concord.cord04Roles.MetadataEntity import com.vitorpamplona.quartz.concord.cord04Roles.RoleEntity import com.vitorpamplona.quartz.concord.cord05Invites.CommunityInvite @@ -68,8 +78,11 @@ import com.vitorpamplona.quartz.concord.cord05Invites.ConcordInviteListEntry import com.vitorpamplona.quartz.concord.cord05Invites.ConcordInviteListEvent import com.vitorpamplona.quartz.concord.cord05Invites.ConcordInviteListTombstone import com.vitorpamplona.quartz.concord.cord05Invites.ConcordInviteRegistry +import com.vitorpamplona.quartz.concord.cord05Invites.ConcordInviteVend import com.vitorpamplona.quartz.concord.cord05Invites.InviteBundleStatus import com.vitorpamplona.quartz.concord.cord05Invites.InviteRelayDictionary +import com.vitorpamplona.quartz.concord.cord06Rekey.ChannelRekeyOutcome +import com.vitorpamplona.quartz.concord.cord06Rekey.ConcordChannelRekey import com.vitorpamplona.quartz.concord.cord06Rekey.ConcordRefounding import com.vitorpamplona.quartz.concord.cord06Rekey.IncompleteControlPlaneException import com.vitorpamplona.quartz.concord.cord06Rekey.PendingRefounding @@ -99,19 +112,26 @@ import com.vitorpamplona.quartz.utils.Log import com.vitorpamplona.quartz.utils.RandomInstance import com.vitorpamplona.quartz.utils.TimeUtils import com.vitorpamplona.quartz.utils.concurrent.ConcurrentMap +import kotlinx.coroutines.CancellationException +import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.async import kotlinx.coroutines.awaitAll import kotlinx.coroutines.coroutineScope +import kotlinx.coroutines.flow.MutableSharedFlow import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.SharedFlow import kotlinx.coroutines.flow.SharingStarted import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asSharedFlow import kotlinx.coroutines.flow.asStateFlow import kotlinx.coroutines.flow.combine import kotlinx.coroutines.flow.first import kotlinx.coroutines.flow.stateIn import kotlinx.coroutines.launch import kotlinx.coroutines.sync.Mutex +import kotlinx.coroutines.sync.Semaphore import kotlinx.coroutines.sync.withLock +import kotlinx.coroutines.sync.withPermit import kotlinx.coroutines.withTimeoutOrNull /** Name of the default Concord community Admin role minted by "Make admin". */ @@ -128,6 +148,9 @@ private const val SESSION_WAIT_MS = 10_000L */ private const val RECOVERY_CHECK_INTERVAL_MS = 15 * 60 * 1000L +/** How many times a Pin List write re-applies itself on top of a concurrent edition that won the fold. */ +private const val PIN_REHEAL_RETRIES = 2 + /** * How many recipients one Refounding will re-key. See `AccountConcordActions.boundRecipients`. * @@ -137,6 +160,9 @@ private const val RECOVERY_CHECK_INTERVAL_MS = 15 * 60 * 1000L */ private const val MAX_REFOUNDING_RECIPIENTS = 5_000 +// How many channel epochs a privatisation probes for earlier rotations (Armada MAX_PROBED_CHANNEL_EPOCH). +private const val MAX_PROBED_CHANNEL_EPOCH = 32L + /** A lowercase 32-byte hex key (the Guestbook `invite` tag's creator). */ private val HEX64 = Regex("^[0-9a-f]{64}$") @@ -234,6 +260,21 @@ class AccountConcordActions( /** Adds or replaces [entry] in the Community List; false when it could not be written. */ private suspend fun persistConcordEntry(entry: ConcordCommunityListEntry): Boolean = writeConcordList { it.follow(entry) } + /** + * Rewrites the held entry for [communityId] through [transform], applied to the entry **as the + * List holds it inside the write** ([ConcordChannelListState.update]) — never to a snapshot read + * before a suspension, which a concurrent rekey or import could have moved on. True only when + * [transform] produced a change and it was written. + */ + private suspend fun updateConcordEntry( + communityId: String, + transform: (ConcordCommunityListEntry) -> ConcordCommunityListEntry?, + ): Boolean { + var changed = false + val ok = writeConcordList { list -> list.update(communityId) { cur -> transform(cur)?.also { changed = true } } } + return ok && changed + } + /** Publishes a Guestbook JOIN (kind 3306) for [entry] to its community relays. */ private suspend fun announceConcordGuestbookJoin( entry: ConcordCommunityListEntry, @@ -399,24 +440,30 @@ class AccountConcordActions( retired: List = emptyList(), ): Boolean { val session = account.concordSessions.sessionFor(entry.id) ?: return false + // Only from a drained fold: `published` is read off our honored head, and a partial fold + // would read "no registry" and chain a fresh v1 over the real one (dropped by every reader). + val state = session.foldForWrite() ?: return false + // A dissolved community has no future (CORD-02 §9): no registry edit can change anything. + if (state.dissolved) return false if (!isAuthorizedFor(session, ConcordPermissions.CREATE_INVITE)) return false val cp = controlKeysForWrite(session) ?: return false val me = account.signer.pubKey - val state = session.state.value - val published = state?.registryOf(me).orEmpty() + val published = state.registryOf(me) val next = ConcordInviteRegistry.nextLinks(published, list, entry.id, TimeUtils.now(), minted, retired) - val hasHead = state?.inviteRegistries?.containsKey(me.lowercase()) == true + val hasHead = state.inviteRegistries.containsKey(me.lowercase()) if (next == published.sorted() && (hasHead || next.isEmpty())) return false - // The writer chains off the same authorized head the fold honors (ConcordModeration.headOf). + // The writer chains off the same authorized, floor-aware head the fold honors. val wrap = try { - ConcordModeration.setInviteRegistry(account.signer, cp, entry.id.hexToByteArray(), next, session.controlEditions(), TimeUtils.now(), owner = entry.owner) + ConcordModeration.setInviteRegistry(account.signer, cp, entry.id.hexToByteArray(), next, session.controlEditions(), TimeUtils.now(), owner = entry.owner, floors = session.controlFloors()) + } catch (e: CancellationException) { + throw e } catch (e: Exception) { Log.w("Concord", "invite registry build failed for ${entry.id}", e) return false } - publishConcordWrap(entry, wrap) - return true + // Confirmed: the registry is the community's Public/Private source of truth (CORD-05 §5). + return publishConcordWrapConfirmed(entry, wrap) } /** @@ -844,15 +891,41 @@ class AccountConcordActions( * The Direct Invite inbox: wraps from the dedicated sweep ([refreshConcordDirectInvites]) and * from the NIP-17 giftwrap pipeline land here, parked until the user accepts or declines. */ - val directInviteInbox = ConcordDirectInviteInbox(account.signer) + val directInviteInbox = + ConcordDirectInviteInbox( + account.signer, + // Muted/blocked senders never park; followed ones outrank strangers when the inbox is full. + isHidden = { account.isHidden(it) }, + isFollowed = { it in account.followingKeySet() }, + ) /** - * The parked Direct Invites a UI should show, newest first: invites for communities we don't - * hold, plus catch-ups for ones we do ([ConcordDirectInviteInbox.visible]). + * The parked Direct Invites a UI should show, followed senders first, then newest: invites for + * communities we don't hold (nor left after they were sent), plus catch-ups for ones we do + * ([ConcordDirectInviteInbox.visible]). */ val pendingConcordDirectInvites: StateFlow> = - combine(directInviteInbox.pending, account.concordChannelList.liveCommunities) { pending, joined -> - ConcordDirectInviteInbox.visible(pending.values, joined) + combine( + directInviteInbox.pending, + account.concordChannelList.liveCommunities, + account.concordChannelList.removedAt, + account.hiddenUsers.flow, + // A fold landing can make a parked catch-up admissible or not (the sender's standing). + combine(account.kind3FollowList.flow, account.concordSessions.revision) { follows, _ -> follows }, + ) { pending, joined, removedAt, _, follows -> + ConcordDirectInviteInbox.visible( + pending.values, + joined, + removedAt = removedAt, + isFollowed = { it in follows.authors }, + isHidden = { account.isHidden(it) }, + heldStateOf = { id -> + account.concordSessions + .sessionFor(id) + ?.state + ?.value + }, + ) }.stateIn(account.scope, SharingStarted.WhileSubscribed(5_000), emptyList()) /** @@ -878,9 +951,42 @@ class AccountConcordActions( val filter = ConcordActions.directInvitesFilter(account.signer.pubKey, directInviteInbox.since()) val wraps = account.client.fetchAll(filters = relays.associateWith { listOf(filter) }) wraps.distinctBy { it.id }.forEach { directInviteInbox.offer(it) } + drainConcordCatchUps() return (directInviteInbox.pending.value.keys - before).size } + /** + * Adopts, without a click, every parked catch-up the held fold says is exactly the delivery a + * Grant prescribes (Armada `judgeCatchUp`, [ConcordInviteVend.judgeCatchUp]): a staff sender, a + * recipient who isn't banned, and only live Private Channels our Roles entitle us to. Consent + * came from the Grant. Anything else waits for a manual Accept. Runs after an inbox sweep and on + * the revision tick (a Grant folding late turns a waiting catch-up adoptable). + */ + internal suspend fun drainConcordCatchUps() { + if (!account.isWriteable()) return + val me = account.signer.pubKey + val now = TimeUtils.nowMillis() + for (opened in directInviteInbox.pending.value.values) { + if (opened.isExpired(now)) continue + val held = + account.concordChannelList.liveCommunities.value + .firstOrNull { it.id.equals(opened.invite.communityId, ignoreCase = true) } ?: continue + val state = + account.concordSessions + .sessionFor(held.id) + ?.state + ?.value ?: continue + if (state.dissolved) continue + val verdict = ConcordInviteVend.judgeCatchUp(state.authority, state.privateChannelIds, me, opened.sender, opened.invite, held) + if (verdict != ConcordInviteVend.CatchUpVerdict.ADOPT) continue + val ids = ConcordInviteVend.catchUpChannelIds(held, opened.invite) + if (updateConcordEntry(held.id) { cur -> ConcordInviteVend.adoptCatchUp(cur, opened.invite, ids) }) { + Log.i("Concord") { "Adopted a granted Private Channel key for ${held.id} from ${opened.sender}" } + directInviteInbox.resolve(opened.wrapId) + } + } + } + /** * The recipient's giftwrap inbox (CORD-05 §6): their kind-10050 DM relays, else NIP-65 read * relays — from the cache when we have their lists, fetched otherwise — else the stock set. @@ -916,6 +1022,7 @@ class AccountConcordActions( communityId: String, recipientPubKey: HexKey, expiresAtMs: Long? = null, + onlyChannelIds: Set? = null, ): ConcordDirectInviteSendResult { if (!account.isWriteable()) return ConcordDirectInviteSendResult.NOT_WRITEABLE val recipient = recipientPubKey.lowercase() @@ -929,7 +1036,7 @@ class AccountConcordActions( ?.state ?.value ?: return ConcordDirectInviteSendResult.ROSTER_NOT_LOADED val invite = - when (val draft = ConcordActions.draftDirectInvite(entry, state, account.signer.pubKey, recipient, expiresAtMs)) { + when (val draft = ConcordActions.draftDirectInvite(entry, state, account.signer.pubKey, recipient, expiresAtMs, onlyChannelIds)) { is ConcordDirectInviteDraft.Refused -> return draft.reason is ConcordDirectInviteDraft.Ready -> draft.invite } @@ -971,9 +1078,12 @@ class AccountConcordActions( // No folded roster yet: whether it bans us is unknown, so the invite waits. DirectInviteAcceptPlan.RosterNotLoaded -> ConcordInviteResult.NotReachable DirectInviteAcceptPlan.NothingNew -> ConcordInviteResult.Joined(bundle.communityId) - // Keys only, on the held base: no second Guestbook Join. - is DirectInviteAcceptPlan.CatchUp -> - if (persistConcordEntry(plan.entry)) ConcordInviteResult.Joined(bundle.communityId) else ConcordInviteResult.NotReachable + // Keys only, on the held base: no second Guestbook Join. Re-applied to the entry the + // List holds at write time, so a root imported meanwhile is never written back over. + is DirectInviteAcceptPlan.CatchUp -> { + val ok = writeConcordList { list -> list.update(plan.entry.id) { cur -> ConcordInviteVend.adoptCatchUp(cur, bundle, plan.channelIds) } } + if (ok) ConcordInviteResult.Joined(bundle.communityId) else ConcordInviteResult.NotReachable + } DirectInviteAcceptPlan.Join -> joinValidatedConcordInvite( bundle = bundle, @@ -1140,7 +1250,8 @@ class AccountConcordActions( .findEmojiTags(newText) .map { it.toTagArray() } .toTypedArray() - val wrap = ConcordActions.buildChannelEdit(account.signer, channelKey, channelIdHex, plane.epoch, target, newText, TimeUtils.now(), emojiTags, session.messageExpirationSecs()) + // CORD-08 §2: the Edit keeps the ORIGINAL message's deadline (none if it has none), never now + timer. + val wrap = ConcordActions.buildChannelEdit(account.signer, channelKey, channelIdHex, plane.epoch, target, newText, TimeUtils.now(), emojiTags, expiration = ConcordDisappearing.expirationOf(target)) publishConcordWrap(entry, wrap) return true } @@ -1246,6 +1357,31 @@ class AccountConcordActions( if (relays.isNotEmpty()) account.client.publish(wrap, relays) } + /** + * [publishConcordWrap] for a Control Plane edition whose caller must know it landed: waits for a + * relay OK (`publish` only queues and never reports acceptance) and folds the wrap into the + * session only then, so a refused write never shows as done locally. False when no relay of the + * community accepted it. + */ + private suspend fun publishConcordWrapConfirmed( + entry: ConcordCommunityListEntry, + wrap: Event, + ): Boolean { + val relays = entry.relays.mapNotNullTo(mutableSetOf()) { RelayUrlNormalizer.normalizeOrNull(it) } + if (relays.isEmpty()) return false + val landed = + try { + account.client.publishAndConfirm(wrap, relays) + } catch (e: CancellationException) { + throw e + } catch (e: Exception) { + Log.w("Concord", "Control edition publish failed for ${entry.id}", e) + false + } + if (landed) account.concordSessions.ingest(wrap) + return landed + } + /** * Echo an own Concord channel message into its feed and publish it, driving * the bubble's send state as it goes. @@ -1371,6 +1507,7 @@ class AccountConcordActions( val session = account.concordSessions.sessionFor(communityId) ?: return false if (!account.isWriteable()) return false val cp = controlKeysForAction(session, ConcordPermissions.MANAGE_ROLES, member) ?: return false + val before = session.state.value?.authority // A Grant that first makes its member staff must deliver the control_root in the same // edition (CORD-04 §3) — grantWithStaffDelivery attaches the pairwise wrap when the // roles carry a Control-writing bit and we hold the secret to hand over. @@ -1388,6 +1525,8 @@ class AccountConcordActions( epoch = session.entry.rootEpoch, ) publishConcordWrap(session.entry, wrap) + // Role-gated channel keys follow the Grant: vend what it opened, rotate what it closed. + reconcileConcordChannelAccess(communityId, before) return true } @@ -1500,8 +1639,10 @@ class AccountConcordActions( val session = account.concordSessions.sessionFor(communityId) ?: return false if (!account.isWriteable()) return false val cp = controlKeysForAction(session, ConcordPermissions.MANAGE_ROLES, member) ?: return false + val before = session.state.value?.authority val grantWrap = ConcordModeration.grant(account.signer, cp, communityId.hexToByteArray(), member, emptyList(), session.controlEditions(), TimeUtils.now(), owner = session.entry.owner) publishConcordWrap(session.entry, grantWrap) + reconcileConcordChannelAccess(communityId, before) return true } @@ -1558,14 +1699,20 @@ class AccountConcordActions( val session = account.concordSessions.sessionFor(communityId) ?: return false if (!account.isWriteable()) return false val cp = controlKeysForAction(session, ConcordPermissions.BAN, member) ?: return false + val before = session.state.value?.authority val wrap = ConcordModeration.ban(account.signer, cp, communityId.hexToByteArray(), member, session.controlEditions(), TimeUtils.now(), owner = session.entry.owner) publishConcordWrap(session.entry, wrap) // Judged on the fold that now carries the ban (publishConcordWrap ingests it first). val state = session.state.value if (state != null && state.banRequiresRefounding(listOf(member))) { + // The Refounding rotates every held Private Channel to its entitled set (CORD-06 §3). if (!refoundConcordCommunity(communityId, setOf(member))) { Log.w("Concord") { "Banned $member from the Private community $communityId, but its Refounding did not complete" } } + } else { + // A Public ban keeps the base, so the Private Channels the target could read are cut by + // their own rekeys (CORD-04 §6: "a Private-Channel rekey for a channel-scoped cut"). + reconcileConcordChannelAccess(communityId, before) } return true } @@ -1583,6 +1730,80 @@ class AccountConcordActions( return true } + /** + * Kick [member] (CORD-04 §6, the Cooperative Kick): Role Removal first — an empty Grant when they + * hold roles and this account may strip them (MANAGE_ROLES + outrank; best-effort, as the + * reference client) — so their rank is gone before the departure lands, *then* the Guestbook + * directive (kind 3309) citing our Grant (`vac`). Needs KICK and a strict outrank of the target; + * the directive rides the Guestbook, so no Control write key is needed for it. A kicked member + * may re-join or be re-invited. Refused on a dissolved community (CORD-02 §9). + */ + suspend fun kickConcordMember( + communityId: String, + member: HexKey, + ): Boolean { + val session = account.concordSessions.sessionFor(communityId) ?: return false + if (!account.isWriteable()) return false + if (!isAuthorizedFor(session, ConcordPermissions.KICK, member)) return false + if (session.state.value?.dissolved == true) return false + val me = account.signer.pubKey + val authority = session.state.value?.authority + if (authority != null && authority.rolesOf(member).isNotEmpty() && + (authority.isOwner(me) || authority.canActOn(me, member, ConcordPermissions.MANAGE_ROLES)) + ) { + if (!grantConcordRole(communityId, member, emptyList())) { + Log.w("Concord") { "Kick of $member in $communityId: could not strip their roles first; kicking anyway" } + } + } + val entry = session.entry + val guestbook = ConcordActions.guestbookPlane(entry.root.hexToByteArray(), entry.id.hexToByteArray(), entry.rootEpoch) + val citation = + session.state.value + ?.authority + ?.let { AuthorityCitations.forActor(it, me) } + val wrap = ConcordActions.buildGuestbookKick(account.signer, guestbook, member, citation, TimeUtils.now()) + publishConcordWrap(entry, wrap) + return true + } + + private val _concordKicks = MutableSharedFlow(extraBufferCapacity = 16) + + /** One notice per community this account left because an honored Kick named it ([drainConcordKicks]). */ + val concordKicks: SharedFlow = _concordKicks.asSharedFlow() + + // Rumor ids of the Kicks already complied with, so a revision tick racing the List write acts once. + private val handledConcordKicks = ConcurrentSet() + + /** + * Compliance with a Kick against this account (CORD-04 §6): a compliant client tears the + * Community down locally. For each joined community whose coalesced Guestbook carries an honored + * Kick naming us that postdates this membership ([ConcordCommunitySession.kickedMe]), drop the + * List entry and tombstone it, exactly as a Leave does, and tell the user + * ([concordKicks]). Network-silent beyond the List write (no Guestbook Leave): the Kick already + * says we departed. The tombstone never blocks a later re-join — re-adding an entry bumps its + * `added_at` past the tombstone, and that newer `added_at` puts this Kick behind the new + * membership. Runs on the Concord revision tick; a Guestbook arrival and a control fold (which can + * newly honor a parked Kick) both bump it. + */ + internal suspend fun drainConcordKicks() { + if (!account.isWriteable()) return + for (session in account.concordSessions.sessions()) { + val kick = session.kickedMe() ?: continue + if (!handledConcordKicks.add(kick.rumorId)) continue + val communityId = session.entry.id + val name = + session.state.value + ?.metadata + ?.name + if (leaveConcordCommunity(communityId)) { + Log.i("Concord") { "Kicked from $communityId by ${kick.author}: left the community locally (CORD-04 §6)" } + _concordKicks.tryEmit(ConcordKickNotice(communityId, name, kick.author)) + } else { + handledConcordKicks.remove(kick.rumorId) + } + } + } + // ── Concord pins (CORD-04 §7) ───────────────────────────────────────────── // A Channel's Pin List rides the Control Plane as one replace-entire edition (vsk 11) of // self-proving entries. The read side verifies every entry and applies what this client holds @@ -1625,6 +1846,18 @@ class AccountConcordActions( ) } + /** + * [pinned] as the rumor the chat feed would render — its newest proven words over the original's + * tags (the NIP-92 `imeta` attachments), with the encrypted attachments' keys registered so the + * shared media pipeline fetches and decrypts them exactly as for a feed message. A pin proves its + * message without this account ever having held it, so the keys come from the proof itself. + */ + fun concordPinnedRumor(pinned: ConcordPinnedMessage): Event { + val rumor = pinned.toRumor() + account.registerConcordEncryptedImages(rumor) + return rumor + } + /** The author's newest Concord Edit this account holds for [rumorId], or null. */ private fun heldConcordEdit( rumorId: HexKey, @@ -1655,6 +1888,11 @@ class AccountConcordActions( /** * Runs one pin write: re-reads the list inside the lock (the previous write was echoed into the * session, so this chains onto it), resolves the context, and publishes the edition [op] builds. + * + * The publish waits for a relay OK ([ConcordPinOutcome.NOT_CONFIRMED] otherwise). Then, like a + * ban, the write re-heals: a concurrent curator's edition at the same version may win the fold + * (CORD-04 §1), silently dropping this change, so when the refolded head is not ours the same + * [op] runs again on top of the winner — at most [PIN_REHEAL_RETRIES] times. */ private suspend fun writeConcordPins( communityId: String, @@ -1663,29 +1901,38 @@ class AccountConcordActions( ): ConcordPinOutcome = concordPinMutex.withLock { if (!account.isWriteable()) return@withLock ConcordPinOutcome.NOT_WRITEABLE - val session = account.concordSessions.sessionFor(communityId) ?: return@withLock ConcordPinOutcome.NOT_FOLDED - val definition = - session.state.value - ?.channels - ?.get(channelIdHex) - ?.definition ?: return@withLock ConcordPinOutcome.NOT_FOLDED - val pins = concordChannelPins(communityId, channelIdHex) ?: return@withLock ConcordPinOutcome.NOT_FOLDED - val ctx = - ConcordPinContext( - actor = account.signer, - controlPlane = session.controlPlaneKeys(), - communityId = communityId.hexToByteArray(), - owner = session.entry.owner, - current = session.controlEditions(), - channelIdHex = channelIdHex, - channelIsPrivate = definition.private, - currentPlane = session.currentChannelPlane(channelIdHex), - pins = pins, - authorized = holdsConcordPinBit(session), - ) - val write = op(session, ctx) - write.wrap?.let { publishConcordWrap(session.entry, it) } - write.outcome + repeat(1 + PIN_REHEAL_RETRIES) { + val session = account.concordSessions.sessionFor(communityId) ?: return@withLock ConcordPinOutcome.NOT_FOLDED + val definition = + session.state.value + ?.channels + ?.get(channelIdHex) + ?.definition ?: return@withLock ConcordPinOutcome.NOT_FOLDED + val pins = concordChannelPins(communityId, channelIdHex) ?: return@withLock ConcordPinOutcome.NOT_FOLDED + val ctx = + ConcordPinContext( + actor = account.signer, + controlPlane = session.controlPlaneKeys(), + communityId = communityId.hexToByteArray(), + owner = session.entry.owner, + current = session.controlEditions(), + channelIdHex = channelIdHex, + channelIsPrivate = definition.private, + currentPlane = session.currentChannelPlane(channelIdHex), + pins = pins, + authorized = holdsConcordPinBit(session), + ) + val write = op(session, ctx) + // A retry that finds the winner already says what we meant (ALREADY_PINNED, NOT_PINNED, + // NOTHING_TO_DO) ends here too. + val wrap = write.wrap ?: return@withLock write.outcome + if (!publishConcordWrapConfirmed(session.entry, wrap)) return@withLock ConcordPinOutcome.NOT_CONFIRMED + val ours = ConcordStreamEnvelope.openOrNull(wrap, ctx.controlPlane)?.let { ControlEdition.fromOpened(it) }?.rumorId + if (ours == null || session.pinHeads.value[channelIdHex]?.rumorId == ours) return@withLock ConcordPinOutcome.PUBLISHED + Log.i("Concord") { "Pin List edit in $communityId lost the fold to a concurrent edition; re-applying on the winner" } + } + // Landed every time but kept losing the tie-break: it is on the relays, just not the head. + ConcordPinOutcome.PUBLISHED } /** Pin Concord message [note] into its channel's Pin List, proving it with its original seal. */ @@ -1745,6 +1992,30 @@ class AccountConcordActions( } } + private val concordPinDuties = ConcordPinDutyScheduler() + + /** + * Schedules, in [scope], the delayed pin duties (CORD-04 §7) this account owes in every joined + * community where it may write pins: for each Channel with a Pin List head whose read owes a + * republish, one [settleConcordPins] after the 3–15 s random wait ([ConcordPinDutyScheduler]). + * Called by the account on the Concord revision tick and when a delete or an Edit lands — the + * duties no longer depend on the channel screen being open. + */ + internal fun scheduleConcordPinDuties(scope: CoroutineScope) { + if (!account.isWriteable()) return + for (session in account.concordSessions.sessions()) { + val communityId = session.entry.id + if (!canPinConcord(communityId)) continue + for (channelIdHex in session.pinHeads.value.keys) { + val debt = ConcordPinDutyScheduler.debtOf(concordChannelPins(communityId, channelIdHex)) + concordPinDuties.schedule(scope, ConcordPinDutyScheduler.keyOf(communityId, channelIdHex), debt) { + runCatching { settleConcordPins(communityId, channelIdHex) } + .onFailure { Log.w("Concord", "pin duty for $channelIdHex in $communityId failed", it) } + } + } + } + } + // ── Concord refounding / rekey (CORD-06) ────────────────────────────────── // A ban is a soft removal — the banned member still holds the room key and can // still decrypt traffic; every client just declines to *show* their posts. A @@ -1921,9 +2192,14 @@ class AccountConcordActions( } if (!compactionLanded) Log.w("Concord") { "Refounding ${entry.id}: some compacted Control Plane heads were not accepted at epoch ${build.newEpoch}" } + // 5b. Rotate every held Private Channel (CORD-06 §3), each to its OWN entitled set among the + // kept members, sealed under the PRIOR root so a base-fork loser can still open it. A + // channel that fails to land keeps its key (and is logged): resumable, not atomic. + val rotatedEntry = rotatePrivateChannelsForRefounding(entry, recipients.toSet(), priorRoot, citation) + // 6. Adopt the new epoch ourselves. This rebuilds our session under the new root and // re-folds the compacted Control Plane (with the ban), dropping the removed members. - val adopted = adoptConcordRoot(entry, keys.newRoot, build.newEpoch, build.newControlKeys.address.hexToByteArray(), keys.newControlRoot) + val adopted = adoptConcordRoot(rotatedEntry, keys.newRoot, build.newEpoch, build.newControlKeys.address.hexToByteArray(), keys.newControlRoot) pendingConcordRefoundings.remove(entry.id) // 7. Move every link we minted to the new epoch. Without this the Refounding orphans them, @@ -1935,6 +2211,40 @@ class AccountConcordActions( return compactionLanded } + /** + * The Refounding's channel duty (CORD-06 §3): every held key of a live Private Channel is + * rotated to the members still entitled to it ∩ [kept], plus ourselves, sealed under + * [priorRoot]. Returns [entry] with each rotated channel moved to its new key (the caller adopts + * the new root from it); a channel whose rotation didn't land keeps its old key. + */ + private suspend fun rotatePrivateChannelsForRefounding( + entry: ConcordCommunityListEntry, + kept: Set, + priorRoot: ByteArray, + citation: AuthorityCitation?, + ): ConcordCommunityListEntry { + val session = account.concordSessions.sessionFor(entry.id) ?: return entry + val state = session.state.value ?: return entry + val me = account.signer.pubKey.lowercase() + val publishTo = entry.relays.mapNotNullTo(mutableSetOf()) { RelayUrlNormalizer.normalizeOrNull(it) } + val keptLower = kept.mapTo(HashSet()) { it.lowercase() } + var next = entry + for (held in entry.privateChannels) { + val id = held.channelId.lowercase() + if (id !in state.privateChannelIds || ConcordChannelKeyring.heldKey(entry, id) == null) continue + val keep = ConcordPrivateChannels.keepSet(state.authority, id, me).filterTo(HashSet()) { it in keptLower || it == me } + val newKey = ConcordChannelRekey.mintKey() + val wraps = ConcordPrivateChannels.buildRotation(account.signer, priorRoot, held, newKey, keep, TimeUtils.now(), citation) + val landed = wraps.all { runCatching { account.client.publishAndConfirm(it, publishTo) }.getOrDefault(false) } + if (!landed) { + Log.w("Concord") { "Refounding ${entry.id}: the rekey of private channel $id did not land; it keeps its key" } + continue + } + next = ConcordChannelKeyring.withRotatedKey(next, id, newKey.toHexKey(), held.epoch + 1) ?: next + } + return next + } + // Keys reserved for a Refounding in flight, per community (CORD-06 §3): a retry of the same // rotation reuses them. Process-local — a restart mid-rotation mints afresh, which is why the // rekey chunks are all confirmed before anything is adopted. @@ -2265,12 +2575,15 @@ class AccountConcordActions( if (!account.isWriteable()) return false val cp = controlKeysForAction(session, ConcordPermissions.MANAGE_METADATA) ?: return false // Start from the folded metadata so a field this form doesn't edit — the CORD-08 timer, above - // all — is carried forward instead of reset (CORD-02 §6 round-trip). - val standing = session.state.value?.metadata ?: MetadataEntity() + // all — is carried forward instead of reset (CORD-02 §6 round-trip). Only from a drained fold: + // minting over a head we were never served would chain a fresh v1 (or a stale version) that + // wipes the name, relays and timer — the owner included, who may otherwise act before the fold. + val folded = session.foldForWrite() ?: return false + val standing = folded.metadata ?: MetadataEntity() val metadata = standing.copy(name = name, icon = icon, banner = banner, description = description, relays = relays) // CORD-02 §6 caps are fold gates too: an edition past them would be dropped by every reader. if (!ConcordLimits.metadataFits(metadata)) return false - val wrap = ConcordModeration.editMetadata(account.signer, cp, communityId.hexToByteArray(), metadata, session.controlEditions(), TimeUtils.now(), owner = session.entry.owner) + val wrap = ConcordModeration.editMetadata(account.signer, cp, communityId.hexToByteArray(), metadata, session.controlEditions(), TimeUtils.now(), owner = session.entry.owner, floors = session.controlFloors()) publishConcordWrap(session.entry, wrap) return true } @@ -2290,9 +2603,11 @@ class AccountConcordActions( if (!account.isWriteable()) return false val cp = controlKeysForAction(session, ConcordPermissions.MANAGE_METADATA) ?: return false val timer = secs?.takeIf { it >= 1 } - val standing = session.state.value?.metadata ?: MetadataEntity() + // Same rule as editConcordMetadata: never lay the timer over a head we were not served. + val folded = session.foldForWrite() ?: return false + val standing = folded.metadata ?: MetadataEntity() if (standing.messageExpirationSecs() == timer) return false - val wrap = ConcordModeration.setMessageExpiration(account.signer, cp, communityId.hexToByteArray(), standing, timer, session.controlEditions(), TimeUtils.now(), owner = session.entry.owner) + val wrap = ConcordModeration.setMessageExpiration(account.signer, cp, communityId.hexToByteArray(), standing, timer, session.controlEditions(), TimeUtils.now(), owner = session.entry.owner, floors = session.controlFloors()) publishConcordWrap(session.entry, wrap) postConcordTimerNotices(session, timer ?: 0) return true @@ -2337,10 +2652,13 @@ class AccountConcordActions( suspend fun createConcordChannel( communityId: String, name: String, + private: Boolean = false, + accessRoleName: String? = null, ): Boolean { val session = account.concordSessions.sessionFor(communityId) ?: return false if (!account.isWriteable()) return false val cp = controlKeysForAction(session, ConcordPermissions.MANAGE_CHANNELS) ?: return false + if (private) return createPrivateConcordChannel(session, cp, communityId, name, accessRoleName) val channelId = RandomInstance.bytes(32) val channel = ChannelEntity(name = name.trim()) // Readers drop an empty or over-64-byte name (CORD-03 §2); never mint one. @@ -2397,6 +2715,244 @@ class AccountConcordActions( return true } + // ── Private Channels (CORD-03 §1-2, CORD-04 §2, CORD-05 §6, CORD-06 §1-3) ────────────────── + // A Private Channel reads on its own independent key. Its access list is the Roles scoped to it: + // a Grant that opens one vends the key by Direct Invite, a Grant (or ban) that closes one rotates + // it to the members still entitled. The protocol decisions live in ConcordPrivateChannels / + // ConcordChannelRekey (shared with `amy`); only the network and the List write are here. + + /** + * A new Private Channel (CORD-03 §2): an independent key at channel epoch 0 stored in the List + * FIRST (a lost List write would orphan the only copy), then its access Role and the channel + * edition. Nobody holds the Role yet; granting it vends the key ([grantConcordRole]). + */ + private suspend fun createPrivateConcordChannel( + session: ConcordCommunitySession, + cp: ControlPlaneKeys, + communityId: String, + name: String, + accessRoleName: String?, + ): Boolean { + val build = + ConcordPrivateChannels.create( + actor = account.signer, + cp = cp, + communityId = communityId.hexToByteArray(), + name = name, + accessRoleName = accessRoleName, + current = session.controlEditions(), + authority = session.state.value?.authority, + owner = session.entry.owner, + createdAt = TimeUtils.now(), + ) ?: return false + if (!updateConcordEntry(communityId) { cur -> ConcordChannelKeyring.withChannelKey(cur, build.key) }) return false + build.wraps.forEach { publishConcordWrap(session.entry, it) } + return true + } + + /** + * Converts the Public channel [channelIdHex] to Private (CORD-03 §2): a fresh key at the NEXT + * channel epoch — floored at the highest channel rotation seen on the wire, since a privatiser + * may never have held an earlier generation and a reused epoch is silent and unrecoverable — plus + * a new access Role, then the flag. Protects the future only. MANAGE_CHANNELS. + */ + suspend fun privatizeConcordChannel( + communityId: String, + channelIdHex: HexKey, + accessRoleName: String? = null, + ): Boolean { + val session = account.concordSessions.sessionFor(communityId) ?: return false + if (!account.isWriteable()) return false + val cp = controlKeysForAction(session, ConcordPermissions.MANAGE_CHANNELS) ?: return false + val state = session.state.value ?: return false + val standing = state.channels[channelIdHex]?.definition ?: return false + if (standing.private) return false + val floor = observedChannelEpochFloor(session.entry, channelIdHex) ?: return false + val build = + ConcordPrivateChannels.privatize( + actor = account.signer, + cp = cp, + entry = session.entry, + channelIdHex = channelIdHex, + standing = standing, + accessRoleName = accessRoleName, + current = session.controlEditions(), + authority = state.authority, + createdAt = TimeUtils.now(), + observedFloor = floor, + ) ?: return false + if (!updateConcordEntry(communityId) { cur -> ConcordChannelKeyring.withChannelKey(cur, build.key) }) return false + build.wraps.forEach { publishConcordWrap(session.entry, it) } + return true + } + + /** + * The highest channel epoch a rotation of [channelIdHex] was ever published at, read off the + * rekey addresses every held root derives (CORD-06 §2 addresses need no channel key), or null + * when the read is inconclusive — a rotation at the window's top may have more above it, and + * minting on a guess could reuse an epoch (Armada `channelEpochFloor`). 0 when none is seen or no + * relay answers. + */ + private suspend fun observedChannelEpochFloor( + entry: ConcordCommunityListEntry, + channelIdHex: HexKey, + ): Long? { + val relays = entry.relays.mapNotNullTo(mutableSetOf()) { RelayUrlNormalizer.normalizeOrNull(it) } + if (relays.isEmpty()) return 0 + val channelId = channelIdHex.hexToByteArray() + val window = HashMap() + for (root in (listOf(entry.root) + entry.heldRoots.map { it.key }).distinct()) { + for (epoch in 1L..MAX_PROBED_CHANNEL_EPOCH) window[ConcordChannelRekey.address(root.hexToByteArray(), channelId, epoch).publicKeyHex] = epoch + } + val seen = runCatching { account.client.fetchAll(filters = relays.associateWith { listOf(ConcordActions.planeFilterFor(window.keys.toList())) }) }.getOrDefault(emptyList()) + val highest = seen.mapNotNull { window[it.pubKey] }.maxOrNull() ?: 0 + return if (highest >= MAX_PROBED_CHANNEL_EPOCH) null else highest + } + + /** + * Converts the Private channel [channelIdHex] back to Public (CORD-03 §2): the flag only. The + * held key stays, so its holders keep reading the private era. MANAGE_CHANNELS. + */ + suspend fun publicizeConcordChannel( + communityId: String, + channelIdHex: HexKey, + ): Boolean { + val session = account.concordSessions.sessionFor(communityId) ?: return false + if (!account.isWriteable()) return false + val cp = controlKeysForAction(session, ConcordPermissions.MANAGE_CHANNELS) ?: return false + val standing = + session.state.value + ?.channels + ?.get(channelIdHex) + ?.definition ?: return false + val wrap = ConcordPrivateChannels.publicize(account.signer, cp, communityId.hexToByteArray(), channelIdHex, standing, session.controlEditions(), session.entry.owner, TimeUtils.now()) ?: return false + publishConcordWrap(session.entry, wrap) + return true + } + + // Channel keys reserved for a rotation in flight, keyed by (community, channel, new epoch, + // prevcommit): a retry re-delivers the SAME key rather than minting a sibling that would split + // the members across two keys at one epoch (Armada `mintOrReuseRotationKey`). Process-local. + private val pendingConcordChannelRotations = ConcurrentMap() + + /** + * Rotates Private Channel [channelIdHex] (a single-channel Rekey, CORD-06 §1-2) to exactly the + * members entitled to it today plus ourselves, cutting everyone else. [removed] names who the + * rotation cuts, for the authority check — the Rotator must hold MANAGE_CHANNELS and strictly + * outrank each of them; null takes every known member who is not kept. Every chunk must land on + * a relay before we adopt the new key. Returns whether the rotation was published and adopted. + */ + suspend fun rekeyConcordChannel( + communityId: String, + channelIdHex: HexKey, + removed: Set? = null, + ): Boolean { + val session = account.concordSessions.sessionFor(communityId) ?: return false + if (!account.isWriteable()) return false + val state = session.state.value ?: return false + if (state.dissolved) return false + val entry = session.entry + val me = account.signer.pubKey + val held = ConcordChannelKeyring.heldKey(entry, channelIdHex) ?: return false + val authority = state.authority + val keep = ConcordPrivateChannels.keepSet(authority, channelIdHex, me) + val cut = removed ?: (session.allMembers() - keep) + if (!ConcordPrivateChannels.canRotate(authority, me, cut)) { + Log.w("Concord") { "Refusing to rotate $channelIdHex in $communityId: not MANAGE_CHANNELS, or does not outrank a cut member (CORD-06 §3)" } + return false + } + val editions = session.controlEditions() + val citation = ConcordReceive.rotationCitation(entry, editions, me) + if (citation == null && !authority.isOwner(me)) return false + val publishTo = entry.relays.mapNotNullTo(mutableSetOf()) { RelayUrlNormalizer.normalizeOrNull(it) } + if (publishTo.isEmpty()) return false + + val newEpoch = held.epoch + 1 + val reservation = "${entry.id}:${held.channelId.lowercase()}:$newEpoch:${ConcordChannelRekey.prevCommit(held.epoch, held.key.hexToByteArray())}" + val newKey = pendingConcordChannelRotations.getOrPut(reservation) { ConcordChannelRekey.mintKey() } + val wraps = ConcordPrivateChannels.buildRotation(account.signer, entry.root.hexToByteArray(), held, newKey, keep, TimeUtils.now(), citation) + for (wrap in wraps) { + if (!runCatching { account.client.publishAndConfirm(wrap, publishTo) }.getOrDefault(false)) { + Log.w("Concord") { "Channel rekey of $channelIdHex aborted: a chunk was not accepted by any relay; retrying reuses the same key" } + return false + } + } + // Adopt at once: the rotator must never keep writing under the severed key. + val adopted = + updateConcordEntry(entry.id) { cur -> + if (ConcordChannelKeyring.heldKey(cur, channelIdHex)?.epoch != held.epoch) null else ConcordChannelKeyring.withRotatedKey(cur, channelIdHex, newKey.toHexKey(), newEpoch) + } + if (adopted) pendingConcordChannelRotations.remove(reservation) + return adopted + } + + /** + * Follows a roster change with the keys it implies (Armada `handleToggleRole`): every Private + * Channel whose entitled set moved between [before] and the current fold ([ConcordInviteVend.accessChanges]) + * — a member who gained one is handed its key by Direct Invite (only the channels gained), and + * one who lost one is cut by rotating it. Only keys we hold can move; a channel we can't vend or + * rotate is logged, since a revoke that cuts nobody is the failure to hear about. + */ + private suspend fun reconcileConcordChannelAccess( + communityId: String, + before: AuthorityResolver?, + ) { + val session = account.concordSessions.sessionFor(communityId) ?: return + val state = session.state.value ?: return + if (before == null || state.dissolved) return + val me = account.signer.pubKey.lowercase() + val changes = ConcordInviteVend.accessChanges(before, state.authority, state.privateChannelIds) + if (changes.isEmpty()) return + + val vend = HashMap>() + for (change in changes) { + val held = ConcordChannelKeyring.heldKey(session.entry, change.channelIdHex) + if (held == null) { + Log.w("Concord") { "Access to ${change.channelIdHex} changed, but we hold no key to vend or rotate it" } + continue + } + for (member in change.gained - me) vend.getOrPut(member) { HashSet() }.add(change.channelIdHex) + val cut = change.lost - me + if (cut.isNotEmpty() && !rekeyConcordChannel(communityId, change.channelIdHex, cut)) { + Log.w("Concord") { "Could not rotate ${change.channelIdHex}: ${cut.size} member(s) may keep reading it until someone who can rotates it" } + } + } + for ((member, channels) in vend) { + val sent = sendConcordDirectInvite(communityId, member, onlyChannelIds = channels) + if (sent != ConcordDirectInviteSendResult.SENT) Log.w("Concord") { "Could not deliver ${channels.size} channel key(s) to $member: $sent" } + } + } + + /** + * Drains the buffered channel rekeys of every joined community (CORD-06 §2 receive path): for + * each held Private Channel, a complete, honored rotation carrying our blob off the key we hold + * moves the key forward; a complete one from a Rotator who outranks us that omits us drops it and + * records the cut. Runs on the revision tick; idempotent once applied (the held epoch moves on). + */ + internal suspend fun drainConcordChannelRekeys() { + if (!account.isWriteable()) return + for (session in account.concordSessions.sessions()) { + val state = session.state.value ?: continue + // Death wins every race (CORD-02 §9). + if (state.dissolved) continue + val wraps = session.pendingChannelRekeyWraps() + if (wraps.isEmpty()) continue + val entry = session.entry + val outcomes = ConcordPrivateChannels.receive(entry, wraps, session.controlEditions(), state.authority, account.signer) + if (outcomes.isEmpty()) continue + val fromEpochs = entry.privateChannels.associate { it.channelId.lowercase() to it.epoch } + if (updateConcordEntry(entry.id) { cur -> ConcordPrivateChannels.applyOutcome(cur, outcomes, fromEpochs) }) { + for ((id, outcome) in outcomes) { + when (outcome) { + is ChannelRekeyOutcome.Adopted -> Log.i("Concord") { "Channel rekey ${entry.id}/$id: adopted epoch ${outcome.epoch}" } + is ChannelRekeyOutcome.Removed -> Log.i("Concord") { "Channel rekey ${entry.id}/$id: cut at epoch ${outcome.epoch}" } + ChannelRekeyOutcome.None -> Unit + } + } + } + } + } + /** * Read-only preview of an invite link: parse it, fetch the kind-33301 bundle from * the link's relays (+ our outbox), and unlock it with the fragment token — WITHOUT @@ -2523,7 +3079,7 @@ class AccountConcordActions( * never asked for again and stays invisible. This sweep uses **no `since`**: it re-fetches the * whole plane every run. * - **Per-filter cap:** a relay caps a REQ's result (~100/filter on relay.dreamith.to), which can - * crop a busy Control Plane. This **pages past the cap** ([fetchAllPagesFromPool] walks `until` + * crop a busy Control Plane. This **pages past the cap** ([fetchAllPages] walks `until` * cursors until a plane is drained), so the fold sees every edition regardless of the cap. * * Current + every held-prior epoch's Control Plane is swept (the anti-rollback floor folds from the @@ -2543,9 +3099,74 @@ class AccountConcordActions( if (authorsByRelay.isEmpty()) return // No `since`, no `limit` → fetchAllPages treats each filter as unbounded and pages until a // plane is fully drained (empty page), so the whole Control Plane lands regardless of the cap. - val byRelay = authorsByRelay.mapValues { (_, authors) -> listOf(ConcordActions.planeFilterFor(authors.toList())) } - var drained = 0 - account.client.fetchAllPagesFromPool(filters = byRelay) { _, _ -> drained++ } - Log.d("Concord") { "syncConcordControlPlanes: paged ${authorsByRelay.size} relay(s), drained $drained control wrap(s)" } + // Paged per relay (8 at a time) rather than through the pool helper, because the drained flag + // below needs each relay's ending: only DRAINED proves the relay had nothing more. + val gate = Semaphore(8) + val perRelay = + coroutineScope { + authorsByRelay + .map { (relay, authors) -> + async { + gate.withPermit { + val wraps = ArrayList() + val end = + try { + account.client.fetchAllPages(relay, listOf(ConcordActions.planeFilterFor(authors.toList()))) { wraps.add(it) }.end + } catch (e: CancellationException) { + throw e + } catch (e: Exception) { + Log.w("Concord", "Control Plane sweep failed on $relay", e) + null + } + Triple(authors, end == PagedFetchResult.End.DRAINED, wraps) + } + } + }.awaitAll() + } + // Fold the swept wraps in before flagging anything drained: the global cache connector also + // ingests them, but asynchronously, and the flag must never run ahead of the fold (the session + // dedups by wrap id, so the second delivery is a no-op). + var swept = 0 + for ((_, _, wraps) in perRelay) { + for (wrap in wraps) { + account.concordSessions.ingest(wrap) + swept++ + } + } + val drainedAddresses = perRelay.filter { it.second }.flatMapTo(HashSet()) { it.first } + // One relay drained whole is enough for everyday writes (a dead relay must not freeze pins and + // metadata forever); the Refounding compaction keeps its own majority rule. + for (entry in entries) { + val session = account.concordSessions.sessionFor(entry.id) ?: continue + if (session.controlPlaneAddress in drainedAddresses) session.markControlDrained() + } + Log.d("Concord") { "syncConcordControlPlanes: paged ${authorsByRelay.size} relay(s), swept $swept control wrap(s), ${drainedAddresses.size} plane(s) drained" } + pruneExpiredConcordRegistries(entries) + } + + // Communities (at an epoch) whose registry was already checked for elapsed links this process. + private val registryPruneChecked = ConcurrentSet() + + /** + * CORD-05 §5: once a community's Control Plane has drained, republish this account's Invite + * Registry there pruned when it still lists a link the Invite List says has expired (or no longer + * holds). Otherwise an elapsed link — which nothing else ever retires — keeps the community Public + * forever, and a Private ban would never Refound. Once per community and epoch per process; the + * Invite List is read only when some drained community actually has a registry of ours. + */ + private suspend fun pruneExpiredConcordRegistries(entries: List) { + if (!account.isWriteable()) return + val me = account.signer.pubKey + val due = + entries.filter { entry -> + val state = account.concordSessions.sessionFor(entry.id)?.foldForWrite() ?: return@filter false + !state.dissolved && state.registryOf(me).isNotEmpty() && registryPruneChecked.add("${entry.id}@${entry.rootEpoch}") + } + if (due.isEmpty()) return + val list = readConcordInviteList() ?: return + for (entry in due) { + // Publishes only when the pruned list differs from the honored one. + if (publishConcordInviteRegistry(entry, list)) Log.i("Concord") { "Pruned elapsed invite links from this account's registry in ${entry.id}" } + } } } diff --git a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/DecryptAndIndexProcessor.kt b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/DecryptAndIndexProcessor.kt index 5ca3c6f8f7..946bb4953f 100644 --- a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/DecryptAndIndexProcessor.kt +++ b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/DecryptAndIndexProcessor.kt @@ -37,6 +37,7 @@ import com.vitorpamplona.quartz.marmot.mip03GroupMessages.GroupEvent import com.vitorpamplona.quartz.nip01Core.core.Event import com.vitorpamplona.quartz.nip01Core.core.IEvent import com.vitorpamplona.quartz.nip17Dm.base.ChatroomKeyable +import com.vitorpamplona.quartz.nip21UriScheme.toNostrUri import com.vitorpamplona.quartz.nip28PublicChat.message.ChannelMessageEvent import com.vitorpamplona.quartz.nip37Drafts.DraftWrapEvent import com.vitorpamplona.quartz.nip53LiveActivities.chat.LiveActivitiesChatMessageEvent @@ -346,7 +347,21 @@ class GiftWrapEventHandler( eventNote: Note, publicNote: Note, ) { - val innerGift = event.unwrapOrNull(account.signer) ?: return + val innerGift = + try { + event.unwrapThrowing(account.signer) + } catch (e: CancellationException) { + throw e + } catch (e: Exception) { + // A Direct Invite-tagged wrap (CORD-05 §6) that will never open is written off in the + // invite inbox too, so its sweep does not decrypt it again; a signer that merely + // could not answer now leaves it to be retried. + if (ConcordDirectInvite.isInviteTagged(event) && !ConcordDirectInvite.isTransientSignerFailure(e)) { + account.concord.directInviteInbox.markNotInvite(event.id) + } + Log.d("GiftWrapEvent") { "Couldn't Decrypt the content " + event.toNostrUri() } + return + } eventNote.event = event.copyNoContent() @@ -535,18 +550,33 @@ class SealEventHandler( eventNote: Note, publicNote: Note, ) { - val innerRumor = event.unsealOrNull(account.signer) ?: return + // Decrypted once, kept as the seal carries it (claimed author intact) so a Direct Invite can be + // checked against NIP-59 anti-spoofing without a second decrypt. + val rumor = + try { + event.unsealRumorThrowing(account.signer) + } catch (e: CancellationException) { + throw e + } catch (e: Exception) { + Log.w("RumorEvent", "Fail to decrypt or parse Rumor", e) + return + } + val innerRumor = event.unsealed(rumor) // A Concord Direct Invite (CORD-05 §6) is a standard NIP-59 giftwrap, so the DM inbox sees // it too — tagged `k=3313` or not. It is not a DM: its rumor carries a community's keys. Hand - // the seal to the Concord invite inbox, which re-opens it with the NIP-59 anti-spoofing check - // the generic unseal skips and parks it for the user, and keep the rumor out of the cache and - // every chat feed. Must run before the seal's content is stripped below. + // the seal and its rumor to the Concord invite inbox, which runs the NIP-59 anti-spoofing + // check the generic unseal skips and parks it for the user, and keep the rumor out of the + // cache and every chat feed. if (innerRumor.kind == ConcordDirectInvite.KIND) { - account.concord.directInviteInbox.offerSeal(publicNote.event ?: event, event) + account.concord.directInviteInbox.offerRumor(publicNote.event ?: event, event, rumor) eventNote.event = event.copyNoContent() return } + // Tagged as an invite but carrying something else: never one, so the inbox sweep skips it. + (publicNote.event as? GiftWrapEvent)?.let { wrap -> + if (ConcordDirectInvite.isInviteTagged(wrap)) account.concord.directInviteInbox.markNotInvite(wrap.id) + } eventNote.event = event.copyNoContent() diff --git a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordChannelListState.kt b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordChannelListState.kt index 1b6fa04690..0939d33665 100644 --- a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordChannelListState.kt +++ b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordChannelListState.kt @@ -196,6 +196,19 @@ class ConcordChannelListState( emptyList(), ) + /** + * When this account left each community it no longer holds (community id → the List + * tombstone's `removed_at`, unix ms, CORD-02 §8). A Direct Invite sent at or before that moment + * stays buried instead of resurfacing right after the leave. + */ + @OptIn(ExperimentalCoroutinesApi::class) + val removedAt: StateFlow> = + listChanges + .transformLatest { emit(document().residue.removals()) } + .onStart { emit(document().residue.removals()) } + .flowOn(Dispatchers.IO) + .stateIn(scope, SharingStarted.Eagerly, emptyMap()) + /** The distinct community ids across the joined list — the "servers" rail. */ @OptIn(ExperimentalCoroutinesApi::class) val liveServers: StateFlow> = @@ -243,6 +256,28 @@ class ConcordChannelListState( write(set, doc.entries.filterNot { it.id == entry.id } + live, doc.residue) } + /** + * Read-modify-write one membership: [transform] receives the entry for [communityId] **as the + * List holds it inside the write lock** and returns its replacement, or null to write nothing. + * Returns the fragment events to publish (empty when the community isn't held or nothing + * changed). + * + * Use this, never [follow] with a snapshot, for any change that touches one field of a live + * entry (a channel key, a cut): the List can move between reading a snapshot and writing it — + * a rekey adopted, a new root imported — and following the stale copy would write the old + * root back over it. + */ + suspend fun update( + communityId: String, + transform: (ConcordCommunityListEntry) -> ConcordCommunityListEntry?, + ): List = + writeLock.withLock { + val (set, doc) = snapshot() + val current = doc.entries.firstOrNull { it.id == communityId } ?: return@withLock emptyList() + val next = transform(current) ?: return@withLock emptyList() + write(set, doc.entries.map { if (it.id == communityId) next else it }, doc.residue) + } + /** * Leave [communityId]: drop its membership and tombstone it (CORD-02 §8 — only a tombstone * subtracts a membership; a missing entry is just unseen news another fragment may still diff --git a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordCommunitySession.kt b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordCommunitySession.kt index b736c47363..8e0e16f65d 100644 --- a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordCommunitySession.kt +++ b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordCommunitySession.kt @@ -27,14 +27,18 @@ import com.vitorpamplona.amethyst.commons.actions.ConcordLocalEdit import com.vitorpamplona.amethyst.commons.actions.ConcordPinSource import com.vitorpamplona.amethyst.commons.actions.ConcordPinVerifier import com.vitorpamplona.amethyst.commons.actions.ConcordPinning +import com.vitorpamplona.amethyst.commons.actions.ConcordPrivateChannels import com.vitorpamplona.amethyst.commons.util.KmpLock import com.vitorpamplona.amethyst.commons.util.withLock import com.vitorpamplona.quartz.concord.cord02Community.ConcordCommunityListEntry import com.vitorpamplona.quartz.concord.cord02Community.ConcordCommunityState import com.vitorpamplona.quartz.concord.cord02Community.ConcordDissolution +import com.vitorpamplona.quartz.concord.cord02Community.Guestbook +import com.vitorpamplona.quartz.concord.cord02Community.GuestbookAction import com.vitorpamplona.quartz.concord.cord02Community.GuestbookEntry import com.vitorpamplona.quartz.concord.cord03Channels.ChannelChat import com.vitorpamplona.quartz.concord.cord03Channels.ConcordDisappearing +import com.vitorpamplona.quartz.concord.cord03Channels.ConcordWebxdc import com.vitorpamplona.quartz.concord.cord04Roles.ControlEdition import com.vitorpamplona.quartz.concord.cord04Roles.EditionFold import com.vitorpamplona.quartz.concord.cord04Roles.EntityFloor @@ -73,6 +77,8 @@ data class ExpiredConcordRumor( val wrapId: HexKey, val rumorId: HexKey, val expiresAt: Long, + /** The URLs of the rumor's encrypted attachments, whose decryption keys go with it (CORD-08 §3). */ + val attachmentUrls: List = emptyList(), ) /** @@ -283,6 +289,14 @@ class ConcordCommunitySession( private val baseRekeyWraps = LinkedHashMap() private val siblingRekeyWraps = LinkedHashMap() + // Channel-rekey addresses (CORD-06 §2) for each held Private Channel's next epochs, under the + // current root and the prior one (a Refounding seals its channel rekeys under the prior root, + // CORD-06 §3) -> key. Re-derived whenever the held channel keys change, since each adoption + // moves the window forward. + @Volatile + private var channelRekeyKeys: Map = ConcordPrivateChannels.watchKeys(entry) + private val channelRekeyWraps = LinkedHashMap() + // Current channel plane pubkey -> plane (channel id, key, bound epoch), refreshed on each control // re-fold. A Public Channel's plane derives from the root at the root epoch; a Private one's from // its held channel key at the channel epoch (CORD-03 §1). A Private Channel we hold no key for has @@ -301,6 +315,46 @@ class ConcordCommunitySession( private val _state = MutableStateFlow(null) val state: StateFlow = _state + private val _controlDrained = MutableStateFlow(false) + + /** + * True once this session's current Control Plane has been swept whole at least once — every + * relay page drained and ingested ([markControlDrained]) — so [state] is a fold of the full plane + * rather than of whatever the live subscription delivered first. + * + * Until then the fold may be partial (a cropped first page, an edition below the live `since` + * cursor), and a write built on it can erase what it never saw: a Pin List edition replaces the + * list entire (CORD-04 §7: never write from a list the fold was not served), a metadata edition + * minted without the head resets the name and relays, a registry edit chains onto a stale head. + * Writers refuse while this is false; readers may show a partial fold but must not call an + * absent entity "none". One way: a session never un-drains (a Refounding builds a new session). + */ + val controlDrained: StateFlow = _controlDrained + + /** Records that the whole current Control Plane has been paged in and ingested (see [controlDrained]). */ + fun markControlDrained() { + _controlDrained.value = true + } + + /** + * The fold a Control Plane write may be built from: [state] once the plane has drained, else + * null. Every writer that lays its edition over a folded head (metadata, timer, registry, pins) + * goes through this, the owner included — the owner may act before the fold, but not write over + * a head they have not been served. + */ + fun foldForWrite(): ConcordCommunityState? = if (_controlDrained.value) _state.value else null + + // The anti-rollback floors the last fold used, so a writer can chain onto the same floor-aware head. + @Volatile + private var lastFloors: Map = emptyMap() + + /** + * The per-entity anti-rollback floors (from the prior epochs' Control Planes) the current fold + * honors — what a writer passes so it chains onto the head readers fold to, not the head of the + * current epoch's editions alone. + */ + fun controlFloors(): Map = lastFloors + private val _pinHeads = MutableStateFlow>(emptyMap()) /** @@ -312,9 +366,22 @@ class ConcordCommunitySession( private val _members = MutableStateFlow>(emptySet()) - /** The live Guestbook membership set (self-signed joins minus later leaves). */ + /** The live Guestbook membership set (self-signed joins minus later leaves and honored Kicks). */ val members: StateFlow> = _members + private val _guestbook = MutableStateFlow>(emptyMap()) + + /** + * The coalesced Guestbook (CORD-02 §5): each npub's latest Join, Leave or honored Kick, by + * lowercase pubkey. Kicks are judged against the current roster, so this re-derives on every + * control fold as well as on every Guestbook arrival. + */ + val guestbook: StateFlow> = _guestbook + + // Author (lowercase) -> the newest CORD-02 §4 ms of a message of theirs we decrypted: observation + // only counts *forward* of their latest Leave or Kick (CORD-02 §5). + private val observedAtMs = HashMap() + private val _observedAuthors = MutableStateFlow>(emptySet()) /** @@ -362,7 +429,37 @@ class ConcordCommunitySession( val s = _state.value val roster = if (s != null) s.authority.roleHolders() + s.ownerPubKey.lowercase() else emptySet() val banned = s?.authority?.bannedMembers().orEmpty() - return (_members.value + _observedAuthors.value + roster) - banned + return (_members.value + _observedAuthors.value + roster) - banned - departedMembers().keys + } + + /** + * Members the Guestbook shows as departed (lowercase hex -> their winning Leave or Kick): their + * latest motion is a Leave or an honored Kick and we have seen nothing of theirs since + * (CORD-02 §5: observation only counts forward). The owner never departs by a Kick. + */ + fun departedMembers(): Map { + val coalesced = _guestbook.value + if (coalesced.isEmpty()) return emptyMap() + val owner = entry.owner.lowercase() + return lock.withLock { + coalesced.filter { (pubkey, motion) -> + motion.action != GuestbookAction.JOIN && + pubkey != owner && + (observedAtMs[pubkey] ?: Long.MIN_VALUE) <= motion.ms + } + } + } + + /** + * The honored Kick naming this account that postdates this membership (CORD-04 §6), or null. + * A Kick older than the entry's `added_at` judged an earlier membership — a re-join (a later + * Join, or a re-invite that re-added the entry) leaves it behind. Never for the owner. + */ + fun kickedMe(): GuestbookEntry? { + val me = myPubKey.lowercase() + if (me == entry.owner.lowercase()) return null + val mine = _guestbook.value[me] ?: return null + return mine.takeIf { it.action == GuestbookAction.KICK && it.ms > entry.addedAt } } /** The size of [allMembers] — the community's true (best-effort) member count. */ @@ -389,6 +486,7 @@ class ConcordCommunitySession( address == nextBaseRekeyAddress || address == siblingBaseRekeyAddress || address == dissolvedAddress || + address in channelRekeyKeys || address in historicalControlKeys || lock.withLock { address in channelKeysByAddress || address in historicalChannelKeysByAddress } @@ -474,7 +572,13 @@ class ConcordCommunitySession( * The auxiliary plane keys (Guestbook, next base-rekey, and the CORD-02 §9 dissolution address) * for their own isolated AUTH. */ - fun auxStreamKeys(): List = listOfNotNull(guestbookKey, nextBaseRekeyKey, dissolvedKey, siblingBaseRekeyKey) + fun auxStreamKeys(): List = listOfNotNull(guestbookKey, nextBaseRekeyKey, dissolvedKey, siblingBaseRekeyKey) + channelRekeyKeys.values + + /** The channel-rekey addresses this session watches (CORD-06 §2), for the auxiliary subscription. */ + fun channelRekeyAddresses(): Set = channelRekeyKeys.keys + + /** The buffered kind-3303 wraps seen at [channelRekeyAddresses], for the account's channel-rekey drain. */ + fun pendingChannelRekeyWraps(): List = lock.withLock { channelRekeyWraps.values.toList() } /** The community's current Control Plane editions — the input a moderation edition chains onto. */ fun controlEditions(): List = lock.withLock { editionsLocked(controlWraps.values.toList(), controlKeys) } @@ -540,6 +644,7 @@ class ConcordCommunitySession( // Control material may already have swapped in an entry carrying the new keys. if (privateKeySet(newEntry) == derivedPrivateKeys) return false entry = newEntry + channelRekeyKeys = ConcordPrivateChannels.watchKeys(newEntry) true } // Nothing folded yet: the first control wrap derives the planes from the swapped-in entry. @@ -606,6 +711,14 @@ class ConcordCommunitySession( lock.withLock { siblingRekeyWraps[wrap.id] = wrap } return ConcordIngestOutcome.STRUCTURAL } + in channelRekeyKeys -> { + // Buffer only, like the base rekeys: opening a blob takes the account signer, and the + // rotator's authority is judged against the fold at drain time. + lock.withLock { + if (channelRekeyWraps.put(wrap.id, wrap) != null) return ConcordIngestOutcome.NON_STRUCTURAL // dup + } + return ConcordIngestOutcome.STRUCTURAL + } else -> { // A prior-epoch Control Plane wrap: buffer it and re-fold, so the anti-rollback // floor rises as the old epochs drain in. Structural — the floor can change the @@ -646,6 +759,8 @@ class ConcordCommunitySession( ingestTyping(wrap, channelIdHex, key, epoch) return ConcordIngestOutcome.NON_STRUCTURAL } + // An expired wrap this session already swept, delivered again: ours, but never opened again. + if (wasSwept(wrap.id)) return ConcordIngestOutcome.NON_STRUCTURAL val isNew = lock.withLock { channelWrapsById.getOrPut(channelIdHex) { LinkedHashMap() }.put(wrap.id, wrap) == null @@ -700,6 +815,7 @@ class ConcordCommunitySession( val wraps = controlWraps.values.toList() val editions = editionsLocked(wraps, controlKeys) val floors = controlFloorsLocked() + lastFloors = floors val folded = ConcordCommunityState.fold(editions, communityIdBytes, entry.owner, floors) val prevAddresses = channelKeysByAddress.keys.toHashSet() @@ -725,6 +841,9 @@ class ConcordCommunitySession( next.filterKeys { it !in prevAddresses }.values.map { it.channelIdHex } } + // Kicks are judged against the roster, so a fold can honor (or drop) a held Kick. + refoldGuestbook() + // Project only channels whose current plane is new (a first fold, or a plane that moved when a // Private Channel's key arrived). Existing planes' wraps were already emitted incrementally as // they arrived — re-projecting all channels on every control edition would be @@ -785,7 +904,9 @@ class ConcordCommunitySession( ConcordActions.guestbookEntry(wrap, guestbookKey).also { guestbookEntryByWrapId[wrap.id] = it } } } - _members.value = ConcordActions.projectGuestbook(entries) + val coalesced = Guestbook.coalesce(entries, TimeUtils.nowMillis(), _state.value?.authority) + _guestbook.value = coalesced + _members.value = ConcordActions.joinedMembers(coalesced) } } @@ -813,7 +934,17 @@ class ConcordCommunitySession( val authors = HashSet() val now = TimeUtils.now() for (wrap in wraps) { - val rumor = ConcordActions.openChannelRumorAnyExpiry(wrap, key, channelIdHex, epoch) ?: continue + val rumor = ConcordActions.openChannelRumorAnyExpiry(wrap, key, channelIdHex, epoch, ChannelChat.PLANE_KINDS) ?: continue + // A WebXDC signal (kind 3310) rides the plane but is never a chat row: held apart for a + // WebXDC host, never handed to the store, so it can't reach a feed, a preview or an + // unread count. Its author is still observably present (CORD-02 §5). + if (ConcordWebxdc.isWebxdc(rumor)) { + if (!ConcordDisappearing.isExpired(rumor, now) && holdWebxdc(channelIdHex, rumor)) { + observe(rumor) + authors.add(rumor.pubKey.lowercase()) + } + continue + } // Pins reopen the carrying wrap to disclose this one message's keys (CORD-04 §7). lock.withLock { wrapIdByRumorId[rumor.id] = wrap.id } // CORD-08 §3: only the rumor's own tag counts. A rumor carrying one is remembered so the @@ -821,10 +952,11 @@ class ConcordCommunitySession( // never handed to the store — and queued for the next sweep so its wrap goes too. val expiresAt = ConcordDisappearing.expirationOf(rumor) if (expiresAt != null) { - trackExpiring(wrap.id, channelIdHex, rumor.id, expiresAt) + trackExpiring(wrap.id, channelIdHex, rumor.id, expiresAt, ChannelChat.encryptedImagesOf(rumor).map { it.url }) if (expiresAt <= now) continue } authors.add(rumor.pubKey.lowercase()) + observe(rumor) onRumor(entry.id, channelIdHex, rumor, seenOnRelays) } // Every author we just decrypted is observably present (CORD-02 §5), so fold them into the @@ -834,6 +966,54 @@ class ConcordCommunitySession( } } + /** Records [rumor]'s author as seen at its CORD-02 §4 time (observation counts forward only). */ + private fun observe(rumor: Event) { + val author = rumor.pubKey.lowercase() + val atMs = ChannelChat.orderingMs(rumor) ?: (rumor.createdAt * 1000) + lock.withLock { if (atMs > (observedAtMs[author] ?: Long.MIN_VALUE)) observedAtMs[author] = atMs } + } + + // ── WebXDC signals (kind 3310) ─────────────────────────────────────────── + + // Channel id -> its WebXDC signals by rumor id, in arrival order, bounded per channel. + private val webxdcByChannel = HashMap>() + + private val _webxdcRevision = MutableStateFlow(0L) + + /** Bumps whenever a new WebXDC signal is held — what a WebXDC host re-reads [webxdcSignals] on. */ + val webxdcRevision: StateFlow = _webxdcRevision + + /** + * [channelIdHex]'s held WebXDC signals (kind 3310: app state updates and realtime peer signals, + * [ConcordWebxdc]) not yet expired (CORD-08: app state disappears with the chat plane), oldest + * first on the CORD-02 §4 basis. Amethyst has no WebXDC host; this is the plumbing one would read. + */ + fun webxdcSignals( + channelIdHex: HexKey, + now: Long = TimeUtils.now(), + ): List = + lock + .withLock { webxdcByChannel[channelIdHex]?.values?.toList() } + .orEmpty() + .filterNot { ConcordDisappearing.isExpired(it, now) } + .sortedBy { ChannelChat.orderingMs(it) ?: (it.createdAt * 1000) } + + /** Holds [rumor] for [channelIdHex]; false when already held. Keeps the newest [MAX_WEBXDC_PER_CHANNEL] arrivals. */ + private fun holdWebxdc( + channelIdHex: HexKey, + rumor: Event, + ): Boolean { + val added = + lock.withLock { + val held = webxdcByChannel.getOrPut(channelIdHex) { LinkedHashMap() } + if (held.put(rumor.id, rumor) != null) return@withLock false + while (held.size > MAX_WEBXDC_PER_CHANNEL) held.remove(held.keys.first()) + true + } + if (added) _webxdcRevision.update { it + 1 } + return added + } + // ── Disappearing messages (CORD-08) ────────────────────────────────────── /** Wrap id -> the expiring rumor it carries, for every rumor with an `expiration` we emitted or refused. */ @@ -854,42 +1034,86 @@ class ConcordCommunitySession( */ fun messageExpirationSecs(): Long? = _state.value?.metadata?.messageExpirationSecs() + /** + * The same entries as [expiringByWrapId], kept sorted by `expiresAt` (then wrap id), so a sweep + * pops only what is due instead of scanning every tracked message, and the next deadline is the + * head. Common code has no priority queue; a binary-searched insert into an array list is the + * same order of cost here. + */ + private val expiringByDeadline = ArrayList() + + /** + * Wrap ids this session already swept, newest last and bounded: relays keep re-delivering an + * expired wrap (a relay that ignores NIP-40, a backfill page), and each would otherwise be opened + * again only to be refused and swept again. + */ + private val sweptWrapIds = LinkedHashSet() + + private val deadlineOrder = compareBy({ it.expiresAt }, { it.wrapId }) + private fun trackExpiring( wrapId: HexKey, channelIdHex: HexKey, rumorId: HexKey, expiresAt: Long, + attachmentUrls: List = emptyList(), ) { - lock.withLock { - expiringByWrapId[wrapId] = ExpiredConcordRumor(channelIdHex, wrapId, rumorId, expiresAt) - _nextExpiry.update { if (it == null || expiresAt < it) expiresAt else it } - } + lock.withLock { trackLocked(ExpiredConcordRumor(channelIdHex, wrapId, rumorId, expiresAt, attachmentUrls)) } } + private fun trackLocked(entry: ExpiredConcordRumor) { + val prior = expiringByWrapId[entry.wrapId] + if (prior != null) { + // A re-projection re-emits the same wrap: same rumor, same deadline — nothing to move. + if (prior.expiresAt == entry.expiresAt) return + val at = expiringByDeadline.binarySearch(prior, deadlineOrder) + if (at >= 0) expiringByDeadline.removeAt(at) + } + expiringByWrapId[entry.wrapId] = entry + val at = expiringByDeadline.binarySearch(entry, deadlineOrder) + expiringByDeadline.add(if (at < 0) -at - 1 else at, entry) + _nextExpiry.value = expiringByDeadline.first().expiresAt + } + + /** True when [wrapId] was already swept as expired: a re-delivery is dropped before it is opened. */ + private fun wasSwept(wrapId: HexKey): Boolean = lock.withLock { wrapId in sweptWrapIds } + /** * Forgets every rumor whose `expiration` is at or before [now] (CORD-08 §3): its wrap leaves the * channel buffer, so no re-projection can resurrect it, and it is returned so the caller purges - * the rumor's note and the wrap's note from its store. A wrap re-delivered later is refused again - * at ingest. + * the rumor's note and the wrap's note from its store. A wrap re-delivered later is dropped at + * ingest without being opened. */ fun sweepExpired(now: Long = TimeUtils.now()): List = lock.withLock { - if (expiringByWrapId.isEmpty()) return@withLock emptyList() + if (expiringByDeadline.isEmpty() || expiringByDeadline.first().expiresAt > now) return@withLock emptyList() val out = ArrayList() - val it = expiringByWrapId.values.iterator() - while (it.hasNext()) { - val expiring = it.next() - if (expiring.expiresAt <= now) { - channelWrapsById[expiring.channelIdHex]?.remove(expiring.wrapId) - wrapIdByRumorId.remove(expiring.rumorId) - out.add(expiring) - it.remove() - } + while (expiringByDeadline.isNotEmpty() && expiringByDeadline.first().expiresAt <= now) { + val expiring = expiringByDeadline.removeAt(0) + expiringByWrapId.remove(expiring.wrapId) + channelWrapsById[expiring.channelIdHex]?.remove(expiring.wrapId) + wrapIdByRumorId.remove(expiring.rumorId) + sweptWrapIds.add(expiring.wrapId) + out.add(expiring) } - _nextExpiry.value = expiringByWrapId.values.minOfOrNull { it.expiresAt } + while (sweptWrapIds.size > MAX_SWEPT_WRAP_IDS) sweptWrapIds.remove(sweptWrapIds.first()) + _nextExpiry.value = expiringByDeadline.firstOrNull()?.expiresAt out } + /** Every disappearing rumor this session still tracks — handed to the session that replaces it. */ + fun trackedExpiring(): List = lock.withLock { expiringByDeadline.toList() } + + /** + * Adopts [entries] tracked by the session this one replaces (a Refounding rebuilds the session): + * their rumors are already in the store, and without this nothing would ever purge them once + * their deadline passes, since the new session never sees the old epoch's wraps again. + */ + fun carryExpiring(entries: Collection) { + if (entries.isEmpty()) return + lock.withLock { entries.forEach { trackLocked(it) } } + } + /** True while [channelIdHex]'s buffer holds [wrapId] — for tests of the sweep. */ internal fun isBuffered( channelIdHex: HexKey, @@ -924,7 +1148,9 @@ class ConcordCommunitySession( // An expired message leaves the pinned list too (CORD-08 §3: never display an expired rumor); // its proof is still valid, but the rumor's own tag says it is gone. val hidden = { pin: ConcordPins.VerifiedPin -> isKilled(pin) || pin.tags.isExpirationBefore(now) } - return ConcordPinning.read(_pinHeads.value[channelIdHex], channelIdHex, { pinUnsealKey(channelIdHex, it) }, pinVerifier, hidden, newestEdit) + // Not drained yet: the head may simply not have been served, so the result is marked partial + // (shown, never written from — CORD-04 §7). + return ConcordPinning.read(_pinHeads.value[channelIdHex], channelIdHex, { pinUnsealKey(channelIdHex, it) }, pinVerifier, hidden, newestEdit, complete = _controlDrained.value) } /** @@ -955,5 +1181,11 @@ class ConcordCommunitySession( /** A typing heartbeat is considered current for this many seconds after it's seen. */ const val TYPING_STALE_SECS = 8L + + /** WebXDC signals held per channel (the reference client scans its newest 2000 for peer signals). */ + const val MAX_WEBXDC_PER_CHANNEL = 2000 + + /** How many swept (expired) wrap ids a session remembers to drop their re-deliveries unopened. */ + const val MAX_SWEPT_WRAP_IDS = 4096 } } diff --git a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordDirectInviteInbox.kt b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordDirectInviteInbox.kt index 10e74ca258..fd7cbc13b5 100644 --- a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordDirectInviteInbox.kt +++ b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordDirectInviteInbox.kt @@ -31,8 +31,11 @@ import com.vitorpamplona.quartz.concord.cord05Invites.OpenedDirectInvite import com.vitorpamplona.quartz.nip01Core.core.Event import com.vitorpamplona.quartz.nip01Core.core.HexKey import com.vitorpamplona.quartz.nip01Core.signers.NostrSigner +import com.vitorpamplona.quartz.nip59Giftwrap.rumors.Rumor +import com.vitorpamplona.quartz.nip59Giftwrap.seals.SealEvent import com.vitorpamplona.quartz.nip59Giftwrap.wraps.GiftWrapEvent import com.vitorpamplona.quartz.utils.TimeUtils +import kotlinx.coroutines.CancellationException import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.StateFlow import kotlinx.coroutines.flow.asStateFlow @@ -52,6 +55,12 @@ class ConcordDirectInviteView( val opened: OpenedDirectInvite, val catchUp: Boolean, val expired: Boolean, + /** For a [catchUp]: the ids of the Private Channels it would newly add (not every key it carries). */ + val newChannelIds: List = emptyList(), + /** The rumor's `sentAt` clamped to the time it was ranked, so a future date buys no rank. */ + val clampedSentAt: Long = opened.sentAt, + /** True when this account follows the sender: ranked above strangers. */ + val followedSender: Boolean = false, ) { val wrapId: HexKey get() = opened.wrapId val sender: HexKey get() = opened.sender @@ -60,11 +69,17 @@ class ConcordDirectInviteView( val name: String get() = opened.invite.name val icon: ImagePointer? get() = opened.invite.icon - /** Names of the Private Channels the bundle carries (what a catch-up would add). */ - val channelNames: List get() = - opened.invite.channels - .filter { it.key.isNotBlank() } - .map { it.name } + /** + * Names of the Private Channels a catch-up would newly add — [newChannelIds] only, named by + * [foldedName] (the held community's folded channel name) when it knows the channel, else by the + * bundle's own label. + */ + fun newChannelNames(foldedName: (HexKey) -> String? = { null }): List { + val ids = newChannelIds.mapTo(HashSet()) { it.lowercase() } + return opened.invite.channels + .filter { it.id.lowercase() in ids } + .map { foldedName(it.id)?.takeIf { name -> name.isNotBlank() } ?: it.name } + } } /** What accepting a Direct Invite does; see [ConcordDirectInviteInbox.acceptPlan]. */ @@ -75,9 +90,14 @@ sealed interface DirectInviteAcceptPlan { /** A community we don't hold: run the shared join path. */ data object Join : DirectInviteAcceptPlan - /** A held community: store [entry] — the held one plus the newly granted Private Channel keys. */ + /** + * A held community: store [entry] — the held one plus the newly granted Private Channel keys + * ([channelIds]). A writer re-applies [channelIds] to the entry it reads inside the List write + * ([ConcordInviteVend.adoptCatchUp] with `only`), never [entry] itself, which is a snapshot. + */ class CatchUp( val entry: ConcordCommunityListEntry, + val channelIds: List, ) : DirectInviteAcceptPlan /** A held community the bundle adds nothing to (or can't: a different base, or dissolved). */ @@ -96,23 +116,37 @@ sealed interface DirectInviteAcceptPlan { * Wraps arrive from anywhere — a `{"kinds":[1059],"#p":[me],"#k":["3313"]}` sweep * ([com.vitorpamplona.amethyst.commons.actions.ConcordActions.directInvitesFilter]), or the general * NIP-17 giftwrap pipeline, which honours an untagged invite all the same — and are [offer]ed here. - * The inbox opens each wrap once (two NIP-44 decrypts), dedupes by wrap id, drops a wrap whose NIP-40 - * `expiration` has passed, validates the bundle exactly like a fetched one, and parks it in - * [pending]. **Nothing** else happens: no relay connection, no icon fetch, no Join, until the user - * accepts (the caller's join path) or [decline]s. + * The inbox opens each wrap once (two NIP-44 decrypts; none more when the DM pipeline already + * unsealed it, [offerRumor]), dedupes by wrap id, drops a wrap whose NIP-40 `expiration` has passed, + * validates the bundle exactly like a fetched one, and parks it in [pending]. **Nothing** else + * happens: no relay connection, no icon fetch, no Join, until the user accepts (the caller's join + * path) or [decline]s. * - * Declined wrap ids are remembered ([declined], restorable via [restoreDeclined]) so a re-delivered - * wrap never resurfaces. [newestWrapCreatedAt] is the sweep cursor; query from [since], which - * rewinds it by NIP-59's two-day backdate window. + * A wrap is written off ([seen]) only on a definitive outcome — opened, not an invite for us, or + * expired. A signer that could not answer (timed out, busy, not approved) leaves it to be retried by + * the next delivery or sweep. + * + * Bounded: at most [MAX_PENDING] invites are parked; past it the lowest-ranked one goes (a sender + * [isFollowed] outranks a stranger, then newer outranks older). Invites from senders [isHidden] + * (muted or blocked) are never parked. + * + * Declined wrap ids are remembered ([declined], restorable via [restoreDeclined], at most + * [DECLINED_CAP]) so a re-delivered wrap never resurfaces. [newestWrapCreatedAt] is the sweep cursor; + * query from [since], which rewinds it by NIP-59's two-day backdate window. */ class ConcordDirectInviteInbox( private val signer: NostrSigner, + private val isHidden: (HexKey) -> Boolean = { false }, + private val isFollowed: (HexKey) -> Boolean = { false }, ) { private val mutex = Mutex() - /** Wrap ids already handled this session (opened, refused, or expired), oldest first. */ + /** Wrap ids with a definitive outcome this session (opened, refused, or expired), oldest first. */ private val seen = LinkedHashSet() + /** Wrap ids being opened right now, so a concurrent delivery of the same wrap is not decrypted twice. */ + private val inFlight = HashSet() + private val _pending = MutableStateFlow>(emptyMap()) /** Parked invites by wrap id, as opened. See [visible] for what a UI should show. */ @@ -120,7 +154,7 @@ class ConcordDirectInviteInbox( private val _declined = MutableStateFlow>(emptySet()) - /** Wrap ids the user declined; persisted by the front end so they stay declined across restarts. */ + /** Wrap ids the user declined, oldest first; persisted by the front end so they stay declined across restarts. */ val declined: StateFlow> = _declined.asStateFlow() /** The newest wrap `created_at` offered so far (the sweep cursor), or null on a cold inbox. */ @@ -131,21 +165,27 @@ class ConcordDirectInviteInbox( /** The `since` for the next sweep: the cursor rewound by the backdate window (null = everything). */ fun since(): Long? = ConcordDirectInvite.inboxSince(newestWrapCreatedAt) - /** Replaces the declined set — used to restore it from disk at startup. Drops any pending one. */ - fun restoreDeclined(wrapIds: Set) { - _declined.value = wrapIds - _pending.update { current -> current.filterKeys { it !in wrapIds } } + /** + * Replaces the declined set — used to restore it from disk at startup — keeping the newest + * [DECLINED_CAP]. Drops any pending one. Serialized with [offer] so a restore can't race a park. + */ + suspend fun restoreDeclined(wrapIds: Set) { + mutex.withLock { + _declined.value = bounded(wrapIds) + _pending.update { current -> current.filterKeys { it !in wrapIds } } + } } /** * Considers one kind-1059 [wrap] addressed to us. Returns the parked invite (new or already * pending), or null when it isn't one: not a direct invite for us, a forgery, an invalid - * bundle, an expired handoff, or a wrap the user already declined. Never throws. + * bundle, an expired handoff, a hidden sender, a wrap the user already declined — or a signer + * that could not answer now (retried on the next offer). Never throws but for cancellation. */ suspend fun offer( wrap: Event, nowSecs: Long = TimeUtils.now(), - ): OpenedDirectInvite? = admit(wrap, nowSecs) { ConcordDirectInvite.open(wrap, signer) } + ): OpenedDirectInvite? = admit(wrap, nowSecs) { ConcordDirectInvite.openOrRetry(wrap, signer) } /** * [offer] for a pipeline that already peeled [wrap] down to its kind-13 [seal] (the NIP-17 @@ -156,7 +196,27 @@ class ConcordDirectInviteInbox( wrap: Event, seal: Event, nowSecs: Long = TimeUtils.now(), - ): OpenedDirectInvite? = admit(wrap, nowSecs) { ConcordDirectInvite.openSeal(wrap.id, seal, signer) } + ): OpenedDirectInvite? = admit(wrap, nowSecs) { ConcordDirectInvite.openSealOrRetry(wrap.id, seal, signer) } + + /** + * [offerSeal] for a pipeline that already decrypted [seal] into [rumor] (the rumor as the seal + * carries it, its claimed author intact — [SealEvent.unsealRumorThrowing]): validated without + * any further decrypt. + */ + suspend fun offerRumor( + wrap: Event, + seal: Event, + rumor: Rumor, + nowSecs: Long = TimeUtils.now(), + ): OpenedDirectInvite? = admit(wrap, nowSecs) { ConcordDirectInvite.openRumor(wrap.id, seal, rumor) } + + /** + * Records [wrapId] as definitively not an invite for us (it failed to open for a reason no retry + * changes, or opened to something else), so a sweep that fetches it again skips the decrypt. + */ + suspend fun markNotInvite(wrapId: HexKey) { + mutex.withLock { if (wrapId !in _pending.value) remember(wrapId) } + } private suspend fun admit( wrap: Event, @@ -165,20 +225,54 @@ class ConcordDirectInviteInbox( ): OpenedDirectInvite? { if (wrap.kind != GiftWrapEvent.KIND) return null mutex.withLock { + // The cursor only advances to a time that has happened (plus the skew allowance): a + // future-dated wrap would otherwise push `since` past every invite sent until then. + val stamp = minOf(wrap.createdAt, nowSecs + FUTURE_SKEW_SECS) val newest = newestWrapCreatedAt - if (newest == null || wrap.createdAt > newest) newestWrapCreatedAt = wrap.createdAt + if (newest == null || stamp > newest) newestWrapCreatedAt = stamp _pending.value[wrap.id]?.let { return it } - if (wrap.id in _declined.value || wrap.id in seen) return null - remember(wrap.id) + if (wrap.id in _declined.value || wrap.id in seen || wrap.id in inFlight) return null + inFlight.add(wrap.id) } - // An expired handoff is never decrypted or surfaced (NIP-40 on the wrap mirrors expires_at). - if (ConcordDirectInvite.isWrapExpired(wrap, nowSecs)) return null - val opened = open() ?: return null - mutex.withLock { - if (wrap.id in _declined.value) return null - _pending.update { it + (wrap.id to opened) } + try { + // An expired handoff is never decrypted or surfaced (NIP-40 on the wrap mirrors expires_at). + if (ConcordDirectInvite.isWrapExpired(wrap, nowSecs)) { + mutex.withLock { remember(wrap.id) } + return null + } + val opened = + try { + open() + } catch (e: CancellationException) { + throw e + } catch (_: Exception) { + // The signer could not answer now: not written off, so the next offer retries it. + return null + } + mutex.withLock { + remember(wrap.id) + if (opened == null || wrap.id in _declined.value) return null + // Muted or blocked senders never reach the inbox. + if (isHidden(opened.sender)) return null + _pending.update { park(it, opened, nowSecs) } + } + return _pending.value[wrap.id] + } finally { + mutex.withLock { inFlight.remove(wrap.id) } } - return opened + } + + /** [current] plus [opened], shedding the lowest-ranked invite past [MAX_PENDING]. */ + private fun park( + current: Map, + opened: OpenedDirectInvite, + nowSecs: Long, + ): Map { + val next = current + (opened.wrapId to opened) + if (next.size <= MAX_PENDING) return next + val rank = compareBy({ isFollowed(it.sender) }, { clampedSentAt(it, nowSecs) }, { it.wrapId }) + val drop = next.values.minWithOrNull(rank) ?: return next + return next - drop.wrapId } /** The parked invite behind [wrapId], if any. */ @@ -188,7 +282,7 @@ class ConcordDirectInviteInbox( fun decline(wrapId: HexKey): Boolean { val id = get(wrapId)?.wrapId ?: return false _pending.update { it - id } - _declined.update { it + id } + _declined.update { bounded(it + id) } return true } @@ -209,6 +303,23 @@ class ConcordDirectInviteInbox( /** Cap on remembered wrap ids; the oldest half is shed past it (a sweep re-dedupes deeper). */ const val SEEN_CAP = 4096 + /** Cap on parked invites (the reference client's bound): a flood can't grow the inbox without end. */ + const val MAX_PENDING = 256 + + /** Cap on remembered declines, newest kept: a declined wrap older than that has long expired or been buried. */ + const val DECLINED_CAP = 4096 + + /** Clock skew tolerated on a wrap's `created_at` before it stops moving the sweep cursor. */ + const val FUTURE_SKEW_SECS = 15 * 60L + + private fun bounded(ids: Set): Set = if (ids.size <= DECLINED_CAP) ids else ids.toList().takeLast(DECLINED_CAP).toCollection(LinkedHashSet()) + + /** [opened]'s `sentAt` (the sender's word) clamped to [nowSecs]: a future date buys no rank. */ + fun clampedSentAt( + opened: OpenedDirectInvite, + nowSecs: Long, + ): Long = minOf(opened.sentAt, nowSecs) + /** * What accepting [opened] should do (CORD-05 §6), given the community entry this account * already [held] (if any) and its folded [heldState]: @@ -216,9 +327,11 @@ class ConcordDirectInviteInbox( * - not held → [DirectInviteAcceptPlan.Join] (the shared join path, which still ban-gates * against the community's own Control Plane); * - held on the SAME base with new Private Channel keys → [DirectInviteAcceptPlan.CatchUp], - * the held entry with only those keys merged in — never moving the base (Armada - * `catchUpChannelIds`) — unless the held roster bans [me]; refused while the roster isn't - * folded ([DirectInviteAcceptPlan.RosterNotLoaded]); + * the held entry with only those keys ADDED — never moving the base, never replacing a + * held key (Armada `catchUpChannelIds`) — and only from a sender who is staff in the held + * fold, for channels it knows as live Private Channels + * ([ConcordInviteVend.admissibleCatchUpIds]); refused when the held roster bans [me], and + * while it isn't folded ([DirectInviteAcceptPlan.RosterNotLoaded]); * - held otherwise (nothing new, a different base, dissolved) → [DirectInviteAcceptPlan.NothingNew]. */ fun acceptPlan( @@ -230,49 +343,83 @@ class ConcordDirectInviteInbox( ): DirectInviteAcceptPlan { if (opened.isExpired(nowMs)) return DirectInviteAcceptPlan.Expired if (held == null) return DirectInviteAcceptPlan.Join - val adopted = ConcordInviteVend.adoptCatchUp(held, opened.invite) ?: return DirectInviteAcceptPlan.NothingNew + if (ConcordInviteVend.catchUpChannelIds(held, opened.invite).isEmpty()) return DirectInviteAcceptPlan.NothingNew if (heldState == null) return DirectInviteAcceptPlan.RosterNotLoaded // Death wins every race (CORD-02 §9): a dissolved community takes no new keys. if (heldState.dissolved) return DirectInviteAcceptPlan.NothingNew if (heldState.authority.isBanned(me)) return DirectInviteAcceptPlan.Banned - return DirectInviteAcceptPlan.CatchUp(adopted) + val ids = ConcordInviteVend.admissibleCatchUpIds(held, opened.invite, heldState.authority, heldState.privateChannelIds, opened.sender) + if (ids.isEmpty()) return DirectInviteAcceptPlan.NothingNew + val adopted = ConcordInviteVend.adoptCatchUp(held, opened.invite, ids) ?: return DirectInviteAcceptPlan.NothingNew + return DirectInviteAcceptPlan.CatchUp(adopted, ids) } /** * What a UI shows out of [pending], given the communities this account already holds - * ([joined]): newest first, with + * ([joined]) and the ones it left ([removedAt], community id → the Community List + * tombstone's `removed_at` in unix ms): followed senders first, then newest first, with * - an invite for a community already held on the SAME base that carries a Private Channel * key it lacks kept as a [ConcordDirectInviteView.catchUp]; * - any other invite for a held community (nothing new, or a different base — which may * never move the held one) hidden; - * - one invite per community (newest `sentAt`, ties by wrap id), catch-ups keyed by their + * - an invite sent at or before the user left that community hidden (it would otherwise + * resurface right after leaving; a fresh re-invite still shows — Armada `tombstonedAt`); + * - invites from [isHidden] (muted/blocked) senders hidden; + * - one invite per community and sender (newest clamped `sentAt`, ties by wrap id), so a + * future-dated invite can only ever shadow its own sender's; catch-ups keyed by their * channel set too since each may vend a key no other wrap carries (Armada - * `dedupeParkedInvites`). + * `dedupeParkedInvites`). `sentAt` is the sender's word, so it is clamped to now for both + * ordering and the tombstone check. */ fun visible( pending: Collection, joined: List, nowMs: Long = TimeUtils.nowMillis(), + removedAt: Map = emptyMap(), + isFollowed: (HexKey) -> Boolean = { false }, + isHidden: (HexKey) -> Boolean = { false }, + heldStateOf: (communityId: HexKey) -> ConcordCommunityState? = { null }, ): List { + val nowSecs = nowMs / 1000 val heldById = joined.associateBy { it.id.lowercase() } + val removedById = removedAt.mapKeys { it.key.lowercase() } val byKey = LinkedHashMap() for (opened in pending) { + if (isHidden(opened.sender)) continue val communityId = opened.invite.communityId.lowercase() + val sentAt = clampedSentAt(opened, nowSecs) + val buriedAt = removedById[communityId] + if (buriedAt != null && sentAt * 1000 <= buriedAt) continue val held = heldById[communityId] - val newChannels = ConcordInviteVend.catchUpChannelIds(held, opened.invite) + // For a held community whose fold is in, only what accepting would actually adopt: + // a catch-up from a non-staff sender, for channels the fold doesn't know as Private, + // or into a dissolved community is refused by [acceptPlan], so it is not offered. + val heldState = held?.let { heldStateOf(it.id) } + val newChannels = + when { + held == null -> emptyList() + heldState == null -> ConcordInviteVend.catchUpChannelIds(held, opened.invite) + heldState.dissolved -> emptyList() + else -> ConcordInviteVend.admissibleCatchUpIds(held, opened.invite, heldState.authority, heldState.privateChannelIds, opened.sender) + } if (held != null && newChannels.isEmpty()) continue val catchUp = held != null - val key = if (catchUp) communityId + "|" + newChannels.sorted().joinToString(",") else communityId - val view = ConcordDirectInviteView(opened, catchUp, opened.isExpired(nowMs)) + val base = communityId + "|" + opened.sender.lowercase() + val key = if (catchUp) base + "|" + newChannels.sorted().joinToString(",") else base + val view = ConcordDirectInviteView(opened, catchUp, opened.isExpired(nowMs), newChannels.toList(), sentAt, isFollowed(opened.sender)) val existing = byKey[key] if (existing == null || - opened.sentAt > existing.opened.sentAt || - (opened.sentAt == existing.opened.sentAt && opened.wrapId < existing.opened.wrapId) + sentAt > existing.clampedSentAt || + (sentAt == existing.clampedSentAt && opened.wrapId < existing.opened.wrapId) ) { byKey[key] = view } } - return byKey.values.sortedWith(compareByDescending { it.opened.sentAt }.thenBy { it.wrapId }) + return byKey.values.sortedWith( + compareByDescending { it.followedSender } + .thenByDescending { it.clampedSentAt } + .thenBy { it.wrapId }, + ) } } } diff --git a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordKickNotice.kt b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordKickNotice.kt new file mode 100644 index 0000000000..36f2290718 --- /dev/null +++ b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordKickNotice.kt @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2025 Vitor Pamplona + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the + * Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR + * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ +package com.vitorpamplona.amethyst.commons.model.concord + +import com.vitorpamplona.quartz.nip01Core.core.HexKey + +/** + * This account complied with an honored Kick (CORD-04 §6) and left [communityId] locally. + * [communityName] is the folded name at the time (null when unnamed), for the user notice; + * [kickedBy] is the kicker. A Kick is re-joinable: a new invite brings the member back. + */ +class ConcordKickNotice( + val communityId: String, + val communityName: String?, + val kickedBy: HexKey, +) diff --git a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordPinDutyScheduler.kt b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordPinDutyScheduler.kt new file mode 100644 index 0000000000..771e3936f4 --- /dev/null +++ b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordPinDutyScheduler.kt @@ -0,0 +1,96 @@ +/* + * Copyright (c) 2025 Vitor Pamplona + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the + * Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR + * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ +package com.vitorpamplona.amethyst.commons.model.concord + +import com.vitorpamplona.amethyst.commons.actions.ConcordChannelPins +import com.vitorpamplona.amethyst.commons.actions.ConcordPinning +import com.vitorpamplona.amethyst.commons.util.KmpLock +import com.vitorpamplona.amethyst.commons.util.withLock +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Job +import kotlinx.coroutines.delay +import kotlinx.coroutines.launch + +/** + * Runs the delayed Pin List duties a PIN_MESSAGES holder owes keyless readers (CORD-04 §7) — the + * deletion omission and the Edit refresh — from the account, not from an open channel screen, so a + * debt is settled whether or not anyone is looking at the channel. + * + * Rate-limited the way the spec asks: each duty waits a short random delay + * ([ConcordPinning.dutyDelayMs], 3–15 s) and the caller's settle re-reads before publishing, so + * simultaneous curators collapse to one publisher and a burst of deletes or edits costs one write; + * at most one duty per channel is in flight; and each distinct debt is attempted **once**, so a + * write that keeps failing never spins. A new debt (another delete, a newer Edit) is a new attempt. + */ +class ConcordPinDutyScheduler( + private val delayMs: () -> Long = { ConcordPinning.dutyDelayMs() }, +) { + private val lock = KmpLock() + + // Channel key -> the debt last attempted there. + private val attempted = HashMap() + + // Channel key -> its duty in flight. + private val inFlight = HashMap() + + /** + * Schedules [settle] in [scope] for the channel [key] when [debt] is non-null, was not attempted + * yet, and no duty for [key] is in flight. Returns whether it scheduled one. + */ + fun schedule( + scope: CoroutineScope, + key: String, + debt: String?, + settle: suspend () -> Unit, + ): Boolean { + if (debt == null) return false + return lock.withLock { + if (attempted[key] == debt || inFlight[key]?.isActive == true) return@withLock false + attempted[key] = debt + inFlight[key] = + scope.launch { + delay(delayMs()) + try { + settle() + } finally { + lock.withLock { inFlight.remove(key) } + } + } + true + } + } + + companion object { + /** The identity of what [pins] owes (its erased entries and the Edits to attach), or null when nothing. */ + fun debtOf(pins: ConcordChannelPins?): String? { + if (pins == null || !pins.owesRepublish) return null + return (pins.killed.map { "d" + it.rumorId } + pins.pins.mapNotNull { p -> p.newerEdit?.let { "e" + it.rumorId } }) + .sorted() + .joinToString("|") + } + + /** The scheduler key of one channel. */ + fun keyOf( + communityId: String, + channelIdHex: String, + ): String = "$communityId|$channelIdHex" + } +} diff --git a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordSessionManager.kt b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordSessionManager.kt index 82c43a895e..05b886afde 100644 --- a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordSessionManager.kt +++ b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordSessionManager.kt @@ -79,6 +79,9 @@ class ConcordSessionManager( */ val nextExpiry: StateFlow = _nextExpiry + // Guards the compute-and-assign of [nextExpiry]. Declared before `init` for the same reason. + private val expiryLock = KmpLock() + private val lock = KmpLock() private val stateWatchers = HashMap() // communityId -> state collector @@ -118,7 +121,11 @@ class ConcordSessionManager( } private fun recomputeNextExpiry() { - _nextExpiry.value = registry.sessions().mapNotNull { it.nextExpiry.value }.minOrNull() + // Computed and assigned under one lock: two watchers racing could otherwise let a slower, + // staler computation overwrite an earlier deadline, and the sweep would sleep past it. + expiryLock.withLock { + _nextExpiry.value = registry.sessions().mapNotNull { it.nextExpiry.value }.minOrNull() + } } /** diff --git a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordSessionRegistry.kt b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordSessionRegistry.kt index 3ae9882837..a38341d551 100644 --- a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordSessionRegistry.kt +++ b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordSessionRegistry.kt @@ -76,7 +76,10 @@ class ConcordSessionRegistry( for ((id, entry) in wanted) { val existing = sessions[id] if (existing == null || existing.entry.root != entry.root || existing.entry.rootEpoch != entry.rootEpoch) { - sessions[id] = ConcordCommunitySession(entry, myPubKey, onRumor) + // CORD-08 §3: the disappearing messages the old session tracked are already in the + // store, and the new session never sees their wraps again — carry their deadlines + // over, or nothing would ever purge them. + sessions[id] = ConcordCommunitySession(entry, myPubKey, onRumor).also { fresh -> existing?.let { fresh.carryExpiring(it.trackedExpiring()) } } created += id } else { // Same epoch, but the Control Plane write key may have just arrived — a diff --git a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/service/http/EncryptionKeyCache.kt b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/service/http/EncryptionKeyCache.kt index 0776c12eb4..8312fff7ee 100644 --- a/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/service/http/EncryptionKeyCache.kt +++ b/commons/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/service/http/EncryptionKeyCache.kt @@ -49,6 +49,11 @@ class EncryptionKeyCache { ) = add(url, DecryptInformation(cipher, expectedMimeType)) fun get(url: String): DecryptInformation? = cache.get(url) + + /** Forgets [url]'s key, e.g. when the message that carried it expired (CORD-08). */ + fun remove(url: String) { + cache.remove(url) + } } class DecryptInformation( diff --git a/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/actions/ConcordInviteRegistryPublishTest.kt b/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/actions/ConcordInviteRegistryPublishTest.kt index 2ae9fbd741..982138608a 100644 --- a/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/actions/ConcordInviteRegistryPublishTest.kt +++ b/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/actions/ConcordInviteRegistryPublishTest.kt @@ -118,4 +118,30 @@ class ConcordInviteRegistryPublishTest { add(ConcordModeration.setInviteRegistry(inviter, cp, cid, emptyList(), editions, createdAt = 7L, owner = community.ownerPubKey)) assertFalse(fold().isPublic) } + + @Test + fun aRegistryEditChainsOntoTheFloorAwareHeadAcrossARefounding() = + runTest { + // The prior epoch reached v2 of the owner's registry; the current epoch has not (yet) + // re-wrapped it, so the honored head is the floor, not "no registry". + val community = ConcordCommunityFactory.create(owner, "Nostrichs", createdAt = 1L, relays = listOf("wss://r.example")) + val cp = community.controlPlane + val cid = community.communityId + val prior = ConcordActions.controlEditions(community.genesisWraps, cp).toMutableList() + prior += ConcordActions.controlEditions(listOf(ConcordModeration.setInviteRegistry(owner, cp, cid, listOf(link1), prior, 2L, owner = community.ownerPubKey)), cp) + prior += ConcordActions.controlEditions(listOf(ConcordModeration.setInviteRegistry(owner, cp, cid, listOf(link1, link2), prior, 3L, owner = community.ownerPubKey)), cp) + val v2 = prior.last() + assertEquals(2L, v2.version) + val floors = ConcordCommunityState.authorizedHeads(prior, cid, community.ownerPubKey) + + val current = ConcordActions.controlEditions(community.genesisWraps, cp) + val naive = ConcordActions.controlEditions(listOf(ConcordModeration.setInviteRegistry(owner, cp, cid, listOf(link2), current, 4L, owner = community.ownerPubKey)), cp).single() + assertEquals(1L, naive.version, "ignoring the floor forks a fresh v1 below the honored v2") + + val chained = ConcordActions.controlEditions(listOf(ConcordModeration.setInviteRegistry(owner, cp, cid, listOf(link2), current, 4L, owner = community.ownerPubKey, floors = floors)), cp).single() + assertEquals(3L, chained.version) + assertEquals(v2.hashHex, chained.prevHash?.toHexKey()) + // And the fold with the same floors honors it. + assertEquals(listOf(link2), ConcordCommunityState.fold(current + chained, cid, community.ownerPubKey, floors).registryOf(owner.pubKey)) + } } diff --git a/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/actions/ConcordPinnedMediaTest.kt b/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/actions/ConcordPinnedMediaTest.kt new file mode 100644 index 0000000000..03faa5545d --- /dev/null +++ b/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/actions/ConcordPinnedMediaTest.kt @@ -0,0 +1,113 @@ +/* + * Copyright (c) 2025 Vitor Pamplona + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the + * Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR + * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ +package com.vitorpamplona.amethyst.commons.actions + +import com.vitorpamplona.amethyst.commons.model.concord.ConcordCommunitySession +import com.vitorpamplona.amethyst.commons.model.nip92IMeta.appendMissingImetaUrls +import com.vitorpamplona.quartz.concord.cord02Community.ConcordCommunityFactory +import com.vitorpamplona.quartz.concord.cord02Community.ConcordCommunityListEntry +import com.vitorpamplona.quartz.concord.cord03Channels.ChannelChat +import com.vitorpamplona.quartz.nip01Core.core.Event +import com.vitorpamplona.quartz.nip01Core.core.toHexKey +import com.vitorpamplona.quartz.nip01Core.crypto.KeyPair +import com.vitorpamplona.quartz.nip01Core.signers.NostrSignerInternal +import com.vitorpamplona.quartz.utils.ciphers.AESGCM +import kotlinx.coroutines.test.runTest +import kotlin.test.Test +import kotlin.test.assertContentEquals +import kotlin.test.assertEquals +import kotlin.test.assertNotNull + +/** + * A pinned message carrying an encrypted attachment renders like the feed message it pins (CORD-04 §7 + * SHOULD): the rumor rebuilt from the verified proof keeps the `imeta` tags — so the attachment's + * decryption key reaches the media pipeline even when this account never held the message — and an + * attachment-only message still gets its URL as text, as the feed gives it. + */ +class ConcordPinnedMediaTest { + private val owner = NostrSignerInternal(KeyPair()) + private val alice = NostrSignerInternal(KeyPair()) + + @Test + fun aPinnedImageKeepsItsEncryptedAttachment() = + runTest { + val community = ConcordCommunityFactory.create(owner, "Nostrichs", createdAt = 1L, relays = listOf("wss://r.example")) + val entry = + ConcordCommunityListEntry( + id = community.communityIdHex, + owner = community.ownerPubKey, + ownerSalt = community.ownerSalt.toHexKey(), + root = community.communityRoot.toHexKey(), + rootEpoch = community.rootEpoch, + controlPk = community.controlPkHex, + controlRoot = community.controlRoot.toHexKey(), + relays = listOf("wss://r.example"), + name = "Nostrichs", + ) + val rumors = mutableListOf() + val session = ConcordCommunitySession(entry, owner.pubKey) { _, _, rumor, _ -> rumors += rumor } + community.genesisWraps.forEach { session.ingest(it) } + // The genesis wraps are the whole plane; pin writes wait for a drained fold (CORD-04 §7). + session.markControlDrained() + val general = community.generalChannelIdHex + val plane = assertNotNull(session.currentChannelPlane(general)) + + val url = "https://blossom.example/ciphertext.bin" + val cipher = AESGCM(ByteArray(32) { 0x11 }, ByteArray(16) { 0x22 }) + val imeta = ChannelChat.encryptedImageImeta(url, "image/jpeg", "800x600", null, cipher, "aa".repeat(32)) + // An attachment-only message: empty words, the image only in its imeta (Armada allows it). + session.ingest(ConcordActions.buildChannelImageMessage(alice, plane.key, general, plane.epoch, "", listOf(imeta), 10L)) + val message = rumors.last() + + fun ctx(pins: ConcordChannelPins) = + ConcordPinContext( + actor = owner, + controlPlane = session.controlPlaneKeys(), + communityId = community.communityId, + owner = community.ownerPubKey, + current = session.controlEditions(), + channelIdHex = general, + channelIsPrivate = false, + currentPlane = plane, + pins = pins, + authorized = true, + ) + + val evidence = ConcordPinEvidence(rumors) + val before = assertNotNull(session.readPins(general, evidence::isKilled, evidence::newestEdit)) + val write = ConcordPinning.pin(ctx(before), assertNotNull(session.pinSource(general, message.id)), 11L) + session.ingest(assertNotNull(write.wrap)) + + val pinned = assertNotNull(session.readPins(general, evidence::isKilled, evidence::newestEdit)).pins.single() + val rumor = pinned.toRumor() + assertEquals(message.id, rumor.id) + assertEquals(alice.pubKey, rumor.pubKey) + + val attachment = ChannelChat.encryptedImagesOf(rumor).single() + assertEquals(url, attachment.url) + assertContentEquals(cipher.keyBytes, attachment.key) + assertContentEquals(cipher.nonce, attachment.nonce) + // The words carry the ciphertext URL (Armada's assembly), so the shared renderer shows it. + assertEquals(url, rumor.content) + // A client that sent only the imeta (empty words) still renders it: the feed's fallback. + assertEquals(url, appendMissingImetaUrls("", rumor)) + } +} diff --git a/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/actions/ConcordPinningTest.kt b/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/actions/ConcordPinningTest.kt index 18fbf29889..f83af59cd1 100644 --- a/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/actions/ConcordPinningTest.kt +++ b/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/actions/ConcordPinningTest.kt @@ -76,9 +76,10 @@ class ConcordPinningTest { val community: NewConcordCommunity, entry: ConcordCommunityListEntry, me: HexKey, + drained: Boolean = true, ) { val rumors = mutableListOf() - val session = ConcordCommunitySession(entry, me) { _, _, rumor, _ -> rumors += rumor } + val session = ConcordCommunitySession(entry, me) { _, _, rumor, _ -> rumors += rumor }.also { if (drained) it.markControlDrained() } fun pins(channelIdHex: HexKey) = ConcordPinEvidence(rumors).let { evidence -> assertNotNull(session.readPins(channelIdHex, evidence::isKilled, evidence::newestEdit)) } @@ -139,6 +140,60 @@ class ConcordPinningTest { return h } + @Test + fun noPinWriteIsBuiltBeforeTheControlPlaneHasDrained() = + runTest { + val h = harness() + val general = h.community.generalChannelIdHex + val message = h.post(alice, general, "ship it", 10L) + assertEquals(ConcordPinOutcome.PUBLISHED, h.pin(owner, general, message, 11L).outcome) + + // A second device that has folded only part of the plane: here the genesis without the pin. + val partial = Harness(h.community, entryFor(h.community), owner.pubKey, drained = false) + h.community.genesisWraps.forEach { partial.session.ingest(it) } + val read = partial.pins(general) + assertFalse(read.complete, "no head yet reads as not-yet-served, not as an empty list") + assertNull(read.head) + + // A replace-entire write from that read would erase the pin it never saw (§7). + val refused = ConcordPinning.unpin(partial.ctx(owner, general), message.id, 12L) + assertEquals(ConcordPinOutcome.NOT_FOLDED, refused.outcome) + assertNull(refused.wrap) + + // Once the plane is drained (the pin landed), writes proceed from the full list. + h.session.controlPlaneWraps().forEach { partial.session.ingest(it) } + partial.session.markControlDrained() + assertTrue(partial.pins(general).complete) + assertEquals(ConcordPinOutcome.PUBLISHED, ConcordPinning.unpin(partial.ctx(owner, general), message.id, 12L).outcome) + } + + @Test + fun aPinThatLosesAConcurrentTieReappliesOnTopOfTheWinner() = + runTest { + val h = harness() + val general = h.community.generalChannelIdHex + val one = h.post(alice, general, "one", 10L) + val two = h.post(alice, general, "two", 11L) + + // Two curators read the same (empty) head and each write v1 at once. + val ctx = h.ctx(owner, general) + val a = ConcordPinning.pin(ctx, h.session.pinSource(general, one.id)!!, 12L) + val b = ConcordPinning.pin(ctx, h.session.pinSource(general, two.id)!!, 12L) + h.session.ingest(a.wrap!!) + h.session.ingest(b.wrap!!) + val folded = h.pins(general) + assertTrue(folded.isPinned(one.id) xor folded.isPinned(two.id), "one edition wins the tie, the other's pin is gone") + val loser = if (folded.isPinned(one.id)) two else one + + // The re-heal: the loser runs its write again on the refolded head, chaining onto the winner. + val heal = ConcordPinning.pin(h.ctx(owner, general), h.session.pinSource(general, loser.id)!!, 13L) + assertEquals(ConcordPinOutcome.PUBLISHED, heal.outcome) + h.session.ingest(heal.wrap!!) + val healed = h.pins(general) + assertTrue(healed.isPinned(one.id) && healed.isPinned(two.id)) + assertEquals(2L, healed.head!!.version) + } + @Test fun aPinRoundTripsThroughTheControlPlaneAndUnpinRemovesIt() = runTest { diff --git a/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/actions/ConcordPrivateChannelsTest.kt b/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/actions/ConcordPrivateChannelsTest.kt new file mode 100644 index 0000000000..c6355c62c4 --- /dev/null +++ b/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/actions/ConcordPrivateChannelsTest.kt @@ -0,0 +1,237 @@ +/* + * Copyright (c) 2025 Vitor Pamplona + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the + * Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR + * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ +package com.vitorpamplona.amethyst.commons.actions + +import com.vitorpamplona.amethyst.commons.model.ConcordDirectInviteDraft +import com.vitorpamplona.amethyst.commons.model.concord.ConcordCommunitySession +import com.vitorpamplona.amethyst.commons.model.concord.ConcordIngestOutcome +import com.vitorpamplona.quartz.concord.cord02Community.ConcordCommunityFactory +import com.vitorpamplona.quartz.concord.cord02Community.ConcordCommunityListEntry +import com.vitorpamplona.quartz.concord.cord02Community.ConcordCommunityState +import com.vitorpamplona.quartz.concord.cord02Community.NewConcordCommunity +import com.vitorpamplona.quartz.concord.cord02Community.PrivateChannelKey +import com.vitorpamplona.quartz.concord.cord03Channels.ConcordChannelKeyring +import com.vitorpamplona.quartz.concord.cord04Roles.ControlEdition +import com.vitorpamplona.quartz.concord.cord05Invites.ConcordInviteVend +import com.vitorpamplona.quartz.concord.cord06Rekey.ChannelRekeyOutcome +import com.vitorpamplona.quartz.concord.cord06Rekey.ConcordChannelRekey +import com.vitorpamplona.quartz.nip01Core.core.Event +import com.vitorpamplona.quartz.nip01Core.core.hexToByteArray +import com.vitorpamplona.quartz.nip01Core.core.toHexKey +import com.vitorpamplona.quartz.nip01Core.crypto.KeyPair +import com.vitorpamplona.quartz.nip01Core.signers.NostrSignerInternal +import kotlinx.coroutines.test.runTest +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFalse +import kotlin.test.assertIs +import kotlin.test.assertNotNull +import kotlin.test.assertNull +import kotlin.test.assertTrue + +/** + * Private Channels end to end, headless (CORD-03 §1-2, CORD-04 §2, CORD-05 §6, CORD-06 §1-2): create + * with an access Role, vend on grant through a Direct Invite limited to the gained channel, the + * recipient's click-free adoption, rotate on revoke to the remaining entitled set, and each member's + * receive (the kept adopts, the cut drops the key and records the cut). Plus privatise/publicise. + */ +class ConcordPrivateChannelsTest { + private val owner = NostrSignerInternal(KeyPair()) + private val alice = NostrSignerInternal(KeyPair()) + private val bob = NostrSignerInternal(KeyPair()) + + private class World( + val community: NewConcordCommunity, + val editions: MutableList, + ) { + fun add(wrap: Event) { + editions += ConcordActions.controlEditions(listOf(wrap), community.controlPlane) + } + + fun state(): ConcordCommunityState = ConcordCommunityState.fold(editions, community.communityId, community.ownerPubKey) + } + + private suspend fun world(): World { + val c = ConcordCommunityFactory.create(owner, "Nostrichs", createdAt = 1L, relays = listOf("wss://relay.example")) + return World(c, ConcordActions.controlEditions(c.genesisWraps, c.controlPlane).toMutableList()) + } + + private fun entryOf( + c: NewConcordCommunity, + channels: List = emptyList(), + ) = ConcordCommunityListEntry( + id = c.communityIdHex, + owner = c.ownerPubKey, + ownerSalt = c.ownerSalt.toHexKey(), + root = c.communityRoot.toHexKey(), + rootEpoch = c.rootEpoch, + controlPk = c.controlPkHex, + privateChannels = channels, + relays = listOf("wss://relay.example"), + name = "Nostrichs", + addedAt = 1_000L, + ) + + @Test + fun aPrivateChannelIsVendedOnGrantAndRotatedOnRevoke() = + runTest { + val w = world() + val c = w.community + val cid = c.communityId + + // 1. Create: an access Role at the bottom of the roster, the channel flagged private, a key at epoch 0. + val build = assertNotNull(ConcordPrivateChannels.create(owner, c.controlPlane, cid, "mods", null, w.editions, w.state().authority, c.ownerPubKey, 2L)) + build.wraps.forEach { w.add(it) } + val ch = build.channelIdHex + assertEquals(0L, build.key.epoch) + assertTrue(ch in w.state().privateChannelIds) + val role = assertNotNull(w.state().roles[build.roleIdHex]) + assertEquals("channel", role.scope?.kind) + assertEquals(ch, role.scope?.channelId) + assertEquals("0", role.permissions) + val ownerEntry = assertNotNull(ConcordChannelKeyring.withChannelKey(entryOf(c), build.key)) + + // 2. Grant alice and bob the access Role: both gained the channel. + val beforeGrant = w.state().authority + w.add(ConcordModeration.grant(owner, c.controlPlane, cid, alice.pubKey, listOf(build.roleIdHex), w.editions, 3L, owner = c.ownerPubKey)) + w.add(ConcordModeration.grant(owner, c.controlPlane, cid, bob.pubKey, listOf(build.roleIdHex), w.editions, 3L, owner = c.ownerPubKey)) + val granted = ConcordInviteVend.accessChanges(beforeGrant, w.state().authority, w.state().privateChannelIds).single() + assertEquals(setOf(alice.pubKey, bob.pubKey), granted.gained) + + // 3. Vend: a Direct Invite limited to the gained channel, from staff, adopted by alice without a click. + val draft = assertIs(ConcordActions.draftDirectInvite(ownerEntry, w.state(), owner.pubKey, alice.pubKey, onlyChannelIds = setOf(ch))) + assertEquals(listOf(ch), draft.invite.channels.map { it.id }) + val aliceHeld = entryOf(c) + assertEquals( + ConcordInviteVend.CatchUpVerdict.ADOPT, + ConcordInviteVend.judgeCatchUp(w.state().authority, w.state().privateChannelIds, alice.pubKey, owner.pubKey, draft.invite, aliceHeld), + ) + val aliceEntry = assertNotNull(ConcordInviteVend.adoptCatchUp(aliceHeld, draft.invite)) + val bobEntry = assertNotNull(ConcordChannelKeyring.withChannelKey(entryOf(c), build.key)) + assertEquals(build.key.key, ConcordChannelKeyring.heldKey(aliceEntry, ch)?.key) + + // 4. Revoke bob: he lost the channel, so the owner rotates it to the remaining entitled set. + val beforeRevoke = w.state().authority + w.add(ConcordModeration.grant(owner, c.controlPlane, cid, bob.pubKey, emptyList(), w.editions, 4L, owner = c.ownerPubKey)) + val revoked = ConcordInviteVend.accessChanges(beforeRevoke, w.state().authority, w.state().privateChannelIds).single() + assertEquals(setOf(bob.pubKey), revoked.lost) + val keep = ConcordPrivateChannels.keepSet(w.state().authority, ch, owner.pubKey) + assertEquals(setOf(owner.pubKey, alice.pubKey), keep) + assertTrue(ConcordPrivateChannels.canRotate(w.state().authority, owner.pubKey, revoked.lost)) + // A plain member can't rotate anyone out. + assertFalse(ConcordPrivateChannels.canRotate(w.state().authority, alice.pubKey, setOf(bob.pubKey))) + + val newKey = ConcordChannelRekey.mintKey() + val held = assertNotNull(ConcordChannelKeyring.heldKey(ownerEntry, ch)) + val wraps = ConcordPrivateChannels.buildRotation(owner, c.communityRoot, held, newKey, keep, 5L, authority = null) + + // 5. Receive: alice adopts epoch 1, bob is cut and the cut is recorded. + val aliceOut = ConcordPrivateChannels.receive(aliceEntry, wraps, w.editions, w.state().authority, alice) + val adopted = assertIs(aliceOut[ch]) + assertEquals(1L, adopted.epoch) + val aliceNext = assertNotNull(ConcordPrivateChannels.applyOutcome(aliceEntry, aliceOut, mapOf(ch to 0L))) + assertEquals(newKey.toHexKey(), ConcordChannelKeyring.heldKey(aliceNext, ch)?.key) + assertEquals(1L, ConcordChannelKeyring.heldKey(aliceNext, ch)?.epoch) + + val bobOut = ConcordPrivateChannels.receive(bobEntry, wraps, w.editions, w.state().authority, bob) + assertEquals(1L, assertIs(bobOut[ch]).epoch) + val bobNext = assertNotNull(ConcordPrivateChannels.applyOutcome(bobEntry, bobOut, mapOf(ch to 0L))) + assertNull(ConcordChannelKeyring.heldKey(bobNext, ch)) + assertEquals(mapOf(ch to 1L), ConcordChannelKeyring.cutsOf(bobNext)) + // The stale epoch-0 key can't come back through a bundle. + assertTrue(ConcordInviteVend.catchUpChannelIds(bobNext, draft.invite).isEmpty()) + + // A result computed from a stale epoch never rolls the List back. + assertNull(ConcordPrivateChannels.applyOutcome(aliceNext, aliceOut, mapOf(ch to 0L))) + } + + @Test + fun aRotationFromAMemberWithoutAuthorityIsIgnored() = + runTest { + val w = world() + val c = w.community + val build = assertNotNull(ConcordPrivateChannels.create(owner, c.controlPlane, c.communityId, "mods", null, w.editions, w.state().authority, c.ownerPubKey, 2L)) + build.wraps.forEach { w.add(it) } + w.add(ConcordModeration.grant(owner, c.controlPlane, c.communityId, alice.pubKey, listOf(build.roleIdHex), w.editions, 3L, owner = c.ownerPubKey)) + w.add(ConcordModeration.grant(owner, c.controlPlane, c.communityId, bob.pubKey, listOf(build.roleIdHex), w.editions, 3L, owner = c.ownerPubKey)) + val aliceEntry = assertNotNull(ConcordChannelKeyring.withChannelKey(entryOf(c), build.key)) + + // Bob holds the key but no MANAGE_CHANNELS: holding a key is never authority (CORD-06 §3). + val forged = ConcordPrivateChannels.buildRotation(bob, c.communityRoot, build.key, ConcordChannelRekey.mintKey(), setOf(bob.pubKey), 5L, authority = null) + assertTrue(ConcordPrivateChannels.receive(aliceEntry, forged, w.editions, w.state().authority, alice).isEmpty()) + } + + @Test + fun aSessionWatchesAndBuffersItsChannelRekeys() = + runTest { + val c = world().community + val chId = ByteArray(32) { 0x5C } + val key = PrivateChannelKey(chId.toHexKey(), "10".repeat(32), 3, "mods") + val entry = entryOf(c, listOf(key)) + val session = ConcordCommunitySession(entry, alice.pubKey) + + // The next LOOKAHEAD channel epochs past the held one, under the current root. + val next = ConcordChannelRekey.address(c.communityRoot, chId, 4).publicKeyHex + assertTrue(next in session.channelRekeyAddresses()) + assertTrue(ConcordChannelRekey.address(c.communityRoot, chId, 3 + ConcordChannelRekey.LOOKAHEAD.toLong()).publicKeyHex in session.channelRekeyAddresses()) + assertFalse(ConcordChannelRekey.address(c.communityRoot, chId, 3).publicKeyHex in session.channelRekeyAddresses()) + assertTrue(session.ownsPlane(next)) + // Also subscribed with the auxiliary planes. + assertTrue(ConcordSubscriptionPlanner.auxiliaryPlaneSubs(listOf(entry)).any { it.pubKeyHex == next }) + + val wraps = ConcordPrivateChannels.buildRotation(owner, c.communityRoot, key, ConcordChannelRekey.mintKey(), setOf(alice.pubKey), 5L, null) + assertEquals(ConcordIngestOutcome.STRUCTURAL, session.ingest(wraps.single())) + assertEquals(ConcordIngestOutcome.NON_STRUCTURAL, session.ingest(wraps.single())) + assertEquals(listOf(wraps.single().id), session.pendingChannelRekeyWraps().map { it.id }) + } + + @Test + fun privatizeClimbsTheChannelEpochAndPublicizeFlipsTheFlagBack() = + runTest { + val w = world() + val c = w.community + val general = c.generalChannelIdHex + val standing = assertNotNull(w.state().channels[general]).definition + assertFalse(standing.private) + + val build = assertNotNull(ConcordPrivateChannels.privatize(owner, c.controlPlane, entryOf(c), general, standing, "insiders", w.editions, w.state().authority, 2L)) + build.wraps.forEach { w.add(it) } + // The first privatisation is epoch 1 (CORD-03 §2); a floor seen on the wire lifts it. + assertEquals(1L, build.key.epoch) + assertTrue(general in w.state().privateChannelIds) + assertEquals("insiders", w.state().roles[build.roleIdHex]?.name) + val later = assertNotNull(ConcordPrivateChannels.privatize(owner, c.controlPlane, entryOf(c), general, standing, null, w.editions, w.state().authority, 2L, observedFloor = 4)) + assertEquals(5L, later.key.epoch) + // Already private: nothing to do. + assertNull(ConcordPrivateChannels.privatize(owner, c.controlPlane, entryOf(c), general, w.state().channels[general]!!.definition, null, w.editions, w.state().authority, 2L)) + + val flip = assertNotNull(ConcordPrivateChannels.publicize(owner, c.controlPlane, c.communityId, general, w.state().channels[general]!!.definition, w.editions, c.ownerPubKey, 3L)) + w.add(flip) + assertFalse(general in w.state().privateChannelIds) + // The held private-era key keeps reading its history once the channel is public again. + val heldEntry = assertNotNull(ConcordChannelKeyring.withChannelKey(entryOf(c), build.key)) + val planes = ConcordActions.historicalChannelPlanes(heldEntry, general, isPrivate = false) + assertTrue(planes.any { it.epoch == 1L }) + // And the next privatisation climbs past it. + assertEquals(2L, ConcordChannelKeyring.nextChannelEpoch(heldEntry, general)) + assertTrue(general.hexToByteArray().size == 32) + } +} diff --git a/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordCommunitySessionTest.kt b/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordCommunitySessionTest.kt index dd56764a26..2a4178d508 100644 --- a/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordCommunitySessionTest.kt +++ b/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordCommunitySessionTest.kt @@ -200,4 +200,24 @@ class ConcordCommunitySessionTest { community.genesisWraps.forEach { session.ingest(it) } assertTrue(session.state.value!!.dissolved) } + + @Test + fun noWriteIsBuiltFromAFoldThatHasNotDrained() = + runTest { + val community = ConcordCommunityFactory.create(owner, "Nostrichs", createdAt = 1L, relays = listOf("wss://r.example")) + val session = ConcordCommunitySession(entryFor(community), owner.pubKey) + assertEquals(null, session.foldForWrite(), "nothing folded") + + // The live subscription delivered part of the plane: readable, but not a base for a write. + session.ingest(community.genesisWraps.first()) + assertTrue(session.state.value != null) + assertFalse(session.controlDrained.value) + assertEquals(null, session.foldForWrite()) + + // The sweep paged the whole plane in and flagged it: writes may chain onto this fold. + community.genesisWraps.forEach { session.ingest(it) } + session.markControlDrained() + assertEquals(session.state.value, session.foldForWrite()) + assertTrue(session.controlFloors().isEmpty(), "no prior epoch held, no floor") + } } diff --git a/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordDirectInviteInboxTest.kt b/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordDirectInviteInboxTest.kt index d50201fabb..372c3e7ff7 100644 --- a/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordDirectInviteInboxTest.kt +++ b/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordDirectInviteInboxTest.kt @@ -27,11 +27,20 @@ import com.vitorpamplona.quartz.concord.cord02Community.ConcordCommunityListEntr import com.vitorpamplona.quartz.concord.cord02Community.ConcordCommunityState import com.vitorpamplona.quartz.concord.cord02Community.NewConcordCommunity import com.vitorpamplona.quartz.concord.cord02Community.PrivateChannelKey +import com.vitorpamplona.quartz.concord.cord04Roles.ChannelEntity import com.vitorpamplona.quartz.concord.cord05Invites.CommunityInvite import com.vitorpamplona.quartz.concord.cord05Invites.InviteChannel +import com.vitorpamplona.quartz.nip01Core.core.Event +import com.vitorpamplona.quartz.nip01Core.core.HexKey +import com.vitorpamplona.quartz.nip01Core.core.hexToByteArray import com.vitorpamplona.quartz.nip01Core.core.toHexKey import com.vitorpamplona.quartz.nip01Core.crypto.KeyPair +import com.vitorpamplona.quartz.nip01Core.signers.NostrSigner import com.vitorpamplona.quartz.nip01Core.signers.NostrSignerInternal +import com.vitorpamplona.quartz.nip01Core.signers.SignerExceptions +import com.vitorpamplona.quartz.nip57Zaps.PrivateZapEvent +import com.vitorpamplona.quartz.nip57Zaps.ZapRequestEvent +import com.vitorpamplona.quartz.nip59Giftwrap.rumors.Rumor import com.vitorpamplona.quartz.nip59Giftwrap.seals.SealEvent import kotlinx.coroutines.test.runTest import kotlin.test.Test @@ -91,6 +100,13 @@ class ConcordDirectInviteInboxTest { private fun stateOf(c: NewConcordCommunity): ConcordCommunityState = ConcordCommunityState.fold(ConcordActions.controlEditions(c.genesisWraps, c.controlPlane), c.communityId, c.ownerPubKey) + /** [c]'s fold with [vip] defined as a live Private Channel. */ + private suspend fun stateWithVip(c: NewConcordCommunity): ConcordCommunityState { + val editions = ConcordActions.controlEditions(c.genesisWraps, c.controlPlane).toMutableList() + editions += ConcordActions.controlEditions(listOf(ConcordModeration.defineChannel(owner, c.controlPlane, c.communityId, vip.hexToByteArray(), ChannelEntity(name = "vip", private = true), editions, createdAt = 2L, owner = c.ownerPubKey)), c.controlPlane) + return ConcordCommunityState.fold(editions, c.communityId, c.ownerPubKey) + } + @Test fun aValidWrapIsParkedWithItsVerifiedSenderAndDedupedByWrapId() = runTest { @@ -138,6 +154,30 @@ class ConcordDirectInviteInboxTest { assertSame(opened, inbox.offer(wrap)) } + @Test + fun theDmPipelineRumorPathParksWithoutAnotherDecryptAndTheSweepSkipsIt() = + runTest { + val c = community() + val counting = FlakySigner(me) + val inbox = ConcordDirectInviteInbox(counting) + val wrap = ConcordActions.buildDirectInvite(sender, me.pubKey, inviteFor(c)) + // What the NIP-17 pipeline did already: one decrypt per layer. + val seal = assertIs(wrap.unwrapOrNull(me)) + val rumor = seal.unsealRumorThrowing(me) + val opened = assertNotNull(inbox.offerRumor(wrap.copyNoContent(), seal, rumor)) + assertEquals(sender.pubKey, opened.sender) + assertEquals(0, counting.decrypts, "the inbox never decrypted again") + // The sweep fetching the same wrap later costs nothing either. + assertSame(opened, inbox.offer(wrap)) + assertEquals(0, counting.decrypts) + + // A spoofed rumor (claimed author differs from the seal's) is refused on this path too. + val spoofed = Rumor(rumor.id, stranger.pubKey, rumor.createdAt, rumor.kind, rumor.tags, rumor.content) + val other = ConcordActions.buildDirectInvite(sender, me.pubKey, inviteFor(c)) + val otherSeal = assertIs(other.unwrapOrNull(me)) + assertNull(inbox.offerRumor(other.copyNoContent(), otherSeal, spoofed)) + } + @Test fun declineDiscardsAndTheWrapNeverResurfaces() = runTest { @@ -191,22 +231,184 @@ class ConcordDirectInviteInboxTest { assertFalse(byWrap.getValue(toNew.wrapId).catchUp) assertTrue(byWrap.getValue(toNew.wrapId).expired) assertFalse(byWrap.getValue(catchUp.wrapId).expired) - assertEquals(listOf("vip"), byWrap.getValue(catchUp.wrapId).channelNames) + assertEquals(listOf("vip"), byWrap.getValue(catchUp.wrapId).newChannelNames()) + // Named by the held fold when it knows the channel. + assertEquals(listOf("VIP lounge"), byWrap.getValue(catchUp.wrapId).newChannelNames { if (it == vip) "VIP lounge" else null }) } @Test - fun visibleKeepsOneInvitePerCommunity() = + fun aCatchUpThatAcceptWouldRefuseIsNotOffered() = + runTest { + val c = community() + val editions = ConcordActions.controlEditions(c.genesisWraps, c.controlPlane).toMutableList() + editions += ConcordActions.controlEditions(listOf(ConcordModeration.defineChannel(owner, c.controlPlane, c.communityId, vip.hexToByteArray(), ChannelEntity(name = "vip", private = true), editions, 2L, owner = c.ownerPubKey)), c.controlPlane) + val state = ConcordCommunityState.fold(editions, c.communityId, c.ownerPubKey) + val grant = listOf(InviteChannel(vip, "db".repeat(32), 0, "vip")) + val inbox = ConcordDirectInviteInbox(me) + // A plain member hands over a key: accept refuses it (not staff), so it is not a card. + val fromMember = assertNotNull(inbox.offer(ConcordActions.buildDirectInvite(sender, me.pubKey, inviteFor(c, channels = grant)))) + val fromOwner = assertNotNull(inbox.offer(ConcordActions.buildDirectInvite(owner, me.pubKey, inviteFor(c, channels = grant)))) + val held = listOf(heldEntryOf(c)) + + val views = ConcordDirectInviteInbox.visible(inbox.pending.value.values, held, heldStateOf = { state }) + assertEquals(listOf(fromOwner.wrapId), views.map { it.wrapId }) + assertIs(ConcordDirectInviteInbox.acceptPlan(fromOwner, held.single(), state, me.pubKey)) + assertEquals(DirectInviteAcceptPlan.NothingNew, ConcordDirectInviteInbox.acceptPlan(fromMember, held.single(), state, me.pubKey)) + + // Before the fold is in, the verdict is unknown: both stay (accept waits for the roster). + assertEquals(2, ConcordDirectInviteInbox.visible(inbox.pending.value.values, held).size) + // A dissolved community takes no keys at all. + assertTrue(ConcordDirectInviteInbox.visible(inbox.pending.value.values, held, heldStateOf = { state.withDissolved(true) }).isEmpty()) + } + + @Test + fun visibleKeepsOneInvitePerCommunityAndSender() = runTest { val c = community() val inbox = ConcordDirectInviteInbox(me) val older = assertNotNull(inbox.offer(ConcordActions.buildDirectInvite(sender, me.pubKey, inviteFor(c), createdAt = 1_700_000_000L))) - val newer = assertNotNull(inbox.offer(ConcordActions.buildDirectInvite(stranger, me.pubKey, inviteFor(c), createdAt = 1_700_000_100L))) - assertEquals(2, inbox.pending.value.size) + val newer = assertNotNull(inbox.offer(ConcordActions.buildDirectInvite(sender, me.pubKey, inviteFor(c), createdAt = 1_700_000_100L))) + val fromStranger = assertNotNull(inbox.offer(ConcordActions.buildDirectInvite(stranger, me.pubKey, inviteFor(c), createdAt = 1_700_000_050L))) + assertEquals(3, inbox.pending.value.size) val views = ConcordDirectInviteInbox.visible(inbox.pending.value.values, emptyList()) - assertEquals(listOf(newer.wrapId), views.map { it.wrapId }) + assertEquals(listOf(newer.wrapId, fromStranger.wrapId), views.map { it.wrapId }) assertFalse(older.wrapId in views.map { it.wrapId }) } + @Test + fun aFutureDatedInviteNeitherHidesALegitOneNorOutranksIt() = + runTest { + val c = community() + val inbox = ConcordDirectInviteInbox(me) + val now = 1_700_000_000L + val legit = assertNotNull(inbox.offer(ConcordActions.buildDirectInvite(sender, me.pubKey, inviteFor(c), createdAt = now - 10), nowSecs = now)) + // A stranger's invite dated a year ahead: it may show, but it cannot shadow the sender's. + val future = assertNotNull(inbox.offer(ConcordActions.buildDirectInvite(stranger, me.pubKey, inviteFor(c), createdAt = now + 365 * 86_400L), nowSecs = now)) + val views = ConcordDirectInviteInbox.visible(inbox.pending.value.values, emptyList(), nowMs = now * 1000) + assertEquals(setOf(legit.wrapId, future.wrapId), views.map { it.wrapId }.toSet()) + assertEquals(now, views.first { it.wrapId == future.wrapId }.clampedSentAt, "ranked as if sent now, not a year ahead") + + // Nor does it drag the sweep cursor into the future (D6): `since` stays near now. + assertTrue(inbox.newestWrapCreatedAt!! <= now + ConcordDirectInviteInbox.FUTURE_SKEW_SECS) + } + + @Test + fun anInviteSentBeforeTheUserLeftTheCommunityStaysBuried() = + runTest { + val c = community() + val inbox = ConcordDirectInviteInbox(me) + val now = 1_700_000_000L + assertNotNull(inbox.offer(ConcordActions.buildDirectInvite(sender, me.pubKey, inviteFor(c), createdAt = now - 100), nowSecs = now)) + val leftAtMs = (now - 50) * 1000 + val removed = mapOf(c.communityIdHex to leftAtMs) + assertTrue(ConcordDirectInviteInbox.visible(inbox.pending.value.values, emptyList(), nowMs = now * 1000, removedAt = removed).isEmpty()) + + // A fresh re-invite sent after leaving shows. + val fresh = assertNotNull(inbox.offer(ConcordActions.buildDirectInvite(stranger, me.pubKey, inviteFor(c), createdAt = now - 10), nowSecs = now)) + assertEquals(listOf(fresh.wrapId), ConcordDirectInviteInbox.visible(inbox.pending.value.values, emptyList(), nowMs = now * 1000, removedAt = removed).map { it.wrapId }) + } + + @Test + fun followedSendersRankFirstAndHiddenSendersAreNeverParked() = + runTest { + val c = community() + val other = community() + val inbox = ConcordDirectInviteInbox(me, isHidden = { it == stranger.pubKey }, isFollowed = { it == owner.pubKey }) + val now = 1_700_000_000L + assertNull(inbox.offer(ConcordActions.buildDirectInvite(stranger, me.pubKey, inviteFor(c), createdAt = now), nowSecs = now), "a muted sender never parks") + val newer = assertNotNull(inbox.offer(ConcordActions.buildDirectInvite(sender, me.pubKey, inviteFor(c), createdAt = now), nowSecs = now)) + val followed = assertNotNull(inbox.offer(ConcordActions.buildDirectInvite(owner, me.pubKey, inviteFor(other), createdAt = now - 1_000), nowSecs = now)) + val views = ConcordDirectInviteInbox.visible(inbox.pending.value.values, emptyList(), nowMs = now * 1000, isFollowed = { it == owner.pubKey }) + assertEquals(listOf(followed.wrapId, newer.wrapId), views.map { it.wrapId }) + } + + @Test + fun theInboxIsBoundedAndShedsTheLowestRanked() = + runTest { + val c = community() + val inbox = ConcordDirectInviteInbox(me, isFollowed = { it == owner.pubKey }) + val now = 1_700_000_000L + val followed = assertNotNull(inbox.offer(ConcordActions.buildDirectInvite(owner, me.pubKey, inviteFor(c), createdAt = now - 10_000), nowSecs = now)) + repeat(ConcordDirectInviteInbox.MAX_PENDING) { i -> + inbox.offer(ConcordActions.buildDirectInvite(sender, me.pubKey, inviteFor(c), createdAt = now - 5_000 + i), nowSecs = now) + } + assertEquals(ConcordDirectInviteInbox.MAX_PENDING, inbox.pending.value.size) + assertTrue(followed.wrapId in inbox.pending.value, "the followed sender's older invite outranks strangers' newer ones") + } + + @Test + fun aSignerThatCannotAnswerNowLeavesTheWrapToBeRetried() = + runTest { + val c = community() + val flaky = FlakySigner(me) + val inbox = ConcordDirectInviteInbox(flaky) + val wrap = ConcordActions.buildDirectInvite(sender, me.pubKey, inviteFor(c)) + + flaky.failNext = true + assertNull(inbox.offer(wrap), "the signer timed out: nothing parked") + // Not written off: the next delivery opens it. + assertNotNull(inbox.offer(wrap)) + + // A definitive failure (not for us) is written off: a later offer never decrypts again. + val notOurs = ConcordActions.buildDirectInvite(sender, stranger.pubKey, inviteFor(c)) + assertNull(inbox.offer(notOurs)) + val before = flaky.decrypts + assertNull(inbox.offer(notOurs)) + assertEquals(before, flaky.decrypts) + } + + /** Delegates to [inner], throwing a transient signer failure on the next decrypt when [failNext]. */ + private class FlakySigner( + private val inner: NostrSignerInternal, + ) : NostrSigner(inner.pubKey) { + var failNext = false + var decrypts = 0 + + override fun isWriteable() = inner.isWriteable() + + override suspend fun sign( + createdAt: Long, + kind: Int, + tags: Array>, + content: String, + ): T = inner.sign(createdAt, kind, tags, content) + + override suspend fun nip04Encrypt( + plaintext: String, + toPublicKey: HexKey, + ) = inner.nip04Encrypt(plaintext, toPublicKey) + + override suspend fun nip04Decrypt( + ciphertext: String, + fromPublicKey: HexKey, + ) = inner.nip04Decrypt(ciphertext, fromPublicKey) + + override suspend fun nip44Encrypt( + plaintext: String, + toPublicKey: HexKey, + ) = inner.nip44Encrypt(plaintext, toPublicKey) + + override suspend fun nip44Decrypt( + ciphertext: String, + fromPublicKey: HexKey, + ): String { + decrypts++ + if (failNext) { + failNext = false + throw SignerExceptions.TimedOutException("signer busy") + } + return inner.nip44Decrypt(ciphertext, fromPublicKey) + } + + override suspend fun decryptZapEvent(event: ZapRequestEvent): PrivateZapEvent = inner.decryptZapEvent(event) + + override suspend fun deriveKey(nonce: HexKey) = inner.deriveKey(nonce) + + override suspend fun signPsbt(psbtHex: String) = inner.signPsbt(psbtHex) + + override fun hasForegroundSupport() = inner.hasForegroundSupport() + } + @Test fun acceptRefusesAnExpiredInvite() = runTest { @@ -221,17 +423,23 @@ class ConcordDirectInviteInboxTest { runTest { val c = community() val held = heldEntryOf(c) - val state = stateOf(c) + val state = stateWithVip(c) val grant = listOf(InviteChannel(vip, "db".repeat(32), 0, "vip")) - // Same base, new key: a catch-up that keeps the held base and anchor. - val catchUp = assertNotNull(ConcordActions.openDirectInvite(ConcordActions.buildDirectInvite(sender, me.pubKey, inviteFor(c, channels = grant)), me)) + // Same base, new key, from staff (the owner): a catch-up that keeps the held base and anchor. + val catchUp = assertNotNull(ConcordActions.openDirectInvite(ConcordActions.buildDirectInvite(owner, me.pubKey, inviteFor(c, channels = grant)), me)) val plan = assertIs(ConcordDirectInviteInbox.acceptPlan(catchUp, held, state, me.pubKey)) assertEquals(held.root, plan.entry.root) assertEquals(held.rootEpoch, plan.entry.rootEpoch) assertEquals(held.controlPk, plan.entry.controlPk) assertEquals("anchor", plan.entry.inviteRef) assertEquals(listOf(vip), plan.entry.privateChannels.map { it.channelId }) + assertEquals(listOf(vip), plan.channelIds) + + // A plain keyholder can't plant a key, and a channel the fold doesn't know as Private isn't one. + val fromMember = assertNotNull(ConcordActions.openDirectInvite(ConcordActions.buildDirectInvite(sender, me.pubKey, inviteFor(c, channels = grant)), me)) + assertEquals(DirectInviteAcceptPlan.NothingNew, ConcordDirectInviteInbox.acceptPlan(fromMember, held, state, me.pubKey)) + assertEquals(DirectInviteAcceptPlan.NothingNew, ConcordDirectInviteInbox.acceptPlan(catchUp, held, stateOf(c), me.pubKey)) // No fold yet: the ban verdict is unknown, so it waits. assertEquals(DirectInviteAcceptPlan.RosterNotLoaded, ConcordDirectInviteInbox.acceptPlan(catchUp, held, null, me.pubKey)) @@ -240,6 +448,11 @@ class ConcordDirectInviteInboxTest { val holding = held.let { ConcordCommunityListEntry(it.id, it.owner, it.ownerSalt, it.root, it.rootEpoch, it.controlPk, privateChannels = listOf(PrivateChannelKey(vip, "db".repeat(32), 0, "vip")), relays = it.relays, name = it.name) } assertEquals(DirectInviteAcceptPlan.NothingNew, ConcordDirectInviteInbox.acceptPlan(catchUp, holding, state, me.pubKey)) + // Even from staff, a bundle never REPLACES a held key — not at a higher, nor an absurd, epoch. + // A held key moves only through a channel rekey, whose prevcommit proves continuity. + val hijack = assertNotNull(ConcordActions.openDirectInvite(ConcordActions.buildDirectInvite(owner, me.pubKey, inviteFor(c, channels = listOf(InviteChannel(vip, "ee".repeat(32), 1_000_000_000L, "vip")))), me)) + assertEquals(DirectInviteAcceptPlan.NothingNew, ConcordDirectInviteInbox.acceptPlan(hijack, holding, state, me.pubKey)) + // A different base for a held community is never adopted, keys or not. val baseMove = assertNotNull(ConcordActions.openDirectInvite(ConcordActions.buildDirectInvite(sender, me.pubKey, inviteFor(c, root = "99".repeat(32), channels = grant)), me)) assertEquals(DirectInviteAcceptPlan.NothingNew, ConcordDirectInviteInbox.acceptPlan(baseMove, held, state, me.pubKey)) diff --git a/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordDisappearingSessionTest.kt b/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordDisappearingSessionTest.kt index 4b073861e0..1dc1422d5e 100644 --- a/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordDisappearingSessionTest.kt +++ b/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordDisappearingSessionTest.kt @@ -36,6 +36,7 @@ import com.vitorpamplona.quartz.nip01Core.crypto.KeyPair import com.vitorpamplona.quartz.nip01Core.signers.NostrSignerInternal import com.vitorpamplona.quartz.nip92IMeta.IMetaTagBuilder import com.vitorpamplona.quartz.utils.TimeUtils +import com.vitorpamplona.quartz.utils.ciphers.AESGCM import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.test.runTest import kotlin.test.Test @@ -114,7 +115,6 @@ class ConcordDisappearingSessionTest { ConcordActions.buildChannelInlineReply(owner, plane.key, general, plane.epoch, parent, "quote", at, timerSecs = timer), ConcordActions.buildChannelReply(owner, plane.key, general, plane.epoch, parent, "thread", at, timerSecs = timer), ConcordActions.buildChannelImageReply(owner, plane.key, general, plane.epoch, parent, "thread pic", imeta, at, timerSecs = timer), - ConcordActions.buildChannelEdit(owner, plane.key, general, plane.epoch, parent, "edited", at, timerSecs = timer), ConcordActions.buildChannelReaction(owner, plane.key, general, plane.epoch, parent, "+", at, timerSecs = timer), ) for (wrap in durable) { @@ -142,6 +142,32 @@ class ConcordDisappearingSessionTest { assertEquals(listOf("p"), off.tags.map { it[0] }) } + @Test + fun anEditKeepsTheOriginalMessagesDeadlineNotNowPlusTimer() = + runTest { + val (community, session) = session(day) + val general = community.generalChannelIdHex + val plane = session.currentChannelPlane(general)!! + val sentAt = 1_000_000L + val original = ChannelChat.message(owner.pubKey, general, plane.epoch, "hi", sentAt, ConcordDisappearing.withExpiration(emptyArray(), sentAt + 7 * day)) + val editedAt = sentAt + 3 * day + + // Default: the target's own deadline, verbatim, inside and outside. + val edit = ConcordActions.buildChannelEdit(owner, plane.key, general, plane.epoch, original, "hi!", editedAt) + assertEquals(sentAt + 7 * day, ConcordDisappearing.expirationOf(opened(edit, plane.key))) + assertEquals((sentAt + 7 * day).toString(), wrapExpiration(edit)) + + // A message sent without a timer stays timer-free when edited, even though a timer is on now. + val forever = ChannelChat.message(owner.pubKey, general, plane.epoch, "forever", sentAt) + val editForever = ConcordActions.buildChannelEdit(owner, plane.key, general, plane.epoch, forever, "still forever", editedAt) + assertNull(ConcordDisappearing.expirationOf(opened(editForever, plane.key))) + assertNull(wrapExpiration(editForever)) + + // A smuggled expiration in extraTags never overrides the original's. + val smuggled = ConcordActions.buildChannelEdit(owner, plane.key, general, plane.epoch, forever, "x", editedAt, arrayOf(arrayOf("expiration", "5"))) + assertNull(ConcordDisappearing.expirationOf(opened(smuggled, plane.key))) + } + @Test fun anAlreadyExpiredRumorIsRefusedAndItsWrapPurged() = runTest { @@ -195,6 +221,79 @@ class ConcordDisappearingSessionTest { assertNull(session.nextExpiry.value) } + @Test + fun theSweepPopsOnlyWhatIsDueInDeadlineOrderAndCarriesAttachmentUrls() = + runTest { + val (community, session) = session(day) + val general = community.generalChannelIdHex + val plane = session.currentChannelPlane(general)!! + val now = TimeUtils.now() + val image = listOf(ChannelChat.encryptedImageImeta("https://blossom.example/blob", "image/png", null, null, AESGCM(), null)) + val late = ConcordActions.buildChannelMessage(owner, plane.key, general, plane.epoch, "late", now, timerSecs = 3 * day) + val soon = ConcordActions.buildChannelImageMessage(owner, plane.key, general, plane.epoch, "soon", image, now, timerSecs = day) + val mid = ConcordActions.buildChannelMessage(owner, plane.key, general, plane.epoch, "mid", now, timerSecs = 2 * day) + listOf(late, soon, mid).forEach { session.ingest(it) } + assertEquals(now + day, session.nextExpiry.value, "the head of the deadline order") + + val first = session.sweepExpired(now + 2 * day) + assertEquals(listOf(soon.id, mid.id), first.map { it.wrapId }, "due ones only, soonest first") + // CORD-08 §3: the image's decryption key must go with the message. + assertEquals(listOf("https://blossom.example/blob"), first.first().attachmentUrls) + assertEquals(now + 3 * day, session.nextExpiry.value) + assertEquals(listOf(late.id), session.sweepExpired(now + 3 * day).map { it.wrapId }) + assertNull(session.nextExpiry.value) + } + + @Test + fun aSweptWrapDeliveredAgainIsNotOpenedAgain() = + runTest { + val captured = mutableListOf() + val (community, session) = session(day, captured) + val general = community.generalChannelIdHex + val plane = session.currentChannelPlane(general)!! + val stale = ConcordActions.buildChannelMessage(owner, plane.key, general, plane.epoch, "stale", TimeUtils.now() - 2 * day, timerSecs = day) + session.ingest(stale) + assertEquals(listOf(stale.id), session.sweepExpired().map { it.wrapId }) + + // A relay serving it again: claimed, dropped unopened — no new deadline, no re-sweep loop. + assertEquals(ConcordIngestOutcome.NON_STRUCTURAL, session.ingest(stale)) + assertNull(session.nextExpiry.value) + assertFalse(session.isBuffered(general, stale.id)) + assertTrue(captured.none { it.content == "stale" }) + } + + @Test + fun aRefoundingCarriesTheTrackedDeadlinesIntoTheNewSession() = + runTest { + val community = ConcordCommunityFactory.create(owner, "Nostrichs", createdAt = 1L, relays = listOf("wss://r.example")) + val registry = ConcordSessionRegistry() + val entry = entryFor(community) + registry.sync(listOf(entry), owner.pubKey) + val old = registry.sessionFor(community.communityIdHex)!! + community.genesisWraps.forEach { old.ingest(it) } + val plane = old.currentChannelPlane(community.generalChannelIdHex)!! + val now = TimeUtils.now() + val live = ConcordActions.buildChannelMessage(owner, plane.key, community.generalChannelIdHex, plane.epoch, "bye", now, timerSecs = day) + old.ingest(live) + + // The root rolls: the registry rebuilds the session, which never sees the old wrap again. + val rolled = + ConcordCommunityListEntry( + id = entry.id, + owner = entry.owner, + ownerSalt = entry.ownerSalt, + root = KeyPair().pubKey.toHexKey(), + rootEpoch = entry.rootEpoch + 1, + relays = entry.relays, + name = entry.name, + ) + registry.sync(listOf(rolled), owner.pubKey) + val fresh = registry.sessionFor(community.communityIdHex)!! + assertTrue(fresh !== old) + assertEquals(now + day, fresh.nextExpiry.value) + assertEquals(listOf(live.id), fresh.sweepExpired(now + day).map { it.wrapId }) + } + @Test fun theManagerSchedulesOnTheEarliestDeadlineAndSweepsPerCommunity() = runTest { diff --git a/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordKickTest.kt b/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordKickTest.kt new file mode 100644 index 0000000000..033509101c --- /dev/null +++ b/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordKickTest.kt @@ -0,0 +1,188 @@ +/* + * Copyright (c) 2025 Vitor Pamplona + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the + * Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR + * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ +package com.vitorpamplona.amethyst.commons.model.concord + +import com.vitorpamplona.amethyst.commons.actions.ConcordActions +import com.vitorpamplona.amethyst.commons.actions.ConcordModeration +import com.vitorpamplona.quartz.concord.cord02Community.ConcordCommunityFactory +import com.vitorpamplona.quartz.concord.cord02Community.ConcordCommunityListEntry +import com.vitorpamplona.quartz.concord.cord02Community.ConcordCommunityState +import com.vitorpamplona.quartz.concord.cord02Community.GuestbookAction +import com.vitorpamplona.quartz.concord.cord02Community.NewConcordCommunity +import com.vitorpamplona.quartz.concord.cord04Roles.AuthorityCitation +import com.vitorpamplona.quartz.concord.cord04Roles.ConcordPermissions +import com.vitorpamplona.quartz.concord.cord04Roles.RoleEntity +import com.vitorpamplona.quartz.nip01Core.core.Event +import com.vitorpamplona.quartz.nip01Core.core.toHexKey +import com.vitorpamplona.quartz.nip01Core.crypto.KeyPair +import com.vitorpamplona.quartz.nip01Core.signers.NostrSignerInternal +import kotlinx.coroutines.test.runTest +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFalse +import kotlin.test.assertNotNull +import kotlin.test.assertNull +import kotlin.test.assertTrue + +/** + * The Cooperative Kick (CORD-02 §5, CORD-04 §6) through the session fold: an honored Kick departs its + * target in everyone's roster and tells the target's own client to leave; a Kick from someone who may + * not kick is dropped; a Kick whose Grant has not folded yet parks until it does; and a re-join + * (a newer Join, or a re-added entry) leaves the Kick behind. + */ +class ConcordKickTest { + private val owner = NostrSignerInternal(KeyPair()) + private val mod = NostrSignerInternal(KeyPair()) + private val target = NostrSignerInternal(KeyPair()) + private val bystander = NostrSignerInternal(KeyPair()) + + private class World( + val community: NewConcordCommunity, + val controlWraps: MutableList, + ) { + fun state(): ConcordCommunityState = ConcordCommunityState.fold(ConcordActions.controlEditions(controlWraps, community.controlPlane), community.communityId, community.ownerPubKey) + } + + /** A community whose owner defined a Mod role (position 5, KICK only) and granted it to [mod]. */ + private suspend fun world(): Pair { + val c = ConcordCommunityFactory.create(owner, "Nostrichs", createdAt = 1L, relays = listOf("wss://relay.example")) + val w = World(c, c.genesisWraps.toMutableList()) + val roleId = ByteArray(32) { 7 } + val role = RoleEntity(name = "Mod", position = 5, permissions = ConcordPermissions.of(ConcordPermissions.KICK).toWire()) + w.controlWraps += ConcordModeration.defineRole(owner, c.controlPlane, c.communityId, roleId, role, ConcordActions.controlEditions(w.controlWraps, c.controlPlane), 2L, owner = c.ownerPubKey) + val modGrant = ConcordModeration.grant(owner, c.controlPlane, c.communityId, mod.pubKey, listOf(roleId.toHexKey()), ConcordActions.controlEditions(w.controlWraps, c.controlPlane), 3L, owner = c.ownerPubKey) + w.controlWraps += modGrant + return w to modGrant + } + + private fun entryOf( + c: NewConcordCommunity, + addedAt: Long, + ) = ConcordCommunityListEntry( + id = c.communityIdHex, + owner = c.ownerPubKey, + ownerSalt = c.ownerSalt.toHexKey(), + root = c.communityRoot.toHexKey(), + rootEpoch = c.rootEpoch, + controlPk = c.controlPkHex, + relays = listOf("wss://relay.example"), + name = "Nostrichs", + addedAt = addedAt, + ) + + private fun session( + c: NewConcordCommunity, + me: String, + wraps: List, + addedAt: Long = 1_000L, + ): ConcordCommunitySession = ConcordCommunitySession(entryOf(c, addedAt), me) { _, _, _, _ -> }.also { s -> wraps.forEach { s.ingest(it) } } + + private fun guestbook(c: NewConcordCommunity) = ConcordActions.guestbookPlane(c.communityRoot, c.communityId, c.rootEpoch) + + private fun citationOf( + w: World, + actor: String, + ): AuthorityCitation? = w.state().authority.citationFor(actor) + + @Test + fun anHonoredKickDepartsTheTargetAndAsksTheirClientToLeave() = + runTest { + val (w, _) = world() + val c = w.community + val gb = guestbook(c) + val join = ConcordActions.buildGuestbookJoin(target, gb, createdAt = 5L) + val kick = ConcordActions.buildGuestbookKick(mod, gb, target.pubKey, citationOf(w, mod.pubKey), createdAt = 10L) + + val ownerView = session(c, owner.pubKey, w.controlWraps + join + kick) + val t = target.pubKey.lowercase() + assertEquals(GuestbookAction.KICK, ownerView.guestbook.value[t]?.action) + assertFalse(t in ownerView.members.value) + assertEquals(GuestbookAction.KICK, ownerView.departedMembers()[t]?.action) + assertFalse(t in ownerView.allMembers()) + assertNull(ownerView.kickedMe()) // the Kick names the target, not the owner + + // The target's client finds the Kick against this membership and complies. + val targetView = session(c, target.pubKey, w.controlWraps + join + kick, addedAt = 1_000L) + val verdict = assertNotNull(targetView.kickedMe()) + assertEquals(mod.pubKey, verdict.author) + + // Re-invited after the Kick: the entry's added_at postdates it, so it judges nothing. + assertNull(session(c, target.pubKey, w.controlWraps + join + kick, addedAt = 11_000L).kickedMe()) + + // Re-joined: a newer self-signed Join supersedes the Kick. + val rejoin = ConcordActions.buildGuestbookJoin(target, gb, createdAt = 20L) + targetView.ingest(rejoin) + assertNull(targetView.kickedMe()) + assertTrue(t in targetView.members.value) + } + + @Test + fun aKickFromSomeoneWhoMayNotKickIsDropped() = + runTest { + val (w, _) = world() + val c = w.community + val gb = guestbook(c) + val join = ConcordActions.buildGuestbookJoin(target, gb, createdAt = 5L) + // A roleless member holds no KICK; nobody may kick the owner. + val forged = ConcordActions.buildGuestbookKick(bystander, gb, target.pubKey, citationOf(w, bystander.pubKey), createdAt = 10L) + val atOwner = ConcordActions.buildGuestbookKick(mod, gb, owner.pubKey, citationOf(w, mod.pubKey), createdAt = 10L) + + val targetView = session(c, target.pubKey, w.controlWraps + join + forged + atOwner) + assertEquals(GuestbookAction.JOIN, targetView.guestbook.value[target.pubKey.lowercase()]?.action) + assertNull(targetView.kickedMe()) + assertNull(targetView.guestbook.value[owner.pubKey.lowercase()]) + assertTrue(targetView.departedMembers().isEmpty()) + } + + @Test + fun aKickParksUntilItsCitedGrantFolds() = + runTest { + val (w, modGrant) = world() + val c = w.community + val gb = guestbook(c) + val join = ConcordActions.buildGuestbookJoin(target, gb, createdAt = 5L) + val kick = ConcordActions.buildGuestbookKick(mod, gb, target.pubKey, citationOf(w, mod.pubKey), createdAt = 10L) + + // The Guestbook can lead the Control Plane: without the mod's Grant their Kick parks. + val targetView = session(c, target.pubKey, (w.controlWraps - modGrant) + join + kick) + assertNull(targetView.kickedMe()) + assertEquals(GuestbookAction.JOIN, targetView.guestbook.value[target.pubKey.lowercase()]?.action) + + // The Grant folds: the same held Kick is now honored, with no Guestbook arrival. + targetView.ingest(modGrant) + assertNotNull(targetView.kickedMe()) + } + + @Test + fun aKickWithoutACitationFromANonOwnerParks() = + runTest { + val (w, _) = world() + val c = w.community + val gb = guestbook(c) + val join = ConcordActions.buildGuestbookJoin(target, gb, createdAt = 5L) + val uncited = ConcordActions.buildGuestbookKick(mod, gb, target.pubKey, citation = null, createdAt = 10L) + assertNull(session(c, target.pubKey, w.controlWraps + join + uncited).kickedMe()) + + // The owner cites nothing and needs nothing. + val byOwner = ConcordActions.buildGuestbookKick(owner, gb, target.pubKey, citation = null, createdAt = 10L) + assertNotNull(session(c, target.pubKey, w.controlWraps + join + byOwner).kickedMe()) + } +} diff --git a/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordPinDutySchedulerTest.kt b/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordPinDutySchedulerTest.kt new file mode 100644 index 0000000000..6110e7e842 --- /dev/null +++ b/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordPinDutySchedulerTest.kt @@ -0,0 +1,71 @@ +/* + * Copyright (c) 2025 Vitor Pamplona + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the + * Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR + * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ +package com.vitorpamplona.amethyst.commons.model.concord + +import com.vitorpamplona.amethyst.commons.actions.ConcordChannelPins +import kotlinx.coroutines.test.advanceTimeBy +import kotlinx.coroutines.test.advanceUntilIdle +import kotlinx.coroutines.test.runCurrent +import kotlinx.coroutines.test.runTest +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFalse +import kotlin.test.assertNull +import kotlin.test.assertTrue + +/** + * The account-level pin duty scheduler (CORD-04 §7): a duty waits its random delay, a channel runs + * one duty at a time, and a debt is attempted once — so a burst of ticks costs one write and a failing + * write never spins — while a new debt is a new attempt. + */ +class ConcordPinDutySchedulerTest { + @Test + fun oneAttemptPerDebtAndOneDutyPerChannel() = + runTest { + val scheduler = ConcordPinDutyScheduler(delayMs = { 5_000L }) + var runs = 0 + + assertTrue(scheduler.schedule(this, "c|a", "d1") { runs++ }) + assertFalse(scheduler.schedule(this, "c|a", "d1") { runs++ }, "the same debt twice") + assertFalse(scheduler.schedule(this, "c|a", "d2") { runs++ }, "a second duty while one is in flight") + assertTrue(scheduler.schedule(this, "c|b", "d1") { runs++ }, "another channel is independent") + + advanceTimeBy(4_999) + runCurrent() + assertEquals(0, runs, "a duty waits its delay before settling") + advanceUntilIdle() + assertEquals(2, runs) + + assertFalse(scheduler.schedule(this, "c|a", "d1") { runs++ }, "an attempted debt is never respun") + assertTrue(scheduler.schedule(this, "c|a", "d2") { runs++ }, "a new debt is a new attempt") + advanceUntilIdle() + assertEquals(3, runs) + } + + @Test + fun nothingOwedSchedulesNothing() = + runTest { + val scheduler = ConcordPinDutyScheduler(delayMs = { 0L }) + assertFalse(scheduler.schedule(this, "c|a", null) { error("must not run") }) + assertNull(ConcordPinDutyScheduler.debtOf(null)) + assertNull(ConcordPinDutyScheduler.debtOf(ConcordChannelPins.none("aa".repeat(32)))) + } +} diff --git a/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordWebxdcSessionTest.kt b/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordWebxdcSessionTest.kt new file mode 100644 index 0000000000..d00e5160ce --- /dev/null +++ b/commons/src/commonTest/kotlin/com/vitorpamplona/amethyst/commons/model/concord/ConcordWebxdcSessionTest.kt @@ -0,0 +1,96 @@ +/* + * Copyright (c) 2025 Vitor Pamplona + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the + * Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR + * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ +package com.vitorpamplona.amethyst.commons.model.concord + +import com.vitorpamplona.amethyst.commons.actions.ConcordActions +import com.vitorpamplona.quartz.concord.cord02Community.ConcordCommunityFactory +import com.vitorpamplona.quartz.concord.cord02Community.ConcordCommunityListEntry +import com.vitorpamplona.quartz.concord.cord03Channels.ConcordWebxdc +import com.vitorpamplona.quartz.concord.envelope.ConcordStreamEnvelope +import com.vitorpamplona.quartz.nip01Core.core.Event +import com.vitorpamplona.quartz.nip01Core.core.toHexKey +import com.vitorpamplona.quartz.nip01Core.crypto.KeyPair +import com.vitorpamplona.quartz.nip01Core.signers.NostrSignerInternal +import kotlinx.coroutines.test.runTest +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertNotNull +import kotlin.test.assertTrue + +/** + * WebXDC signals (kind 3310) on a Chat Plane (F10): the session accepts them under the plane's strict + * binding and holds them for a WebXDC host, but never hands them to the chat store — so they never + * become feed rows, previews or unread messages — while ordinary messages on the same plane still do. + */ +class ConcordWebxdcSessionTest { + private val owner = NostrSignerInternal(KeyPair()) + private val alice = NostrSignerInternal(KeyPair()) + private val topic = "A".repeat(26) + "234567".repeat(4) + "BC" + + @Test + fun webxdcSignalsAreHeldApartFromChatRows() = + runTest { + val community = ConcordCommunityFactory.create(owner, "Nostrichs", createdAt = 1L, relays = listOf("wss://r.example")) + val entry = + ConcordCommunityListEntry( + id = community.communityIdHex, + owner = community.ownerPubKey, + ownerSalt = community.ownerSalt.toHexKey(), + root = community.communityRoot.toHexKey(), + rootEpoch = community.rootEpoch, + controlPk = community.controlPkHex, + controlRoot = community.controlRoot.toHexKey(), + relays = listOf("wss://r.example"), + name = "Nostrichs", + ) + val stored = mutableListOf() + val session = ConcordCommunitySession(entry, owner.pubKey) { _, _, rumor, _ -> stored += rumor } + community.genesisWraps.forEach { session.ingest(it) } + val general = community.generalChannelIdHex + val plane = assertNotNull(session.currentChannelPlane(general)) + + val update = ConcordWebxdc.stateUpdate(alice.pubKey, general, plane.epoch, "uuid-1", "{\"move\":1}", createdAt = 10L) + val ad = ConcordWebxdc.peerSignal(alice.pubKey, general, plane.epoch, topic, "node-addr", createdAt = 11L) + // Bound to another epoch: the plane's strict binding still refuses it. + val misbound = ConcordWebxdc.stateUpdate(alice.pubKey, general, plane.epoch + 1, "uuid-1", "{}", createdAt = 12L) + for (rumor in listOf(update, ad, misbound)) { + session.ingest(ConcordStreamEnvelope.wrap(rumor, plane.key, alice, encrypted = true, createdAt = rumor.createdAt)) + } + val message = ConcordActions.buildChannelMessage(alice, plane.key, general, plane.epoch, "hello", 13L) + session.ingest(message) + + // Only the chat message reached the store (feeds, previews, unread counts read from there). + assertEquals(listOf("hello"), stored.map { it.content }) + assertTrue(stored.none { it.kind == ConcordWebxdc.KIND }) + + // The signals are held for a WebXDC host, oldest first; the misbound one is not. + val held = session.webxdcSignals(general) + assertEquals(listOf(update.id, ad.id), held.map { it.id }) + assertEquals("uuid-1", ConcordWebxdc.sessionOf(held.first())) + assertEquals("node-addr", ConcordWebxdc.parsePeerSignal(held.last().content)?.addr) + assertEquals(2L, session.webxdcRevision.value) + + // A duplicate delivery holds nothing new; the author counts as observed either way. + session.ingest(ConcordStreamEnvelope.wrap(update, plane.key, alice, encrypted = true, createdAt = 10L)) + assertEquals(2, session.webxdcSignals(general).size) + assertTrue(alice.pubKey.lowercase() in session.observedAuthors.value) + } +} diff --git a/commonsUI/src/commonMain/composeResources/values/strings.xml b/commonsUI/src/commonMain/composeResources/values/strings.xml index c3c70cbcfc..b936aabc3e 100644 --- a/commonsUI/src/commonMain/composeResources/values/strings.xml +++ b/commonsUI/src/commonMain/composeResources/values/strings.xml @@ -619,6 +619,9 @@ This channel's pins are sealed under a key you don't hold, so they can't be shown here, and pinning is paused until they can be read. %1$d of %2$d pins · %3$d% of the size budget used Tap a pin to jump to it + Pin a disappearing message? + This message is set to disappear. Pinning it keeps its words in the channel's pin list after the timer erases the message itself. + Pin anyway Pins The pinned list is sealed under a key you don't hold. Changing it now would drop pins you can't see. This channel already has 25 pins. Unpin one first. @@ -645,6 +648,15 @@ Owner Admin Banned + Kicked + Left + Kick + Kick this member? + Their roles are removed and their app is asked to leave the community. A kick is cooperative: it does not change any keys, and they can rejoin with an invite. To cut off their access, ban or remove them instead. + Could not kick this member. + Removed from community + A moderator removed you from %1$s. You can rejoin with a new invite. + A moderator removed you from a community. You can rejoin with a new invite. Join community Concord community invite Concord invite (open the full invite link to join) @@ -3628,15 +3640,23 @@ %1$d channel %1$d channels + Access role name New channel Delete channel Delete Delete #%1$s? This can't be undone and the channel can't be recreated with the same id. Delete channel? + Make private + #%1$s gets its own key from now on, and the "%2$s" role decides who can read it. Nobody holds that role yet: grant it to the members who should have access. Messages already posted stay readable to everyone in the community. + Make public + Every member of the community will be able to read #%1$s from now on. Messages posted while it was private stay readable only to the members who held its key. Channel name No messages yet + Only members holding its access role can read it. Grant the role to let them in; revoking it rotates the channel key. + Private channel Rename channel Rename + Rotate key No channels yet. Create The community could not be created: no relay accepted it, or your community list could not be updated. Check the relays and try again. diff --git a/commonsUI/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/ui/screen/loggedIn/chats/publicChannels/concord/ConcordChannelListScreen.kt b/commonsUI/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/ui/screen/loggedIn/chats/publicChannels/concord/ConcordChannelListScreen.kt index f7a3ea083a..7b09389ac0 100644 --- a/commonsUI/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/ui/screen/loggedIn/chats/publicChannels/concord/ConcordChannelListScreen.kt +++ b/commonsUI/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/ui/screen/loggedIn/chats/publicChannels/concord/ConcordChannelListScreen.kt @@ -43,6 +43,7 @@ import androidx.compose.material3.IconButton import androidx.compose.material3.MaterialTheme import androidx.compose.material3.OutlinedTextField import androidx.compose.material3.Scaffold +import androidx.compose.material3.Switch import androidx.compose.material3.Text import androidx.compose.material3.TextButton import androidx.compose.runtime.Composable @@ -75,15 +76,23 @@ import com.vitorpamplona.amethyst.commons.resources.Res import com.vitorpamplona.amethyst.commons.resources.app_name import com.vitorpamplona.amethyst.commons.resources.back import com.vitorpamplona.amethyst.commons.resources.cancel +import com.vitorpamplona.amethyst.commons.resources.concord_channel_access_role_label import com.vitorpamplona.amethyst.commons.resources.concord_channel_create import com.vitorpamplona.amethyst.commons.resources.concord_channel_delete import com.vitorpamplona.amethyst.commons.resources.concord_channel_delete_confirm import com.vitorpamplona.amethyst.commons.resources.concord_channel_delete_message import com.vitorpamplona.amethyst.commons.resources.concord_channel_delete_title +import com.vitorpamplona.amethyst.commons.resources.concord_channel_make_private +import com.vitorpamplona.amethyst.commons.resources.concord_channel_make_private_message +import com.vitorpamplona.amethyst.commons.resources.concord_channel_make_public +import com.vitorpamplona.amethyst.commons.resources.concord_channel_make_public_message import com.vitorpamplona.amethyst.commons.resources.concord_channel_name_label import com.vitorpamplona.amethyst.commons.resources.concord_channel_no_messages +import com.vitorpamplona.amethyst.commons.resources.concord_channel_private_hint +import com.vitorpamplona.amethyst.commons.resources.concord_channel_private_toggle import com.vitorpamplona.amethyst.commons.resources.concord_channel_rename import com.vitorpamplona.amethyst.commons.resources.concord_channel_rename_save +import com.vitorpamplona.amethyst.commons.resources.concord_channel_rotate_key import com.vitorpamplona.amethyst.commons.resources.concord_channels_empty import com.vitorpamplona.amethyst.commons.resources.concord_direct_invite_action import com.vitorpamplona.amethyst.commons.resources.concord_edit_title @@ -118,6 +127,7 @@ import com.vitorpamplona.amethyst.commons.ui.screen.loggedIn.qrcode.QrCodeDrawer import com.vitorpamplona.amethyst.commons.ui.stringRes import com.vitorpamplona.amethyst.commons.viewmodels.AccountViewModel import com.vitorpamplona.quartz.concord.cord03Channels.ConcordChannelId +import com.vitorpamplona.quartz.concord.cord03Channels.ConcordChannelKeyring import com.vitorpamplona.quartz.concord.cord04Roles.ConcordPermissions import com.vitorpamplona.quartz.nip01Core.core.HexKey import com.vitorpamplona.quartz.utils.TimeUtils @@ -236,11 +246,11 @@ fun ConcordChannelListScreen( initialName = editor.initialName, isCreate = editor.channelIdHex == null, onDismiss = { channelEditor = null }, - onConfirm = { newName -> + onConfirm = { newName, makePrivate, accessRoleName -> channelEditor = null scope.launch { if (editor.channelIdHex == null) { - account.concord.createConcordChannel(communityId, newName) + account.concord.createConcordChannel(communityId, newName, makePrivate, accessRoleName) } else { account.concord.renameConcordChannel(communityId, editor.channelIdHex, newName) } @@ -249,6 +259,26 @@ fun ConcordChannelListScreen( ) } + // Privatise / publicise a channel (CORD-03 §2): both are MANAGE_CHANNELS edits, and both say + // plainly what they can't do — a conversion protects the future only. + var channelToConvert by remember { mutableStateOf(null) } + channelToConvert?.let { target -> + ConcordChannelConvertDialog( + target = target, + onDismiss = { channelToConvert = null }, + onConfirm = { accessRoleName -> + channelToConvert = null + scope.launch { + if (target.toPrivate) { + account.concord.privatizeConcordChannel(communityId, target.channelIdHex, accessRoleName) + } else { + account.concord.publicizeConcordChannel(communityId, target.channelIdHex) + } + } + }, + ) + } + channelToDelete?.let { target -> val id = target.channelIdHex ?: return@let AlertDialog( @@ -444,6 +474,8 @@ fun ConcordChannelListScreen( .keys .sorted() } + // A rotation needs the current key (CORD-06): only a holder can rotate. + val holdsKey = def.private && session?.entry?.let { ConcordChannelKeyring.heldKey(it, entry.key) } != null ConcordChannelListRow( communityId = communityId, channelKey = entry.key, @@ -455,6 +487,9 @@ fun ConcordChannelListScreen( onClick = { nav.nav(Route.Concord(communityId, entry.key)) }, onRename = { channelEditor = ConcordChannelEditor(channelIdHex = entry.key, initialName = name) }, onDelete = { channelToDelete = ConcordChannelEditor(channelIdHex = entry.key, initialName = name) }, + onTogglePrivate = { channelToConvert = ConcordChannelConversion(entry.key, name, toPrivate = !def.private) }, + isPrivate = def.private, + onRotateKey = if (holdsKey) ({ scope.launch { account.concord.rekeyConcordChannel(communityId, entry.key) } }) else null, ) HorizontalDivider(thickness = 0.25.dp, color = MaterialTheme.colorScheme.outlineVariant) } @@ -482,6 +517,9 @@ private fun ConcordChannelListRow( onClick: () -> Unit, onRename: () -> Unit, onDelete: () -> Unit, + onTogglePrivate: () -> Unit, + isPrivate: Boolean, + onRotateKey: (() -> Unit)?, ) { val account = accountViewModel.account // getOrCreate (not getIfExists): a channel folded on the Control Plane may have no message note @@ -545,6 +583,9 @@ private fun ConcordChannelListRow( ConcordChannelRowMenu( onRename = onRename, onDelete = onDelete, + onTogglePrivate = onTogglePrivate, + isPrivate = isPrivate, + onRotateKey = onRotateKey, ) } } @@ -673,11 +714,62 @@ private data class ConcordChannelEditor( val initialName: String, ) -/** The per-channel-row overflow menu (rename / delete), shown only to channel managers. */ +/** A pending privatise ([toPrivate]) or publicise of [channelIdHex]. */ +private data class ConcordChannelConversion( + val channelIdHex: String, + val name: String, + val toPrivate: Boolean, +) + +/** Confirms a Private/Public conversion; privatising also names the new access Role. */ +@Composable +private fun ConcordChannelConvertDialog( + target: ConcordChannelConversion, + onDismiss: () -> Unit, + onConfirm: (String?) -> Unit, +) { + var roleName by remember { mutableStateOf(target.name) } + val action = if (target.toPrivate) Res.string.concord_channel_make_private else Res.string.concord_channel_make_public + AlertDialog( + onDismissRequest = onDismiss, + title = { Text(stringRes(action)) }, + text = { + Column(verticalArrangement = Arrangement.spacedBy(8.dp)) { + if (target.toPrivate) { + Text(stringRes(Res.string.concord_channel_make_private_message, target.name, roleName.ifBlank { target.name })) + OutlinedTextField( + value = roleName, + onValueChange = { roleName = it }, + singleLine = true, + label = { Text(stringRes(Res.string.concord_channel_access_role_label)) }, + modifier = Modifier.fillMaxWidth(), + ) + } else { + Text(stringRes(Res.string.concord_channel_make_public_message, target.name)) + } + } + }, + confirmButton = { + TextButton(onClick = { onConfirm(roleName.trim().ifBlank { null }) }) { + Text(stringRes(action)) + } + }, + dismissButton = { + TextButton(onClick = onDismiss) { + Text(stringRes(Res.string.cancel)) + } + }, + ) +} + +/** The per-channel-row overflow menu (rename / privacy / rotate / delete), shown only to channel managers. */ @Composable private fun ConcordChannelRowMenu( onRename: () -> Unit, onDelete: () -> Unit, + onTogglePrivate: () -> Unit, + isPrivate: Boolean, + onRotateKey: (() -> Unit)?, ) { var expanded by remember { mutableStateOf(false) } Box { @@ -696,6 +788,22 @@ private fun ConcordChannelRowMenu( onRename() }, ) + DropdownMenuItem( + text = { Text(stringRes(if (isPrivate) Res.string.concord_channel_make_public else Res.string.concord_channel_make_private)) }, + onClick = { + expanded = false + onTogglePrivate() + }, + ) + onRotateKey?.let { rotate -> + DropdownMenuItem( + text = { Text(stringRes(Res.string.concord_channel_rotate_key)) }, + onClick = { + expanded = false + rotate() + }, + ) + } DropdownMenuItem( text = { Text( @@ -718,9 +826,11 @@ private fun ConcordChannelEditDialog( initialName: String, isCreate: Boolean, onDismiss: () -> Unit, - onConfirm: (String) -> Unit, + onConfirm: (name: String, makePrivate: Boolean, accessRoleName: String?) -> Unit, ) { var name by remember { mutableStateOf(initialName) } + var makePrivate by remember { mutableStateOf(false) } + var roleName by remember { mutableStateOf("") } AlertDialog( onDismissRequest = onDismiss, title = { @@ -735,18 +845,43 @@ private fun ConcordChannelEditDialog( ) }, text = { - OutlinedTextField( - value = name, - onValueChange = { name = it }, - singleLine = true, - label = { Text(stringRes(Res.string.concord_channel_name_label)) }, - modifier = Modifier.fillMaxWidth(), - ) + Column(verticalArrangement = Arrangement.spacedBy(8.dp)) { + OutlinedTextField( + value = name, + onValueChange = { name = it }, + singleLine = true, + label = { Text(stringRes(Res.string.concord_channel_name_label)) }, + modifier = Modifier.fillMaxWidth(), + ) + // A new channel may be Private (CORD-03): its own key, and an access Role — the + // Roles scoped to a channel ARE its access list (CORD-04 §2). + if (isCreate) { + Row(verticalAlignment = Alignment.CenterVertically) { + Text(stringRes(Res.string.concord_channel_private_toggle), modifier = Modifier.weight(1f)) + Switch(checked = makePrivate, onCheckedChange = { makePrivate = it }) + } + if (makePrivate) { + Text( + stringRes(Res.string.concord_channel_private_hint), + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + OutlinedTextField( + value = roleName, + onValueChange = { roleName = it }, + singleLine = true, + placeholder = { Text(name.trim()) }, + label = { Text(stringRes(Res.string.concord_channel_access_role_label)) }, + modifier = Modifier.fillMaxWidth(), + ) + } + } + } }, confirmButton = { TextButton( enabled = name.isNotBlank(), - onClick = { if (name.isNotBlank()) onConfirm(name.trim()) }, + onClick = { if (name.isNotBlank()) onConfirm(name.trim(), makePrivate, roleName.trim().ifBlank { null }) }, ) { Text( stringRes( diff --git a/commonsUI/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/ui/screen/loggedIn/chats/publicChannels/concord/ConcordDirectInvites.kt b/commonsUI/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/ui/screen/loggedIn/chats/publicChannels/concord/ConcordDirectInvites.kt index 756ca3cb9c..7467644eb2 100644 --- a/commonsUI/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/ui/screen/loggedIn/chats/publicChannels/concord/ConcordDirectInvites.kt +++ b/commonsUI/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/ui/screen/loggedIn/chats/publicChannels/concord/ConcordDirectInvites.kt @@ -21,11 +21,14 @@ package com.vitorpamplona.amethyst.commons.ui.screen.loggedIn.chats.publicChannels.concord import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box import androidx.compose.foundation.layout.Column import androidx.compose.foundation.layout.PaddingValues import androidx.compose.foundation.layout.Row import androidx.compose.foundation.layout.fillMaxWidth import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.lazy.LazyListScope +import androidx.compose.foundation.lazy.items import androidx.compose.material3.AlertDialog import androidx.compose.material3.Button import androidx.compose.material3.ElevatedCard @@ -84,6 +87,8 @@ import com.vitorpamplona.amethyst.commons.ui.note.creators.userSuggestions.UserS import com.vitorpamplona.amethyst.commons.ui.stringRes import com.vitorpamplona.amethyst.commons.ui.theme.SuggestionListDefaultHeightChat import com.vitorpamplona.amethyst.commons.viewmodels.AccountViewModel +import com.vitorpamplona.quartz.utils.Log +import kotlinx.coroutines.CancellationException import kotlinx.coroutines.launch /** @@ -178,29 +183,48 @@ private fun sendResultMessage(result: ConcordDirectInviteSendResult) = } /** - * The Direct Invites waiting for this account (CORD-05 §6), as cards with Accept / Decline — shown - * at the top of the Concord communities list. Renders nothing when there are none. + * Sweeps the inbox relays for Direct Invites once when the hub opens (wraps the DM pipeline sees + * arrive on their own). Call it once per screen, outside any lazy list: inside a lazy item it would + * re-run every time the item scrolled back into view. + */ +@Composable +fun RefreshConcordDirectInvites(accountViewModel: AccountViewModel) { + val concord = accountViewModel.account.concord + LaunchedEffect(concord) { + try { + concord.refreshConcordDirectInvites() + } catch (e: CancellationException) { + throw e + } catch (e: Exception) { + Log.w("ConcordDirectInvites", "Direct Invite sweep failed", e) + } + } +} + +/** + * The Direct Invites waiting for this account (CORD-05 §6), as lazy items with Accept / Decline — + * shown at the top of the Concord communities list. Adds nothing when there are none. * - * Opening the hub sweeps the inbox relays once; wraps the DM pipeline sees arrive on their own. * The preview is the bundle's own name and a robohash of the community id — **no** icon fetch, no * relay connection to the community, no Join happens before the user taps Accept. The sender is * shown by whatever name the cache already has, without fetching their profile. */ -@Composable -fun ConcordPendingDirectInvites( +fun LazyListScope.concordPendingDirectInvites( + invites: List, accountViewModel: AccountViewModel, nav: INav, - modifier: Modifier = Modifier, ) { - val concord = accountViewModel.account.concord - LaunchedEffect(concord) { runCatching { concord.refreshConcordDirectInvites() } } - - val invites by concord.pendingConcordDirectInvites.collectAsStateWithLifecycle() if (invites.isEmpty()) return - - Column(modifier.fillMaxWidth().padding(horizontal = 12.dp, vertical = 8.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) { - Text(stringRes(Res.string.concord_direct_invites_title), style = MaterialTheme.typography.titleSmall, fontWeight = FontWeight.Bold) - invites.forEach { invite -> + item(key = "concord-direct-invites-title") { + Text( + stringRes(Res.string.concord_direct_invites_title), + style = MaterialTheme.typography.titleSmall, + fontWeight = FontWeight.Bold, + modifier = Modifier.padding(start = 12.dp, end = 12.dp, top = 8.dp), + ) + } + items(invites, key = { "concord-direct-invite-" + it.wrapId }) { invite -> + Box(Modifier.padding(horizontal = 12.dp, vertical = 4.dp)) { ConcordDirectInviteCard(invite, accountViewModel, nav) } } @@ -220,7 +244,20 @@ private fun ConcordDirectInviteCard( val subtitle = when { invite.expired -> stringRes(Res.string.concord_direct_invite_expired) - invite.catchUp -> stringRes(Res.string.concord_direct_invite_catch_up, invite.channelNames.joinToString(", ") { "#$it" }) + invite.catchUp -> { + // Only the channels it newly adds, named as the held community folds them. + val names = + remember(invite) { + val folded = + accountViewModel.account.concordSessions + .sessionFor(invite.communityId) + ?.state + ?.value + ?.channels + invite.newChannelNames { id -> folded?.get(id)?.definition?.name } + } + stringRes(Res.string.concord_direct_invite_catch_up, names.joinToString(", ") { "#$it" }) + } else -> stringRes(Res.string.concord_direct_invite_from, senderName) } diff --git a/commonsUI/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/ui/screen/loggedIn/chats/publicChannels/concord/ConcordHomeScreen.kt b/commonsUI/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/ui/screen/loggedIn/chats/publicChannels/concord/ConcordHomeScreen.kt index eb4963438d..6573796fc1 100644 --- a/commonsUI/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/ui/screen/loggedIn/chats/publicChannels/concord/ConcordHomeScreen.kt +++ b/commonsUI/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/ui/screen/loggedIn/chats/publicChannels/concord/ConcordHomeScreen.kt @@ -80,7 +80,8 @@ import com.vitorpamplona.amethyst.commons.ui.platform.AppBottomBar import com.vitorpamplona.amethyst.commons.ui.platform.rememberConcordImageModel import com.vitorpamplona.amethyst.commons.ui.pluralStringRes import com.vitorpamplona.amethyst.commons.ui.screen.LocalDisplaySettings -import com.vitorpamplona.amethyst.commons.ui.screen.loggedIn.chats.publicChannels.concord.ConcordPendingDirectInvites +import com.vitorpamplona.amethyst.commons.ui.screen.loggedIn.chats.publicChannels.concord.RefreshConcordDirectInvites +import com.vitorpamplona.amethyst.commons.ui.screen.loggedIn.chats.publicChannels.concord.concordPendingDirectInvites import com.vitorpamplona.amethyst.commons.ui.screen.loggedIn.chats.publicChannels.concord.datasource.ConcordChannelSubscription import com.vitorpamplona.amethyst.commons.ui.stringRes import com.vitorpamplona.amethyst.commons.viewmodels.AccountViewModel @@ -120,6 +121,11 @@ fun ConcordHomeScreen( // the stock relays for users who actually use Concord. LaunchedEffect(Unit) { accountViewModel.importConcordCommunities() } + // Direct Invites (CORD-05 §6): one inbox sweep per visit, kept out of the lazy list so it does + // not re-run each time the invites scroll back into view. + RefreshConcordDirectInvites(accountViewModel) + val invites by account.concord.pendingConcordDirectInvites.collectAsStateWithLifecycle() + // Per-community expansion, cycled on tap: absent = CLOSED → UNREAD (peek only the channels with // new messages) → OPEN (all channels) → CLOSED. Multi-open, so several can be expanded at once. // rememberSaveable so the chevron states survive opening a channel and coming back to the hub. @@ -161,16 +167,18 @@ fun ConcordHomeScreen( ) { padding -> if (communities.isEmpty()) { // Direct Invites (CORD-05 §6) are how a first community usually arrives, so they show - // above the empty state rather than being hidden by it. - Column(Modifier.fillMaxSize().padding(padding)) { - ConcordPendingDirectInvites(accountViewModel, nav) - Box(Modifier.fillMaxWidth().weight(1f), contentAlignment = Alignment.Center) { - Text( - stringRes(Res.string.concord_home_empty), - style = MaterialTheme.typography.bodyMedium, - color = MaterialTheme.colorScheme.onSurfaceVariant, - modifier = Modifier.padding(horizontal = 32.dp), - ) + // above the empty state rather than being hidden by it — in a lazy list, so many scroll. + LazyColumn(Modifier.fillMaxSize().padding(padding)) { + concordPendingDirectInvites(invites, accountViewModel, nav) + item(key = "concord-home-empty") { + Box(Modifier.fillParentMaxWidth().fillParentMaxHeight(if (invites.isEmpty()) 1f else 0.5f), contentAlignment = Alignment.Center) { + Text( + stringRes(Res.string.concord_home_empty), + style = MaterialTheme.typography.bodyMedium, + color = MaterialTheme.colorScheme.onSurfaceVariant, + modifier = Modifier.padding(horizontal = 32.dp), + ) + } } } return@Scaffold @@ -195,7 +203,7 @@ fun ConcordHomeScreen( LazyColumn(Modifier.fillMaxSize().padding(padding)) { // Pending Direct Invites (CORD-05 §6), parked until the user accepts or declines. - item(key = "concord-direct-invites") { ConcordPendingDirectInvites(accountViewModel, nav) } + concordPendingDirectInvites(invites, accountViewModel, nav) sorted.forEach { entry -> val state = diff --git a/commonsUI/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/ui/screen/loggedIn/chats/publicChannels/concord/ConcordMembersScreen.kt b/commonsUI/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/ui/screen/loggedIn/chats/publicChannels/concord/ConcordMembersScreen.kt index 0ee288bd3b..27b70f9428 100644 --- a/commonsUI/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/ui/screen/loggedIn/chats/publicChannels/concord/ConcordMembersScreen.kt +++ b/commonsUI/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/ui/screen/loggedIn/chats/publicChannels/concord/ConcordMembersScreen.kt @@ -66,6 +66,9 @@ import com.vitorpamplona.amethyst.commons.resources.concord_members_ban import com.vitorpamplona.amethyst.commons.resources.concord_members_ban_message import com.vitorpamplona.amethyst.commons.resources.concord_members_ban_title import com.vitorpamplona.amethyst.commons.resources.concord_members_empty +import com.vitorpamplona.amethyst.commons.resources.concord_members_kick +import com.vitorpamplona.amethyst.commons.resources.concord_members_kick_message +import com.vitorpamplona.amethyst.commons.resources.concord_members_kick_title import com.vitorpamplona.amethyst.commons.resources.concord_members_make_admin import com.vitorpamplona.amethyst.commons.resources.concord_members_remove import com.vitorpamplona.amethyst.commons.resources.concord_members_remove_admin @@ -82,6 +85,8 @@ import com.vitorpamplona.amethyst.commons.resources.concord_members_title import com.vitorpamplona.amethyst.commons.resources.concord_members_unban import com.vitorpamplona.amethyst.commons.resources.concord_role_admin import com.vitorpamplona.amethyst.commons.resources.concord_role_banned +import com.vitorpamplona.amethyst.commons.resources.concord_role_kicked +import com.vitorpamplona.amethyst.commons.resources.concord_role_left import com.vitorpamplona.amethyst.commons.resources.concord_role_owner import com.vitorpamplona.amethyst.commons.resources.more_options import com.vitorpamplona.amethyst.commons.ui.navigation.navs.INav @@ -91,6 +96,8 @@ import com.vitorpamplona.amethyst.commons.ui.screen.loggedIn.chats.publicChannel import com.vitorpamplona.amethyst.commons.ui.stringRes import com.vitorpamplona.amethyst.commons.ui.theme.Size35dp import com.vitorpamplona.amethyst.commons.viewmodels.AccountViewModel +import com.vitorpamplona.quartz.concord.cord02Community.GuestbookAction +import com.vitorpamplona.quartz.concord.cord02Community.GuestbookEntry import com.vitorpamplona.quartz.concord.cord04Roles.ConcordPermissions import com.vitorpamplona.quartz.nip01Core.core.HexKey import kotlinx.coroutines.flow.MutableStateFlow @@ -134,12 +141,16 @@ fun ConcordMembersScreen( // roster collapses to just the owner + privileged roles. val guestbookMembers by (session?.members ?: remember { MutableStateFlow(emptySet()) }).collectAsStateWithLifecycle() val observedAuthors by (session?.observedAuthors ?: remember { MutableStateFlow(emptySet()) }).collectAsStateWithLifecycle() + // The coalesced Guestbook: a member whose latest motion is a Leave or an honored Kick (and who has + // not posted since) shows as departed (CORD-02 §5, CORD-04 §6). + val guestbook by (session?.guestbook ?: remember { MutableStateFlow(emptyMap()) }).collectAsStateWithLifecycle() val myPubKey = account.signer.pubKey val roster = - remember(state, guestbookMembers, observedAuthors) { + remember(state, guestbookMembers, observedAuthors, guestbook) { val s = state ?: return@remember emptyList() val authority = s.authority + val departed = session?.departedMembers().orEmpty() val pubkeys = (listOf(s.ownerPubKey) + authority.roleHolders() + authority.bannedMembers() + guestbookMembers + observedAuthors) .map { it.lowercase() } @@ -154,8 +165,8 @@ fun ConcordMembersScreen( .minByOrNull { r -> r.position } ?.name ?.takeIf { n -> n.isNotBlank() } - RosterEntry(it, ConcordMembership.of(authority, it), roleName, authority.rolesOf(it)) - }.sortedWith(compareBy({ it.membership.sortRank() }, { it.pubkey })) + RosterEntry(it, ConcordMembership.of(authority, it), roleName, authority.rolesOf(it), departed[it]?.action) + }.sortedWith(compareBy({ it.sortRank() }, { it.pubkey })) } val iAmOwner = state?.authority?.isOwner(myPubKey) == true @@ -164,6 +175,7 @@ fun ConcordMembersScreen( // which IS ban-aware — a thin margin for the escalation in docs/concord-soft-ban-audit.md. val iCanBan = state?.let { it.authority.isOwner(myPubKey) || it.authority.hasPermission(myPubKey, ConcordPermissions.BAN) } == true val iCanManageRoles = state?.authority?.hasPermission(myPubKey, ConcordPermissions.MANAGE_ROLES) == true + val iCanKick = state?.let { it.authority.isOwner(myPubKey) || it.authority.hasPermission(myPubKey, ConcordPermissions.KICK) } == true // The roles this viewer may actually hand out. The fold drops a grant whose granter does // not *strictly* outrank every assigned role, so offering a role at or above our own @@ -224,6 +236,8 @@ fun ConcordMembersScreen( canBanTarget = iAmOwner || state?.authority?.canActOn(myPubKey, entry.pubkey, ConcordPermissions.BAN) == true, + // A Kick needs KICK and a strict outrank of the target (CORD-04 §6), the same rank rule. + canKickTarget = iCanKick && state?.authority?.canActOn(myPubKey, entry.pubkey, ConcordPermissions.KICK) == true, viewerCanManageRoles = iCanManageRoles, // canActOn folds the whole rank rule for us: we hold MANAGE_ROLES, we're not // banned, the target isn't the owner (unremovable), and we strictly outrank @@ -248,6 +262,7 @@ private fun ConcordMemberRow( viewerIsOwner: Boolean, viewerCanBan: Boolean, canBanTarget: Boolean, + canKickTarget: Boolean, viewerCanManageRoles: Boolean, canManageRolesOnTarget: Boolean, assignableRoles: List, @@ -266,6 +281,8 @@ private fun ConcordMemberRow( val canBan = viewerCanBan && canBanTarget && !isOwnerTarget && !isSelf // Hard removal (CORD-06 Refounding) rotates the community key; same authority as ban. val canRemove = viewerCanBan && canBanTarget && !isOwnerTarget && !isSelf + // A Kick is the cooperative removal (CORD-04 §6): pointless against a banned or already-kicked member. + val canKick = canKickTarget && !isOwnerTarget && !isSelf && !isBanned && entry.departure != GuestbookAction.KICK // Shown to any MANAGE_ROLES holder, but disabled with a reason when this particular // member (or every defined role) is out of our reach — a grant we don't outrank // publishes fine and is then dropped by every client's fold, so a silently no-op @@ -277,7 +294,7 @@ private fun ConcordMemberRow( assignableRoles.isEmpty() -> stringRes(Res.string.concord_members_roles_none_assignable) else -> null } - val hasMenu = canToggleAdmin || canBan || canRemove || viewerCanManageRoles + val hasMenu = canToggleAdmin || canBan || canRemove || canKick || viewerCanManageRoles var editRoles by remember { mutableStateOf(false) } if (editRoles) { @@ -292,6 +309,17 @@ private fun ConcordMemberRow( ) } + var confirmKick by remember { mutableStateOf(false) } + if (confirmKick) { + ConcordKickMemberDialog( + onConfirm = { + accountViewModel.kickConcordMember(communityId, entry.pubkey) + confirmKick = false + }, + onDismiss = { confirmKick = false }, + ) + } + // A ban is reversible here, but not for the banned member: clients such as Armada drop the // community from a banned member's list on sight, so a mis-tap still costs them the community. var confirmBan by remember { mutableStateOf(false) } @@ -335,7 +363,7 @@ private fun ConcordMemberRow( Text(entry.pubkey.take(8), fontWeight = FontWeight.SemiBold, maxLines = 1, overflow = TextOverflow.Ellipsis) } } - MemberBadge(entry.membership, entry.roleName) + MemberBadge(entry.membership, entry.roleName, entry.departure) if (hasMenu) { var expanded by remember { mutableStateOf(false) } // One Box for button + menu: an expanded DropdownMenu emits a node, and as a direct child @@ -375,6 +403,15 @@ private fun ConcordMemberRow( }, ) } + if (canKick) { + DropdownMenuItem( + text = { Text(stringRes(Res.string.concord_members_kick)) }, + onClick = { + confirmKick = true + expanded = false + }, + ) + } if (canBan) { DropdownMenuItem( text = { Text(stringRes(if (isBanned) Res.string.concord_members_unban else Res.string.concord_members_ban)) }, @@ -405,15 +442,18 @@ private fun ConcordMemberRow( } } -/** A small pill labelling the member's standing (owner / role name / banned; plain members render nothing). */ +/** A small pill labelling the member's standing (owner / role name / banned / kicked / left; plain members render nothing). */ @Composable private fun MemberBadge( membership: ConcordMembership, roleName: String?, + departure: GuestbookAction?, ) { val label = when { membership == ConcordMembership.BANNED -> stringRes(Res.string.concord_role_banned) + departure == GuestbookAction.KICK -> stringRes(Res.string.concord_role_kicked) + departure == GuestbookAction.LEAVE -> stringRes(Res.string.concord_role_left) membership == ConcordMembership.OWNER -> stringRes(Res.string.concord_role_owner) // Show the actual granted role ("Admin", "Moderator", or a custom role) rather than a // one-size-fits-all badge; fall back to the generic "Admin" label if a role-holder's @@ -422,8 +462,18 @@ private fun MemberBadge( membership == ConcordMembership.ADMIN -> stringRes(Res.string.concord_role_admin) else -> return } - val container = if (membership == ConcordMembership.BANNED) MaterialTheme.colorScheme.errorContainer else MaterialTheme.colorScheme.primaryContainer - val content = if (membership == ConcordMembership.BANNED) MaterialTheme.colorScheme.onErrorContainer else MaterialTheme.colorScheme.onPrimaryContainer + val container = + when { + membership == ConcordMembership.BANNED -> MaterialTheme.colorScheme.errorContainer + departure != null -> MaterialTheme.colorScheme.surfaceVariant + else -> MaterialTheme.colorScheme.primaryContainer + } + val content = + when { + membership == ConcordMembership.BANNED -> MaterialTheme.colorScheme.onErrorContainer + departure != null -> MaterialTheme.colorScheme.onSurfaceVariant + else -> MaterialTheme.colorScheme.onPrimaryContainer + } Surface(shape = RoundedCornerShape(6.dp), color = container) { Text( text = label, @@ -492,6 +542,27 @@ private fun ConcordRolesDialog( ) } +/** Confirms a Kick — spells out that it is cooperative and re-joinable (CORD-04 §6). */ +@Composable +private fun ConcordKickMemberDialog( + onConfirm: () -> Unit, + onDismiss: () -> Unit, +) { + AlertDialog( + onDismissRequest = onDismiss, + title = { Text(stringRes(Res.string.concord_members_kick_title)) }, + text = { Text(stringRes(Res.string.concord_members_kick_message)) }, + confirmButton = { + TextButton(onClick = onConfirm) { + Text(stringRes(Res.string.concord_members_kick), color = MaterialTheme.colorScheme.error) + } + }, + dismissButton = { + TextButton(onClick = onDismiss) { Text(stringRes(Res.string.cancel)) } + }, + ) +} + /** Confirms a hard removal — spells out that it rotates the community key (CORD-06). */ @Composable private fun ConcordConfirmMemberActionDialog( @@ -523,6 +594,8 @@ private class RosterEntry( val roleName: String?, /** Every role id the member currently holds — the preselection for the role picker. */ val roleIds: Set, + /** Their winning Leave or honored Kick when the Guestbook shows them departed, else null. */ + val departure: GuestbookAction?, ) /** One role the viewer is allowed to hand out, ordered by [position] (lower ranks higher). */ @@ -532,7 +605,9 @@ private class AssignableRole( val position: Long, ) -/** Owner first, then admins, then plain members, then banned last. */ +/** Owner first, then admins, then plain members, then departed (left/kicked) members, then banned last. */ +private fun RosterEntry.sortRank(): Int = if (departure != null && membership != ConcordMembership.BANNED && membership != ConcordMembership.OWNER) 35 else membership.sortRank() * 10 + private fun ConcordMembership.sortRank(): Int = when (this) { ConcordMembership.OWNER -> 0 diff --git a/commonsUI/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/ui/screen/loggedIn/chats/publicChannels/concord/ConcordPinnedMessages.kt b/commonsUI/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/ui/screen/loggedIn/chats/publicChannels/concord/ConcordPinnedMessages.kt index 9bf91f3b60..627e92a3ba 100644 --- a/commonsUI/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/ui/screen/loggedIn/chats/publicChannels/concord/ConcordPinnedMessages.kt +++ b/commonsUI/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/ui/screen/loggedIn/chats/publicChannels/concord/ConcordPinnedMessages.kt @@ -31,6 +31,7 @@ import androidx.compose.foundation.layout.padding import androidx.compose.foundation.layout.size import androidx.compose.foundation.lazy.LazyColumn import androidx.compose.foundation.lazy.items +import androidx.compose.material3.AlertDialog import androidx.compose.material3.Badge import androidx.compose.material3.BadgedBox import androidx.compose.material3.ExperimentalMaterial3Api @@ -39,11 +40,12 @@ import androidx.compose.material3.IconButton import androidx.compose.material3.MaterialTheme import androidx.compose.material3.ModalBottomSheet import androidx.compose.material3.Text +import androidx.compose.material3.TextButton import androidx.compose.material3.rememberModalBottomSheetState import androidx.compose.runtime.Composable -import androidx.compose.runtime.LaunchedEffect import androidx.compose.runtime.State import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.produceState import androidx.compose.runtime.remember import androidx.compose.ui.Alignment @@ -51,6 +53,7 @@ import androidx.compose.ui.Modifier import androidx.compose.ui.text.font.FontWeight import androidx.compose.ui.text.style.TextOverflow import androidx.compose.ui.unit.dp +import androidx.lifecycle.compose.collectAsStateWithLifecycle import com.vitorpamplona.amethyst.commons.actions.ConcordChannelPins import com.vitorpamplona.amethyst.commons.actions.ConcordPinnedMessage import com.vitorpamplona.amethyst.commons.actions.ConcordPinning @@ -58,8 +61,14 @@ import com.vitorpamplona.amethyst.commons.icons.symbols.Icon import com.vitorpamplona.amethyst.commons.icons.symbols.MaterialSymbol import com.vitorpamplona.amethyst.commons.icons.symbols.MaterialSymbols import com.vitorpamplona.amethyst.commons.model.cache.LocalCache +import com.vitorpamplona.amethyst.commons.model.nip92IMeta.appendMissingImetaUrls +import com.vitorpamplona.amethyst.commons.model.toImmutableListOfLists import com.vitorpamplona.amethyst.commons.relayClient.user.observeUserInfo import com.vitorpamplona.amethyst.commons.resources.Res +import com.vitorpamplona.amethyst.commons.resources.cancel +import com.vitorpamplona.amethyst.commons.resources.concord_pin_expiring_body +import com.vitorpamplona.amethyst.commons.resources.concord_pin_expiring_confirm +import com.vitorpamplona.amethyst.commons.resources.concord_pin_expiring_title import com.vitorpamplona.amethyst.commons.resources.concord_pinned_budget import com.vitorpamplona.amethyst.commons.resources.concord_pinned_empty import com.vitorpamplona.amethyst.commons.resources.concord_pinned_open_hint @@ -68,6 +77,8 @@ import com.vitorpamplona.amethyst.commons.resources.concord_pinned_unavailable import com.vitorpamplona.amethyst.commons.resources.message_edited import com.vitorpamplona.amethyst.commons.resources.relay_group_pinned_content_description import com.vitorpamplona.amethyst.commons.resources.relay_group_unpin_message +import com.vitorpamplona.amethyst.commons.ui.components.TranslatableRichTextViewer +import com.vitorpamplona.amethyst.commons.ui.navigation.navs.INav import com.vitorpamplona.amethyst.commons.ui.note.timeAgoNoDot import com.vitorpamplona.amethyst.commons.ui.stringRes import com.vitorpamplona.amethyst.commons.ui.theme.placeholderText @@ -76,8 +87,13 @@ import com.vitorpamplona.quartz.concord.cord03Channels.ConcordChatEditEvent import com.vitorpamplona.quartz.concord.cord04Roles.pins.ConcordPins import com.vitorpamplona.quartz.nip01Core.core.HexKey import com.vitorpamplona.quartz.nip09Deletions.DeletionRequestEvent +import com.vitorpamplona.quartz.utils.TimeUtils import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.ExperimentalCoroutinesApi import kotlinx.coroutines.delay +import kotlinx.coroutines.flow.collectLatest +import kotlinx.coroutines.flow.conflate +import kotlinx.coroutines.flow.distinctUntilChanged import kotlinx.coroutines.flow.filter import kotlinx.coroutines.flow.map import kotlinx.coroutines.flow.merge @@ -86,9 +102,15 @@ import org.jetbrains.compose.resources.StringResource /** * [channelId]'s verified pins (CORD-04 §7), re-read whenever the Control Plane seats a new Pin List - * head, the fold changes, or a delete / Edit lands in the cache (a held delete hides its entry at - * once; a held newer Edit marks it edited). Null until the community has folded the channel. + * head, the fold changes or finishes draining, a delete / Edit naming a pinned message lands in the + * cache (a held delete hides its entry at once; a held newer Edit marks it edited), or a pinned + * message's disappearing-message deadline passes (CORD-08 §3). Null until the community has folded + * the channel. + * + * The session is looked up again on every session-set change: it may not exist at first + * composition, and a Refounding replaces it — a captured one would read the dead epoch forever. */ +@OptIn(ExperimentalCoroutinesApi::class) @Composable fun rememberConcordChannelPins( communityId: String, @@ -97,56 +119,100 @@ fun rememberConcordChannelPins( ): State { val account = accountViewModel.account return produceState(null, account, communityId, channelId) { - val session = account.concordSessions.sessionFor(communityId) ?: return@produceState - val evidence = - account.cache.live.newEventBundles.filter { notes -> - notes.any { it.event is DeletionRequestEvent || it.event is ConcordChatEditEvent } + account.concordSessions.revision + .map { account.concordSessions.sessionFor(communityId) } + .distinctUntilChanged { a, b -> a === b } + .collectLatest { session -> + if (session == null) { + value = null + return@collectLatest + } + // Only deletes and Edits that name a message this list carries can change the read. + val evidence = + account.cache.live.newEventBundles.filter { notes -> + val carried = value?.rumorIds ?: return@filter true + notes.any { note -> + val event = note.event + (event is DeletionRequestEvent || event is ConcordChatEditEvent) && + event.tags.any { it.size >= 2 && it[0] == "e" && it[1] in carried } + } + } + merge(session.pinHeads.map { }, session.state.map { }, session.controlDrained.map { }, evidence.map { }) + .conflate() + .collectLatest { + // Re-read, then sleep until the next pinned message expires: an expired one + // leaves the list, and nothing else would trigger that re-read. A new trigger + // cancels the wait. + while (true) { + val pins = withContext(Dispatchers.Default) { account.concord.concordChannelPins(communityId, channelId) } + value = pins + val now = TimeUtils.now() + val next = pins?.nextExpiry(now) ?: break + delay((next - now) * 1000 + 250) + } + } } - merge(session.pinHeads.map { }, session.state.map { }, evidence.map { }).collect { - value = withContext(Dispatchers.Default) { account.concord.concordChannelPins(communityId, channelId) } - } } } /** - * The deletion omission and the Edit refresh a PIN_MESSAGES holder owes keyless readers (§7), run - * the way the spec asks: after a short random wait, re-read, and publish only if still owed — so - * simultaneous curators collapse to one publisher and a burst of edits costs one write. One attempt - * per distinct debt, so a failure never spins. + * [pins] as a reader should see them: entries by a banned author (CORD-04 §4 — every client declines + * to show their posts) or by someone this account mutes or blocks are left out. */ @Composable -fun ConcordPinDuties( +fun rememberVisibleConcordPins( communityId: String, - channelId: String, - pins: ConcordChannelPins?, + pins: ConcordChannelPins, accountViewModel: AccountViewModel, -) { - val debt = - remember(pins) { - pins - ?.takeIf { it.owesRepublish } - ?.let { p -> (p.killed.map { "d" + it.rumorId } + p.pins.mapNotNull { it.newerEdit?.let { e -> "e" + e.rumorId } }).sorted().joinToString("|") } - } ?: return - val attempted = remember(communityId, channelId) { HashSet() } - LaunchedEffect(communityId, channelId, debt) { - if (debt in attempted || !accountViewModel.account.concord.canPinConcord(communityId)) return@LaunchedEffect - delay(ConcordPinning.dutyDelayMs()) - attempted.add(debt) - accountViewModel.launchSigner { accountViewModel.account.concord.settleConcordPins(communityId, channelId) } +): List { + val account = accountViewModel.account + val revision by account.concordSessions.revision.collectAsStateWithLifecycle() + val hidden by account.hiddenUsers.flow.collectAsStateWithLifecycle() + return remember(pins, revision, hidden) { + val authority = + account.concordSessions + .sessionFor(communityId) + ?.state + ?.value + ?.authority + ConcordPinning.visible(pins, isBanned = { authority?.isBanned(it) == true }, isHidden = { account.isHidden(it) }) } } +/** + * The Pin action on a disappearing message (one carrying a CORD-08 `expiration`) asks first: the pin + * carries the message's words in its proof, so it keeps them readable after the timer erased the + * message everywhere else. + */ +@Composable +fun ConcordExpiringPinDialog( + onConfirm: () -> Unit, + onDismiss: () -> Unit, +) { + AlertDialog( + onDismissRequest = onDismiss, + title = { Text(stringRes(Res.string.concord_pin_expiring_title)) }, + text = { Text(stringRes(Res.string.concord_pin_expiring_body)) }, + confirmButton = { TextButton(onClick = onConfirm) { Text(stringRes(Res.string.concord_pin_expiring_confirm)) } }, + dismissButton = { TextButton(onClick = onDismiss) { Text(stringRes(Res.string.cancel)) } }, + ) +} + /** The channel header's pinned-messages entry point: a pin with a count badge. Hidden when there is nothing to show. */ @Composable fun ConcordPinnedButton( + communityId: String, pins: ConcordChannelPins?, + accountViewModel: AccountViewModel, onClick: () -> Unit, ) { - if (pins == null || (pins.count == 0 && !pins.sealedUnavailable)) return + if (pins == null) return + val count = rememberVisibleConcordPins(communityId, pins, accountViewModel).size + if (count == 0 && !pins.sealedUnavailable) return IconButton(onClick = onClick) { BadgedBox( badge = { - if (pins.count > 0) Badge { Text(pins.count.toString()) } + if (count > 0) Badge { Text(count.toString()) } }, ) { Icon(symbol = MaterialSymbols.PushPin, contentDescription = stringRes(Res.string.relay_group_pinned_content_description)) @@ -156,8 +222,9 @@ fun ConcordPinnedButton( /** * The pinned-messages sheet: each verified pin with its author, time and words (marked edited when - * revised), an "unavailable" notice when the list is sealed under a key this account never held, - * a jump to the message when it resolves locally, and Unpin for those who may write pins. + * revised) rendered like the chat feed renders the message — links, mentions and its `imeta` + * attachments included — an "unavailable" notice when the list is sealed under a key this account + * never held, a jump to the message when it resolves locally, and Unpin for those who may write pins. */ @OptIn(ExperimentalMaterial3Api::class) @Composable @@ -166,11 +233,16 @@ fun ConcordPinnedMessagesSheet( channelId: String, pins: ConcordChannelPins, accountViewModel: AccountViewModel, + nav: INav, onJumpToMessage: (HexKey) -> Unit, onDismiss: () -> Unit, ) { val canPin = remember(pins) { accountViewModel.account.concord.canPinConcord(communityId) } - val session = remember(communityId) { accountViewModel.account.concordSessions.sessionFor(communityId) } + val revision by accountViewModel.account.concordSessions.revision + .collectAsStateWithLifecycle() + val session = remember(communityId, revision) { accountViewModel.account.concordSessions.sessionFor(communityId) } + // Banned authors and muted/blocked users stay out of the sheet, as they do from the feed. + val shown = rememberVisibleConcordPins(communityId, pins, accountViewModel) ModalBottomSheet( onDismissRequest = onDismiss, @@ -198,7 +270,7 @@ fun ConcordPinnedMessagesSheet( modifier = Modifier.padding(horizontal = 16.dp), ) } - if (pins.count > 0) { + if (shown.isNotEmpty()) { Text( text = stringRes(Res.string.concord_pinned_open_hint), style = MaterialTheme.typography.labelSmall, @@ -210,16 +282,18 @@ fun ConcordPinnedMessagesSheet( if (pins.sealedUnavailable) { PinNotice(Res.string.concord_pinned_unavailable, MaterialSymbols.Lock) - } else if (pins.count == 0) { + } else if (shown.isEmpty() && pins.complete) { + // Only a drained fold may say "no pins"; before that the list may simply not be served yet. PinNotice(Res.string.concord_pinned_empty, MaterialSymbols.PushPin) } LazyColumn { - items(pins.pins, key = { it.rumorId }) { pinned -> + items(shown, key = { it.rumorId }) { pinned -> val jumpable = remember(pinned.rumorId, session) { session?.holdsRumor(pinned.rumorId) == true } PinnedRow( pinned = pinned, accountViewModel = accountViewModel, + nav = nav, onClick = if (jumpable) { { @@ -257,6 +331,7 @@ private fun PinNotice( private fun PinnedRow( pinned: ConcordPinnedMessage, accountViewModel: AccountViewModel, + nav: INav, onClick: (() -> Unit)?, onUnpin: (() -> Unit)?, ) { @@ -292,12 +367,7 @@ private fun PinnedRow( ) } } - Text( - text = pinned.content, - style = MaterialTheme.typography.bodyMedium, - maxLines = 6, - overflow = TextOverflow.Ellipsis, - ) + PinnedContent(pinned, accountViewModel, nav) } if (onUnpin != null) { IconButton(onClick = onUnpin) { @@ -307,6 +377,35 @@ private fun PinnedRow( } } +/** + * The pinned message's words and attachments through the chat feed's own pipeline: the rumor rebuilt + * from the proof (its encrypted attachments' keys registered), an attachment-only message given its + * `imeta` URLs as text exactly as the feed does, and the shared rich-text viewer rendering the media. + */ +@Composable +private fun PinnedContent( + pinned: ConcordPinnedMessage, + accountViewModel: AccountViewModel, + nav: INav, +) { + val rumor = remember(pinned) { accountViewModel.account.concord.concordPinnedRumor(pinned) } + val tags = remember(rumor) { rumor.tags.toImmutableListOfLists() } + val content = remember(rumor) { appendMissingImetaUrls(rumor.content, rumor) } + val background = MaterialTheme.colorScheme.surface + val backgroundColor = remember(background) { mutableStateOf(background) } + TranslatableRichTextViewer( + content = content, + canPreview = true, + quotesLeft = 0, + tags = tags, + backgroundColor = backgroundColor, + id = pinned.rumorId, + authorPubKey = pinned.author, + accountViewModel = accountViewModel, + nav = nav, + ) +} + /** [hex]'s best display name, reactively, falling back to a short hex. */ @Composable private fun rememberPinAuthorName( diff --git a/commonsUI/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/viewmodels/AccountViewModel.kt b/commonsUI/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/viewmodels/AccountViewModel.kt index 5f6b424ee1..04fd5e1192 100644 --- a/commonsUI/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/viewmodels/AccountViewModel.kt +++ b/commonsUI/src/commonMain/kotlin/com/vitorpamplona/amethyst/commons/viewmodels/AccountViewModel.kt @@ -75,8 +75,13 @@ import com.vitorpamplona.amethyst.commons.resources.cashu_failed_redemption import com.vitorpamplona.amethyst.commons.resources.cashu_failed_redemption_explainer_error_msg import com.vitorpamplona.amethyst.commons.resources.cashu_successful_redemption import com.vitorpamplona.amethyst.commons.resources.cashu_successful_redemption_explainer +import com.vitorpamplona.amethyst.commons.resources.concord_kicked_message +import com.vitorpamplona.amethyst.commons.resources.concord_kicked_message_unnamed +import com.vitorpamplona.amethyst.commons.resources.concord_kicked_title +import com.vitorpamplona.amethyst.commons.resources.concord_members_kick_failed import com.vitorpamplona.amethyst.commons.resources.concord_members_roles_failed import com.vitorpamplona.amethyst.commons.resources.concord_members_roles_title +import com.vitorpamplona.amethyst.commons.resources.concord_members_title import com.vitorpamplona.amethyst.commons.resources.concord_pin_failed_generic import com.vitorpamplona.amethyst.commons.resources.concord_pin_failed_message import com.vitorpamplona.amethyst.commons.resources.concord_pin_failed_title @@ -288,6 +293,18 @@ class AccountViewModel( } } } + + // An honored Kick made us leave a Concord community (CORD-04 §6); the removal is otherwise silent. + viewModelScope.launch { + account.concord.concordKicks.collect { notice -> + val name = notice.communityName?.takeIf { it.isNotBlank() } + if (name != null) { + toastManager.toast(Res.string.concord_kicked_title, Res.string.concord_kicked_message, name) + } else { + toastManager.toast(Res.string.concord_kicked_title, Res.string.concord_kicked_message_unnamed) + } + } + } } /** @@ -668,6 +685,16 @@ class AccountViewModel( if (ban) account.concord.banConcordMember(communityId, member) else account.concord.unbanConcordMember(communityId, member) } + /** Kick [member] from [communityId] (CORD-04 §6: strip their roles, then the Guestbook directive). */ + fun kickConcordMember( + communityId: String, + member: HexKey, + ) = launchSigner { + if (!account.concord.kickConcordMember(communityId, member)) { + toastManager.toast(Res.string.concord_members_title, Res.string.concord_members_kick_failed) + } + } + /** * Remove [member] from [communityId] absolutely (CORD-06 Refounding): rotate the * community key so the member's key stops working for anything sent afterwards. diff --git a/quartz/plans/2026-09-29-concord-spec-conformance.md b/quartz/plans/2026-09-29-concord-spec-conformance.md index 51f1ff2cc6..a8324e1e6a 100644 --- a/quartz/plans/2026-09-29-concord-spec-conformance.md +++ b/quartz/plans/2026-09-29-concord-spec-conformance.md @@ -70,7 +70,7 @@ Ranked security > interop > feature inside each group. | I9 | 06 §3 | Rotations carry no `vac` | **fixed** — rotations carry `vac` on every chunk (`ConcordRotationAuthority.citationFor`, owner none); receivers require `ConcordReceive.isHonoredRotation` (BAN + `citationSatisfied`, Armada semantics) in the app drain and CLI `rekey`; a rotator whose chunks cite different Grants is dropped | | I10 | 06 | 120 base blobs per chunk can overflow NIP-44; Armada budgets 99 @104 B / 90 @136 B | **fixed** — `ConcordRekey.chunkBlobs` budgets the rumor JSON at 40,960 bytes (Armada `REKEY_RUMOR_MAX_BYTES`) plus the 120 count cap; test pins the seal (wrap plaintext) ≤ 65,535 with 136-byte blobs | | I11 | 05 §3 | Invite links carry more than 3 bootstrap relays; Armada's decoder throws | **fixed** — `encodeFragment` truncates non-stock lists to 3 (stock set stays a flag); `decodeFragment` refuses count > 3 | -| I12 | 06 §3 | No race convergence (lowest new root), not idempotent on retry | **fixed** — `findNewRoot` converges on the lowest authorized root (`accept` filter before `converge`); sessions watch the current epoch's own rekey address and `drainConcordRekeys` heals down-only (`ConcordReceive.withHealedRoot`), keeping the losing root as a same-epoch held root (only the lowest per epoch is folded: `canonicalHeldRoots`); retries reuse reserved keys (`ConcordRefounding.reserveKeys`; in-memory in the app, persisted in amy's store). Not done: the CLI has no heal step; re-issuing a losing branch's channel keys (no private channels yet, F7) | +| I12 | 06 §3 | No race convergence (lowest new root), not idempotent on retry | **fixed** — `findNewRoot` converges on the lowest authorized root (`accept` filter before `converge`); sessions watch the current epoch's own rekey address and `drainConcordRekeys` heals down-only (`ConcordReceive.withHealedRoot`), keeping the losing root as a same-epoch held root (only the lowest per epoch is folded: `canonicalHeldRoots`); retries reuse reserved keys (`ConcordRefounding.reserveKeys`; in-memory in the app, persisted in amy's store). Not done: the CLI has no heal step; re-issuing a losing branch's channel keys on the winning chain (F7 rotates private channels inside a Refounding under the prior root, which both branches can open, but a losing refounder does not yet re-issue its channel keys after the heal) | | I13 | 03 §3 | Binding check not strict (duplicates accepted, `"04"`/`"+4"` parse) | **fixed** — exactly one `channel` and one `epoch` tag, epoch compared as its canonical decimal string (Armada `uniqueTag`/`checkChannelBinding`); builders drop binding tags smuggled in `extraTags` | | I14 | 03 §2 | Channel deletion not terminal across the chain; no 64-byte name cap | **fixed** — any gated channel edition with `deleted:true` retires the channel for good (Armada `everDeleted`); the channel gate refuses an empty or >64-byte name so the fold falls back to the previous candidate, and `defineChannel`/create/rename refuse to mint one | | I15 | 02 §4 | No `ms` tag on chat rumors | **fixed** — every `ChannelChat` rumor carries `["ms", 0..999]` after the binding; malformed/duplicated `ms` drops the rumor; `channelMessages` and edit recency order by `created_at*1000+ms` (the shared feed still sorts by `created_at`; open PR #7 may drop `ms`) | @@ -82,19 +82,59 @@ Ranked security > interop > feature inside each group. | # | Spec | Finding | Status | |---|---|---|---| -| F1 | 04 §7 | Pins | **fixed** — commons `ConcordPinning` reads each Channel's Pin List off the session fold (`pinHeads`, gated on PIN_MESSAGES + `vac`, with the fold's floors), opens the sealed form with the held key of its epoch (`sealedUnavailable` kept distinct from empty), verifies entries through a per-entry-identity cache, hides entries killed by the author's held kind 5 and marks entries behind a newer held Edit as edited; pin/unpin reopen the message's original wrap (session rumor→wrap index) and write the next edition over the head read, in the channel's folded form (a private-era sealed list is never re-formed public), withheld when unreadable, refused past 25 entries / 32,768 bytes; deleting your own pinned message publishes the omission at once, and an open channel runs the delayed (3–15 s) re-read-then-publish duty for other holders' omissions and the Edit refresh. App: Pin/Unpin in the message sheet, header pin badge + pinned sheet (author, time, edited, unavailable, jump), budget line; `amy concord pins/pin/unpin`. Also fixed `DeletionIndex.DeletionRequest.compareTo` (compared the pubkey with itself, so any author's kind 5 matched on JVM/Android). Open SHOULDs: the duties run only while the channel screen is open (no background scheduler); a Rotator does not republish under the new key after a private-channel rekey, and a Banlist revert is not re-healed; compaction does not omit a deleted Channel's Pin List; pinned attachments render as text only | +| F1 | 04 §7 | Pins | **fixed** — commons `ConcordPinning` reads each Channel's Pin List off the session fold (`pinHeads`, gated on PIN_MESSAGES + `vac`, with the fold's floors), opens the sealed form with the held key of its epoch (`sealedUnavailable` kept distinct from empty), verifies entries through a per-entry-identity cache, hides entries killed by the author's held kind 5 and marks entries behind a newer held Edit as edited; pin/unpin reopen the message's original wrap (session rumor→wrap index) and write the next edition over the head read, in the channel's folded form (a private-era sealed list is never re-formed public), withheld when unreadable, refused past 25 entries / 32,768 bytes; deleting your own pinned message publishes the omission at once, and an open channel runs the delayed (3–15 s) re-read-then-publish duty for other holders' omissions and the Edit refresh. App: Pin/Unpin in the message sheet, header pin badge + pinned sheet (author, time, edited, unavailable, jump), budget line; `amy concord pins/pin/unpin`. Also fixed `DeletionIndex.DeletionRequest.compareTo` (compared the pubkey with itself, so any author's kind 5 matched on JVM/Android). Open SHOULDs: a Rotator does not republish under the new key after a private-channel rekey, and a Banlist revert is not re-healed; compaction does not omit a deleted Channel's Pin List. **Fixed since** (features batch): the delayed duties run from the account, not the screen — `ConcordPinDutyScheduler` + `AccountConcordActions.scheduleConcordPinDuties`, fired on every Concord revision tick and whenever a delete or an Edit lands (sampled 1 s), for every community where we may write pins and every Channel with a Pin List head; each duty waits the 3–15 s random delay, one per channel in flight, one attempt per distinct debt, and `settleConcordPins` re-reads before publishing (the screen's `ConcordPinDuties` composable is gone); pinned messages render through the feed's pipeline — the rumor rebuilt from the proof (`ConcordPinnedMessage.toRumor`, keeping the original's `imeta` tags) registers its encrypted attachments' keys and goes through `appendMissingImetaUrls` + the shared `TranslatableRichTextViewer`, so images (and links, mentions) show in the pinned sheet even for a message this account never held | | F2 | 08 | Disappearing Messages (sender tags, reader refusal/hiding/purge, 1740 notice, settings UI) | **fixed** — every durable Chat rumor (9/1111/7/3302, image variants) signs `created_at + timer` from the send-time fold and its wrap repeats it (`ConcordStreamEnvelope.wrap(outerTags)`, random `p` kept; never on 5/1740/typing); expired rumors refused at ingest (`openChannelRumor`, session, rumor sink), hidden in feed/preview/unread (`Account.isAcceptable`), and purged from LocalCache + wrap note + session buffer by a sweep scheduled on the earliest deadline (`ConcordSessionManager.nextExpiry`); typed `ConcordTimerNoticeEvent` posted per held channel after a timer change and rendered as a system row only for MANAGE_METADATA authors; timer picker in the edit screen + composer indicator; `amy concord timer`, `send` tags, `read` filters | -| F3 | 07 | A/V calls: only key derivation, the 27235 grant and 23313 presence builders exist; no broker/SFU client, no media E2EE. Needs a LiveKit client whose license must be checked first | open — out of scope for this pass | -| F4 | 07 | Broker token has no nonce (same-second requests collide in the broker's replay set); presence fold doesn't take latest-per-author | open → chat-plane batch (quartz only) | +| F3 | 07 | A/V calls: only key derivation, the 27235 grant (now with Armada's nonce, F4) and the 23313 presence fold exist; no broker/SFU client, no media E2EE | open — **deferred** (maintainer decision, 2026-09-29). Two blockers found: (1) `io.livekit:livekit-android` 2.29.0 pulls runtime `javax.sip:android-jain-sip-ri` 1.3.0-91, whose `android.javax.sip.*` API classes carry the Sun/BEA "use is subject to license terms" header under the proprietary JSIP spec license (no linking exception; STOP under our licensing rule); it can't simply be excluded because LiveKit's `PeerConnectionTransport` munges SDP through its `SdpFactory` on every publish. (2) Interop: Armada keys LiveKit E2EE with `keySize: 256` (AES-256-GCM per CORD-07 §3), but every native LiveKit/webrtc-sdk frame cryptor derives 128 bits (`frame_crypto_transformer.h` `DeriveKeys(..., 128)`), so an Android client can't decode Armada frames. Matching settings otherwise: HKDF-SHA256 (salt `LKFrameEncryptionKey`, info 128 zero bytes), per-identity key = quartz `voiceSenderKey`, `sharedKey=false`, ratchet window 0, failure tolerance -1, keyring 16, trailer `IV(12) ‖ [12, keyIndex]`. Paths when resumed: CORD-07 allows the 128-bit native key, or a patched WebRTC honouring 256; own LiveKit signaling (Apache-2.0 protocol) instead of livekit-android avoids jain-sip; desktop via webrtc-java 0.19 encoded-frame transforms (WARN: statically linked LGPL FFmpeg). Armada's default broker `https://armada.buzz` answers the capability probe and mints LiveKit HS256 JWTs (6 h TTL, 128-bit identity, SFU `wss://av.armada.buzz`) | +| F4 | 07 | Broker token has no nonce (same-second requests collide in the broker's replay set); presence fold doesn't take latest-per-author | **fixed** — `ConcordBrokerToken.buildAuthEvent` signs a fresh `["nonce", <64 hex>]` after `u`/`method` (Armada `signAvGrant`'s tag, order and 32-byte width), so two members' same-second grants never share an id; `VoicePresenceInfo` carries the CORD-02 §4 `ms` basis + rumor id, `parse` drops a bad verb, an identity-less `joined` or a malformed `ms`, and `VoicePresence.fold`/`latestPerAuthor` take each author's latest presence (ms, lower rumor id on a tie, as Armada `foldVoicePresence`) before staleness and the one-claimant identity check; `joined`/`left` stamp `ms`. No app caller yet (the voice UI is not built) | | F5 | 05 §5 | Invite Registry (vsk 8) not published or folded | **fixed** — `ConcordInviteRegistry` (builder, strict-array decode, `nextLinks` pruning expired/tombstoned links) + `ConcordCommunityState.inviteRegistries`/`liveInviteLinks`/`isPublic`/`hasForeignLiveLinks`/`banRequiresRefounding`/`retiringWouldPrivatize` (gated on CREATE_INVITE, coordinate bound to author); mint/revoke publish the registry (app + amy); a Private ban Refounds, a Public one is the Banlist alone; retiring the last live link runs a privatizing Refounding (`privatizeConcordCommunity`; amy reports it and adds `refound --privatize`); Public/Private shown in the server view and warned in the revoke dialog. Deviation from Armada, following the spec: a ban Refounds iff the community is Private without the targets' registries (Armada rotates whenever no *foreign* link exists, and only warns on privatizing revokes) | -| F6 | 05 §6 | Direct invites: wire format only, no send/receive | **fixed** — wrap backdates seal/wrap ≤2 days, carries NIP-40 `expiration` = `expires_at`, `ConcordDirectInvite.open` returns the seal-verified sender and refuses rumor/seal pubkey mismatch, bad seal sig, non-3313 rumors, §1 bounds and bad owner proof; send (`sendConcordDirectInvite` / `amy concord invite --to`) vends only the private channels the recipient's channel-scoped roles grant (`ConcordInviteVend`, Armada `vendableChannels`) to their 10050 → NIP-65 read → stock relays; headless `ConcordDirectInviteInbox` (sweep via `directInvitesFilter` + the NIP-17 seal handler) dedupes by wrap id, skips expired wraps, parks invites, remembers declines; accept shares the link join path, refuses past `expires_at`, and for a held community only adopts new private-channel keys on the same root/epoch/control_pk (`catchUpChannelIds`); UI card + "Invite by npub"; `amy concord invites/accept/decline`. Not done: Armada's auto-adopt of staff-sent catch-ups (`judgeCatchUp`) and `channel_cuts` (not modeled here) | -| F7 | 06 §1-2 | Channel-scope rekeys; private-channel keys in invites | open (depends on S2) | +| F6 | 05 §6 | Direct invites: wire format only, no send/receive | **fixed** — wrap backdates seal/wrap ≤2 days, carries NIP-40 `expiration` = `expires_at`, `ConcordDirectInvite.open` returns the seal-verified sender and refuses rumor/seal pubkey mismatch, bad seal sig, non-3313 rumors, §1 bounds and bad owner proof; send (`sendConcordDirectInvite` / `amy concord invite --to`) vends only the private channels the recipient's channel-scoped roles grant (`ConcordInviteVend`, Armada `vendableChannels`) to their 10050 → NIP-65 read → stock relays; headless `ConcordDirectInviteInbox` (sweep via `directInvitesFilter` + the NIP-17 seal handler) dedupes by wrap id, skips expired wraps, parks invites, remembers declines; accept shares the link join path, refuses past `expires_at`, and for a held community only adopts new private-channel keys on the same root/epoch/control_pk (`catchUpChannelIds`); UI card + "Invite by npub"; `amy concord invites/accept/decline`. F7 follow-ups done: staff-sent catch-ups auto-adopt (`judgeCatchUp`), `channel_cuts` is modeled, and a catch-up now only ADDS a missing key from a staff sender for a live Private Channel (never replaces a held key), re-applied inside the List write | +| F7 | 06 §1-2 | Channel-scope rekeys; private-channel keys in invites | **fixed** — quartz `ConcordChannelRekey`: root-keyed `concord/rekey-pseudonym` address, 72-byte scope-bound blobs, chunked 3303 with `prevcommit` over the held channel key and `vac` on every chunk; the receive walk adopts only complete, honored (owner / MANAGE_CHANNELS / BAN + synced `vac`) rotations off the held key (multi-epoch, racing rotators → lowest key) and treats "no blob" as a cut only from a rotator who outranks us, published after our join. `ConcordChannelKeyring` rotates keys in place, reads older keys from `seed`/peer `priors` (never writes intermediate keys, CORD-02 §8) and models Armada's `channel_cuts` floor (extension, round-tripped). `ConcordInviteVend.entitledMembers`/`accessChanges`/`judgeCatchUp`. Commons `ConcordPrivateChannels` + app verbs: create Private channel (key at channel epoch 0 + bit-less access Role, as Armada), privatise (next channel epoch, floored by probing the rekey addresses) / publicise, `rekeyConcordChannel`, vend on grant (Direct Invite limited to the gained channels) and rotate on revoke/ban, the Refounding rotates every held private channel under the prior root, sessions subscribe/AUTH/buffer the channel-rekey window and the revision tick drains it; staff catch-ups auto-adopt. Links carry no channel keys (F6's `vendableChannels`, audience link). UI: Private toggle + access-role name on create, Make private/public + Rotate key per channel. `amy concord channel create/privatize/publicize/rekey`, `rekey`/`grant`/`refound` follow channel keys. Not done: republishing a rotated channel's sealed Pin List under the new key (a SHOULD); history across our own rotations after restart (intermediate keys stay out of the List by spec, and the key walk from `seed` is not implemented); a role *scope edit* in the UI does not trigger reconcile (only grants/revokes/bans do) | | F8 | 06 §2, 02 §8 | Walk forward from `seed`; we still keep intermediate roots in a `held_roots` List extension the spec says doesn't belong there | open | -| F9 | 04 §6 | Kick (kind 3309) | open | -| F10 | 03 | WebXDC (kind 3310) | open | +| F9 | 04 §6 | Kick (kind 3309) | **fixed** — quartz `Guestbook.kick` writes the examples' shape (`ms`, `p`, `vac`), `Guestbook.parse` reads Kicks too (target, author, `ms` basis, rumor id, citation; malformed `ms`/target dropped; a 3306 "kick" verb is not a Kick), `Guestbook.canKick` honors one only from a KICK holder who strictly outranks the target with a synced `vac` (block-until-synced), and `Guestbook.coalesce` is the CORD-02 §5 fold (latest per npub by ms, lower rumor id on a tie, >1 h future dropped, banned authors dropped) — the old projection was createdAt-only and ignored Kicks. Commons: the session coalesces against its roster and re-coalesces on every control fold (a parked Kick lands when its Grant folds), exposes `guestbook`, `departedMembers()` (Leave/Kick not followed by newer observed activity — observation counts forward only) and `kickedMe()` (honored Kick postdating the entry's `added_at`); `allMembers()` drops the departed; guestbook seals must be encrypted. `kickConcordMember` strips roles first (MANAGE_ROLES + outrank, best-effort, as Armada) then publishes the directive; the revision tick's `drainConcordKicks` leaves the community locally (List tombstone, like Leave; network-silent) and emits a `ConcordKickNotice` the app toasts. Re-join works: `follow` bumps `added_at` past the tombstone, which also puts the old Kick behind the new membership. UI: Kick (KICK + outrank, confirm dialog) next to Ban in the members roster; departed members show a Kicked/Left badge. `amy concord kick COMMUNITY USER`. Not done: Armada's double-read debounce before self-removal, the dissolution ordering rule for Kicks (we refuse to *write* one on a dissolved community but do not date-check received ones), and Guestbook snapshots (kind 3312) | +| F10 | 03 | WebXDC (kind 3310) | **fixed (plumbing only)** — 3310 was refused by the Chat gate and silently dropped. quartz `ConcordWebxdc` builds/parses what Armada puts on the kind (the spec leaves the payload opaque, examples §2.6): app **state updates** (`["i", ]`, `["alt","Webxdc update"]`, optional `info`/`document`/`summary`, JSON content) and realtime **peer signals** (`{"op":"ad","topic":<52-char base32>,"addr":…}` / `{"op":"left","topic":…}`, addr ≤ 2048, as Vector bounds it), both under the usual `channel`/`epoch`/`ms` binding; `ChannelChat.PLANE_KINDS` = `CHAT_KINDS` + 3310 and `acceptOpened(…, kinds)`, so 3310 stays out of `CHAT_KINDS` (never a row, never pinnable, still refused by `EventCache.consumeConcordRumor`). The session opens its planes with `PLANE_KINDS` and routes 3310 into a bounded per-channel buffer (`webxdcSignals(channel)`, `webxdcRevision`; 2000 per channel, CORD-08-expired ones filtered) instead of the chat store, so feeds, previews and unread counts never see it; its author still counts as observed. Amethyst has no WebXDC host. **Full support** (Armada `useConcordAppSync` + `XdcAttachment`, interoperating with Vector) would take: rendering an `.xdc` attachment (`application/x-webxdc` imeta carrying a `webxdc` session/topic id, or a topic derived from URL + message id) as an app card; a sandboxed WebView runtime exposing the webxdc JS API (`sendUpdate`/`setUpdateListener` → durable 3310 state updates for the session, read back by `#i`, with the CORD-08 `expiration`; `joinRealtimeChannel` → realtime); and for realtime an iroh gossip transport (Vector's frame format with the 36-byte `seq‖sender` trailer, topic = base32(sha256(…))) advertised/withdrawn by 3310 peer signals and folded latest-per-author (ties to `left`, >1 h future refused) — there is no relay fallback by design. The `:napplet` WebView sandbox is the natural host; iroh has no Kotlin implementation (our `:quic` is plain QUIC/HTTP3) | + +## Audit 2 (2026-09-29) — batch A (non-Refounding) + +Root cause shared by P1/P13/R7: nothing told a session its Control Plane had finished its +initial drain. Now `ConcordCommunitySession.controlDrained` is set by +`syncConcordControlPlanes` once a relay pages the whole current plane (`DRAINED`) and the +swept wraps are ingested; `foldForWrite()` is the fold writers may build on (null before). +Batch B can reuse it for the ban/privatize decisions. + +| # | Status | +|---|---| +| P1 | **fixed** — `ConcordChannelPins.complete`; `ConcordPinning.refusal` → `NOT_FOLDED` until drained; the sheet never says "no pins" before the drain | +| P2 | **fixed** — `buildChannelEdit(expiration = expirationOf(target))`: an Edit carries the original's deadline verbatim (none if it has none); a smuggled `expiration` in `extraTags` is dropped (Armada `useTransport.ts`; the spec's "computed from the rumor's own created_at" reads otherwise — noted) | +| P3 | **fixed** — pin writes `publishAndConfirm` (`NOT_CONFIRMED` otherwise) and re-apply the same op atop a concurrent winner, ≤2 retries | +| P4 | **fixed** — `rememberConcordChannelPins`, the pinned sheet and `ConcordTimerIndicator` re-resolve the session on `concordSessions.revision` | +| P5 | **fixed** — the pins re-read at the soonest pinned message's NIP-40 deadline (`ConcordChannelPins.nextExpiry`) | +| P6 | **fixed** — list reads memoized by head rumor id (`ConcordPinVerifier.readList`); `PinListRead.sealedForm` (no second parse); evidence trigger filtered to deletes/Edits naming a pinned rumor; action-sheet pin state via `produceState` on `Dispatchers.Default`. The per-channel verifier cache stays the session-wide 512-entry one | +| P7 | **fixed** — deadlines kept sorted (binary-searched insert; no PriorityQueue in common code); sweeps pop only what is due; the account sweep waits 2 s past a deadline to coalesce | +| P8 | **fixed** — bounded (4096) set of swept wrap ids; re-deliveries dropped before opening | +| P9 | **fixed** — `ConcordSessionRegistry.sync` carries `trackedExpiring()` into the rebuilt session | +| P10 | **fixed** — sheet and badge leave out banned authors and muted/blocked users (`ConcordPinning.visible`) | +| P11 | **fixed** — confirm dialog before pinning a message carrying `expiration`; `amy concord pin` refuses (`expiring_message`) without `--force` | +| P12 | **fixed** — `amy concord pins` hides expired pinned messages | +| P13 | **fixed** — `editConcordMetadata` / `setConcordMessageExpiration` return false until drained (the owner too) and chain onto the floor-aware head | +| P14 | **fixed** — `ExpiredConcordRumor.attachmentUrls`; the sweep evicts them from `encryptionKeyCache` | +| recomputeNextExpiry | **fixed** — computed and assigned under a lock | +| D3 | **fixed** — `SealEvent.unsealRumorThrowing` + `ConcordDirectInvite.openRumor`/`offerRumor`: the NIP-17 seal handler decrypts once; k=3313 wraps that never open are marked seen (GiftWrap and Seal handlers), so the hub's sweep skips them. Chosen over a persisted cursor: the DM pipeline sees every invite wrap first in the same process, so the sweep re-decrypts nothing it already handled; a cold start still re-sweeps from `since = null` once per process | +| D4 | **fixed** — ≤256 parked (followed senders outrank strangers, then newer), hidden senders never park and are filtered, followed senders listed first, invites rendered as lazy items (the empty state scrolls) | +| D5 | **fixed** — an invite whose clamped `sentAt` is at or before the Community List tombstone's `removed_at` stays hidden (`ConcordChannelListState.removedAt`) | +| D6 | **fixed** — the cursor advances to `min(created_at, now + 15 min)` | +| D7 | **fixed** — dedupe per (community, sender), ranked by `sentAt` clamped to now | +| D8 | **fixed** — written off only on a definitive outcome; `openOrRetry` rethrows a transient signer failure (timeout, not approved, backgrounded, not found) and the inbox leaves the wrap for a retry | +| D10 | **fixed** — declines capped at 4096 (app + amy); `restoreDeclined` is `suspend` under the inbox mutex; the sweep runs once per hub visit outside the lazy list and rethrows cancellation; catch-up cards list only newly adopted channels, by folded name. Also (F7 note): `visible()` hides a catch-up `acceptPlan` would refuse against the held fold | +| R3 | **fixed** — a readable Invite List is authoritative in `nextLinks` (no resurrected links); registry edits are `publishAndConfirm`ed | +| R7 | **fixed** — `publishConcordInviteRegistry` skips until drained and chains onto the floor-aware head (`ConcordModeration.setInviteRegistry(floors = session.controlFloors())`) | +| R8 | **fixed** — no registry edit on a dissolved community; `retiringWouldPrivatize` is false once dissolved, so a revoke there reports `REVOKED` | +| R9 | **fixed** — after a drain, this account's registry is republished pruned when it lists an elapsed/unbacked link (once per community and epoch per process) | +| R11 | **fixed** — `invite_links_locator` memoized per (community, author) in `AuthorityResolver` | ## Spec issues to raise upstream +- CORD-07 §3 mandates AES-256-GCM frames, but LiveKit's native SDKs (Android, Swift, Rust, C++) only derive 128-bit frame keys (`livekit-client` documents keySize 128 as "the only value supported by non-web SDKs"), so a conforming native client can't interoperate with a 256-bit web client. The spec should allow (or require) the 128-bit derived key, or pin the KDF output length explicitly. + - CORD-06 §1 counts rekey capacity in blobs ("up to 120 participants per event"), but 120 base blobs overflow NIP-44's 65,535-byte plaintext once wrapped; the spec should state the byte budget (Armada uses a 40,960-byte rumor ceiling). diff --git a/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord02Community/ConcordCommunityList.kt b/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord02Community/ConcordCommunityList.kt index a69154843a..a6097cf5a6 100644 --- a/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord02Community/ConcordCommunityList.kt +++ b/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord02Community/ConcordCommunityList.kt @@ -143,6 +143,18 @@ class ConcordListResidue( return ConcordListResidue(extras, tombstones.filterNot { it === prior } + next, unparsedEntries) } + /** The latest `removed_at` (unix ms) per community this residue tombstones. */ + fun removals(): Map { + val out = HashMap() + for (t in tombstones) { + val id = (t["community_id"] as? JsonPrimitive)?.contentOrNull ?: continue + val at = (t["removed_at"] as? JsonPrimitive)?.longOrNull ?: continue + val prev = out[id] + if (prev == null || at > prev) out[id] = at + } + return out + } + /** The latest `removed_at` this residue holds for [communityId], or null when it was never left. */ fun removedAt(communityId: String): Long? = tombstones diff --git a/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord02Community/ConcordCommunityState.kt b/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord02Community/ConcordCommunityState.kt index 5222e39d52..2d430392d0 100644 --- a/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord02Community/ConcordCommunityState.kt +++ b/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord02Community/ConcordCommunityState.kt @@ -67,6 +67,9 @@ data class ConcordCommunityState( */ val inviteRegistries: Map> = emptyMap(), ) { + /** The ids of the live (non-deleted) Private Channels (CORD-03), lowercase hex. */ + val privateChannelIds: Set by lazy { channels.filterValues { it.definition.private }.keys.mapTo(HashSet()) { it.lowercase() } } + /** The aggregate active-set of live public links: every honored registry's link signers (CORD-05 §5). */ val liveInviteLinks: Set by lazy { inviteRegistries.values.flatMapTo(HashSet()) { it } } @@ -114,9 +117,11 @@ data class ConcordCommunityState( /** * Whether retiring [linkSigners] would flip the community Private (CORD-05 §2): it is Public * now and no live link would remain. Retiring the last live link is a Refounding (CORD-06). + * Never for a [dissolved] community: death wins every race (CORD-02 §9), so there is nothing + * left to Refound and a revoke there is only a revoke. */ fun retiringWouldPrivatize(linkSigners: Collection): Boolean { - if (!isPublic) return false + if (dissolved || !isPublic) return false val retiring = linkSigners.mapTo(HashSet()) { it.lowercase() } return liveInviteLinks.all { it in retiring } } diff --git a/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord02Community/Guestbook.kt b/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord02Community/Guestbook.kt index d7566f394f..c242f509a9 100644 --- a/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord02Community/Guestbook.kt +++ b/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord02Community/Guestbook.kt @@ -20,31 +20,58 @@ */ package com.vitorpamplona.quartz.concord.cord02Community +import com.vitorpamplona.quartz.concord.cord03Channels.tags.MsTag +import com.vitorpamplona.quartz.concord.cord04Roles.AuthorityCitation +import com.vitorpamplona.quartz.concord.cord04Roles.AuthorityResolver +import com.vitorpamplona.quartz.concord.cord04Roles.ConcordPermissions +import com.vitorpamplona.quartz.concord.cord04Roles.control.tags.VacTag import com.vitorpamplona.quartz.nip01Core.core.Event import com.vitorpamplona.quartz.nip01Core.core.HexKey import com.vitorpamplona.quartz.nip01Core.core.firstTagValue +import com.vitorpamplona.quartz.nip01Core.core.isValid import com.vitorpamplona.quartz.nip59Giftwrap.rumors.RumorAssembler -/** A self-signed membership motion on the Guestbook Plane. */ +/** + * A membership motion on the Guestbook Plane: the self-signed Join and Leave verbs of kind 3306, + * and an authorized [KICK] (kind 3309), which is never a 3306 verb. + */ enum class GuestbookAction( val wire: String, ) { JOIN("join"), LEAVE("leave"), + + /** An authorized Kick (kind 3309): the target is departed, and asked to leave (CORD-04 §6). */ + KICK("kick"), ; companion object { - fun of(wire: String) = entries.firstOrNull { it.wire == wire } + /** The kind-3306 verb [wire] names — only `join` and `leave` ride that kind. */ + fun of(wire: String) = + when (wire) { + JOIN.wire -> JOIN + LEAVE.wire -> LEAVE + else -> null + } } } -/** A parsed Guestbook join/leave: who ([member]), what ([action]), and invite attribution. */ +/** + * A parsed Guestbook motion: whose state it sets ([member] — the target, for a Kick), what + * ([action]), who signed it ([author] — the member themself for a Join/Leave, the kicker for a + * Kick), and invite attribution (Joins only). [ms] is the CORD-02 §4 ordering basis + * (`created_at * 1000 + ms`) and [rumorId] the equal-time tiebreak; [citation] is a Kick's `vac`. + */ class GuestbookEntry( val member: HexKey, val action: GuestbookAction, val createdAt: Long, val inviteCreator: HexKey?, val inviteLabel: String?, + val author: HexKey = member, + val ms: Long = createdAt * 1000, + val rumorId: HexKey = "", + val citation: AuthorityCitation? = null, ) /** @@ -66,6 +93,9 @@ object Guestbook { const val TAG_INVITE = "invite" const val TAG_P = "p" + /** An entry dated further than this ahead of the receiver's clock is dropped outright (CORD-02 §5). */ + const val MAX_FUTURE_MS = 60 * 60 * 1000L + /** A self-signed join (kind 3306), optionally attributing the invite used. */ fun join( memberPubKey: HexKey, @@ -99,31 +129,126 @@ object Guestbook { } /** - * An authorized Kick (kind 3309) directing [target] to leave. A Kick is only - * honored by clients when its signer holds [com.vitorpamplona.quartz.concord - * .cord04Roles.ConcordPermissions.KICK] and outranks the target — a Kick from - * a non-KICK holder is dropped (CORD-04 §The Three Removals). + * An authorized Kick (kind 3309) directing [target] to leave, citing the Grant the actor acts + * under ([citation], the `vac` — null only for the owner, who cites nothing). Tags in the + * examples' order: `ms`, `p`, `vac`. A Kick is only honored by clients when its signer holds + * [ConcordPermissions.KICK] and strictly outranks the target ([canKick]) — a Kick from a + * non-KICK holder is dropped (CORD-04 §6). */ fun kick( actorPubKey: HexKey, target: HexKey, createdAt: Long, - ): Event = RumorAssembler.assembleRumor(actorPubKey, createdAt, KIND_KICK, arrayOf(arrayOf(TAG_P, target)), "") + subMs: Int = MsTag.remainderFor(createdAt), + citation: AuthorityCitation? = null, + ): Event { + val tags = ArrayList>(3) + tags.add(MsTag.assemble(subMs)) + tags.add(arrayOf(TAG_P, target)) + if (citation != null) tags.add(VacTag.assemble(citation)) + return RumorAssembler.assembleRumor(actorPubKey, createdAt, KIND_KICK, tags.toTypedArray(), "") + } - /** Parses a Guestbook join/leave rumor, or null if it is not one. */ + /** + * Parses a Guestbook Join/Leave (kind 3306) or Kick (kind 3309), or null if it is neither or is + * malformed: an unknown verb, a Kick naming no valid 64-hex target, or a malformed/duplicated + * `ms` tag (dropped, never interpreted — CORD-02 §5). + */ fun parse(rumor: Event): GuestbookEntry? { - if (rumor.kind != KIND_JOIN_LEAVE) return null - val action = GuestbookAction.of(rumor.content) ?: return null - val invite = rumor.tags.firstOrNull { it.size >= 2 && it[0] == TAG_INVITE } - return GuestbookEntry( - member = rumor.pubKey, - action = action, - createdAt = rumor.createdAt, - inviteCreator = invite?.getOrNull(1), - inviteLabel = invite?.getOrNull(2), - ) + val ms = MsTag.orderingMs(rumor.createdAt, rumor.tags) + when (rumor.kind) { + KIND_JOIN_LEAVE -> { + val action = GuestbookAction.of(rumor.content) ?: return null + if (ms == null) return null + val invite = if (action == GuestbookAction.JOIN) rumor.tags.firstOrNull { it.size >= 2 && it[0] == TAG_INVITE } else null + return GuestbookEntry( + member = rumor.pubKey, + action = action, + createdAt = rumor.createdAt, + inviteCreator = invite?.getOrNull(1), + inviteLabel = invite?.getOrNull(2), + author = rumor.pubKey, + ms = ms, + rumorId = rumor.id, + ) + } + KIND_KICK -> { + val target = kickTarget(rumor)?.lowercase()?.takeIf { it.isValid() } ?: return null + if (ms == null) return null + return GuestbookEntry( + member = target, + action = GuestbookAction.KICK, + createdAt = rumor.createdAt, + inviteCreator = null, + inviteLabel = null, + author = rumor.pubKey, + ms = ms, + rumorId = rumor.id, + citation = rumor.tags.firstOrNull { VacTag.isTag(it) }?.let { VacTag.parse(it) }, + ) + } + else -> return null + } } /** The kick target's pubkey from a kind-3309 rumor, or null. */ fun kickTarget(rumor: Event): HexKey? = if (rumor.kind == KIND_KICK) rumor.tags.firstTagValue(TAG_P) else null + + /** + * Whether the Kick [entry] is honored against the folded [authority] (CORD-04 §5/§6): its + * author holds [ConcordPermissions.KICK], is not banned, and strictly outranks the target (the + * owner is never a valid target), judged against the **current** roster — and its `vac` is + * synced (block-until-synced: a citation we cannot yet match parks the Kick, here drops it + * until a later fold). + */ + fun canKick( + authority: AuthorityResolver, + entry: GuestbookEntry, + ): Boolean = + entry.action == GuestbookAction.KICK && + authority.canActOn(entry.author, entry.member, ConcordPermissions.KICK) && + authority.citationSatisfied(entry.author, entry.citation) + + /** True when [next] supersedes [prev]: later on the ms basis, or the lower rumor id on a tie. */ + private fun supersedes( + prev: GuestbookEntry?, + next: GuestbookEntry, + ): Boolean = prev == null || next.ms > prev.ms || (next.ms == prev.ms && next.rumorId < prev.rumorId) + + /** + * Coalesces [entries] flat (CORD-02 §5): one final state per npub (lowercase), where their + * latest Join, Leave or honored Kick wins — later ms, ties to the lower rumor id. + * - an entry more than [MAX_FUTURE_MS] ahead of [nowMs] is dropped; + * - a [banned] author's entries, Kicks included, are dropped (CORD-04 §4); + * - a Kick counts only when [canKick] honors it (a Kick from a non-KICK holder is dropped). + */ + fun coalesce( + entries: Collection, + nowMs: Long, + canKick: (GuestbookEntry) -> Boolean, + banned: Set = emptySet(), + ): Map { + val out = HashMap() + for (entry in entries) { + if (entry.ms > nowMs + MAX_FUTURE_MS) continue + if (entry.author.lowercase() in banned) continue + if (entry.action == GuestbookAction.KICK && !canKick(entry)) continue + val key = entry.member.lowercase() + if (supersedes(out[key], entry)) out[key] = entry + } + return out + } + + /** [coalesce] with Kicks judged by [canKick] against [authority], and its banlist applied. */ + fun coalesce( + entries: Collection, + nowMs: Long, + authority: AuthorityResolver?, + ): Map = + coalesce( + entries, + nowMs, + canKick = { authority != null && canKick(authority, it) }, + banned = authority?.bannedMembers().orEmpty(), + ) } diff --git a/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord03Channels/ChannelChat.kt b/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord03Channels/ChannelChat.kt index 318dfff466..988c99ed7b 100644 --- a/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord03Channels/ChannelChat.kt +++ b/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord03Channels/ChannelChat.kt @@ -435,11 +435,20 @@ object ChannelChat { /** True when [kind] may ride a Chat Plane ([CHAT_KINDS]). */ fun isChatKind(kind: Int): Boolean = kind in CHAT_KINDS + /** + * Every rumor kind a Chat Plane carries (CORD-02 Appendix B): the chat kinds plus the WebXDC + * signal ([ConcordWebxdc], kind 3310), which rides the plane under the same binding but is never + * a chat row — so it is kept out of [CHAT_KINDS], and only a caller that routes it apart (the + * session's WebXDC buffer) opens a plane with this set. + */ + val PLANE_KINDS: Set = CHAT_KINDS + ConcordWebxdc.KIND + /** * The Chat Plane ingest gate for a wrap already opened under [channelId]'s key at [epoch]: * returns its rumor only when every Chat rule holds, else null (drop it). * - the seal is the encrypted kind 20013 (CORD-02 §5: a plaintext 20014 seal is Control-only); - * - the rumor kind is a Chat kind ([CHAT_KINDS]), never another plane's; + * - the rumor kind is one of [kinds] — by default the Chat kinds ([CHAT_KINDS]), never another + * plane's; [PLANE_KINDS] also admits the WebXDC signal for a caller that routes it apart; * - the binding is strict: exactly one `channel` and one `epoch`, equal to the plane's * ([isBoundTo], CORD-03 §3); * - its `ms` tag, if any, is well formed (CORD-02 §4/§5 — a malformed one is dropped, never @@ -449,10 +458,11 @@ object ChannelChat { opened: OpenedStreamEvent, channelId: HexKey, epoch: Long, + kinds: Set = CHAT_KINDS, ): Event? { if (opened.sealKind != ConcordStreamEnvelope.KIND_SEAL_ENCRYPTED) return null val rumor = opened.rumor - if (!isChatKind(rumor.kind)) return null + if (rumor.kind !in kinds) return null if (!isBoundTo(rumor, channelId, epoch)) return null if (orderingMs(rumor) == null) return null return rumor diff --git a/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord03Channels/ConcordChannelKeyring.kt b/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord03Channels/ConcordChannelKeyring.kt new file mode 100644 index 0000000000..0df4cd0898 --- /dev/null +++ b/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord03Channels/ConcordChannelKeyring.kt @@ -0,0 +1,239 @@ +/* + * Copyright (c) 2025 Vitor Pamplona + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the + * Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR + * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ +package com.vitorpamplona.quartz.concord.cord03Channels + +import com.vitorpamplona.quartz.concord.cord02Community.ConcordCommunityListEntry +import com.vitorpamplona.quartz.concord.cord02Community.ConcordEntryResidue +import com.vitorpamplona.quartz.concord.cord02Community.PrivateChannelKey +import com.vitorpamplona.quartz.nip01Core.core.HexKey +import kotlinx.serialization.json.JsonArray +import kotlinx.serialization.json.JsonObject +import kotlinx.serialization.json.JsonPrimitive +import kotlinx.serialization.json.contentOrNull +import kotlinx.serialization.json.longOrNull + +/** A Private Channel key held for an older channel epoch — it still reads its own era's history. */ +class HistoricalChannelKey( + val key: HexKey, + val epoch: Long, +) + +/** + * The Private Channel keys a Community List entry holds, and how a rotation rewrites them + * (CORD-03 §1-2, CORD-06 §2, CORD-02 §8). + * + * - **Current keys** are the entry's `channels` (`privateChannels`): exactly one per channel, the + * newest epoch held. A rotation replaces it in place, keeping any unknown keys another client + * wrote inside the channel object (the round-trip rule, CORD-02 §6/§8). + * - **Older keys** are never written by this client: CORD-02 §8 keeps intermediate keys out of the + * List ("a client's own optimisation … it does not belong in the List"). They are still *read* + * wherever they already are — the entry's `seed` snapshot (the earliest epoch held, the backfill + * anchor) and the reference client's `priors` extension inside a channel object — so history + * written before a rotation stays readable. + * - **Cuts** are the reference client's `channel_cuts` extension on the entry: per channel, the + * channel epoch whose rotation cut this member out. A floor, never rolled back: a key below it is + * refused, so a stale bundle or catch-up cannot quietly restore revoked access. Kept as the raw + * extension (`[{ "id", "epoch" }]`) with every other field in each object preserved. + */ +object ConcordChannelKeyring { + const val CHANNEL_CUTS = "channel_cuts" + const val PRIORS = "priors" + + private val HEX64 = Regex("^[0-9a-fA-F]{64}$") + + /** The current key held for [channelIdHex], or null (a keyless listing is not a key). */ + fun heldKey( + entry: ConcordCommunityListEntry, + channelIdHex: HexKey, + ): PrivateChannelKey? = entry.privateChannels.firstOrNull { it.channelId.equals(channelIdHex, ignoreCase = true) && HEX64.matches(it.key) } + + // ---- cuts ------------------------------------------------------------------ + + /** The `channel_cuts` floors on [entry], channel id (lowercase) → cut epoch (max wins). */ + fun cutsOf(entry: ConcordCommunityListEntry): Map { + val raw = entry.residue.entryExtras[CHANNEL_CUTS] as? JsonArray ?: return emptyMap() + val out = HashMap() + for (element in raw) { + val obj = element as? JsonObject ?: continue + val id = (obj["id"] as? JsonPrimitive)?.contentOrNull?.lowercase() ?: continue + val epoch = (obj["epoch"] as? JsonPrimitive)?.longOrNull ?: continue + if (epoch > (out[id] ?: Long.MIN_VALUE)) out[id] = epoch + } + return out + } + + /** True when a key for [channelIdHex] at [epoch] sits below a recorded cut and must be refused. */ + fun isCutOff( + entry: ConcordCommunityListEntry, + channelIdHex: HexKey, + epoch: Long, + ): Boolean = cutsOf(entry)[channelIdHex.lowercase()]?.let { epoch < it } ?: false + + /** + * [entry] with a cut for [channelIdHex] at [epoch] merged into `channel_cuts` (max wins — a + * removal never rolls back). Other channels' cut objects, and unknown keys inside the replaced + * one, ride through untouched. + */ + fun withCut( + entry: ConcordCommunityListEntry, + channelIdHex: HexKey, + epoch: Long, + ): ConcordCommunityListEntry { + val id = channelIdHex.lowercase() + val existing = (entry.residue.entryExtras[CHANNEL_CUTS] as? JsonArray)?.toList() ?: emptyList() + if ((cutsOf(entry)[id] ?: Long.MIN_VALUE) >= epoch) return entry + val mine = existing.filter { (it as? JsonObject)?.let { o -> (o["id"] as? JsonPrimitive)?.contentOrNull?.lowercase() == id } == true } + val base = (mine.firstOrNull() as? JsonObject) ?: JsonObject(emptyMap()) + val next = JsonObject(base + mapOf("id" to JsonPrimitive(id), "epoch" to JsonPrimitive(epoch))) + val cuts = JsonArray(existing.filterNot { it in mine } + next) + val extras = JsonObject(entry.residue.entryExtras + (CHANNEL_CUTS to cuts)) + return entry.copyChannels(entry.privateChannels, ConcordEntryResidue(extras, entry.residue.seed, entry.residue.currentExtras)) + } + + // ---- current keys ---------------------------------------------------------- + + /** + * [entry] holding [key] as the current key for its channel — replacing a lower epoch, keeping + * the replaced object's unknown fields — or null when it would not move anything forward: a key + * at or below the held epoch, or one below a recorded cut. + */ + fun withChannelKey( + entry: ConcordCommunityListEntry, + key: PrivateChannelKey, + ): ConcordCommunityListEntry? { + if (!HEX64.matches(key.key) || !HEX64.matches(key.channelId)) return null + if (isCutOff(entry, key.channelId, key.epoch)) return null + val held = entry.privateChannels.firstOrNull { it.channelId.equals(key.channelId, ignoreCase = true) } + if (held != null && HEX64.matches(held.key) && held.epoch >= key.epoch) return null + val next = + PrivateChannelKey( + channelId = key.channelId.lowercase(), + key = key.key.lowercase(), + epoch = key.epoch, + name = key.name.ifBlank { held?.name ?: "" }, + extras = held?.extras ?: key.extras, + ) + return entry.copyChannels(entry.privateChannels.filterNot { it.channelId.equals(key.channelId, ignoreCase = true) } + next, entry.residue) + } + + /** [entry] with [channelIdHex]'s key moved to [newKeyHex] at [newEpoch] (a rotation it launched or adopted). */ + fun withRotatedKey( + entry: ConcordCommunityListEntry, + channelIdHex: HexKey, + newKeyHex: HexKey, + newEpoch: Long, + ): ConcordCommunityListEntry? { + val held = heldKey(entry, channelIdHex) ?: return null + return withChannelKey(entry, PrivateChannelKey(held.channelId, newKeyHex, newEpoch, held.name, held.extras)) + } + + /** + * [entry] after a rotation to [cutEpoch] cut this member from [channelIdHex] (CORD-06 §2): the + * key leaves `channels` and the cut is recorded, so no older key can come back. + */ + fun withoutChannel( + entry: ConcordCommunityListEntry, + channelIdHex: HexKey, + cutEpoch: Long, + ): ConcordCommunityListEntry { + val dropped = entry.copyChannels(entry.privateChannels.filterNot { it.channelId.equals(channelIdHex, ignoreCase = true) }, entry.residue) + return withCut(dropped, channelIdHex, cutEpoch) + } + + // ---- older keys -------------------------------------------------------------- + + /** + * Every older key this entry still carries for [channelIdHex] — the `seed` snapshot's and any + * `priors` a peer wrote — excluding the current one, newest first. Each reads its own epoch's + * history. + */ + fun historicalKeys( + entry: ConcordCommunityListEntry, + channelIdHex: HexKey, + ): List { + val id = channelIdHex.lowercase() + val current = heldKey(entry, id) + val out = LinkedHashMap, HistoricalChannelKey>() + + fun add( + key: String?, + epoch: Long?, + ) { + if (key == null || epoch == null || !HEX64.matches(key)) return + val k = key.lowercase() + if (current != null && current.key.equals(k, ignoreCase = true) && current.epoch == epoch) return + out.getOrPut(epoch to k) { HistoricalChannelKey(k, epoch) } + } + current?.extras?.get(PRIORS)?.let { priors -> + for (p in (priors as? JsonArray).orEmpty()) { + val obj = p as? JsonObject ?: continue + add((obj["key"] as? JsonPrimitive)?.contentOrNull, (obj["epoch"] as? JsonPrimitive)?.longOrNull) + } + } + val seedChannels = entry.residue.seed?.get("channels") as? JsonArray + for (c in seedChannels.orEmpty()) { + val obj = c as? JsonObject ?: continue + if ((obj["id"] as? JsonPrimitive)?.contentOrNull?.lowercase() != id) continue + add((obj["key"] as? JsonPrimitive)?.contentOrNull, (obj["epoch"] as? JsonPrimitive)?.longOrNull) + } + return out.values.sortedByDescending { it.epoch } + } + + /** + * The channel epoch a privatisation must mint at (CORD-03 §2): one past the highest generation + * this entry knows of — the held key, any older key, a recorded cut — and [observedFloor] (the + * highest rotation epoch seen on the wire, for a privatiser who never held earlier + * generations). Monotonic, so a stale key is always a lower epoch; 1 for a never-private channel. + */ + fun nextChannelEpoch( + entry: ConcordCommunityListEntry, + channelIdHex: HexKey, + observedFloor: Long = 0, + ): Long { + val id = channelIdHex.lowercase() + var highest = observedFloor + entry.privateChannels.filter { it.channelId.equals(id, ignoreCase = true) }.forEach { highest = maxOf(highest, it.epoch) } + historicalKeys(entry, id).forEach { highest = maxOf(highest, it.epoch) } + cutsOf(entry)[id]?.let { highest = maxOf(highest, it) } + return highest + 1 + } + + private fun ConcordCommunityListEntry.copyChannels( + privateChannels: List, + residue: ConcordEntryResidue, + ) = ConcordCommunityListEntry( + id = id, + owner = owner, + ownerSalt = ownerSalt, + root = root, + rootEpoch = rootEpoch, + controlPk = controlPk, + controlRoot = controlRoot, + heldRoots = heldRoots, + privateChannels = privateChannels, + relays = relays, + name = name, + addedAt = addedAt, + inviteRef = inviteRef, + excludedAtEpoch = excludedAtEpoch, + residue = residue, + ) +} diff --git a/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord03Channels/ConcordWebxdc.kt b/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord03Channels/ConcordWebxdc.kt new file mode 100644 index 0000000000..1bfdd76cdb --- /dev/null +++ b/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord03Channels/ConcordWebxdc.kt @@ -0,0 +1,163 @@ +/* + * Copyright (c) 2025 Vitor Pamplona + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the + * Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR + * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ +package com.vitorpamplona.quartz.concord.cord03Channels + +import com.vitorpamplona.quartz.concord.cord03Channels.tags.ChannelTag +import com.vitorpamplona.quartz.concord.cord03Channels.tags.EpochTag +import com.vitorpamplona.quartz.concord.cord03Channels.tags.MsTag +import com.vitorpamplona.quartz.concord.cord04Roles.ConcordJson +import com.vitorpamplona.quartz.nip01Core.core.Event +import com.vitorpamplona.quartz.nip01Core.core.HexKey +import com.vitorpamplona.quartz.nip01Core.core.firstTagValue +import com.vitorpamplona.quartz.nip59Giftwrap.rumors.RumorAssembler +import kotlinx.serialization.json.JsonObject +import kotlinx.serialization.json.JsonPrimitive +import kotlinx.serialization.json.buildJsonObject +import kotlinx.serialization.json.put + +/** + * A WebXDC realtime peer signal: [topic] is the app's gossip topic (52 base32 characters), and + * [addr] the advertised, opaque node address — null for a departure (`"left"`). + */ +class WebxdcPeerSignal( + val topic: String, + val addr: String?, +) { + val isAdvert: Boolean get() = addr != null +} + +/** + * WebXDC on the Chat Plane (kind 3310, CORD-02 Appendix B; examples §2.6). The CORDs register the + * kind — a Chat rumor with the usual `channel`/`epoch`/`ms` binding — but do not pin its payload: the + * content is app-level and opaque to the protocol. A 3310 is **never a chat message**: it is not a + * feed row, not a preview, not unread; a client with no WebXDC host just holds it for one. + * + * What rides it in practice is the reference client's (Armada, interoperating with Vector), which + * this object builds and parses so a future host has the plumbing: + * - an app **state update** for one app session: `["i", ]` and `["alt", "Webxdc update"]` + * (plus optional `info`, `document`, `summary`), the content being the JSON payload; + * - a realtime **peer signal**, untagged beyond the binding: content + * `{"op":"ad","topic":<52-char base32>,"addr":}` to advertise a gossip endpoint, or + * `{"op":"left","topic":…}` to withdraw it. + * Amethyst has no WebXDC runtime; see the conformance review (F10) for what full support would take. + */ +object ConcordWebxdc { + const val KIND = 3310 + + const val TAG_SESSION = "i" + const val TAG_ALT = "alt" + const val ALT_UPDATE = "Webxdc update" + const val TAG_INFO = "info" + const val TAG_DOCUMENT = "document" + const val TAG_SUMMARY = "summary" + + /** A topic id is 32 bytes, so its RFC 4648 base32 form (no padding) is always this long. */ + const val TOPIC_ID_CHARS = 52 + + /** The longest advertised node address honored (Vector's cap); anything longer is not one. */ + const val MAX_NODE_ADDR_CHARS = 2048 + + private const val OP_AD = "ad" + private const val OP_LEFT = "left" + + /** True when [rumor] is a WebXDC signal. */ + fun isWebxdc(rumor: Event): Boolean = rumor.kind == KIND + + /** An app state update for app session [session] on [channelId]/[epoch]; [payload] is the app's JSON. */ + fun stateUpdate( + authorPubKey: HexKey, + channelId: HexKey, + epoch: Long, + session: String, + payload: String, + createdAt: Long, + info: String? = null, + document: String? = null, + summary: String? = null, + ms: Int = MsTag.remainderFor(createdAt), + ): Event { + val tags = binding(channelId, epoch, ms) + tags.add(arrayOf(TAG_SESSION, session)) + tags.add(arrayOf(TAG_ALT, ALT_UPDATE)) + if (info != null) tags.add(arrayOf(TAG_INFO, info)) + if (document != null) tags.add(arrayOf(TAG_DOCUMENT, document)) + if (summary != null) tags.add(arrayOf(TAG_SUMMARY, summary)) + return RumorAssembler.assembleRumor(authorPubKey, createdAt, KIND, tags.toTypedArray(), payload) + } + + /** + * A realtime peer signal on [channelId]/[epoch]: an advert of [nodeAddr] for [topic], or, when + * [nodeAddr] is null, the departure from it. + */ + fun peerSignal( + authorPubKey: HexKey, + channelId: HexKey, + epoch: Long, + topic: String, + nodeAddr: String?, + createdAt: Long, + ms: Int = MsTag.remainderFor(createdAt), + ): Event = RumorAssembler.assembleRumor(authorPubKey, createdAt, KIND, binding(channelId, epoch, ms).toTypedArray(), peerSignalContent(topic, nodeAddr)) + + /** The peer-signal body, key order `op`, `topic`, `addr` as the reference client writes it. */ + fun peerSignalContent( + topic: String, + nodeAddr: String?, + ): String = + buildJsonObject { + put("op", if (nodeAddr == null) OP_LEFT else OP_AD) + put("topic", topic) + if (nodeAddr != null) put("addr", nodeAddr) + }.toString() + + /** The app session a state update belongs to, or null (a peer signal carries none). */ + fun sessionOf(rumor: Event): String? = if (rumor.kind == KIND) rumor.tags.firstTagValue(TAG_SESSION) else null + + /** Exactly [TOPIC_ID_CHARS] uppercase RFC 4648 base32 characters (Vector's receive-side check). */ + fun isTopicId(value: String?): Boolean = value != null && value.length == TOPIC_ID_CHARS && value.all { it in 'A'..'Z' || it in '2'..'7' } + + /** + * Parses an untrusted peer-signal body: null unless it is `{"op":"ad","topic","addr"}` with a + * valid topic and a non-empty address of at most [MAX_NODE_ADDR_CHARS], or `{"op":"left","topic"}`. + */ + fun parsePeerSignal(content: String): WebxdcPeerSignal? { + val obj = runCatching { ConcordJson.instance.parseToJsonElement(content) }.getOrNull() as? JsonObject ?: return null + val topic = (obj["topic"] as? JsonPrimitive)?.takeIf { it.isString }?.content ?: return null + if (!isTopicId(topic)) return null + val op = (obj["op"] as? JsonPrimitive)?.takeIf { it.isString }?.content + return when (op) { + OP_LEFT -> WebxdcPeerSignal(topic, null) + OP_AD -> { + val addr = (obj["addr"] as? JsonPrimitive)?.takeIf { it.isString }?.content ?: return null + if (addr.isEmpty() || addr.length > MAX_NODE_ADDR_CHARS) return null + WebxdcPeerSignal(topic, addr) + } + else -> null + } + } + + /** The binding every Chat rumor commits, in the examples' order: channel, epoch, ms. */ + private fun binding( + channelId: HexKey, + epoch: Long, + ms: Int, + ): ArrayList> = arrayListOf(ChannelTag.assemble(channelId), EpochTag.assemble(epoch), MsTag.assemble(ms)) +} diff --git a/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord04Roles/AuthorityResolver.kt b/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord04Roles/AuthorityResolver.kt index b2f43b77e6..c5175cc830 100644 --- a/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord04Roles/AuthorityResolver.kt +++ b/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord04Roles/AuthorityResolver.kt @@ -26,6 +26,7 @@ import com.vitorpamplona.quartz.nip01Core.core.hexToByteArray import com.vitorpamplona.quartz.nip01Core.core.hexToByteArrayOrNull import com.vitorpamplona.quartz.nip01Core.core.toHexKey import com.vitorpamplona.quartz.utils.Log +import com.vitorpamplona.quartz.utils.cache.ConcurrentLruCache /** * Resolves the owner-rooted authority state of a Concord community from its @@ -84,6 +85,9 @@ data class AuthorityResolver private constructor( fun isOwner(pubKey: String): Boolean = pubKey.lowercase() == ownerLower + /** The owner's pubkey (lowercase hex), proven by the `community_id` rather than any fold. */ + fun owner(): String = ownerLower + fun isBanned(pubKey: String): Boolean = pubKey.lowercase() in banned /** The role ids a member currently holds (empty for the owner and for plain members). */ @@ -277,6 +281,25 @@ data class AuthorityResolver private constructor( return g.takeIf { coordinate == edition.entityIdHex } } + /** + * `invite_links_locator(community, author)` as hex, memoized: it is an HKDF per call, and the + * well-formedness gate asks it for every registry edition on every refold of every community. + * The derivation is a pure function of its inputs, so a cached value can never go stale. + */ + private val inviteLinksCoordinates = ConcurrentLruCache(1024) + + internal fun inviteLinksCoordinateHex( + communityId: ByteArray, + communityIdHex: String, + author: String, + ): String { + val key = communityIdHex + author.lowercase() + inviteLinksCoordinates.get(key)?.let { return it } + val coordinate = ConcordKeyDerivation.inviteLinksCoordinate(communityId, author.hexToByteArray()).toHexKey() + inviteLinksCoordinates.put(key, coordinate) + return coordinate + } + /** See [isWellFormed]. */ private fun wellFormed( edition: ControlEdition, @@ -294,7 +317,7 @@ data class AuthorityResolver private constructor( // CORD-05 §5: the coordinate binds to the author, so each creator owns exactly their own // list; the content must be a JSON array (a malformed one falls back to the previous head). ControlEntityKind.INVITE_REGISTRY -> - edition.entityIdHex == ConcordKeyDerivation.inviteLinksCoordinate(communityId, edition.author.hexToByteArray()).toHexKey() && + edition.entityIdHex == inviteLinksCoordinateHex(communityId, communityIdHex, edition.author) && ConcordInviteRegistry.isWellFormed(edition.content) else -> true } diff --git a/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord04Roles/pins/ConcordPins.kt b/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord04Roles/pins/ConcordPins.kt index 316dc9aa9a..d78778c90c 100644 --- a/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord04Roles/pins/ConcordPins.kt +++ b/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord04Roles/pins/ConcordPins.kt @@ -106,10 +106,13 @@ object ConcordPins { val sealedUnavailable: Boolean, /** True when the content broke a cap or the format, so every reader treats it as empty. */ val violating: Boolean, + /** True when the content is the sealed form (`{"epoch","sealed"}`) — the same answer as [isSealedForm]. */ + val sealedForm: Boolean = false, ) { companion object { val EMPTY = PinListRead(emptyList(), sealedUnavailable = false, violating = false) val VIOLATING = PinListRead(emptyList(), sealedUnavailable = false, violating = true) + val VIOLATING_SEALED = PinListRead(emptyList(), sealedUnavailable = false, violating = true, sealedForm = true) } } @@ -137,18 +140,23 @@ object ConcordPins { val entries = root["entries"] if (entries != null) return entriesOf(entries) + // From here the content is the sealed form exactly when [isSealedForm] says so — reported on + // the read so a caller need not parse the content a second time. + val sealedForm = root["sealed"] != null + val violating = if (sealedForm) PinListRead.VIOLATING_SEALED else PinListRead.VIOLATING val epoch = (root["epoch"] as? JsonPrimitive)?.takeIf { it.isString }?.content val sealed = (root["sealed"] as? JsonPrimitive)?.takeIf { it.isString }?.content - if (epoch == null || sealed == null || !DECIMAL.matches(epoch)) return PinListRead.VIOLATING - val epochValue = epoch.toLongOrNull() ?: return PinListRead.VIOLATING - val key = unsealKey(epochValue) ?: return PinListRead(emptyList(), sealedUnavailable = true, violating = false) + if (epoch == null || sealed == null || !DECIMAL.matches(epoch)) return violating + val epochValue = epoch.toLongOrNull() ?: return violating + val key = unsealKey(epochValue) ?: return PinListRead(emptyList(), sealedUnavailable = true, violating = false, sealedForm = true) val inner = try { parse(Nip44.v2.decrypt(sealed, key)) as? JsonObject } catch (_: Exception) { null - } ?: return PinListRead.VIOLATING - return entriesOf(inner["entries"] ?: return PinListRead.VIOLATING) + } ?: return violating + val read = entriesOf(inner["entries"] ?: return violating) + return PinListRead(read.entries, read.sealedUnavailable, read.violating, sealedForm = true) } private fun entriesOf(element: JsonElement): PinListRead { diff --git a/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord05Invites/ConcordDirectInvite.kt b/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord05Invites/ConcordDirectInvite.kt index d3c74c06ba..ae1a79ee96 100644 --- a/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord05Invites/ConcordDirectInvite.kt +++ b/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord05Invites/ConcordDirectInvite.kt @@ -27,6 +27,7 @@ import com.vitorpamplona.quartz.nip01Core.crypto.KeyPair import com.vitorpamplona.quartz.nip01Core.crypto.verify import com.vitorpamplona.quartz.nip01Core.signers.NostrSigner import com.vitorpamplona.quartz.nip01Core.signers.NostrSignerInternal +import com.vitorpamplona.quartz.nip01Core.signers.SignerExceptions import com.vitorpamplona.quartz.nip40Expiration.ExpirationTag import com.vitorpamplona.quartz.nip40Expiration.isExpirationBefore import com.vitorpamplona.quartz.nip59Giftwrap.rumors.Rumor @@ -35,6 +36,7 @@ import com.vitorpamplona.quartz.nip59Giftwrap.seals.SealEvent import com.vitorpamplona.quartz.nip59Giftwrap.wraps.GiftWrapEvent import com.vitorpamplona.quartz.utils.RandomInstance import com.vitorpamplona.quartz.utils.TimeUtils +import kotlinx.coroutines.CancellationException /** * A Direct Invite opened by its recipient (CORD-05 §6): the bundle plus the seal-verified [sender]. @@ -118,6 +120,9 @@ object ConcordDirectInvite { ) } + /** True when [wrap] is a giftwrap carrying the `["k","3313"]` Direct Invite index tag (a hint, not authority). */ + fun isInviteTagged(wrap: Event): Boolean = wrap.kind == GiftWrapEvent.KIND && wrap.tags.any { it.size >= 2 && it[0] == TAG_K && it[1] == KIND.toString() } + /** * True when [wrap]'s NIP-40 `expiration` (unix seconds) is at or before [nowSecs]: an expired * handoff is never decrypted or surfaced. @@ -144,15 +149,27 @@ object ConcordDirectInvite { suspend fun open( wrap: Event, recipientSigner: NostrSigner, + ): OpenedDirectInvite? = definitiveOrNull { openOrRetry(wrap, recipientSigner) } + + /** + * [open], except that a failure that says nothing about the wrap — the coroutine cancelled, or + * the signer unable to answer right now (timed out, busy, not approved, not found) — is thrown + * instead of reported as "not an invite", so an inbox can leave the wrap to be retried rather + * than write it off for good. Null still means definitively not a valid invite for us. + */ + suspend fun openOrRetry( + wrap: Event, + recipientSigner: NostrSigner, ): OpenedDirectInvite? { if (wrap.kind != GiftWrapEvent.KIND) return null + val plaintext = decryptOrNull { recipientSigner.nip44Decrypt(wrap.content, wrap.pubKey) } ?: return null val seal = try { - Event.fromJson(recipientSigner.nip44Decrypt(wrap.content, wrap.pubKey)) + Event.fromJson(plaintext) } catch (_: Exception) { return null } - return openSeal(wrap.id, seal, recipientSigner) + return openSealOrRetry(wrap.id, seal, recipientSigner) } /** @@ -163,11 +180,41 @@ object ConcordDirectInvite { wrapId: HexKey, seal: Event, recipientSigner: NostrSigner, + ): OpenedDirectInvite? = definitiveOrNull { openSealOrRetry(wrapId, seal, recipientSigner) } + + /** [openSeal] with [openOrRetry]'s transient-failure contract. */ + suspend fun openSealOrRetry( + wrapId: HexKey, + seal: Event, + recipientSigner: NostrSigner, + ): OpenedDirectInvite? { + if (seal !is SealEvent) return null + if (!runCatching { seal.verify() }.getOrDefault(false)) return null + val plaintext = decryptOrNull { recipientSigner.nip44Decrypt(seal.content, seal.pubKey) } ?: return null + val rumor = + try { + Rumor.fromJson(plaintext) + } catch (_: Exception) { + return null + } + return openRumor(wrapId, seal, rumor) + } + + /** + * [openSeal] for a pipeline that already decrypted [seal] into [rumor] — the rumor exactly as the + * seal carries it, its claimed `pubkey` NOT yet overwritten by the seal's (see + * [SealEvent.unsealRumorThrowing]) — so the invite costs no second decrypt. Validates only: the + * seal's signature, the NIP-59 anti-spoofing author check, the rumor kind, the §1 bounds and the + * owner proof. Never throws. + */ + fun openRumor( + wrapId: HexKey, + seal: Event, + rumor: Rumor, ): OpenedDirectInvite? { if (seal !is SealEvent) return null return try { if (!seal.verify()) return null - val rumor = Rumor.fromJson(recipientSigner.nip44Decrypt(seal.content, seal.pubKey)) // NIP-59 anti-spoofing: the rumor's claimed author must be the seal's signer. The generic // unseal path overwrites the rumor's pubkey with the seal's, which hides a mismatch; here // a mismatch is a forgery and the whole invite is refused. @@ -189,6 +236,41 @@ object ConcordDirectInvite { } } + /** + * True for a signer failure that says the signer could not answer *now* — timed out, not + * approved (yet), backgrounded without permission, not found — not that the payload is + * undecryptable, so the same wrap may open on a later try. A signer that tried and failed + * ([SignerExceptions.CouldNotPerformException], which is also how a local key reports a payload + * that is not for it) is definitive. + */ + fun isTransientSignerFailure(e: Throwable): Boolean = + e is SignerExceptions.TimedOutException || + e is SignerExceptions.ManuallyUnauthorizedException || + e is SignerExceptions.AutomaticallyUnauthorizedException || + e is SignerExceptions.RunningOnBackgroundWithoutAutomaticPermissionException || + e is SignerExceptions.SignerNotFoundException + + /** [decrypt]'s plaintext, null when the payload is not for us, rethrowing a transient failure. */ + private suspend fun decryptOrNull(decrypt: suspend () -> String): String? = + try { + decrypt() + } catch (e: CancellationException) { + throw e + } catch (e: Exception) { + if (isTransientSignerFailure(e)) throw e + null + } + + /** Runs [block], turning a transient failure into null for the callers that never retry. */ + private suspend fun definitiveOrNull(block: suspend () -> OpenedDirectInvite?): OpenedDirectInvite? = + try { + block() + } catch (e: CancellationException) { + throw e + } catch (_: Exception) { + null + } + /** * Opens a direct-invite giftwrap addressed to [recipientSigner] and returns the * [CommunityInvite], or null if it isn't a valid direct invite for this user. See [open], which diff --git a/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord05Invites/ConcordInviteRegistry.kt b/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord05Invites/ConcordInviteRegistry.kt index 9d4cd3612c..70a1c5ff69 100644 --- a/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord05Invites/ConcordInviteRegistry.kt +++ b/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord05Invites/ConcordInviteRegistry.kt @@ -115,13 +115,18 @@ object ConcordInviteRegistry { /** * The link signers [creator]'s next registry edition lists (CORD-05 §5, "a Registry edit * accompanies every mint and every retire"): the registry they currently publish ([published], - * their honored head), plus every link their Invite List [list] still holds for [communityIdHex], - * plus [minted]; minus [retired], and minus every link the list records as tombstoned or past its - * `expires_at` at [nowSecs] — an elapsed link can no longer be joined, so it must stop keeping the - * community Public. A null [list] (unreadable) contributes nothing and prunes nothing. + * their honored head) and [minted], minus [retired]. * - * The Invite List half heals a registry that fell behind: a link minted before any registry was - * published (or by a device whose registry edit never landed) is re-listed on the next edit. + * When the Invite List [list] is readable it is **authoritative**: the result is exactly the + * links it still holds live for [communityIdHex] (not tombstoned, not past `expires_at` at + * [nowSecs]) plus [minted]. A registry entry no live list entry backs is dropped — a retired + * link's list entry is gone after the tombstone merge (so it can no longer be marked dead by its + * token), and carrying the [published] entry forward would resurrect it and keep the community + * Public forever. Every link is recorded in the list before its URL is handed out, so nothing + * live is lost; and the list half heals a registry that fell behind (a link minted before any + * registry was published is re-listed on the next edit). + * + * A null [list] (unreadable) keeps [published] as is: it contributes nothing and prunes nothing. */ fun nextLinks( published: Collection, @@ -133,8 +138,9 @@ object ConcordInviteRegistry { ): List { val dead = retired.mapTo(HashSet()) { it.lowercase() } val live = LinkedHashSet() - published.forEach { live += it.lowercase() } - if (list != null) { + if (list == null) { + published.forEach { live += it.lowercase() } + } else { val tombstoned = list.tombstones.mapTo(HashSet()) { it.token } for (entry in list.entries) { if (!entry.communityId.equals(communityIdHex, ignoreCase = true)) continue diff --git a/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord05Invites/ConcordInviteVend.kt b/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord05Invites/ConcordInviteVend.kt index c0cb4df4d9..148ff1eb0d 100644 --- a/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord05Invites/ConcordInviteVend.kt +++ b/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord05Invites/ConcordInviteVend.kt @@ -20,9 +20,9 @@ */ package com.vitorpamplona.quartz.concord.cord05Invites -import com.vitorpamplona.quartz.concord.cord02Community.ConcordCommunityList.withPrivateChannels import com.vitorpamplona.quartz.concord.cord02Community.ConcordCommunityListEntry import com.vitorpamplona.quartz.concord.cord02Community.PrivateChannelKey +import com.vitorpamplona.quartz.concord.cord03Channels.ConcordChannelKeyring import com.vitorpamplona.quartz.concord.cord04Roles.AuthorityResolver import com.vitorpamplona.quartz.nip01Core.core.HexKey @@ -80,6 +80,51 @@ object ConcordInviteVend { return held.filter { it.key.isNotBlank() && isEntitled(authority, memberHex, it.channelId) } } + /** + * Everyone entitled to [channelIdHex]'s key under [authority]: the owner plus every non-banned + * holder of a Role scoped to the channel. Entitlement needs a Grant, so the roster enumerates it + * exactly — no member census required. This is the keep-set of a channel rotation (CORD-06). + */ + fun entitledMembers( + authority: AuthorityResolver, + channelIdHex: HexKey, + ): Set { + val scoped = channelRoleIds(authority, channelIdHex) + val out = HashSet() + out.add(authority.owner()) + for (member in authority.roleHolders()) { + if (authority.isBanned(member)) continue + if (authority.rolesOf(member).any { it in scoped }) out.add(member.lowercase()) + } + return out + } + + /** Who gained and who lost a Private Channel's entitlement between two folds. */ + class AccessChange( + val channelIdHex: HexKey, + val gained: Set, + val lost: Set, + ) + + /** + * How a roster change — a Grant, a revoke, a Role's scope edit or deletion, a ban — moved + * entitlement to each of [channelIds] (Armada `channelsHingingOn`, generalised to any edit): + * the members to vend each channel's key to, and the ones a rotation must now cut. Channels + * nobody gained or lost are omitted. + */ + fun accessChanges( + before: AuthorityResolver, + after: AuthorityResolver, + channelIds: Collection, + ): List = + channelIds.mapNotNull { id -> + val was = entitledMembers(before, id) + val now = entitledMembers(after, id) + val gained = now - was + val lost = was - now + if (gained.isEmpty() && lost.isEmpty()) null else AccessChange(id.lowercase(), gained, lost) + } + /** The [held] keys as bundle channel grants (lowercase hex, as Armada writes them). */ fun toInviteChannels(held: List): List = held.map { InviteChannel(it.channelId.lowercase(), it.key.lowercase(), it.epoch, it.name) } @@ -92,6 +137,12 @@ object ConcordInviteVend { * the member onto attacker-read streams. So it counts only on the SAME `community_root`, * `root_epoch` and `control_pk` (swapping `control_pk` alone would eclipse the member onto an * attacker's Control Plane); the base advances only by a CORD-06 rekey. + * + * And it only ever ADDS a channel this member holds no key for. A held key moves forward only + * through a channel rekey (CORD-06 §2), whose `prevcommit` proves it extends the very key held; + * a bare bundle proves nothing, so letting one replace a held key would let any keyholder + * park a member on a dead key at an absurd epoch that every later honest delivery then loses + * to. A key below a recorded cut (the rotation that removed us) never comes back either. */ fun catchUpChannelIds( held: ConcordCommunityListEntry?, @@ -102,34 +153,109 @@ object ConcordInviteVend { if (!bundle.communityRoot.equals(held.root, ignoreCase = true)) return emptyList() if (bundle.rootEpoch != held.rootEpoch) return emptyList() if (!sameOptionalHex(bundle.controlPk, held.controlPk)) return emptyList() - val heldEpochs = held.privateChannels.filter { it.key.isNotBlank() }.associate { it.channelId.lowercase() to it.epoch } + val heldIds = held.privateChannels.filter { HEX64.matches(it.key) }.mapTo(HashSet()) { it.channelId.lowercase() } return bundle.channels .filter { HEX64.matches(it.id) && HEX64.matches(it.key) } - .filter { c -> - val heldEpoch = heldEpochs[c.id.lowercase()] - heldEpoch == null || c.epoch > heldEpoch - }.map { it.id.lowercase() } + .filter { it.id.lowercase() !in heldIds } + .filterNot { ConcordChannelKeyring.isCutOff(held, it.id, it.epoch) } + .map { it.id.lowercase() } .distinct() } /** - * [held] with the Private Channel keys [bundle] newly contributes ([catchUpChannelIds]) merged - * in — a newer epoch replaces the held one — or null when the bundle contributes nothing. The - * base, epoch, control keys and every other field stay exactly as held. + * The subset of [catchUpChannelIds] a catch-up may actually deliver against the held fold: only + * from a [sender] who is staff there (the owner or a Control-writing permission holder, + * CORD-04 §3 — a plain keyholder could otherwise plant a wrong key that blocks the right one), + * and only for channels the fold knows as live Private Channels ([privateChannelIds]). Empty + * when either fails. + */ + fun admissibleCatchUpIds( + held: ConcordCommunityListEntry?, + bundle: CommunityInvite, + authority: AuthorityResolver, + privateChannelIds: Set, + sender: HexKey, + ): List { + if (!authority.isStaff(sender)) return emptyList() + val live = privateChannelIds.mapTo(HashSet()) { it.lowercase() } + return catchUpChannelIds(held, bundle).filter { it in live } + } + + /** + * [held] with the Private Channel keys [bundle] newly contributes ([catchUpChannelIds], narrowed + * to [only] when given) added, or null when the bundle contributes nothing. A held key is never + * replaced; the base, epoch, control keys and every other field stay exactly as held. */ fun adoptCatchUp( held: ConcordCommunityListEntry, bundle: CommunityInvite, + only: Collection? = null, ): ConcordCommunityListEntry? { - val newIds = catchUpChannelIds(held, bundle).toSet() + val newIds = catchUpChannelIds(held, bundle).filter { only == null || it in only }.toSet() if (newIds.isEmpty()) return null val delivered = bundle.channels .filter { it.id.lowercase() in newIds && HEX64.matches(it.key) } .groupBy { it.id.lowercase() } .map { (id, grants) -> grants.maxBy { it.epoch }.let { PrivateChannelKey(id, it.key.lowercase(), it.epoch, it.name) } } - val kept = held.privateChannels.filterNot { it.channelId.lowercase() in newIds } - return held.withPrivateChannels(kept + delivered) + // Through the keyring: a replaced key keeps the unknown fields another client wrote in it. + var next = held + for (key in delivered) next = ConcordChannelKeyring.withChannelKey(next, key) ?: next + return if (next === held) null else next + } + + /** Why a catch-up Direct Invite may or may not be adopted without a click ([judgeCatchUp]). */ + enum class CatchUpVerdict { + /** The Grant was the consent: adopt now. */ + ADOPT, + + /** No folded roster yet (the Grant's fold lags): wait. */ + NO_FOLD, + + /** Not a catch-up at all ([catchUpChannelIds] is empty). */ + NOTHING_NEW, + + /** The recipient is banned (CORD-04 §4). */ + BANNED, + + /** A plain keyholder sent it; only staff may plant a key automatically. */ + SENDER_NOT_STAFF, + + /** It carries a channel the recipient's Roles don't entitle them to. */ + NOT_ENTITLED, + } + + /** + * Whether a parked catch-up invite — a Direct Invite carrying a Private Channel key an existing + * member lacks, which is how a role grant's key arrives (CORD-05 §6) — may be adopted WITHOUT a + * click (Armada `judgeCatchUp`). Consent came from the Grant; this checks the bundle is the + * delivery it prescribes, against the folded [authority]: + * - the [sender] is the owner or staff (CORD-04 §3), so a plain keyholder can't plant a wrong + * key that would block the right one; + * - the [recipient] isn't banned; + * - EVERY newly contributed channel is one the recipient's Roles entitle them to ([isEntitled]). + * + * - every such channel is a live Private Channel in the fold ([privateChannelIds]). + * + * A manual Accept still needs a staff sender and a live Private Channel + * ([admissibleCatchUpIds]); only the entitlement check is waived by the click. + */ + fun judgeCatchUp( + authority: AuthorityResolver?, + privateChannelIds: Set, + recipient: HexKey, + sender: HexKey, + bundle: CommunityInvite, + held: ConcordCommunityListEntry?, + ): CatchUpVerdict { + val vended = catchUpChannelIds(held, bundle) + if (vended.isEmpty()) return CatchUpVerdict.NOTHING_NEW + if (authority == null) return CatchUpVerdict.NO_FOLD + if (authority.isBanned(recipient)) return CatchUpVerdict.BANNED + if (!authority.isStaff(sender)) return CatchUpVerdict.SENDER_NOT_STAFF + val live = privateChannelIds.mapTo(HashSet()) { it.lowercase() } + if (vended.any { it !in live || !isEntitled(authority, recipient, it) }) return CatchUpVerdict.NOT_ENTITLED + return CatchUpVerdict.ADOPT } private val HEX64 = Regex("^[0-9a-fA-F]{64}$") diff --git a/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord06Rekey/ConcordChannelRekey.kt b/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord06Rekey/ConcordChannelRekey.kt new file mode 100644 index 0000000000..ba021db451 --- /dev/null +++ b/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord06Rekey/ConcordChannelRekey.kt @@ -0,0 +1,328 @@ +/* + * Copyright (c) 2025 Vitor Pamplona + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the + * Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR + * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ +package com.vitorpamplona.quartz.concord.cord06Rekey + +import com.vitorpamplona.quartz.concord.cord04Roles.AuthorityCitation +import com.vitorpamplona.quartz.concord.cord04Roles.control.tags.VacTag +import com.vitorpamplona.quartz.concord.crypto.ConcordKeyDerivation +import com.vitorpamplona.quartz.concord.crypto.GroupKey +import com.vitorpamplona.quartz.concord.envelope.ConcordStreamEnvelope +import com.vitorpamplona.quartz.nip01Core.core.Event +import com.vitorpamplona.quartz.nip01Core.core.HexKey +import com.vitorpamplona.quartz.nip01Core.core.firstTagValue +import com.vitorpamplona.quartz.nip01Core.core.hexToByteArray +import com.vitorpamplona.quartz.nip01Core.core.toHexKey +import com.vitorpamplona.quartz.nip01Core.signers.NostrSigner +import com.vitorpamplona.quartz.nip59Giftwrap.rumors.RumorAssembler +import com.vitorpamplona.quartz.utils.RandomInstance + +/** + * One Private Channel's rotation as a receiver sees it (CORD-06 §2): the kind-3303 chunks one + * [rotator] published at one ([newEpoch], [prevCommit]) — two Rotators concurrently rekeying the + * same epoch never merge into one set. [complete] once every chunk `1..total` is held; a missing + * chunk is never a removal. [createdAt] is the newest chunk's `created_at` (seconds), which a + * receiver compares against its join time: a rotation predating the join is not an exclusion. + */ +class ChannelRotation( + val rotator: HexKey, + val channelIdHex: HexKey, + val newEpoch: Long, + val prevEpoch: Long, + val prevCommit: HexKey, + val total: Int, + val chunks: Map>, + val authority: AuthorityCitation?, + val createdAt: Long, +) { + val complete: Boolean get() = (1..total).all { it in chunks } + + /** Every blob across the held chunks. */ + fun blobs(): List = chunks.values.flatten() +} + +/** A key the receiver stepped off while walking a channel's rotations: it still reads its own era. */ +class SteppedChannelKey( + val key: ByteArray, + val epoch: Long, + /** When the rotation that superseded it was published (seconds). */ + val retiredAt: Long, +) + +/** What a Private Channel's pending rotations mean for the key this account holds (CORD-06 §2). */ +sealed class ChannelRekeyOutcome { + /** Nothing to act on (no honored complete rotation past the held epoch, or one we cannot yet verify). */ + object None : ChannelRekeyOutcome() + + /** Adopt [key] at [epoch]; [steppedOver] are the keys the walk left behind, newest first. */ + class Adopted( + val key: ByteArray, + val epoch: Long, + val steppedOver: List, + ) : ChannelRekeyOutcome() + + /** + * A complete, honored rotation to [epoch] that could have carried our blob did not: we were cut + * from the channel. Drop the key and record the cut, so a stale bundle cannot restore it. + */ + class Removed( + val epoch: Long, + ) : ChannelRekeyOutcome() +} + +/** + * Single-channel Rekeys (CORD-06 §1-2): rotate one Private Channel's independent key to exactly the + * members who should keep reading it, and follow such a rotation as a member. + * + * - **Address.** A channel rotation to `new_epoch` rides `group_key("concord/rekey-pseudonym", + * community_root, channel_id, new_epoch)` — keyed by the *community* root, not the channel key + * (CORD-02 derivation table), so every member can precompute it. A Refounding seals its channel + * rekeys under the **prior** root (CORD-06 §3), so a receiver watches under the root it holds and + * the one before it. + * - **Blob.** 72 bytes, `scope_id[32] ‖ epoch_be[8] ‖ new_key[32]`, with the channel id as the + * scope ([RekeyPayload]); scope and epoch are verified against the tags before adoption. + * - **Continuity.** `prevcommit` is the epoch-key commitment over the channel key being replaced at + * its epoch; a receiver adopts only a rotation off the exact key it holds, walking several + * rotations in one pass when it missed some. + * - **Authority.** A single-channel Rekey needs `MANAGE_CHANNELS`, a Refounding's needs `BAN`, and + * the Rotator must strictly outrank every removed target — so a receiver treats "no blob for me" + * as a removal only from a Rotator that outranks it (Armada `useChannelRekeyWatch`). + * + * Pinned byte-for-byte to the reference client's `lib/rekey.ts` (`encodeWrappedKey`, + * `buildRekeyRumors`, `channelRekeyGroupKey`) and walk (`useChannelRekeyWatch`). + */ +object ConcordChannelRekey { + /** + * How many channel epochs past the held one a member watches. Watching only `held + 1` strands + * anyone who missed a rotation — they'd never learn they were removed. The reference client's + * `CHANNEL_REKEY_LOOKAHEAD`. + */ + const val LOOKAHEAD = 8 + + /** The rekey address a rotation of [channelId] to [newEpoch] rides, sealed under [sealingRoot]. */ + fun address( + sealingRoot: ByteArray, + channelId: ByteArray, + newEpoch: Long, + ): GroupKey = ConcordKeyDerivation.channelRekeyAddress(sealingRoot, channelId, newEpoch) + + /** The `prevcommit` a rotation off [heldKey] at [heldEpoch] carries (CORD-02 A.5). */ + fun prevCommit( + heldEpoch: Long, + heldKey: ByteArray, + ): HexKey = ConcordKeyDerivation.epochKeyCommitment(heldEpoch, heldKey).toHexKey() + + /** A fresh 32-byte channel key. */ + fun mintKey(): ByteArray = RandomInstance.bytes(32) + + /** + * The kind-1059 wraps of one channel rotation: the chunked kind-3303 rumors delivering + * [newKey] at `heldEpoch + 1` to [recipients] (the rotator should include itself, or nobody + * could rotate the channel next time), each chunk carrying [authority] (`vac`), sealed + * (encrypted, rotator-signed) at [address] under [sealingRoot]. + */ + suspend fun build( + rotatorSigner: NostrSigner, + sealingRoot: ByteArray, + channelId: ByteArray, + heldKey: ByteArray, + heldEpoch: Long, + newKey: ByteArray, + recipients: Collection, + createdAt: Long, + authority: AuthorityCitation? = null, + ): List { + val newEpoch = heldEpoch + 1 + val prevCommit = prevCommit(heldEpoch, heldKey) + val blobs = + recipients.map { it.lowercase() }.distinct().map { recipient -> + ConcordRekey.blobForSigner(rotatorSigner, recipient.hexToByteArray(), channelId, newEpoch, newKey) + } + val widest = blobs.size.coerceAtLeast(1) + val envelopeTags = ConcordRekey.tags(channelId, newEpoch, heldEpoch, prevCommit, widest, widest, authority) + val envelope = + RumorAssembler + .assembleRumor(rotatorSigner.pubKey, createdAt, ConcordRekey.KIND, envelopeTags, "") + .toJson() + .encodeToByteArray() + .size + val chunks = ConcordRekey.chunkBlobs(blobs, envelope) + val stream = address(sealingRoot, channelId, newEpoch) + return chunks.mapIndexed { index, chunk -> + val tags = ConcordRekey.tags(channelId, newEpoch, heldEpoch, prevCommit, index + 1, chunks.size, authority) + val rumor = RumorAssembler.assembleRumor(rotatorSigner.pubKey, createdAt, ConcordRekey.KIND, tags, ConcordRekey.encodeContent(chunk)) + ConcordStreamEnvelope.wrap(rumor, stream, rotatorSigner, encrypted = true, createdAt = createdAt) + } + } + + /** + * Opens the kind-1059 [wraps] seen at channel-rekey addresses ([keys], address hex → key) and + * groups the well-formed chunks for [channelIdHex] into [ChannelRotation]s, keyed by + * (rotator, newepoch, prevcommit). Drops: a wrap at no known address, a plaintext seal (a rekey + * seal is encrypted, CORD-02 §5), a non-3303 rumor, a scope other than the channel, a + * non-decimal or 0-based chunk, a malformed `vac`. A rotation whose chunks disagree on + * `prevepoch`, `total` or citation is distrusted whole. + */ + fun rotations( + wraps: Collection, + keys: Map, + channelIdHex: HexKey, + ): List { + val scope = channelIdHex.lowercase() + val groups = LinkedHashMap>() + for (wrap in wraps.distinctBy { it.id }) { + val key = keys[wrap.pubKey] ?: continue + val opened = ConcordStreamEnvelope.openOrNull(wrap, key) ?: continue + if (opened.sealKind != ConcordStreamEnvelope.KIND_SEAL_ENCRYPTED) continue + val rumor = opened.rumor + if (rumor.kind != ConcordRekey.KIND) continue + if (rumor.tags.firstTagValue(ConcordRekey.TAG_SCOPE)?.lowercase() != scope) continue + val newEpoch = strictLong(rumor.tags.firstTagValue(ConcordRekey.TAG_NEWEPOCH)) ?: continue + val prevEpoch = strictLong(rumor.tags.firstTagValue(ConcordRekey.TAG_PREVEPOCH)) ?: continue + val prevCommit = rumor.tags.firstTagValue(ConcordRekey.TAG_PREVCOMMIT)?.lowercase() ?: continue + if (!HEX64.matches(prevCommit)) continue + val (index, total) = ConcordRekey.chunkOf(rumor.tags) ?: continue + val vacTag = rumor.tags.firstOrNull { it.isNotEmpty() && it[0] == VacTag.TAG_NAME } + val citation = if (vacTag == null) null else VacTag.parse(vacTag) ?: continue + val rotator = opened.author.lowercase() + groups + .getOrPut("$rotator:$newEpoch:$prevCommit") { ArrayList() } + .add(Parsed(rotator, newEpoch, prevEpoch, prevCommit, index, total, ConcordRekey.decodeContent(rumor.content), citation, rumor.createdAt)) + } + return groups.values.mapNotNull { parsed -> + val first = parsed.first() + if (parsed.any { it.prevEpoch != first.prevEpoch || it.total != first.total }) return@mapNotNull null + val citations = parsed.map { p -> p.citation?.let { VacTag.assemble(it).joinToString(",") } }.distinct() + if (citations.size > 1) return@mapNotNull null + ChannelRotation( + rotator = first.rotator, + channelIdHex = scope, + newEpoch = first.newEpoch, + prevEpoch = first.prevEpoch, + prevCommit = first.prevCommit, + total = first.total, + chunks = parsed.groupBy { it.index }.mapValues { (_, same) -> same.first().blobs }, + authority = first.citation, + createdAt = parsed.maxOf { it.createdAt }, + ) + } + } + + /** + * Walks [rotations] of the channel whose key this account holds ([heldKey] at [heldEpoch]) and + * decides what to do (Armada `useChannelRekeyWatch`): + * + * - only **complete** rotations past [heldEpoch] from an [honored] Rotator count; + * - epoch by epoch, ascending: a rotation carrying our blob **and** continuing the key we hold + * at that point (`prevepoch`/`prevcommit`) hands us the next key — racing Rotators at one + * epoch converge on the lexicographically lowest key — and the walk moves on from it; + * - a rotation that carries our blob off a key we can't verify is neither adoption nor removal + * (a gap to fetch); + * - a rotation with no blob for us, published at or after [joinedAtSecs] by a Rotator who + * [outranksMe], is the read-cut (removal needs no chain: hiding is local and safe); + * - a key adopted above the newest exclusion is a re-admission; otherwise the exclusion wins. + * + * The blob opens through [recipientSigner] (one NIP-44 decrypt: bunker-friendly). + */ + suspend fun walk( + rotations: List, + channelIdHex: HexKey, + heldKey: ByteArray, + heldEpoch: Long, + recipientSigner: NostrSigner, + joinedAtSecs: Long, + honored: (ChannelRotation) -> Boolean, + outranksMe: (HexKey) -> Boolean, + ): ChannelRekeyOutcome { + val channelId = channelIdHex.hexToByteArray() + val byEpoch = + rotations + .filter { it.channelIdHex.equals(channelIdHex, ignoreCase = true) && it.newEpoch > heldEpoch && it.complete && honored(it) } + .groupBy { it.newEpoch } + .entries + .sortedBy { it.key } + if (byEpoch.isEmpty()) return ChannelRekeyOutcome.None + + var chainEpoch = heldEpoch + var chainKey = heldKey + var adoptedEpoch: Long? = null + var excludedAt: Long? = null + val stepped = ArrayList() + + for ((epoch, candidates) in byEpoch) { + var keyHere: ByteArray? = null + var publishedHere: Long? = null + var addressedHere = false + for (set in candidates) { + val locator = + ConcordKeyDerivation + .recipientLocator(set.rotator.hexToByteArray(), recipientSigner.pubKey.hexToByteArray(), channelId, epoch) + .toHexKey() + if (set.blobs().none { it.locator == locator }) continue + addressedHere = true + // Only a rotation off the key we hold at this point can hand us the next one. + if (set.prevEpoch != chainEpoch || set.prevCommit != prevCommit(chainEpoch, chainKey)) continue + val payload = + ConcordRekey.findPayloadWithSigner(set.blobs(), recipientSigner, set.rotator.hexToByteArray(), channelId, epoch) + // A channel blob is exactly 72 bytes; a wider (base-form) payload is malformed here. + if (payload == null || payload.newControlPk != null) continue + keyHere = keyHere?.let { if (ConcordRefounding.compareKeys(payload.newKey, it) < 0) payload.newKey else it } ?: payload.newKey + publishedHere = publishedHere?.let { minOf(it, set.createdAt) } ?: set.createdAt + } + val next = keyHere + if (next != null) { + stepped.add(0, SteppedChannelKey(chainKey, chainEpoch, publishedHere ?: 0)) + chainEpoch = epoch + chainKey = next + adoptedEpoch = epoch + continue + } + if (addressedHere) continue + if (candidates.any { it.createdAt >= joinedAtSecs && outranksMe(it.rotator) }) excludedAt = epoch + } + + val adopted = adoptedEpoch + if (adopted != null && (excludedAt == null || adopted > excludedAt)) { + return ChannelRekeyOutcome.Adopted(chainKey, adopted, stepped) + } + return excludedAt?.let { ChannelRekeyOutcome.Removed(it) } ?: ChannelRekeyOutcome.None + } + + private class Parsed( + val rotator: HexKey, + val newEpoch: Long, + val prevEpoch: Long, + val prevCommit: HexKey, + val index: Int, + val total: Int, + val blobs: List, + val citation: AuthorityCitation?, + val createdAt: Long, + ) + + private val HEX64 = Regex("^[0-9a-f]{64}$") + + /** Strict decimal (`0|[1-9][0-9]*`), as the reference client's `isTagDecimal`. */ + private fun strictLong(value: String?): Long? { + if (value.isNullOrEmpty() || value.length > 18 || !value.all { it in '0'..'9' }) return null + if (value.length > 1 && value[0] == '0') return null + return value.toLong() + } +} diff --git a/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord07Voice/ConcordBrokerToken.kt b/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord07Voice/ConcordBrokerToken.kt index 5c509a1b65..07e2da2e7f 100644 --- a/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord07Voice/ConcordBrokerToken.kt +++ b/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord07Voice/ConcordBrokerToken.kt @@ -22,8 +22,10 @@ package com.vitorpamplona.quartz.concord.cord07Voice import com.vitorpamplona.quartz.concord.crypto.GroupKey import com.vitorpamplona.quartz.nip01Core.core.Event +import com.vitorpamplona.quartz.nip01Core.core.toHexKey import com.vitorpamplona.quartz.nip01Core.crypto.KeyPair import com.vitorpamplona.quartz.nip01Core.signers.NostrSignerSync +import com.vitorpamplona.quartz.utils.RandomInstance import kotlin.io.encoding.Base64 import kotlin.io.encoding.ExperimentalEncodingApi @@ -42,6 +44,10 @@ object ConcordBrokerToken { const val AUTH_SCHEME = "Concord" const val TAG_URL = "u" const val TAG_METHOD = "method" + const val TAG_NONCE = "nonce" + + /** Bytes of fresh entropy in the grant's [TAG_NONCE] tag (64 lowercase hex chars, as the reference client). */ + const val NONCE_BYTES = 32 /** The broker path for a voice room (the room = the voice signer's x-only pubkey hex). */ fun wellKnownPath(voiceRoomHex: String): String = "/.well-known/concord/av/$voiceRoomHex" @@ -49,15 +55,27 @@ object ConcordBrokerToken { /** * Builds the kind-27235 auth event for [url]/[method], signed by the channel's * [voiceSigner] key (its public key is the voice room / SFU name). + * + * Every member of a Channel signs with the **same** `voice_key.sk`, so two members + * requesting in the same second would otherwise build byte-identical events — one id — + * and the broker's anti-replay set (keyed on the id, CORD-07 §2) would refuse the second. + * The random [nonce] tag (`["nonce", <64 hex>]`, after `u` and `method`, as the reference + * client signs it) keeps every grant's id unique. */ fun buildAuthEvent( voiceSigner: GroupKey, url: String, createdAt: Long, method: String = "GET", + nonce: String = RandomInstance.bytes(NONCE_BYTES).toHexKey(), ): Event { val signer = NostrSignerSync(KeyPair(privKey = voiceSigner.secretKey)) - return signer.signNormal(createdAt, KIND, arrayOf(arrayOf(TAG_URL, url), arrayOf(TAG_METHOD, method)), "") + return signer.signNormal( + createdAt, + KIND, + arrayOf(arrayOf(TAG_URL, url), arrayOf(TAG_METHOD, method), arrayOf(TAG_NONCE, nonce)), + "", + ) } /** The `Authorization` header value carrying a base64 of the signed auth [event]. */ diff --git a/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord07Voice/VoicePresence.kt b/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord07Voice/VoicePresence.kt index 9cb06f4925..41a8113523 100644 --- a/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord07Voice/VoicePresence.kt +++ b/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/concord/cord07Voice/VoicePresence.kt @@ -23,12 +23,17 @@ package com.vitorpamplona.quartz.concord.cord07Voice import com.vitorpamplona.quartz.concord.cord03Channels.ChannelChat import com.vitorpamplona.quartz.concord.cord03Channels.tags.ChannelTag import com.vitorpamplona.quartz.concord.cord03Channels.tags.EpochTag +import com.vitorpamplona.quartz.concord.cord03Channels.tags.MsTag import com.vitorpamplona.quartz.nip01Core.core.Event import com.vitorpamplona.quartz.nip01Core.core.HexKey import com.vitorpamplona.quartz.nip01Core.core.firstTagValue import com.vitorpamplona.quartz.nip59Giftwrap.rumors.RumorAssembler -/** A parsed voice presence: who is in the call, under which SFU [identity], and on which [broker]. */ +/** + * A parsed voice presence: who is in the call, under which SFU [identity], and on which [broker]. + * [ms] is the CORD-02 §4 ordering basis (`created_at * 1000 + ms`) and [rumorId] the equal-time + * tiebreak — together they decide which of an author's presences is the latest. + */ class VoicePresenceInfo( val author: HexKey, val channelId: HexKey?, @@ -37,6 +42,18 @@ class VoicePresenceInfo( val identity: String?, val broker: String?, val createdAt: Long, + val ms: Long, + val rumorId: HexKey, +) + +/** + * The folded view of one Channel's call (CORD-07 §4): [present] holds each author's latest + * presence when it is a fresh `joined`; [verified] maps an SFU identity to the single author + * whose fresh presence claims it (contested and unclaimed identities are absent). + */ +class VoicePresenceFold( + val present: List, + val verified: Map, ) /** @@ -44,9 +61,11 @@ class VoicePresenceInfo( * Channel plane (like Chat Plane messages), announcing that a member is in the * call under a broker-assigned SFU [VoicePresenceInfo.identity]. * - * A participant renders as a verified member only when **exactly one author's - * fresh signed presence** claims an identity ([verifiedParticipants]); contested - * identities render unverified. Presence is heartbeated every + * Per author the **latest** presence wins ([latestPerAuthor]: millisecond basis, lower rumor id + * on a tie — the reference client's `foldVoicePresence`), so a `left` supersedes an earlier + * `joined` and a heartbeat under a new identity drops the old claim. A participant renders as a + * verified member only when **exactly one author's fresh signed presence** claims an identity + * ([fold]); contested identities render unverified. Presence is heartbeated every * [HEARTBEAT_MS] and considered absent after [STALE_MS]. */ object VoicePresence { @@ -67,48 +86,104 @@ object VoicePresence { identity: String, createdAt: Long, broker: String? = null, - subMs: Int? = null, + subMs: Int? = MsTag.remainderFor(createdAt), ): Event { val tags = ArrayList>() tags.add(ChannelTag.assemble(channelId)) tags.add(EpochTag.assemble(epoch)) tags.add(arrayOf(TAG_IDENTITY, identity)) if (broker != null) tags.add(arrayOf(TAG_BROKER, broker)) - if (subMs != null) tags.add(arrayOf("ms", subMs.toString())) + if (subMs != null) tags.add(MsTag.assemble(subMs)) return RumorAssembler.assembleRumor(authorPubKey, createdAt, KIND, tags.toTypedArray(), CONTENT_JOINED) } - /** A "left" presence bound to the channel/epoch. */ + /** A "left" presence bound to the channel/epoch (identity and broker omitted). */ fun left( authorPubKey: HexKey, channelId: HexKey, epoch: Long, createdAt: Long, - ): Event = RumorAssembler.assembleRumor(authorPubKey, createdAt, KIND, arrayOf(ChannelTag.assemble(channelId), EpochTag.assemble(epoch)), CONTENT_LEFT) + subMs: Int? = MsTag.remainderFor(createdAt), + ): Event { + val tags = ArrayList>(3) + tags.add(ChannelTag.assemble(channelId)) + tags.add(EpochTag.assemble(epoch)) + if (subMs != null) tags.add(MsTag.assemble(subMs)) + return RumorAssembler.assembleRumor(authorPubKey, createdAt, KIND, tags.toTypedArray(), CONTENT_LEFT) + } + /** + * Parses a kind-23313 rumor, or null when malformed: the content is not `joined`/`left`, a + * `joined` names no identity, or the `ms` tag is malformed/duplicated (dropped, never + * interpreted — CORD-02 §5). The caller checks the channel/epoch binding. + */ fun parse(rumor: Event): VoicePresenceInfo? { if (rumor.kind != KIND) return null + val joined = + when (rumor.content) { + CONTENT_JOINED -> true + CONTENT_LEFT -> false + else -> return null + } + val ms = MsTag.orderingMs(rumor.createdAt, rumor.tags) ?: return null + val identity = rumor.tags.firstTagValue(TAG_IDENTITY)?.takeIf { it.isNotEmpty() } + if (joined && identity == null) return null return VoicePresenceInfo( author = rumor.pubKey, channelId = ChannelChat.channelOf(rumor), epoch = ChannelChat.epochOf(rumor), - joined = rumor.content == CONTENT_JOINED, - identity = rumor.tags.firstTagValue(TAG_IDENTITY), - broker = rumor.tags.firstTagValue(TAG_BROKER), + joined = joined, + identity = if (joined) identity else null, + broker = if (joined) rumor.tags.firstTagValue(TAG_BROKER) else null, createdAt = rumor.createdAt, + ms = ms, + rumorId = rumor.id, ) } - /** True if [presence] is within [STALE_MS] of [nowMs] (createdAt is unix seconds). */ + /** True if [presence] is within [STALE_MS] of [nowMs], on the millisecond basis. */ fun isFresh( presence: VoicePresenceInfo, nowMs: Long, - ): Boolean = nowMs - presence.createdAt * 1000 <= STALE_MS + ): Boolean = nowMs - presence.ms <= STALE_MS + + /** True when [candidate] supersedes [current]: later on the ms basis, or the lower rumor id on a tie. */ + private fun isLater( + candidate: VoicePresenceInfo, + current: VoicePresenceInfo, + ): Boolean = candidate.ms > current.ms || (candidate.ms == current.ms && candidate.rumorId < current.rumorId) + + /** Each author's latest presence (CORD-07 §4: ms basis, lower rumor id on equal ms). */ + fun latestPerAuthor(presences: Collection): Map { + val latest = HashMap() + for (p in presences) { + val prev = latest[p.author] + if (prev == null || isLater(p, prev)) latest[p.author] = p + } + return latest + } /** - * Maps each SFU identity to its single verified author across the given fresh - * [presences]. An identity claimed by zero or more-than-one author is omitted - * (contested identities render unverified). + * Folds every received presence of one call: per author the latest wins, then a `joined` + * older than [STALE_MS] counts as absent, then identities claimed by exactly one of the + * remaining authors verify. [VoicePresenceFold.present] is ordered by time, then author. + */ + fun fold( + presences: Collection, + nowMs: Long, + ): VoicePresenceFold { + val present = + latestPerAuthor(presences) + .values + .filter { it.joined && it.identity != null && isFresh(it, nowMs) } + .sortedWith(compareBy { it.ms }.thenBy { it.author }) + return VoicePresenceFold(present, verifiedParticipants(present)) + } + + /** + * Maps each SFU identity to its single verified author across [presences], which must + * already be the per-author latest, fresh presences ([fold] does both). An identity claimed + * by more than one author is omitted (contested identities render unverified). */ fun verifiedParticipants(presences: List): Map { val claimants = HashMap>() diff --git a/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/nip59Giftwrap/seals/SealEvent.kt b/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/nip59Giftwrap/seals/SealEvent.kt index badc0cbc7d..1ea8a13e7c 100644 --- a/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/nip59Giftwrap/seals/SealEvent.kt +++ b/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/nip59Giftwrap/seals/SealEvent.kt @@ -66,9 +66,18 @@ class SealEvent( override fun isContentEncoded() = true - suspend fun unsealThrowing(signer: NostrSigner): Event { - val rumor = Rumor.fromJson(plainContent(signer)) + suspend fun unsealThrowing(signer: NostrSigner): Event = unsealed(unsealRumorThrowing(signer)) + /** + * The rumor exactly as this seal carries it — its claimed `pubkey` NOT yet overwritten by the + * seal's — in one decrypt. For a caller that must run the NIP-59 anti-spoofing check itself + * (rumor author == seal author) and then still wants the merged event: pass the result to + * [unsealed] rather than decrypting again. + */ + suspend fun unsealRumorThrowing(signer: NostrSigner): Rumor = Rumor.fromJson(plainContent(signer)) + + /** [rumor] (decrypted from this seal) merged into the inner event, recorded as [innerEventId]. */ + fun unsealed(rumor: Rumor): Event { val event = rumor.mergeWith(this) innerEventId = event.id diff --git a/quartz/src/commonTest/kotlin/com/vitorpamplona/quartz/concord/cord02Community/GuestbookTest.kt b/quartz/src/commonTest/kotlin/com/vitorpamplona/quartz/concord/cord02Community/GuestbookTest.kt index 30b30480ac..afa2be495d 100644 --- a/quartz/src/commonTest/kotlin/com/vitorpamplona/quartz/concord/cord02Community/GuestbookTest.kt +++ b/quartz/src/commonTest/kotlin/com/vitorpamplona/quartz/concord/cord02Community/GuestbookTest.kt @@ -20,11 +20,21 @@ */ package com.vitorpamplona.quartz.concord.cord02Community +import com.vitorpamplona.quartz.concord.cord04Roles.AuthorityCitation +import com.vitorpamplona.quartz.concord.cord04Roles.AuthorityResolver +import com.vitorpamplona.quartz.concord.cord04Roles.ControlEdition +import com.vitorpamplona.quartz.concord.cord04Roles.ControlEntityKind +import com.vitorpamplona.quartz.concord.cord04Roles.ControlFixtures +import com.vitorpamplona.quartz.nip01Core.core.Event +import com.vitorpamplona.quartz.nip01Core.core.hexToByteArray import com.vitorpamplona.quartz.nip01Core.core.toHexKey import com.vitorpamplona.quartz.nip01Core.crypto.KeyPair import kotlin.test.Test import kotlin.test.assertEquals +import kotlin.test.assertFalse +import kotlin.test.assertNotNull import kotlin.test.assertNull +import kotlin.test.assertTrue class GuestbookTest { private val member = KeyPair().pubKey.toHexKey() @@ -42,6 +52,8 @@ class GuestbookTest { assertEquals(member, entry?.member) assertEquals(creator, entry?.inviteCreator) assertEquals("Reddit", entry?.inviteLabel) + assertEquals(1_700_000_000_128L, entry?.ms) + assertEquals(rumor.id, entry?.rumorId) } @Test @@ -59,7 +71,150 @@ class GuestbookTest { } @Test - fun parseIgnoresNonGuestbookRumors() { - assertNull(Guestbook.parse(Guestbook.kick(creator, target, 1L))) // kick is not a join/leave + fun kickMatchesTheExampleWireShape() { + // examples.md §3.2: content "", tags ms, p, vac. + val citation = AuthorityCitation(ByteArray(32) { 1 }, 3, ByteArray(32) { 2 }) + val rumor = Guestbook.kick(creator, target, createdAt = 1_722_410_000L, subMs = 301, citation = citation) + assertEquals("", rumor.content) + assertEquals(listOf("ms", "p", "vac"), rumor.tags.map { it[0] }) + assertEquals(listOf("ms", "301"), rumor.tags[0].toList()) + assertEquals(listOf("vac", "01".repeat(32), "3", "02".repeat(32)), rumor.tags[2].toList()) + + val entry = assertNotNull(Guestbook.parse(rumor)) + assertEquals(GuestbookAction.KICK, entry.action) + assertEquals(target, entry.member) // the state it sets is the target's + assertEquals(creator, entry.author) + assertEquals(1_722_410_000_301L, entry.ms) + assertEquals(3L, entry.citation?.grantVersion) + } + + @Test + fun parseIgnoresNonGuestbookAndMalformedRumors() { + assertNull(Guestbook.parse(Event("00".repeat(32), member, 1L, 9, emptyArray(), "join", ""))) + // A 3306 whose verb is "kick" is not a Kick: only kind 3309 can kick. + assertNull(Guestbook.parse(Event("00".repeat(32), member, 1L, Guestbook.KIND_JOIN_LEAVE, emptyArray(), "kick", ""))) + // A malformed ms is dropped, never interpreted (CORD-02 §5). + assertNull(Guestbook.parse(Event("00".repeat(32), member, 1L, Guestbook.KIND_JOIN_LEAVE, arrayOf(arrayOf("ms", "1000")), "join", ""))) + // A Kick naming no valid target. + assertNull(Guestbook.parse(Event("00".repeat(32), member, 1L, Guestbook.KIND_KICK, arrayOf(arrayOf("p", "zz")), "", ""))) + } + + // ---- Kick authority (CORD-04 §5/§6) -------------------------------------- + + private val owner = "0f".repeat(32) + private val admin = "a1".repeat(32) + private val mod = "b2".repeat(32) + private val plain = "c3".repeat(32) + private val other = "d4".repeat(32) + private val adminRole = "11".repeat(32) + private val modRole = "22".repeat(32) + + private fun role( + roleId: String, + json: String, + ) = ControlEdition(ControlEntityKind.ROLE, roleId.hexToByteArray(), 0, null, null, json, owner, "role-$roleId", 0) + + private fun grant( + member: String, + roleIds: List, + ) = ControlEdition( + ControlEntityKind.GRANT, + ControlFixtures.grantEid(member).hexToByteArray(), + 0, + null, + null, + """{"member":"$member","role_ids":[${roleIds.joinToString(",") { "\"$it\"" }}]}""", + owner, + "grant-$member", + 0, + ) + + private fun banlist(vararg banned: String) = ControlEdition(ControlEntityKind.BANLIST, ControlFixtures.banlistEid().hexToByteArray(), 0, null, null, "[${banned.joinToString(",") { "\"$it\"" }}]", owner, "ban", 0) + + /** Admin at position 1 (KICK|BAN|MANAGE_ROLES), Mod at position 5 (KICK only). */ + private fun roster(vararg extra: ControlEdition): AuthorityResolver = + ControlFixtures.resolve( + listOf( + role(adminRole, """{"name":"Admin","position":1,"permissions":"25"}"""), + role(modRole, """{"name":"Mod","position":5,"permissions":"8"}"""), + grant(admin, listOf(adminRole)), + grant(mod, listOf(modRole)), + ) + extra, + owner, + ) + + private fun kickBy( + actor: String, + target: String, + authority: AuthorityResolver, + at: Long = 100L, + citation: AuthorityCitation? = authority.citationFor(actor), + ) = Guestbook.parse(Guestbook.kick(actor, target, at, subMs = 0, citation = citation))!! + + private fun join( + who: String, + at: Long, + ) = Guestbook.parse(Guestbook.join(who, at, subMs = 0))!! + + @Test + fun kickHonoredOnlyFromAKickHolderWhoOutranksTheTarget() { + val r = roster() + assertTrue(Guestbook.canKick(r, kickBy(owner, plain, r))) // owner, no citation needed + assertTrue(Guestbook.canKick(r, kickBy(mod, plain, r))) // KICK at position 5 over a roleless member + assertTrue(Guestbook.canKick(r, kickBy(admin, mod, r))) // 1 outranks 5 + assertFalse(Guestbook.canKick(r, kickBy(mod, admin, r))) // 5 does not outrank 1 + assertFalse(Guestbook.canKick(r, kickBy(plain, other, r))) // no KICK bit + assertFalse(Guestbook.canKick(r, kickBy(admin, owner, r))) // the owner is never a target + assertFalse(Guestbook.canKick(r, kickBy(mod, mod, r))) // equal cannot act on equal + } + + @Test + fun kickWithoutASyncedCitationParks() { + val r = roster() + // No vac from a non-owner: the sync floor cannot be met. + assertFalse(Guestbook.canKick(r, kickBy(mod, plain, r, citation = null))) + // A vac ahead of the Grant we hold (not yet synced) parks too. + val held = r.citationFor(mod)!! + val ahead = AuthorityCitation(held.grantId, held.grantVersion + 1, held.grantHash) + assertFalse(Guestbook.canKick(r, kickBy(mod, plain, r, citation = ahead))) + } + + @Test + fun coalesceTakesTheLatestHonoredMotionPerMember() { + val r = roster() + val joined = join(plain, 50L) + val kicked = kickBy(mod, plain, r, at = 100L) + val folded = Guestbook.coalesce(listOf(kicked, joined), nowMs = 200_000L, authority = r) + assertEquals(GuestbookAction.KICK, folded[plain]?.action) + + // A kicked member may re-join: a newer Join supersedes the Kick. + val rejoined = join(plain, 150L) + assertEquals(GuestbookAction.JOIN, Guestbook.coalesce(listOf(kicked, joined, rejoined), 200_000L, r)[plain]?.action) + + // A Kick from someone who may not kick leaves the member joined. + val forged = kickBy(plain, other, r, at = 100L) + val otherJoined = join(other, 50L) + assertEquals(GuestbookAction.JOIN, Guestbook.coalesce(listOf(otherJoined, forged), 200_000L, r)[other]?.action) + + // Without a roster no Kick is honored. + assertEquals(GuestbookAction.JOIN, Guestbook.coalesce(listOf(joined, kicked), 200_000L, authority = null)[plain]?.action) + } + + @Test + fun coalesceDropsFutureAndBannedEntriesAndTiesToTheLowerRumorId() { + val now = 1_000_000L + val future = Guestbook.parse(Guestbook.leave(plain, now / 1000 + 3601, subMs = 0))!! + val joined = join(plain, 10L) + assertEquals(GuestbookAction.JOIN, Guestbook.coalesce(listOf(joined, future), now, authority = null)[plain]?.action) + + // A banned member's own motions are dropped. + val banned = roster(banlist(other)) + assertNull(Guestbook.coalesce(listOf(join(other, 10L)), now, banned)[other]) + + val a = Guestbook.parse(Guestbook.join(plain, 10L, subMs = 5))!! + val b = Guestbook.parse(Guestbook.leave(plain, 10L, subMs = 5))!! + val lower = if (a.rumorId < b.rumorId) a else b + assertEquals(lower.rumorId, Guestbook.coalesce(listOf(a, b), now, authority = null)[plain]?.rumorId) + assertEquals(lower.rumorId, Guestbook.coalesce(listOf(b, a), now, authority = null)[plain]?.rumorId) } } diff --git a/quartz/src/commonTest/kotlin/com/vitorpamplona/quartz/concord/cord03Channels/ConcordChannelKeyringTest.kt b/quartz/src/commonTest/kotlin/com/vitorpamplona/quartz/concord/cord03Channels/ConcordChannelKeyringTest.kt new file mode 100644 index 0000000000..e567776c13 --- /dev/null +++ b/quartz/src/commonTest/kotlin/com/vitorpamplona/quartz/concord/cord03Channels/ConcordChannelKeyringTest.kt @@ -0,0 +1,144 @@ +/* + * Copyright (c) 2025 Vitor Pamplona + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the + * Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR + * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ +package com.vitorpamplona.quartz.concord.cord03Channels + +import com.vitorpamplona.quartz.concord.cord02Community.ConcordCommunityList +import com.vitorpamplona.quartz.concord.cord02Community.ConcordCommunityListEntry +import com.vitorpamplona.quartz.concord.cord02Community.PrivateChannelKey +import com.vitorpamplona.quartz.concord.cord04Roles.ConcordJson +import kotlinx.serialization.json.JsonArray +import kotlinx.serialization.json.JsonObject +import kotlinx.serialization.json.JsonPrimitive +import kotlinx.serialization.json.jsonArray +import kotlinx.serialization.json.jsonObject +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFalse +import kotlin.test.assertNotNull +import kotlin.test.assertNull +import kotlin.test.assertTrue + +/** + * The List side of Private Channel keys (CORD-02 §8, CORD-03 §2, CORD-06 §2): rotations replace + * the one current key in place, older keys are read from `seed` / a peer's `priors` but never + * written, and the reference client's `channel_cuts` floor survives a round trip and refuses a + * key below it. + */ +class ConcordChannelKeyringTest { + private val chan = "a1".repeat(32) + private val other = "b2".repeat(32) + private val k0 = "10".repeat(32) + private val k1 = "11".repeat(32) + private val k2 = "12".repeat(32) + + private fun entry(channels: List) = + ConcordCommunityListEntry( + id = "c0".repeat(32), + owner = "0f".repeat(32), + ownerSalt = "5a".repeat(32), + root = "22".repeat(32), + rootEpoch = 2, + privateChannels = channels, + name = "Test", + addedAt = 1, + ) + + private fun roundTrip(e: ConcordCommunityListEntry): ConcordCommunityListEntry = ConcordCommunityList.decode(ConcordCommunityList.encode(listOf(e))).single() + + @Test + fun aRotationReplacesTheKeyInPlaceKeepingUnknownFields() { + val wire = + """{"entries":[{"community_id":"${"c0".repeat(32)}","added_at":1,"current":{"community_id":"${"c0".repeat(32)}", + "owner":"${"0f".repeat(32)}","owner_salt":"${"5a".repeat(32)}","community_root":"${"22".repeat(32)}","root_epoch":2, + "channels":[{"id":"$chan","key":"$k0","epoch":0,"name":"mods","tint":"red"}],"relays":[],"name":"Test"}}]}""" + val held = ConcordCommunityList.decode(wire).single() + val rotated = assertNotNull(ConcordChannelKeyring.withRotatedKey(held, chan, k1, 1)) + val ch = rotated.privateChannels.single() + assertEquals(k1, ch.key) + assertEquals(1, ch.epoch) + assertEquals("mods", ch.name) + // Another client's field inside the channel object survives. + val back = roundTrip(rotated).privateChannels.single() + assertEquals(JsonPrimitive("red"), back.extras["tint"]) + // Never backward, never sideways. + assertNull(ConcordChannelKeyring.withRotatedKey(rotated, chan, k2, 1)) + assertNull(ConcordChannelKeyring.withRotatedKey(rotated, chan, k2, 0)) + } + + @Test + fun aCutRoundTripsAndRefusesOlderKeys() { + val held = entry(listOf(PrivateChannelKey(chan, k0, 0, "mods"), PrivateChannelKey(other, k1, 3, "vip"))) + val cut = ConcordChannelKeyring.withoutChannel(held, chan, 1) + assertEquals(listOf(other), cut.privateChannels.map { it.channelId }) + + // Written as the reference client's entry-level extension and read back. + val back = roundTrip(cut) + val encoded = ConcordJson.instance.parseToJsonElement(ConcordCommunityList.encode(listOf(cut))).jsonObject + val cuts = encoded["entries"]!!.jsonArray[0].jsonObject["channel_cuts"]!!.jsonArray + assertEquals(listOf(JsonObject(mapOf("id" to JsonPrimitive(chan), "epoch" to JsonPrimitive(1L)))), cuts.toList()) + assertEquals(mapOf(chan to 1L), ConcordChannelKeyring.cutsOf(back)) + + // A stale key below the cut never comes back; one at/above it (a re-grant) does. + assertTrue(ConcordChannelKeyring.isCutOff(back, chan, 0)) + assertNull(ConcordChannelKeyring.withChannelKey(back, PrivateChannelKey(chan, k0, 0))) + assertNotNull(ConcordChannelKeyring.withChannelKey(back, PrivateChannelKey(chan, k2, 1))) + + // Max wins; a lower cut never rolls it back. + assertEquals(1L, ConcordChannelKeyring.cutsOf(ConcordChannelKeyring.withCut(back, chan, 0))[chan]) + assertEquals(4L, ConcordChannelKeyring.cutsOf(ConcordChannelKeyring.withCut(back, chan, 4))[chan]) + } + + @Test + fun anUnknownFieldInsideACutSurvivesARaise() { + val wire = + """{"entries":[{"community_id":"${"c0".repeat(32)}","added_at":1,"channel_cuts":[{"id":"$chan","epoch":1,"why":"x"},{"id":"$other","epoch":2}], + "current":{"community_id":"${"c0".repeat(32)}","owner":"${"0f".repeat(32)}","owner_salt":"${"5a".repeat(32)}", + "community_root":"${"22".repeat(32)}","root_epoch":2,"channels":[],"relays":[],"name":"Test"}}]}""" + val held = ConcordCommunityList.decode(wire).single() + val raised = roundTrip(ConcordChannelKeyring.withCut(held, chan, 3)) + val cuts = raised.residue.entryExtras["channel_cuts"] as JsonArray + val mine = cuts.map { it.jsonObject }.single { (it["id"] as JsonPrimitive).content == chan } + assertEquals(JsonPrimitive("x"), mine["why"]) + assertEquals(mapOf(chan to 3L, other to 2L), ConcordChannelKeyring.cutsOf(raised)) + } + + @Test + fun olderKeysAreReadFromSeedAndPriorsButNeverWritten() { + val wire = + """{"entries":[{"community_id":"${"c0".repeat(32)}","added_at":1, + "seed":{"community_id":"${"c0".repeat(32)}","owner":"${"0f".repeat(32)}","owner_salt":"${"5a".repeat(32)}","community_root":"${"22".repeat(32)}", + "root_epoch":0,"channels":[{"id":"$chan","key":"$k0","epoch":0,"name":"mods"}],"relays":[],"name":"Test"}, + "current":{"community_id":"${"c0".repeat(32)}","owner":"${"0f".repeat(32)}","owner_salt":"${"5a".repeat(32)}","community_root":"${"22".repeat(32)}", + "root_epoch":2,"channels":[{"id":"$chan","key":"$k2","epoch":2,"name":"mods","priors":[{"key":"$k1","epoch":1,"retired_at":5}]}],"relays":[],"name":"Test"}}]}""" + val held = ConcordCommunityList.decode(wire).single() + assertEquals(listOf(1L to k1, 0L to k0), ConcordChannelKeyring.historicalKeys(held, chan).map { it.epoch to it.key }) + // The next privatisation climbs past every generation this entry knows of. + assertEquals(3, ConcordChannelKeyring.nextChannelEpoch(held, chan)) + assertEquals(10, ConcordChannelKeyring.nextChannelEpoch(held, chan, observedFloor = 9)) + assertEquals(1, ConcordChannelKeyring.nextChannelEpoch(held, other)) + + // A rotation we launch adds no prior of its own (CORD-02 §8 keeps intermediate keys out of the List). + val rotated = assertNotNull(ConcordChannelKeyring.withRotatedKey(held, chan, "13".repeat(32), 3)) + val priors = rotated.privateChannels.single().extras[ConcordChannelKeyring.PRIORS] as JsonArray + assertEquals(1, priors.size) + assertFalse(ConcordChannelKeyring.historicalKeys(rotated, chan).any { it.key == "13".repeat(32) }) + } +} diff --git a/quartz/src/commonTest/kotlin/com/vitorpamplona/quartz/concord/cord03Channels/ConcordWebxdcTest.kt b/quartz/src/commonTest/kotlin/com/vitorpamplona/quartz/concord/cord03Channels/ConcordWebxdcTest.kt new file mode 100644 index 0000000000..d25ca3bfb6 --- /dev/null +++ b/quartz/src/commonTest/kotlin/com/vitorpamplona/quartz/concord/cord03Channels/ConcordWebxdcTest.kt @@ -0,0 +1,91 @@ +/* + * Copyright (c) 2025 Vitor Pamplona + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the + * Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR + * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ +package com.vitorpamplona.quartz.concord.cord03Channels + +import com.vitorpamplona.quartz.concord.crypto.ConcordKeyDerivation +import com.vitorpamplona.quartz.concord.crypto.ConcordLabels +import com.vitorpamplona.quartz.concord.envelope.ConcordStreamEnvelope +import com.vitorpamplona.quartz.nip01Core.core.hexToByteArray +import com.vitorpamplona.quartz.nip01Core.crypto.KeyPair +import com.vitorpamplona.quartz.nip01Core.signers.NostrSignerInternal +import kotlinx.coroutines.test.runTest +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFalse +import kotlin.test.assertNotNull +import kotlin.test.assertNull +import kotlin.test.assertTrue + +/** WebXDC signals (kind 3310): Chat-plane plumbing only — built, bound, gated apart from chat rows, parsed. */ +class ConcordWebxdcTest { + private val author = NostrSignerInternal(KeyPair()) + private val channelId = "42".repeat(32) + private val topic = "A".repeat(26) + "234567".repeat(4) + "BC" // 52 base32 chars + + @Test + fun theExamplesBindingAndTheStateUpdateTags() { + val rumor = ConcordWebxdc.stateUpdate(author.pubKey, channelId, 0L, session = "uuid-1", payload = "{\"x\":1}", createdAt = 1_686_840_700L, info = "moved", ms = 266) + assertEquals(3310, rumor.kind) + // examples.md §2.6: channel, epoch, ms — then the app's own tags. + assertEquals(listOf("channel", "epoch", "ms", "i", "alt", "info"), rumor.tags.map { it[0] }) + assertTrue(ChannelChat.isBoundTo(rumor, channelId, 0L)) + assertEquals("uuid-1", ConcordWebxdc.sessionOf(rumor)) + assertEquals("{\"x\":1}", rumor.content) + } + + @Test + fun peerSignalsRoundTripInTheReferenceShape() { + val ad = ConcordWebxdc.peerSignal(author.pubKey, channelId, 0L, topic, nodeAddr = "node-addr", createdAt = 5L) + assertEquals("{\"op\":\"ad\",\"topic\":\"$topic\",\"addr\":\"node-addr\"}", ad.content) + assertNull(ConcordWebxdc.sessionOf(ad)) + val parsed = assertNotNull(ConcordWebxdc.parsePeerSignal(ad.content)) + assertTrue(parsed.isAdvert) + assertEquals("node-addr", parsed.addr) + + val left = ConcordWebxdc.peerSignal(author.pubKey, channelId, 0L, topic, nodeAddr = null, createdAt = 6L) + assertEquals("{\"op\":\"left\",\"topic\":\"$topic\"}", left.content) + assertFalse(assertNotNull(ConcordWebxdc.parsePeerSignal(left.content)).isAdvert) + } + + @Test + fun untrustedPeerSignalsAreBounded() { + assertNull(ConcordWebxdc.parsePeerSignal("not json")) + assertNull(ConcordWebxdc.parsePeerSignal("{\"op\":\"ad\",\"topic\":\"short\",\"addr\":\"a\"}")) + assertNull(ConcordWebxdc.parsePeerSignal("{\"op\":\"ad\",\"topic\":\"${topic.lowercase()}\",\"addr\":\"a\"}")) + assertNull(ConcordWebxdc.parsePeerSignal("{\"op\":\"ad\",\"topic\":\"$topic\",\"addr\":\"\"}")) + assertNull(ConcordWebxdc.parsePeerSignal("{\"op\":\"ad\",\"topic\":\"$topic\",\"addr\":\"${"a".repeat(ConcordWebxdc.MAX_NODE_ADDR_CHARS + 1)}\"}")) + assertNull(ConcordWebxdc.parsePeerSignal("{\"op\":\"join\",\"topic\":\"$topic\"}")) + } + + @Test + fun theChatGateKeepsWebxdcOutOfChatRowsButThePlaneAdmitsIt() = + runTest { + val plane = ConcordKeyDerivation.groupKey(ConcordLabels.CHANNEL, ByteArray(32) { 9 }, channelId.hexToByteArray(), 0) + val rumor = ConcordWebxdc.stateUpdate(author.pubKey, channelId, 0L, "uuid-1", "{}", createdAt = 5L) + val wrap = ConcordStreamEnvelope.wrap(rumor, plane, author, encrypted = true, createdAt = 5L) + val opened = assertNotNull(ConcordStreamEnvelope.openOrNull(wrap, plane)) + + assertFalse(ChannelChat.isChatKind(ConcordWebxdc.KIND), "never a chat row") + assertNull(ChannelChat.acceptOpened(opened, channelId, 0L), "the chat gate refuses it") + assertEquals(rumor.id, ChannelChat.acceptOpened(opened, channelId, 0L, ChannelChat.PLANE_KINDS)?.id, "the plane carries it") + assertNull(ChannelChat.acceptOpened(opened, channelId, 1L, ChannelChat.PLANE_KINDS), "under the same strict binding") + } +} diff --git a/quartz/src/commonTest/kotlin/com/vitorpamplona/quartz/concord/cord04Roles/pins/ConcordPinsTest.kt b/quartz/src/commonTest/kotlin/com/vitorpamplona/quartz/concord/cord04Roles/pins/ConcordPinsTest.kt index 7aaf8510e3..9d365e0a35 100644 --- a/quartz/src/commonTest/kotlin/com/vitorpamplona/quartz/concord/cord04Roles/pins/ConcordPinsTest.kt +++ b/quartz/src/commonTest/kotlin/com/vitorpamplona/quartz/concord/cord04Roles/pins/ConcordPinsTest.kt @@ -167,6 +167,12 @@ class ConcordPinsTest { val noKey = ConcordPins.read(sealed) { null } assertTrue(noKey.sealedUnavailable, "unreadable is not empty: a writer must not build on it") assertTrue(noKey.entries.isEmpty()) + + // The read reports the form itself, matching isSealedForm, so nobody parses twice. + for (content in listOf(sealed, ConcordPins.serializePublic(listOf(entry)), "not json", """{"sealed":1}""", """{"epoch":"x","sealed":"y"}""")) { + assertEquals(ConcordPins.isSealedForm(content), ConcordPins.read(content) { plane.conversationKey }.sealedForm, content) + assertEquals(ConcordPins.isSealedForm(content), ConcordPins.read(content) { null }.sealedForm, content) + } } @Test diff --git a/quartz/src/commonTest/kotlin/com/vitorpamplona/quartz/concord/cord05Invites/ConcordInviteRegistryTest.kt b/quartz/src/commonTest/kotlin/com/vitorpamplona/quartz/concord/cord05Invites/ConcordInviteRegistryTest.kt index 522c1ca0fc..6e0405742d 100644 --- a/quartz/src/commonTest/kotlin/com/vitorpamplona/quartz/concord/cord05Invites/ConcordInviteRegistryTest.kt +++ b/quartz/src/commonTest/kotlin/com/vitorpamplona/quartz/concord/cord05Invites/ConcordInviteRegistryTest.kt @@ -20,6 +20,7 @@ */ package com.vitorpamplona.quartz.concord.cord05Invites +import com.vitorpamplona.quartz.concord.cord04Roles.AuthorityResolver import com.vitorpamplona.quartz.concord.cord04Roles.ConcordPermissions import com.vitorpamplona.quartz.concord.cord04Roles.ControlEdition import com.vitorpamplona.quartz.concord.cord04Roles.ControlEntityKind @@ -196,6 +197,8 @@ class ConcordInviteRegistryTest { assertFalse(state.retiringWouldPrivatize(listOf(link1))) assertTrue(state.retiringWouldPrivatize(listOf(link1, link2))) assertFalse(ControlFixtures.fold(emptyList(), owner).retiringWouldPrivatize(listOf(link1)), "already Private: nothing flips") + // A dissolved community is never Refounded (CORD-02 §9): the last retire is just a retire. + assertFalse(state.withDissolved(true).retiringWouldPrivatize(listOf(link1, link2))) } @Test @@ -259,15 +262,47 @@ class ConcordInviteRegistryTest { val livePk = live.pubKey.toHexKey() val expiredPk = expired.pubKey.toHexKey() - // The published registry still lists the expired link and an unrecorded one (link1); a new mint adds link2. + // The published registry still lists the expired link and one no list entry backs (link1): the + // readable list is authoritative, so both go; the recorded live link heals in; a mint adds link2. val next = ConcordInviteRegistry.nextLinks(listOf(expiredPk, link1), doc, ControlFixtures.COMMUNITY_ID_HEX, nowSecs = 200, minted = listOf(link2)) - assertEquals(listOf(link1, link2, livePk).sorted(), next) + assertEquals(listOf(link2, livePk).sorted(), next) - // Retiring the recorded live link and link1 leaves only the mint. - assertEquals(listOf(link2), ConcordInviteRegistry.nextLinks(next, doc, ControlFixtures.COMMUNITY_ID_HEX, nowSecs = 200, retired = listOf(livePk, link1))) + // Retiring the recorded live link, with the next mint recorded too, leaves only that mint. + val withMint = ConcordInviteListDocument(entries = doc.entries + entry("05", KeyPair()), tombstones = doc.tombstones) + val link3 = withMint.entries.last().signerPubKeyHex() + assertEquals(listOf(link3), ConcordInviteRegistry.nextLinks(next, withMint, ControlFixtures.COMMUNITY_ID_HEX, nowSecs = 200, retired = listOf(livePk))) // Before its expiry the link is still live; an unreadable list prunes nothing. assertTrue(expiredPk in ConcordInviteRegistry.nextLinks(emptyList(), doc, ControlFixtures.COMMUNITY_ID_HEX, nowSecs = 50)) assertEquals(listOf(expiredPk), ConcordInviteRegistry.nextLinks(listOf(expiredPk), null, ControlFixtures.COMMUNITY_ID_HEX, nowSecs = 200)) } + + @Test + fun theMemoizedRegistryCoordinateIsTheDerivedOne() { + val author = KeyPair().pubKey.toHexKey() + val derived = ConcordInviteRegistry.coordinateHex(ControlFixtures.COMMUNITY_ID_HEX.hexToByteArray(), author) + repeat(2) { + assertEquals(derived, AuthorityResolver.inviteLinksCoordinateHex(ControlFixtures.COMMUNITY_ID_HEX.hexToByteArray(), ControlFixtures.COMMUNITY_ID_HEX, author)) + } + // Keyed by community too: the same author elsewhere is a different coordinate. + val other = "ab".repeat(32) + assertEquals(ConcordInviteRegistry.coordinateHex(other.hexToByteArray(), author), AuthorityResolver.inviteLinksCoordinateHex(other.hexToByteArray(), other, author)) + } + + @Test + fun aRetiredLinkWhoseEntryTheMergeDroppedIsNotResurrectedFromThePublishedRegistry() { + val retired = KeyPair() + val kept = KeyPair() + val retiredPk = retired.pubKey.toHexKey() + val keptPk = kept.pubKey.toHexKey() + // After the tombstone merge, the retired link's entry (and its token) is gone from the list: + // only the tombstone remains, which no longer names the signer. + val merged = + ConcordInviteListDocument( + entries = listOf(entry("0a", kept)), + tombstones = listOf(ConcordInviteListTombstone("0b", ControlFixtures.COMMUNITY_ID_HEX)), + ) + // A later, unrelated registry edit (e.g. the next mint) must not carry the retired signer forward. + assertEquals(listOf(keptPk), ConcordInviteRegistry.nextLinks(listOf(retiredPk, keptPk), merged, ControlFixtures.COMMUNITY_ID_HEX, nowSecs = 200)) + } } diff --git a/quartz/src/commonTest/kotlin/com/vitorpamplona/quartz/concord/cord05Invites/ConcordInviteVendTest.kt b/quartz/src/commonTest/kotlin/com/vitorpamplona/quartz/concord/cord05Invites/ConcordInviteVendTest.kt index fc7577a4c6..dd4a66317c 100644 --- a/quartz/src/commonTest/kotlin/com/vitorpamplona/quartz/concord/cord05Invites/ConcordInviteVendTest.kt +++ b/quartz/src/commonTest/kotlin/com/vitorpamplona/quartz/concord/cord05Invites/ConcordInviteVendTest.kt @@ -22,6 +22,12 @@ package com.vitorpamplona.quartz.concord.cord05Invites import com.vitorpamplona.quartz.concord.cord02Community.ConcordCommunityListEntry import com.vitorpamplona.quartz.concord.cord02Community.PrivateChannelKey +import com.vitorpamplona.quartz.concord.cord03Channels.ConcordChannelKeyring +import com.vitorpamplona.quartz.concord.cord04Roles.AuthorityResolver +import com.vitorpamplona.quartz.concord.cord04Roles.ControlEdition +import com.vitorpamplona.quartz.concord.cord04Roles.ControlEntityKind +import com.vitorpamplona.quartz.concord.cord04Roles.ControlFixtures +import com.vitorpamplona.quartz.nip01Core.core.hexToByteArray import kotlin.test.Test import kotlin.test.assertEquals import kotlin.test.assertNotNull @@ -87,15 +93,15 @@ class ConcordInviteVendTest { } @Test - fun aNewerEpochOfAHeldChannelReplacesIt() { - val newer = "ee".repeat(32) - val b = bundle(channels = listOf(InviteChannel(chanA, newer, 2, "mods"))) - assertEquals(listOf(chanA), ConcordInviteVend.catchUpChannelIds(held, b)) - val adopted = assertNotNull(ConcordInviteVend.adoptCatchUp(held, b)) - assertEquals(listOf(Triple(chanA, newer, 2L)), adopted.privateChannels.map { Triple(it.channelId, it.key, it.epoch) }) - - // Same or older epoch contributes nothing. - assertTrue(ConcordInviteVend.catchUpChannelIds(held, bundle(channels = listOf(InviteChannel(chanA, newer, 1)))).isEmpty()) + fun aBundleNeverReplacesAHeldKey() { + // A held key moves only through a channel rekey (prevcommit continuity). A bare bundle at a + // higher — even absurd — epoch contributes nothing, so a keyholder can't park us on a dead key. + val bogus = "ee".repeat(32) + for (epoch in listOf(2L, 1_000_000_000L)) { + val b = bundle(channels = listOf(InviteChannel(chanA, bogus, epoch, "mods"))) + assertTrue(ConcordInviteVend.catchUpChannelIds(held, b).isEmpty()) + assertNull(ConcordInviteVend.adoptCatchUp(held, b)) + } } @Test @@ -114,4 +120,106 @@ class ConcordInviteVendTest { assertTrue(ConcordInviteVend.catchUpChannelIds(held, bundle(channels = listOf(InviteChannel(chanB, "", 0)))).isEmpty()) assertNull(ConcordInviteVend.adoptCatchUp(held, bundle(channels = emptyList()))) } + + // ---- entitlement (Armada channelAccess.ts) and catch-up adoption (catchUpAdoption.ts) -------- + + private val owner = "0f".repeat(32) + private val alice = "a1".repeat(32) + private val bob = "b2".repeat(32) + private val modRole = "71".repeat(32) + private val accessRole = "72".repeat(32) + + private fun role( + roleId: String, + json: String, + ) = ControlEdition(ControlEntityKind.ROLE, roleId.hexToByteArray(), 0, null, null, json, owner, "role-$roleId", 0) + + private fun grant( + member: String, + roleIds: List, + version: Long = 0, + prev: ControlEdition? = null, + ) = ControlEdition( + ControlEntityKind.GRANT, + ControlFixtures.grantEid(member).hexToByteArray(), + version, + prev?.hash, + null, + """{"member":"$member","role_ids":[${roleIds.joinToString(",") { "\"$it\"" }}]}""", + owner, + "grant-$member-$version", + version, + ) + + private val roles = + listOf( + // A staff role (MANAGE_CHANNELS) with server scope, and a bit-less access role scoped to chanA. + role(modRole, """{"role_id":"$modRole","name":"Mod","position":2,"permissions":"2"}"""), + role(accessRole, """{"role_id":"$accessRole","name":"mods-room","position":10,"permissions":"0","scope":{"kind":"channel","channel_id":"$chanA"}}"""), + ) + + private fun authority(vararg extra: ControlEdition): AuthorityResolver = ControlFixtures.resolve(roles + extra, owner) + + @Test + fun theOwnerAndScopedRoleHoldersAreEntitled() { + val aliceIn = grant(alice, listOf(accessRole)) + val bobMod = grant(bob, listOf(modRole)) + val a = authority(aliceIn, bobMod) + assertEquals(setOf(owner, alice), ConcordInviteVend.entitledMembers(a, chanA)) + assertTrue(ConcordInviteVend.isEntitled(a, owner, chanB)) + // A server-scoped staff role grants authority, never read access. + assertTrue(!ConcordInviteVend.isEntitled(a, bob, chanA)) + // A link has no recipient and vends nothing; a member gets exactly their channels. + val held = listOf(PrivateChannelKey(chanA, keyA, 1, "mods"), PrivateChannelKey(chanB, keyB, 0, "vip")) + assertTrue(ConcordInviteVend.vendableChannels(held, a, null).isEmpty()) + assertEquals(listOf(chanA), ConcordInviteVend.vendableChannels(held, a, alice).map { it.channelId }) + assertEquals(listOf(chanA, chanB), ConcordInviteVend.vendableChannels(held, a, owner).map { it.channelId }) + } + + @Test + fun accessChangesNameWhoToVendAndWhoARotationMustCut() { + val aliceIn = grant(alice, listOf(accessRole)) + val before = authority() + val afterGrant = authority(aliceIn) + val granted = ConcordInviteVend.accessChanges(before, afterGrant, listOf(chanA, chanB)).single() + assertEquals(chanA, granted.channelIdHex) + assertEquals(setOf(alice), granted.gained) + assertTrue(granted.lost.isEmpty()) + + val afterRevoke = authority(aliceIn, grant(alice, emptyList(), version = 1, prev = aliceIn)) + val revoked = ConcordInviteVend.accessChanges(afterGrant, afterRevoke, listOf(chanA)).single() + assertEquals(setOf(alice), revoked.lost) + assertTrue(ConcordInviteVend.accessChanges(afterGrant, afterGrant, listOf(chanA)).isEmpty()) + } + + @Test + fun aStaffSentCatchUpForAnEntitledChannelIsAdoptedWithoutAClick() { + val member = held + val grantedChan = bundle(channels = listOf(InviteChannel(chanB, keyB, 0, "vip"))) + val scopedB = role("73".repeat(32), """{"role_id":"${"73".repeat(32)}","name":"vip","position":11,"permissions":"0","scope":{"kind":"channel","channel_id":"$chanB"}}""") + val a = authority(scopedB, grant(alice, listOf("73".repeat(32))), grant(bob, listOf(modRole))) + val live = setOf(chanA, chanB) + assertEquals(ConcordInviteVend.CatchUpVerdict.ADOPT, ConcordInviteVend.judgeCatchUp(a, live, alice, owner, grantedChan, member)) + assertEquals(ConcordInviteVend.CatchUpVerdict.ADOPT, ConcordInviteVend.judgeCatchUp(a, live, alice, bob, grantedChan, member)) + assertEquals(ConcordInviteVend.CatchUpVerdict.NO_FOLD, ConcordInviteVend.judgeCatchUp(null, live, alice, owner, grantedChan, member)) + // A plain keyholder (alice) can't plant a key in bob's list automatically. + assertEquals(ConcordInviteVend.CatchUpVerdict.SENDER_NOT_STAFF, ConcordInviteVend.judgeCatchUp(a, live, bob, alice, grantedChan, member)) + // Bob holds no role scoped to chanB. + assertEquals(ConcordInviteVend.CatchUpVerdict.NOT_ENTITLED, ConcordInviteVend.judgeCatchUp(a, live, bob, owner, grantedChan, member)) + assertEquals(ConcordInviteVend.CatchUpVerdict.NOTHING_NEW, ConcordInviteVend.judgeCatchUp(a, live, alice, owner, bundle(channels = listOf(InviteChannel(chanA, keyA, 1))), member)) + // A channel the fold doesn't know as a live Private Channel is never auto-adopted. + assertEquals(ConcordInviteVend.CatchUpVerdict.NOT_ENTITLED, ConcordInviteVend.judgeCatchUp(a, setOf(chanA), alice, owner, grantedChan, member)) + + // Manual accept: staff sender and a live Private Channel, entitlement waived by the click. + assertEquals(listOf(chanB), ConcordInviteVend.admissibleCatchUpIds(member, grantedChan, a, live, owner)) + assertTrue(ConcordInviteVend.admissibleCatchUpIds(member, grantedChan, a, live, alice).isEmpty()) + assertTrue(ConcordInviteVend.admissibleCatchUpIds(member, grantedChan, a, setOf(chanA), owner).isEmpty()) + } + + @Test + fun aCatchUpNeverRestoresAKeyBelowACut() { + val cut = ConcordChannelKeyring.withoutChannel(held, chanA, 2) + assertTrue(ConcordInviteVend.catchUpChannelIds(cut, bundle(channels = listOf(InviteChannel(chanA, keyA, 1)))).isEmpty()) + assertEquals(listOf(chanA), ConcordInviteVend.catchUpChannelIds(cut, bundle(channels = listOf(InviteChannel(chanA, keyB, 2))))) + } } diff --git a/quartz/src/commonTest/kotlin/com/vitorpamplona/quartz/concord/cord06Rekey/ConcordChannelRekeyTest.kt b/quartz/src/commonTest/kotlin/com/vitorpamplona/quartz/concord/cord06Rekey/ConcordChannelRekeyTest.kt new file mode 100644 index 0000000000..fd8489a45c --- /dev/null +++ b/quartz/src/commonTest/kotlin/com/vitorpamplona/quartz/concord/cord06Rekey/ConcordChannelRekeyTest.kt @@ -0,0 +1,230 @@ +/* + * Copyright (c) 2025 Vitor Pamplona + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the + * Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR + * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ +package com.vitorpamplona.quartz.concord.cord06Rekey + +import com.vitorpamplona.quartz.concord.crypto.ConcordKeyDerivation +import com.vitorpamplona.quartz.concord.crypto.ConcordLabels +import com.vitorpamplona.quartz.concord.crypto.GroupKey +import com.vitorpamplona.quartz.concord.envelope.ConcordStreamEnvelope +import com.vitorpamplona.quartz.nip01Core.core.Event +import com.vitorpamplona.quartz.nip01Core.core.HexKey +import com.vitorpamplona.quartz.nip01Core.core.hexToByteArray +import com.vitorpamplona.quartz.nip01Core.core.toHexKey +import com.vitorpamplona.quartz.nip01Core.crypto.KeyPair +import com.vitorpamplona.quartz.nip01Core.signers.NostrSignerInternal +import com.vitorpamplona.quartz.nip44Encryption.Nip44 +import kotlinx.coroutines.test.runTest +import kotlin.io.encoding.Base64 +import kotlin.io.encoding.ExperimentalEncodingApi +import kotlin.test.Test +import kotlin.test.assertContentEquals +import kotlin.test.assertEquals +import kotlin.test.assertIs +import kotlin.test.assertNotEquals +import kotlin.test.assertNotNull +import kotlin.test.assertSame +import kotlin.test.assertTrue + +/** + * CORD-06 §1-2 single-channel Rekeys: the channel rekey address, the 72-byte scope-bound blob, + * the `prevcommit` continuity walk, chunk completeness, racing rotators and the removal rule — + * pinned to the reference client's `lib/rekey.ts` / `useChannelRekeyWatch`. + */ +class ConcordChannelRekeyTest { + private val admin = NostrSignerInternal(KeyPair()) + private val alice = NostrSignerInternal(KeyPair()) + private val bob = NostrSignerInternal(KeyPair()) + private val root = ByteArray(32) { 0x21 } + private val channelId = ByteArray(32) { 0x5C } + private val channelHex = channelId.toHexKey() + private val key0 = ByteArray(32) { 0x10 } + private val now = 1_700_000_000L + + private fun keysFor(vararg epochs: Long): Map = epochs.associate { e -> ConcordChannelRekey.address(root, channelId, e).let { it.publicKeyHex to it } } + + private suspend fun rotate( + heldKey: ByteArray, + heldEpoch: Long, + newKey: ByteArray, + recipients: List, + rotator: NostrSignerInternal = admin, + createdAt: Long = now, + ): List = ConcordChannelRekey.build(rotator, root, channelId, heldKey, heldEpoch, newKey, recipients + rotator.pubKey, createdAt) + + private suspend fun walk( + wraps: List, + me: NostrSignerInternal, + heldKey: ByteArray = key0, + heldEpoch: Long = 0, + joinedAt: Long = 0, + honored: (ChannelRotation) -> Boolean = { true }, + outranksMe: (HexKey) -> Boolean = { true }, + ): ChannelRekeyOutcome { + val keys = keysFor(*(heldEpoch + 1..heldEpoch + ConcordChannelRekey.LOOKAHEAD).toList().toLongArray()) + return ConcordChannelRekey.walk(ConcordChannelRekey.rotations(wraps, keys, channelHex), channelHex, heldKey, heldEpoch, me, joinedAt, honored, outranksMe) + } + + @Test + fun theChannelRekeyAddressIsTheRootKeyedRekeyPseudonym() { + // CORD-02 derivation table: concord/rekey-pseudonym, prior community_root, channel_id, new_epoch. + val address = ConcordChannelRekey.address(root, channelId, 3) + assertEquals(ConcordKeyDerivation.groupKey(ConcordLabels.REKEY_PSEUDONYM, root, channelId, 3).publicKeyHex, address.publicKeyHex) + // Keyed by the ROOT, never the channel key: every member can precompute it. + assertNotEquals(ConcordKeyDerivation.groupKey(ConcordLabels.REKEY_PSEUDONYM, key0, channelId, 3).publicKeyHex, address.publicKeyHex) + // Distinct per epoch and from the base-rotation address. + assertNotEquals(address.publicKeyHex, ConcordChannelRekey.address(root, channelId, 4).publicKeyHex) + assertNotEquals(address.publicKeyHex, ConcordKeyDerivation.baseRekeyAddress(root, channelId, 3).publicKeyHex) + } + + @OptIn(ExperimentalEncodingApi::class) + @Test + fun aChannelRotationCarriesTheSpecTagsAnd72ByteScopeBoundBlobs() = + runTest { + val newKey = ByteArray(32) { 0x77 } + val wraps = rotate(key0, 0, newKey, listOf(alice.pubKey)) + assertEquals(1, wraps.size) + val opened = assertNotNull(ConcordStreamEnvelope.openOrNull(wraps.single(), ConcordChannelRekey.address(root, channelId, 1))) + // A rekey seal is encrypted; the seal names the rotator. + assertEquals(ConcordStreamEnvelope.KIND_SEAL_ENCRYPTED, opened.sealKind) + assertEquals(admin.pubKey, opened.author) + val rumor = opened.rumor + assertEquals(ConcordRekey.KIND, rumor.kind) + // ["scope", channel_id] ["newepoch", held+1] ["prevepoch", held] ["prevcommit", A.5 over the held key] ["chunk","1","1"] + assertEquals( + listOf( + listOf("scope", channelHex), + listOf("newepoch", "1"), + listOf("prevepoch", "0"), + listOf("prevcommit", ConcordKeyDerivation.epochKeyCommitment(0, key0).toHexKey()), + listOf("chunk", "1", "1"), + ), + rumor.tags.map { it.toList() }, + ) + // Alice's blob opens under the admin<->alice pairwise key to exactly scope ‖ epoch_be ‖ key. + val blobs = ConcordRekey.decodeContent(rumor.content) + assertEquals(2, blobs.size) + val locator = ConcordKeyDerivation.recipientLocator(admin.pubKey.hexToByteArray(), alice.pubKey.hexToByteArray(), channelId, 1).toHexKey() + val mine = blobs.single { it.locator == locator } + val plain = Base64.Default.decode(Nip44.v2.decrypt(mine.wrapped, Nip44.v2.getConversationKey(alice.keyPair.privKey!!, admin.pubKey.hexToByteArray()))) + assertEquals(72, plain.size) + assertContentEquals(channelId, plain.copyOfRange(0, 32)) + assertContentEquals(byteArrayOf(0, 0, 0, 0, 0, 0, 0, 1), plain.copyOfRange(32, 40)) + assertContentEquals(newKey, plain.copyOfRange(40, 72)) + } + + @Test + fun aKeptMemberAdoptsTheNewKeyAndARemovedOneIsCut() = + runTest { + val newKey = ByteArray(32) { 0x42 } + val wraps = rotate(key0, 0, newKey, listOf(alice.pubKey)) + + val kept = assertIs(walk(wraps, alice)) + assertContentEquals(newKey, kept.key) + assertEquals(1, kept.epoch) + assertEquals(1, kept.steppedOver.size) + assertContentEquals(key0, kept.steppedOver.single().key) + + val cut = assertIs(walk(wraps, bob)) + assertEquals(1, cut.epoch) + } + + @Test + fun noBlobIsARemovalOnlyFromAnOutrankingRotatorAfterTheJoin() = + runTest { + val wraps = rotate(key0, 0, ByteArray(32) { 0x42 }, listOf(alice.pubKey)) + // A rotator that does not strictly outrank us cannot cut us (CORD-06 Authority). + assertSame(ChannelRekeyOutcome.None, walk(wraps, bob, outranksMe = { false })) + // A rotation that predates our join is history, not an exclusion. + assertSame(ChannelRekeyOutcome.None, walk(wraps, bob, joinedAt = now + 1)) + // An unauthorized rotator is ignored entirely. + assertSame(ChannelRekeyOutcome.None, walk(wraps, alice, honored = { false })) + } + + @Test + fun aRotationOffAKeyWeDoNotHoldIsNeitherAdoptedNorARemoval() = + runTest { + // The rotator claims to extend a different key at our epoch: a fork, never adopted. + val forged = rotate(ByteArray(32) { 0x66 }, 0, ByteArray(32) { 0x42 }, listOf(alice.pubKey)) + assertSame(ChannelRekeyOutcome.None, walk(forged, alice)) + } + + @Test + fun aMissedRotationIsWalkedInOnePass() = + runTest { + val key1 = ByteArray(32) { 0x31 } + val key2 = ByteArray(32) { 0x32 } + val wraps = rotate(key0, 0, key1, listOf(alice.pubKey)) + rotate(key1, 1, key2, listOf(alice.pubKey), createdAt = now + 10) + val adopted = assertIs(walk(wraps, alice)) + assertContentEquals(key2, adopted.key) + assertEquals(2, adopted.epoch) + assertEquals(listOf(1L, 0L), adopted.steppedOver.map { it.epoch }) + } + + @Test + fun aReadmissionAboveTheCutWinsAndACutAboveTheKeyWins() = + runTest { + val key1 = ByteArray(32) { 0x31 } + val key2 = ByteArray(32) { 0x32 } + // Cut at 1, re-admitted at 2 — but 2 extends key1, which bob never got: no adoption, cut stands. + val wraps = rotate(key0, 0, key1, listOf(alice.pubKey)) + rotate(key1, 1, key2, listOf(alice.pubKey, bob.pubKey)) + assertIs(walk(wraps, bob)) + // Alice kept through 1 and then cut at 2: the cut above her key wins. + val cutLater = rotate(key0, 0, key1, listOf(alice.pubKey)) + rotate(key1, 1, key2, emptyList()) + assertEquals(2, assertIs(walk(cutLater, alice)).epoch) + } + + @Test + fun racingRotatorsConvergeOnTheLowestKey() = + runTest { + val low = ByteArray(32) { 0x01 } + val high = ByteArray(32) { 0x7F } + val other = NostrSignerInternal(KeyPair()) + val wraps = rotate(key0, 0, high, listOf(alice.pubKey)) + rotate(key0, 0, low, listOf(alice.pubKey), rotator = other) + val rotations = ConcordChannelRekey.rotations(wraps, keysFor(1), channelHex) + // Two Rotators at one epoch never merge into one set. + assertEquals(2, rotations.size) + assertContentEquals(low, assertIs(walk(wraps, alice)).key) + } + + @Test + fun anIncompleteRotationIsNeverARemoval() = + runTest { + // 130 recipients span two chunks; drop the second. + val crowd = List(130) { KeyPair().pubKey.toHexKey() } + val wraps = rotate(key0, 0, ByteArray(32) { 0x42 }, crowd) + assertEquals(2, wraps.size) + val rotations = ConcordChannelRekey.rotations(wraps.take(1), keysFor(1), channelHex) + assertTrue(rotations.none { it.complete }) + assertSame(ChannelRekeyOutcome.None, walk(wraps.take(1), bob)) + assertIs(walk(wraps, bob)) + } + + @Test + fun aRotationForAnotherChannelOrAtAnUnwatchedAddressIsIgnored() = + runTest { + val otherChannel = ByteArray(32) { 0x5D } + val elsewhere = ConcordChannelRekey.build(admin, root, otherChannel, key0, 0, ByteArray(32) { 0x42 }, listOf(alice.pubKey), now) + // Not at our channel's addresses, and its scope names another channel. + assertTrue(ConcordChannelRekey.rotations(elsewhere, keysFor(1), channelHex).isEmpty()) + val atOurAddress = mapOf(ConcordChannelRekey.address(root, otherChannel, 1).let { it.publicKeyHex to it }) + assertTrue(ConcordChannelRekey.rotations(elsewhere, atOurAddress, channelHex).isEmpty()) + } +} diff --git a/quartz/src/commonTest/kotlin/com/vitorpamplona/quartz/concord/cord07Voice/ConcordVoiceTest.kt b/quartz/src/commonTest/kotlin/com/vitorpamplona/quartz/concord/cord07Voice/ConcordVoiceTest.kt index f7db089e9d..219dced9f3 100644 --- a/quartz/src/commonTest/kotlin/com/vitorpamplona/quartz/concord/cord07Voice/ConcordVoiceTest.kt +++ b/quartz/src/commonTest/kotlin/com/vitorpamplona/quartz/concord/cord07Voice/ConcordVoiceTest.kt @@ -21,17 +21,21 @@ package com.vitorpamplona.quartz.concord.cord07Voice import com.vitorpamplona.quartz.concord.crypto.ConcordKeyDerivation +import com.vitorpamplona.quartz.nip01Core.core.Event import com.vitorpamplona.quartz.nip01Core.core.toHexKey import com.vitorpamplona.quartz.nip01Core.crypto.KeyPair import com.vitorpamplona.quartz.nip01Core.crypto.verify import kotlin.test.Test import kotlin.test.assertEquals import kotlin.test.assertFalse +import kotlin.test.assertNotEquals +import kotlin.test.assertNull import kotlin.test.assertTrue class ConcordVoiceTest { private val alice = KeyPair().pubKey.toHexKey() private val bob = KeyPair().pubKey.toHexKey() + private val carol = KeyPair().pubKey.toHexKey() private val channelId = "42".repeat(32) @Test @@ -44,20 +48,75 @@ class ConcordVoiceTest { assertEquals(channelId, info?.channelId) assertEquals(0L, info?.epoch) assertTrue(info?.joined == true) + // The examples' tag order: channel, epoch, identity, broker, ms. + assertEquals(listOf("channel", "epoch", "identity", "broker", "ms"), rumor.tags.map { it[0] }) } @Test fun onlyUncontestedIdentitiesVerify() { - val aliceP = VoicePresence.parse(VoicePresence.joined(alice, channelId, 0, "id-alice", 1L))!! + val aliceP = VoicePresence.parse(VoicePresence.joined(alice, channelId, 0, "id-x", 1L))!! val bobP = VoicePresence.parse(VoicePresence.joined(bob, channelId, 0, "id-bob", 1L))!! - // both Alice and Bob claim the same identity -> contested - val contestedA = VoicePresence.parse(VoicePresence.joined(alice, channelId, 0, "id-x", 1L))!! - val contestedB = VoicePresence.parse(VoicePresence.joined(bob, channelId, 0, "id-x", 1L))!! + val carolP = VoicePresence.parse(VoicePresence.joined(carol, channelId, 0, "id-x", 1L))!! - val verified = VoicePresence.verifiedParticipants(listOf(aliceP, bobP, contestedA, contestedB)) - assertEquals(alice, verified["id-alice"]) - assertEquals(bob, verified["id-bob"]) - assertFalse(verified.containsKey("id-x")) // contested identity omitted + val fold = VoicePresence.fold(listOf(aliceP, bobP, carolP), nowMs = 1_000L) + assertEquals(bob, fold.verified["id-bob"]) + assertFalse(fold.verified.containsKey("id-x")) // Alice and Carol both claim it: contested + assertEquals(3, fold.present.size) + } + + @Test + fun latestPresencePerAuthorWins() { + // Alice joined as id-a, left, then rejoined as id-b: only her latest counts. + val joinedA = VoicePresence.parse(VoicePresence.joined(alice, channelId, 0, "id-a", 10L, subMs = 0))!! + val left = VoicePresence.parse(VoicePresence.left(alice, channelId, 0, 20L, subMs = 0))!! + val joinedB = VoicePresence.parse(VoicePresence.joined(alice, channelId, 0, "id-b", 30L, subMs = 0))!! + // Bob's older heartbeat claimed id-b too, but his latest presence is a left. + val bobOld = VoicePresence.parse(VoicePresence.joined(bob, channelId, 0, "id-b", 5L, subMs = 0))!! + val bobLeft = VoicePresence.parse(VoicePresence.left(bob, channelId, 0, 6L, subMs = 0))!! + + // Arrival order must not matter. + val fold = VoicePresence.fold(listOf(joinedB, bobLeft, joinedA, left, bobOld), nowMs = 31_000L) + assertEquals(listOf(alice), fold.present.map { it.author }) + assertEquals("id-b", fold.present.single().identity) + assertEquals(mapOf("id-b" to alice), fold.verified) + + // Before the rejoin arrived, Alice's latest is the left: absent. + assertTrue(VoicePresence.fold(listOf(left, joinedA), nowMs = 21_000L).present.isEmpty()) + } + + @Test + fun msTagOrdersPresencesWithinOneSecond() { + val early = VoicePresence.parse(VoicePresence.joined(alice, channelId, 0, "id-a", 10L, subMs = 100))!! + val late = VoicePresence.parse(VoicePresence.left(alice, channelId, 0, 10L, subMs = 900))!! + assertEquals(10_100L, early.ms) + assertEquals(10_900L, late.ms) + assertTrue(VoicePresence.fold(listOf(late, early), nowMs = 11_000L).present.isEmpty()) + } + + @Test + fun equalTimeTiesBreakByLowerRumorId() { + val a = VoicePresence.parse(VoicePresence.joined(alice, channelId, 0, "id-a", 10L, subMs = 0))!! + val b = VoicePresence.parse(VoicePresence.joined(alice, channelId, 0, "id-b", 10L, subMs = 0))!! + val winner = if (a.rumorId < b.rumorId) a else b + assertEquals(winner.rumorId, VoicePresence.latestPerAuthor(listOf(a, b))[alice]?.rumorId) + assertEquals(winner.rumorId, VoicePresence.latestPerAuthor(listOf(b, a))[alice]?.rumorId) + } + + @Test + fun staleLatestJoinedIsAbsent() { + val p = VoicePresence.parse(VoicePresence.joined(alice, channelId, 0, "id-a", 10L, subMs = 0))!! + assertEquals(1, VoicePresence.fold(listOf(p), nowMs = 10_000L + VoicePresence.STALE_MS).present.size) + assertTrue(VoicePresence.fold(listOf(p), nowMs = 10_001L + VoicePresence.STALE_MS).present.isEmpty()) + } + + @Test + fun malformedPresenceIsDropped() { + val base = VoicePresence.joined(alice, channelId, 0, "id-a", 10L, subMs = 0) + assertNull(VoicePresence.parse(Event(base.id, base.pubKey, base.createdAt, base.kind, base.tags, "here", ""))) + val noIdentity = base.tags.filterNot { it[0] == VoicePresence.TAG_IDENTITY }.toTypedArray() + assertNull(VoicePresence.parse(Event(base.id, base.pubKey, base.createdAt, base.kind, noIdentity, "joined", ""))) + val badMs = base.tags.map { if (it[0] == "ms") arrayOf("ms", "1000") else it }.toTypedArray() + assertNull(VoicePresence.parse(Event(base.id, base.pubKey, base.createdAt, base.kind, badMs, "joined", ""))) } @Test @@ -83,5 +142,22 @@ class ConcordVoiceTest { assertTrue(header.startsWith("Concord ")) } + @Test + fun sameSecondBrokerGrantsNeverShareAnId() { + // Every member signs with the same voice_key.sk; without the nonce two joiners in one + // second build one id and the broker's anti-replay set drops the second (CORD-07 §2). + val voiceSigner = ConcordKeyDerivation.voiceSignerKey(ByteArray(32) { 0x5A }, channelId.chunkedToBytes(), epoch = 0) + val url = "https://broker.example" + ConcordBrokerToken.wellKnownPath(voiceSigner.publicKeyHex) + val a = ConcordBrokerToken.buildAuthEvent(voiceSigner, url, createdAt = 1_700_000_000L) + val b = ConcordBrokerToken.buildAuthEvent(voiceSigner, url, createdAt = 1_700_000_000L) + + val nonceOf = { e: Event -> e.tags.firstOrNull { it[0] == ConcordBrokerToken.TAG_NONCE }?.getOrNull(1) } + assertTrue(Regex("^[0-9a-f]{64}$").matches(nonceOf(a)!!)) + assertNotEquals(nonceOf(a), nonceOf(b)) + assertNotEquals(a.id, b.id) + // Tag order matches the reference client: u, method, nonce. + assertEquals(listOf("u", "method", "nonce"), a.tags.map { it[0] }) + } + private fun String.chunkedToBytes(): ByteArray = ByteArray(length / 2) { substring(it * 2, it * 2 + 2).toInt(16).toByte() } }