From e7a1ad260f00829a36c946bb023399a8926b8ad9 Mon Sep 17 00:00:00 2001 From: Kgothatso Ngako Date: Fri, 23 Oct 2026 15:26:19 +0200 Subject: [PATCH] feat(wallet): a guarded wallet is told to the groups above, and they watch it (Phase 6) A member in both rooms carries a descendant's signed guarded statement into an ancestor's MLS room as a 30333 notice, and can pass one on a generation further. Every ancestor device believes it only when its own guardian root reaches the key the statement names for it. The wallet screen lists the guarded wallets below the group with what is within its reach, and the statements this device can still carry up. Co-Authored-By: Claude Opus 5.5 --- .../composeResources/values/strings.xml | 8 + .../compose/database/model/ChatMessage.kt | 31 +++ .../repository/DatabaseChatRepository.kt | 22 ++ .../bennu/compose/managers/GuardianManager.kt | 242 ++++++++++++++++++ .../nostr/wallet/GuardedWalletNoticeEvent.kt | 46 ++++ .../compose/repository/ChatRepository.kt | 22 ++ .../ui/composable/GroupWalletScreen.kt | 108 +++++++- .../ui/view/model/GroupWalletViewModel.kt | 74 +++++- .../ui/view/state/GroupWalletUIState.kt | 28 ++ .../managers/GuardianSigningJvmTest.kt | 167 ++++++++++++ 10 files changed, 737 insertions(+), 11 deletions(-) create mode 100644 composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/GuardianManager.kt create mode 100644 composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/nostr/wallet/GuardedWalletNoticeEvent.kt diff --git a/composeApp/src/commonMain/composeResources/values/strings.xml b/composeApp/src/commonMain/composeResources/values/strings.xml index c1ac4a99..d313760a 100644 --- a/composeApp/src/commonMain/composeResources/values/strings.xml +++ b/composeApp/src/commonMain/composeResources/values/strings.xml @@ -619,6 +619,14 @@ The groups above this one have agreed to guard its wallet. In a guarded wallet each of them can spend any coin once it has %1$d confirmations, without this group agreeing. Open a guarded wallet Open without guardians + Guarded wallets + Wallets of groups below this one. This group can spend a coin in them once it has %1$d confirmations. + %1$s sats within this group's reach + Tell the groups above + Not yet shared with the groups above that you're in + Share + Shared with the groups above + Couldn't share the wallet Guarded: the groups above this one can spend any coin here once it has %1$d confirmations. Balance %1$s sats diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/model/ChatMessage.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/model/ChatMessage.kt index dcfc8dac..e6a2c8be 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/model/ChatMessage.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/model/ChatMessage.kt @@ -14,6 +14,7 @@ import com.machankura.bennu.compose.exceptions.MarmotUnprocessableInnerEventExce import com.machankura.bennu.compose.managers.ChronicleManager import com.machankura.bennu.compose.managers.GroupKeyStateManager import com.machankura.bennu.compose.managers.GroupWalletManager +import com.machankura.bennu.compose.managers.GuardianManager import com.machankura.bennu.compose.managers.SubgroupManager import com.machankura.bennu.compose.extensions.toHex import com.vitorpamplona.quartz.marmot.GroupEventResult @@ -33,6 +34,7 @@ import com.machankura.bennu.compose.nostr.frost.GroupKeyStateEvent import com.machankura.bennu.compose.nostr.subgroup.SubgroupBirthCertificateEvent import com.machankura.bennu.compose.nostr.wallet.GroupWallet import com.machankura.bennu.compose.nostr.wallet.GroupWalletStatementEvent +import com.machankura.bennu.compose.nostr.wallet.GuardedWalletNoticeEvent import com.machankura.bennu.compose.nostr.nip30303.ArtifactEvent import com.machankura.bennu.compose.nostr.nip30303.ArtifactVersionEvent import com.machankura.bennu.compose.nostr.nip30303.ChapterEvent @@ -497,6 +499,14 @@ data class ChatMessage( */ const val TYPE_GROUP_TRANSACTION_CONFIRMED = "groupTransactionConfirmed" + /** + * A member told this group about a descendant's guarded wallet -- a + * `GuardedWalletNoticeEvent` this device checked and believes. Written + * from the notice, attributed to the member who forwarded it. See + * `docs/group-wallet-guardians.md`. + */ + const val TYPE_GUARDED_WALLET_SHARED = "guardedWalletShared" + val GROUP_IDENTITY_TYPES = setOf( TYPE_GROUP_PROFILE_SIGNED, TYPE_GROUP_RELAYS_SIGNED, @@ -505,6 +515,7 @@ data class ChatMessage( TYPE_LEGACY_GROUP_ENTRY_CURATED, TYPE_GROUP_WALLET_OPENED, TYPE_GROUP_TRANSACTION_CONFIRMED, + TYPE_GUARDED_WALLET_SHARED, ) /** @@ -963,6 +974,26 @@ data class ChatMessage( return null } + // A descendant's guarded wallet, carried up by a member who is in + // both rooms. The row above is the whole record of it -- there is + // no table -- so all that is left is the line, and only for a + // notice this room can actually believe. + if (event.kind == GuardedWalletNoticeEvent.KIND) { + val content = GuardianManager.describeNotice(database, groupEventResult.groupId, event) + ?: return null + return ChatMessage( + giftWrapPayloadId = null, + messageType = TYPE_GUARDED_WALLET_SHARED, + marmotGroupEventId = groupEvent.id, + marmotInnerEventId = event.id, + senderPublicKey = senderIdentity ?: event.pubKey, + isUserMessage = senderIdentity == activeKeyPair.pubKey.toHex(), + chatRoomId = groupEventResult.groupId, + createdAt = Instant.fromEpochSeconds(event.createdAt), + content = content, + ) + } + // Somebody in the room holds none of its signed work and is // asking. Any member may answer and none is elected to: a // duplicate answer costs bandwidth and nothing else, since diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/repository/DatabaseChatRepository.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/repository/DatabaseChatRepository.kt index 3db6572a..afbbe830 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/repository/DatabaseChatRepository.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/repository/DatabaseChatRepository.kt @@ -2,6 +2,7 @@ package com.machankura.bennu.compose.database.repository import fr.acinq.bitcoin.Chain import com.machankura.bennu.compose.managers.GroupWalletManager +import com.machankura.bennu.compose.managers.GuardianManager import com.machankura.bennu.compose.managers.GroupWalletDerivation import com.machankura.bennu.compose.nostr.wallet.GroupWallet import com.machankura.bennu.compose.database.GENESIS_AT @@ -208,6 +209,27 @@ class DatabaseChatRepository( null } + override suspend fun guardedWallets(chatRoomId: String): List = try { + GuardianManager.guardedWalletsOf(database, chatRoomId) + } catch (e: Throwable) { + logger.e("Error reading the guarded wallets $chatRoomId was told about", e) + emptyList() + } + + override suspend fun shareableGuardedWallets(chatRoomId: String, chain: Chain): List = try { + GuardianManager.shareableFrom(database, chatRoomId, chain) + } catch (e: Throwable) { + logger.e("Error reading what $chatRoomId can tell the groups above it", e) + emptyList() + } + + override suspend fun shareGuardedWallet(shareable: GuardianManager.Shareable, userPublicKey: HexKey): Int = try { + GuardianManager.share(database, shareable.statement, shareable.rooms, userPublicKey) + } catch (e: Throwable) { + logger.e("Error telling the groups above about ${shareable.statement.pubKey}'s guarded wallet", e) + 0 + } + override suspend fun groupSignedEvent(chatRoomId: String, id: HexKey): GroupSignedEvent? = try { database.groupSignedEventDao().getById(id)?.takeIf { it.chatRoomId == chatRoomId } } catch (e: Throwable) { diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/GuardianManager.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/GuardianManager.kt new file mode 100644 index 00000000..1f242e4b --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/GuardianManager.kt @@ -0,0 +1,242 @@ +package com.machankura.bennu.compose.managers + +import co.touchlab.kermit.Logger +import com.machankura.bennu.compose.database.BennuDatabase +import com.machankura.bennu.compose.database.model.MarmotInnerEvent +import com.machankura.bennu.compose.database.model.intermdiate.LocalChatRoom +import com.machankura.bennu.compose.nostr.frost.GroupKeyStateEvent +import com.machankura.bennu.compose.nostr.subgroup.SubgroupBirthCertificateEvent +import com.machankura.bennu.compose.nostr.wallet.GroupWalletStatementEvent +import com.machankura.bennu.compose.nostr.wallet.GuardedWalletNoticeEvent +import com.vitorpamplona.quartz.nip01Core.core.Event +import com.vitorpamplona.quartz.nip01Core.core.HexKey +import com.vitorpamplona.quartz.nip01Core.crypto.EventHasher +import fr.acinq.bitcoin.Chain +import kotlin.time.Clock +import kotlin.time.Instant + +/** + * What an ancestor group knows of the guarded wallets beneath it, and how it + * comes to know. + * + * A descendant opens a guarded wallet in its own room. Its ancestors are not in + * that room, so a member who sits in both carries the signed statement across + * as a [GuardedWalletNoticeEvent]; every device in the ancestor's room checks it + * for itself, and from then on watches the wallet and can propose spending from + * it through its own leaf. See `docs/group-wallet-guardians.md`, "How an + * ancestor finds the coins". + * + * A notice forwarded into a middle group can be forwarded again from there, so + * a root needs a member in common with each generation, not with the grandchild. + */ +object GuardianManager { + private const val TAG = "GuardianManager" + + private val logger = Logger.withTag(TAG) + + /** A descendant's guarded wallet, as one of its ancestors holds it. */ + data class GuardedWallet( + /** The ancestor holding it: the room it was told to. */ + val ancestorChatRoomId: String, + val descendantChatRoomId: String, + /** The descendant's signed statement, whole. */ + val statement: Event, + /** The account the statement opens, rederived from the descendant's key. */ + val account: GroupWalletDerivation.Account, + /** The descendant's birth certificate, carried in the statement. */ + val certificate: Event, + /** The rooms the ancestor walks from its own child down to the descendant -- `GuardianDerivation.lineage`. */ + val lineage: List, + ) { + /** What the descendant's parent certified it as. The founding name: a rename does not reach it. */ + val name: String? get() = SubgroupBirthCertificateEvent.parseName(certificate.tags) + + val chain: Chain get() = account.chain + + val openedAt: Instant get() = Instant.fromEpochSeconds(statement.createdAt) + } + + /** + * [statement] as a guarded wallet [ancestorChatRoomId] guards, or null when + * it is not one -- believed on its own merits, never on the word of whoever + * forwarded it: + * + * 1. it is a wallet statement, and the room it is authored by signed it; + * 2. it is guarded, and carries the certificate its guardians came from; + * 3. the certificate's key makes that room, and the statement's xpub, tree + * and descriptors all rederive from it -- `Reading.verifiedAgainst`, which + * also checks the certificate certifies the room and grants exactly those + * guardians; + * 4. the ancestor is among the guardians, and the key the statement names + * for it is the key [ancestorThresholdPublicKey]'s guardian root reaches + * down the line of descent the guardians name. A key it does not reach is + * a leaf this group cannot sign, whatever the statement calls it. + */ + fun verify(statement: Event, ancestorChatRoomId: String, ancestorThresholdPublicKey: HexKey): GuardedWallet? = runCatching { + if (statement.kind != GroupWalletStatementEvent.KIND) return null + val descendantChatRoomId = statement.pubKey + if (!GroupKeyStateEvent.isSignedByRoom(statement, descendantChatRoomId)) return null + + val reading = GroupWalletStatementEvent.read(statement.tags, statement.content) ?: return null + if (reading.guardians.isEmpty()) return null + val certificate = reading.certificate ?: return null + + val descendantKey = SubgroupBirthCertificateEvent.parseThresholdPublicKey(certificate.tags) ?: return null + if (!SharedKeyDerivation.marmotGroupId(descendantKey).equals(descendantChatRoomId, ignoreCase = true)) return null + val account = reading.verifiedAgainst(descendantKey) ?: return null + + val lineage = GuardianDerivation.lineage(account.guardians, descendantChatRoomId, ancestorChatRoomId) ?: return null + val named = account.guardians.first { it.chatRoomId.equals(ancestorChatRoomId, ignoreCase = true) } + val walked = GuardianDerivation.root(ancestorThresholdPublicKey).extendedPublicKey + .derivePublicKey(lineage.map(GuardianDerivation::childIndex)) + if (walked.publicKey != named.publicKey || walked.chaincode != named.chainCode) return null + + GuardedWallet( + ancestorChatRoomId = ancestorChatRoomId, + descendantChatRoomId = descendantChatRoomId, + statement = statement, + account = account, + certificate = certificate, + lineage = lineage, + ) + }.getOrNull() + + /** + * Every guarded wallet [ancestorChatRoomId] has been told about and can sign + * for, one per descendant account on each network. + * + * Read off the notices the room's inbound path filed, checked again each + * time. Where two statements describe one account, the rules + * `GroupWallet.newestAmong` applies to the descendant's own copy apply here: + * the earliest decides the guardians and a later one naming others is + * ignored, so a forwarder cannot move the addresses an ancestor watches. + */ + suspend fun guardedWalletsOf(database: BennuDatabase, ancestorChatRoomId: String): List { + val thresholdPublicKey = GroupWalletManager.thresholdKeyFor(database, ancestorChatRoomId) ?: return emptyList() + val order = compareBy({ it.openedAt }, { it.statement.id }) + + return database.marmotInnerEventDao() + .getByChatRoomAndKinds(ancestorChatRoomId, listOf(GuardedWalletNoticeEvent.KIND)) + .mapNotNull { row -> Event.fromJsonOrNull(row.content) } + .mapNotNull { verify(it, ancestorChatRoomId, thresholdPublicKey) } + .groupBy { Triple(it.descendantChatRoomId, it.chain, it.account.account) } + .mapNotNull { (_, statements) -> + val first = statements.minWithOrNull(order) ?: return@mapNotNull null + statements.filter { it.account.guardians == first.account.guardians }.maxWithOrNull(order) + } + .sortedBy { it.name ?: it.descendantChatRoomId } + } + + /** The guarded wallet [ancestorChatRoomId] holds for [descendantChatRoomId] on [chain] at [account], or null. */ + suspend fun guardedWalletFor( + database: BennuDatabase, + ancestorChatRoomId: String, + descendantChatRoomId: String, + chain: Chain, + account: Long, + ): GuardedWallet? = guardedWalletsOf(database, ancestorChatRoomId).firstOrNull { + it.descendantChatRoomId.equals(descendantChatRoomId, ignoreCase = true) && it.chain == chain && it.account.account == account + } + + /** A guarded statement this device can carry upward, and the rooms it can carry it into. */ + data class Shareable( + val statement: Event, + /** What the statement's room was certified as, for the screen. */ + val name: String?, + val rooms: List, + ) + + /** + * The guarded statements this device can tell to groups above [chatRoomId]: + * the room's own guarded wallet, and every one the room was itself told + * about -- passed on a generation further. Each with the guardian rooms this + * device is a member of and has not told yet. + */ + suspend fun shareableFrom(database: BennuDatabase, chatRoomId: String, chain: Chain): List { + val own = GroupWalletManager.walletFor(database, chatRoomId, chain) + ?.takeIf { it.account.isGuarded } + ?.let { wallet -> + val statement = wallet.signedEvent.toEvent() + val certificate = GroupWalletStatementEvent.read(statement.tags, statement.content)?.certificate + statement to (certificate?.let { SubgroupBirthCertificateEvent.parseName(it.tags) }) + } + val passedOn = guardedWalletsOf(database, chatRoomId) + .filter { it.chain == chain } + .map { it.statement to it.name } + + return (listOfNotNull(own) + passedOn).mapNotNull { (statement, name) -> + val rooms = targetsFor(database, statement, excluding = chatRoomId) + rooms.takeIf { it.isNotEmpty() }?.let { Shareable(statement, name, it) } + } + } + + /** + * The guardian rooms of [statement] this device can post into and has not + * told it yet. Only Marmot rooms: a guardian is a group with a key, and a + * group with a key has an MLS room. + */ + private suspend fun targetsFor(database: BennuDatabase, statement: Event, excluding: String): List { + val guardians = GroupWalletStatementEvent.read(statement.tags, statement.content)?.guardians.orEmpty() + + return guardians + .map { it.chatRoomId } + .filterNot { it.equals(excluding, ignoreCase = true) } + .mapNotNull { database.chatRoomDao().findChatRoomById(it) } + .filter { it.chatRoom.mlsGroupState != null } + .filterNot { room -> alreadyTold(database, room.chatRoom.id, statement.id) } + } + + private suspend fun alreadyTold(database: BennuDatabase, chatRoomId: String, statementId: HexKey): Boolean = + database.marmotInnerEventDao() + .getByChatRoomAndKinds(chatRoomId, listOf(GuardedWalletNoticeEvent.KIND)) + .any { Event.fromJsonOrNull(it.content)?.id == statementId } + + /** + * Tells every room in [rooms] about [statement], as [userPublicKey]: one + * notice each, queued for the outbound pipeline the way every inner event + * is. Returns how many were queued. + */ + suspend fun share( + database: BennuDatabase, + statement: Event, + rooms: List, + userPublicKey: HexKey, + createdAt: Long = Clock.System.now().epochSeconds, + ): Int { + val content = statement.toJson() + val tags = emptyArray>() + + rooms.forEach { room -> + val id = EventHasher.hashId(userPublicKey, createdAt, GuardedWalletNoticeEvent.KIND, tags, content) + database.marmotInnerEventDao().upsert( + MarmotInnerEvent( + id = id, + publicKey = userPublicKey, + kind = GuardedWalletNoticeEvent.KIND, + createdAt = Instant.fromEpochSeconds(createdAt), + tags = tags, + content = content, + chatRoomId = room.chatRoom.id, + ) + ) + logger.i("Told ${room.chatRoom.id} about ${statement.pubKey}'s guarded wallet") + } + + return rooms.size + } + + /** + * What a notice that arrived in [chatRoomId] says, for its transcript line -- + * or null when it is not one this room can believe, which gets no line: a + * line saying a wallet was shared would read as the group being told + * something it was not. + */ + suspend fun describeNotice(database: BennuDatabase, chatRoomId: String, notice: Event): String? { + val statement = GuardedWalletNoticeEvent.statementOf(notice) ?: return null + val thresholdPublicKey = GroupWalletManager.thresholdKeyFor(database, chatRoomId) ?: return null + val wallet = verify(statement, chatRoomId, thresholdPublicKey) ?: return null + + return wallet.name?.let { "Shared the guarded wallet of $it with this group." } + ?: "Shared a subgroup's guarded wallet with this group." + } +} diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/nostr/wallet/GuardedWalletNoticeEvent.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/nostr/wallet/GuardedWalletNoticeEvent.kt new file mode 100644 index 00000000..8826113b --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/nostr/wallet/GuardedWalletNoticeEvent.kt @@ -0,0 +1,46 @@ +package com.machankura.bennu.compose.nostr.wallet + +import com.vitorpamplona.quartz.nip01Core.core.Event +import com.vitorpamplona.quartz.nip01Core.core.Kind + +/** + * A member telling an ancestor group about a descendant's guarded wallet. + * + * The descendant's quorum signed a guarded `GroupWalletStatementEvent` in its + * own room, and the ancestors whose keys are in it are not in that room. A + * member who sits in both carries the statement across, whole, as the content of + * one of these in the ancestor's MLS room: + * + * ``` + * descendant's room every member holds the signed 30331 "we keep a guarded wallet" + * member in both --[ 30333 carrying it ]-> the ancestor's room + * every ancestor device checks it on its own, and watches the wallet + * ``` + * + * The forwarder vouches for nothing. A device believes the statement inside for + * the same reasons a descendant member does -- the descendant's room signed it, + * a certificate it carries certifies that room, the xpub rederives from the key + * the certificate names -- plus one of its own: its own guardian key in the + * statement is the key its group's walk reaches. See `GuardianManager.verify`. + * + * No table: the row the inbound path files for every inner event is the record, + * and each read checks it again. + * + * ### Never on a relay + * + * The statement inside is an xpub, which is every address and the whole + * balance. Like the statement, this only ever lives inside an encryption a relay + * cannot open: it is an MLS application message and nothing else. + * + * ### Why 30333 + * + * The first free number past the transaction proposal (30332), beside the + * statement it carries. + */ +object GuardedWalletNoticeEvent { + val KIND: Kind = 30333 + + /** The statement a notice carries, or null when its content is not an event. Nothing is verified here. */ + fun statementOf(notice: Event): Event? = + notice.takeIf { it.kind == KIND }?.let { Event.fromJsonOrNull(it.content) } +} diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/repository/ChatRepository.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/repository/ChatRepository.kt index 1351e00d..6f4a9cae 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/repository/ChatRepository.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/repository/ChatRepository.kt @@ -3,6 +3,7 @@ package com.machankura.bennu.compose.repository import fr.acinq.bitcoin.Chain import com.machankura.bennu.compose.managers.GroupWalletDerivation import com.machankura.bennu.compose.managers.GroupWalletManager +import com.machankura.bennu.compose.managers.GuardianManager import com.machankura.bennu.compose.nostr.wallet.GroupWallet import com.machankura.bennu.compose.database.model.ChatRoom import com.machankura.bennu.compose.database.model.GiftWrapPayload @@ -127,6 +128,15 @@ interface ChatRepository { */ suspend fun groupWalletGuardedOpening(chatRoomId: String, chain: Chain): GroupWalletManager.GuardedOpening? + /** The guarded wallets of groups below this one that it has been told about and can sign for. */ + suspend fun guardedWallets(chatRoomId: String): List + + /** The guarded statements this device can carry from this group to the groups above it, with where to. */ + suspend fun shareableGuardedWallets(chatRoomId: String, chain: Chain): List + + /** Tells the groups in [shareable] about its statement, as [userPublicKey]. Returns how many were told. */ + suspend fun shareGuardedWallet(shareable: GuardianManager.Shareable, userPublicKey: HexKey): Int + /** * The kind:1s this group signed, newest first. * @@ -391,6 +401,18 @@ interface ChatRepository { chain: Chain ): GroupWalletManager.GuardedOpening? = null + override suspend fun guardedWallets(chatRoomId: String): List = emptyList() + + override suspend fun shareableGuardedWallets( + chatRoomId: String, + chain: Chain + ): List = emptyList() + + override suspend fun shareGuardedWallet( + shareable: GuardianManager.Shareable, + userPublicKey: HexKey + ): Int = 0 + override suspend fun groupPosts(chatRoomId: String): List = emptyList() override suspend fun groupSignedEvent( diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/GroupWalletScreen.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/GroupWalletScreen.kt index a2e00a82..b648c2d1 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/GroupWalletScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/GroupWalletScreen.kt @@ -74,6 +74,18 @@ import bennu.composeapp.generated.resources.group_wallet import bennu.composeapp.generated.resources.nothing_has_been_sent_to_this_wallet_yet import bennu.composeapp.generated.resources.open_a_group_wallet import bennu.composeapp.generated.resources.open_a_guarded_wallet +import bennu.composeapp.generated.resources.a_subgroup +import bennu.composeapp.generated.resources.couldn_t_share_the_wallet +import bennu.composeapp.generated.resources.guarded_wallets +import bennu.composeapp.generated.resources.not_yet_shared_with_the_groups_above +import bennu.composeapp.generated.resources.s_sats_within_this_group_s_reach +import bennu.composeapp.generated.resources.share +import bennu.composeapp.generated.resources.shared_with_the_groups_above +import bennu.composeapp.generated.resources.tell_the_groups_above +import bennu.composeapp.generated.resources.wallets_of_groups_below_this_one +import com.machankura.bennu.compose.managers.GuardianManager +import com.machankura.bennu.compose.ui.view.state.GuardedWalletRow +import androidx.compose.foundation.lazy.LazyListScope import bennu.composeapp.generated.resources.open_without_guardians import bennu.composeapp.generated.resources.the_groups_above_this_one_have_agreed_to_guard_it import bennu.composeapp.generated.resources.guarded_the_groups_above_this_one_can_spend @@ -165,6 +177,11 @@ fun GroupWalletScreen( val couldNotOpen = stringResource(Res.string.couldn_t_ask_the_group_to_open_a_wallet) val sentAgain = stringResource(Res.string.sent_again) val couldNotBump = stringResource(Res.string.couldn_t_bump_the_fee) + val shared = stringResource(Res.string.shared_with_the_groups_above) + val couldNotShare = stringResource(Res.string.couldn_t_share_the_wallet) + val onShare = { shareable: GuardianManager.Shareable -> + groupWalletViewModel.share(shareable, onShared = { notify(shared) }, onFailure = { notify(couldNotShare) }) + } val toSession = { sessionId: String -> onNavigateToRoute(FrostSigningRoute(activeUserPublicKey = activeUserPublicKey, chatRoomId = chatRoomId, sessionId = sessionId)) } @@ -200,8 +217,8 @@ fun GroupWalletScreen( } is GroupWalletUIState.NotOpened -> { - EmptyState( - modifier = Modifier.padding(padding).readableContent(), + val notOpened = @Composable { modifier: Modifier -> EmptyState( + modifier = modifier, message = stringResource(Res.string.this_group_has_not_opened_a_wallet), icon = Icons.Default.AccountBalanceWallet, // Hidden rather than disabled, the way every gated way in @@ -232,7 +249,27 @@ fun GroupWalletScreen( ) } } else null - ) + ) } + + if (state.guardedWallets.isEmpty() && state.shareable.isEmpty()) { + notOpened(Modifier.padding(padding).readableContent()) + } else { + // A group with no wallet of its own can still guard others', + // and still carry a descendant's upward. + LazyColumn( + modifier = Modifier.padding(padding).readableContent().fillMaxSize() + .padding(MaterialTheme.spacing.screenMargin), + verticalArrangement = Arrangement.spacedBy(MaterialTheme.spacing.itemGap) + ) { + item { notOpened(Modifier) } + guardianItems( + guardedWallets = state.guardedWallets, + shareable = state.shareable, + isPending = groupWalletViewModel.isActionPending.value, + onShare = onShare, + ) + } + } } is GroupWalletUIState.Loaded -> { @@ -270,6 +307,8 @@ fun GroupWalletScreen( groupWalletViewModel.bumpFee(sessionId, onSuccess = toSession, onFailure = { notify(couldNotBump) }) } } else null, + isPending = groupWalletViewModel.isActionPending.value, + onShare = onShare, ) } } @@ -337,6 +376,8 @@ private fun OpenWallet( onOpenSpend: (sessionId: String) -> Unit, onSendAgain: ((sessionId: String) -> Unit)?, onBump: ((sessionId: String) -> Unit)?, + isPending: Boolean, + onShare: (GuardianManager.Shareable) -> Unit, ) { val clipboardManager = LocalClipboardManager.current val addressCopied = stringResource(Res.string.address_copied) @@ -495,6 +536,13 @@ private fun OpenWallet( ) } } + + guardianItems( + guardedWallets = state.guardedWallets, + shareable = state.shareable, + isPending = isPending, + onShare = onShare, + ) } } @@ -540,6 +588,60 @@ private fun SpendStatus.label() = when (this) { } /** Confirmed and on-the-way said apart: only the first can be spent by a send-all. */ +/** + * The guarded wallets of groups below this one, and the guarded statements this + * device can still carry to the groups above. Both under the room's own wallet, + * or in place of it for a group that has none. + */ +private fun LazyListScope.guardianItems( + guardedWallets: List, + shareable: List, + isPending: Boolean, + onShare: (GuardianManager.Shareable) -> Unit, +) { + if (guardedWallets.isNotEmpty()) { + item { + Text(text = stringResource(Res.string.guarded_wallets), style = MaterialTheme.typography.titleMedium) + } + item { + Text( + text = stringResource(Res.string.wallets_of_groups_below_this_one, GuardianDerivation.ANCESTOR_DELAY.toInt()), + style = MaterialTheme.typography.bodyMedium, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + items(guardedWallets, key = { "guarded-" + it.wallet.statement.id }) { row -> + ListItem( + leadingContent = { Icon(Icons.Default.AccountBalanceWallet, contentDescription = Decorative) }, + headlineContent = { Text(row.wallet.name ?: stringResource(Res.string.a_subgroup), maxLines = 1, overflow = TextOverflow.Ellipsis) }, + supportingContent = { + Text( + row.withinReach?.let { stringResource(Res.string.s_sats_within_this_group_s_reach, it.grouped()) } + ?: stringResource(Res.string.balance_not_known_yet) + ) + }, + ) + } + } + + if (shareable.isNotEmpty()) { + item { + Text(text = stringResource(Res.string.tell_the_groups_above), style = MaterialTheme.typography.titleMedium) + } + items(shareable, key = { "shareable-" + it.statement.id }) { candidate -> + ListItem( + headlineContent = { Text(candidate.name ?: stringResource(Res.string.a_subgroup), maxLines = 1, overflow = TextOverflow.Ellipsis) }, + supportingContent = { Text(stringResource(Res.string.not_yet_shared_with_the_groups_above)) }, + trailingContent = { + TextButton(onClick = { onShare(candidate) }, enabled = !isPending) { + Text(stringResource(Res.string.share)) + } + }, + ) + } + } +} + @Composable private fun BalanceCard(walletState: GroupWalletState?) { Card(modifier = Modifier.fillMaxWidth()) { diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/GroupWalletViewModel.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/GroupWalletViewModel.kt index 7c09ed3f..5f9d8439 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/GroupWalletViewModel.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/GroupWalletViewModel.kt @@ -7,8 +7,12 @@ import com.machankura.bennu.compose.wallet.GroupSpend import com.machankura.bennu.compose.wallet.GroupSpendBuilder import com.machankura.bennu.compose.wallet.GroupTransactionWatcher import com.machankura.bennu.compose.wallet.GroupWalletRollout +import com.machankura.bennu.compose.managers.GuardianManager +import com.machankura.bennu.compose.ui.view.state.GuardedWalletRow +import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.combine import kotlinx.coroutines.flow.flowOf +import kotlinx.coroutines.flow.map import androidx.compose.runtime.MutableState import androidx.compose.runtime.getValue import androidx.compose.runtime.mutableStateOf @@ -71,16 +75,29 @@ class GroupWalletViewModel( val canSign = localChatRoom.chatRoom.mlsGroupState != null && chatRepository.canSign(chatRoomId) val wallet = chatRepository.groupWallet(chatRoomId, chain) + val guarded = chatRepository.guardedWallets(chatRoomId).filter { it.chain == chain } + val shareable = chatRepository.shareableGuardedWallets(chatRoomId, chain) + val guardedRows = guarded.map { GuardedWalletRow(it, walletState = null) } + + watching?.cancel() if (wallet == null) { - groupWalletUIState = GroupWalletUIState.NotOpened( + val notOpened = GroupWalletUIState.NotOpened( localChatRoom = localChatRoom, account = chatRepository.groupWalletAccount(chatRoomId, chain), canSign = canSign, guarded = if (GroupWalletRollout.offersGuardiansOn(chain)) { chatRepository.groupWalletGuardedOpening(chatRoomId, chain) } else null, + guardedWallets = guardedRows, + shareable = shareable, ) + groupWalletUIState = notOpened + if (guarded.isNotEmpty()) { + watching = viewModelScope.launch(Dispatchers.IO) { + guardedStates(guarded).collect { rows -> groupWalletUIState = notOpened.copy(guardedWallets = rows) } + } + } return@launch } @@ -90,23 +107,64 @@ class GroupWalletViewModel( walletState = null, canWatch = wallets != null, canSign = canSign, + guardedWallets = guardedRows, + shareable = shareable, ) groupWalletUIState = loaded - // The chain and the room's spends, as one state: either changing - // redraws the screen, and neither may overwrite the other. + // The chain, the room's spends and the wallets it guards, as one + // state: any of them changing redraws the screen, and none may + // overwrite another. val chainState = wallets?.walletFor(wallet.account)?.state ?: flowOf(null) - watching?.cancel() watching = viewModelScope.launch(Dispatchers.IO) { - combine(chainState, frostSigningRepository.observeGroupTransactions(chatRoomId)) { state, transactions -> - state to transactions.map { rowOf(it) } - }.collect { (state, rows) -> - groupWalletUIState = loaded.copy(walletState = state, spends = rows) + combine( + chainState, + frostSigningRepository.observeGroupTransactions(chatRoomId), + guardedStates(guarded), + ) { state, transactions, guardedWallets -> + Triple(state, transactions.map { rowOf(it) }, guardedWallets) + }.collect { (state, rows, guardedWallets) -> + groupWalletUIState = loaded.copy(walletState = state, spends = rows, guardedWallets = guardedWallets) } } } } + /** + * Each guarded wallet with what the chain says of it, on the identity's own + * Electrum client -- or with nothing, for a profile that cannot watch. + */ + private suspend fun guardedStates(guarded: List): Flow> { + val wallets = wallets + if (wallets == null || guarded.isEmpty()) return flowOf(guarded.map { GuardedWalletRow(it, walletState = null) }) + + val states = guarded.map { wallet -> wallets.walletFor(wallet.account).state.map { GuardedWalletRow(wallet, it) } } + return combine(states) { it.toList() } + } + + /** + * Tells the groups above about [shareable]'s guarded wallet: one notice into + * each of their rooms this device is in. What is told stays told, so the + * row goes from the screen once it is sent. + */ + fun share(shareable: GuardianManager.Shareable, onShared: () -> Unit, onFailure: () -> Unit) { + if (isActionPending.value) return + isActionPending.value = true + + viewModelScope.launch(Dispatchers.IO) { + val told = chatRepository.shareGuardedWallet(shareable, activeUserPublicKey) + if (told > 0) { + groupWalletUIState = when (val state = groupWalletUIState) { + is GroupWalletUIState.Loaded -> state.copy(shareable = state.shareable - shareable) + is GroupWalletUIState.NotOpened -> state.copy(shareable = state.shareable - shareable) + else -> state + } + } + withContext(Dispatchers.Main) { if (told > 0) onShared() else onFailure() } + isActionPending.value = false + } + } + /** Checked once per session: the PSBT is write-once, so what it says cannot change. */ private val checkedSpends = mutableMapOf() diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/GroupWalletUIState.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/GroupWalletUIState.kt index d8379218..12691e90 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/GroupWalletUIState.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/GroupWalletUIState.kt @@ -3,6 +3,10 @@ package com.machankura.bennu.compose.ui.view.state import com.machankura.bennu.compose.database.model.intermdiate.LocalChatRoom import com.machankura.bennu.compose.managers.GroupWalletDerivation import com.machankura.bennu.compose.managers.GroupWalletManager +import com.machankura.bennu.compose.managers.GuardianDerivation +import com.machankura.bennu.compose.managers.GuardianManager +import fr.acinq.bitcoin.Satoshi +import fr.acinq.lightning.utils.sum import com.machankura.bennu.compose.nostr.wallet.GroupWallet import com.machankura.bennu.compose.wallet.GroupWalletState import com.machankura.bennu.compose.wallet.GroupSpend @@ -27,6 +31,10 @@ sealed interface GroupWalletUIState { val account: GroupWalletDerivation.Account?, val canSign: Boolean, val guarded: GroupWalletManager.GuardedOpening? = null, + /** Guarded wallets of groups below this one. A group with no wallet of its own can still guard others'. */ + val guardedWallets: List = emptyList(), + /** Guarded statements this device can carry to the groups above. */ + val shareable: List = emptyList(), ): GroupWalletUIState /** @@ -44,6 +52,10 @@ sealed interface GroupWalletUIState { val canSign: Boolean, /** The room's spends, newest first. */ val spends: List = emptyList(), + /** Guarded wallets of groups below this one. */ + val guardedWallets: List = emptyList(), + /** Guarded statements this device can carry to the groups above. */ + val shareable: List = emptyList(), ): GroupWalletUIState data class Error( @@ -53,6 +65,22 @@ sealed interface GroupWalletUIState { data object Loading: GroupWalletUIState } +/** A descendant's guarded wallet, as an ancestor's wallet screen lists it. */ +data class GuardedWalletRow( + val wallet: GuardianManager.GuardedWallet, + /** Null before Electrum's first answer, and for a profile that cannot watch the chain. */ + val walletState: GroupWalletState?, +) { + /** + * What this group could spend now: coins confirmed at least as deep as its + * leaf's lock. Null while the chain is not known. + */ + val withinReach: Satoshi? + get() = walletState?.let { state -> + state.utxos.filter { state.confirmations(it) >= GuardianDerivation.ANCESTOR_DELAY }.map { it.amount }.sum() + } +} + /** Where one of the room's spends has got to, as one fact a member reads. */ enum class SpendStatus { WAITING_FOR_SIGNATURES, diff --git a/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/GuardianSigningJvmTest.kt b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/GuardianSigningJvmTest.kt index c8418a88..cf275df8 100644 --- a/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/GuardianSigningJvmTest.kt +++ b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/GuardianSigningJvmTest.kt @@ -29,6 +29,17 @@ import kotlin.test.assertEquals import kotlin.test.assertNotNull import kotlin.test.assertNull import kotlin.time.Instant +import com.machankura.bennu.compose.database.model.GroupSignedEvent +import com.machankura.bennu.compose.nostr.wallet.GroupWalletStatementEvent +import com.machankura.bennu.compose.nostr.wallet.GuardedWalletNoticeEvent +import com.vitorpamplona.quartz.nip01Core.core.hexToByteArray +import com.vitorpamplona.quartz.nip01Core.crypto.EventHasher +import fr.acinq.bitcoin.ByteVector +import fr.acinq.bitcoin.Chain +import fr.acinq.bitcoin.crypto.frost.IndividualNonce +import fr.acinq.bitcoin.crypto.frost.SecretNonce +import fr.acinq.bitcoin.crypto.frost.Session +import kotlin.test.assertTrue /** * A group's guardian keys through the real signing manager, between two of its @@ -187,4 +198,160 @@ class GuardianSigningJvmTest { assertNull(other.session(session.id), "refused at acceptance, so nothing of the member's is ever published for it") } + + // ---- Telling an ancestor about a guarded wallet ----------------------- + + /** The child as a group of its own, so its room can sign its statement. */ + private val childMaterial: KeyMaterial = Frost.trustedDealerKeygen( + thresholdSecretKey = PrivateKey(ByteVector32("c41d".padEnd(62, '0') + "b2")), + nParticipants = participants, + threshold = threshold, + ) + private val guardedChildKey = childMaterial.thresholdPublicKey.value.toHex() + private val guardedChildRoomId = SharedKeyDerivation.marmotGroupId(guardedChildKey) + + /** [material]'s room signing [id], as a quorum of its trusted-dealer shares. */ + private fun roomSignature(material: KeyMaterial, id: String): String { + val cache = SharedKeyDerivation.derive(material.thresholdPublicKey.value.toHex()).cache + val message = ByteVector(id.hexToByteArray()) + val signerIds = listOf(0, 1) + val nonces = signerIds.map { signerId -> + SecretNonce.generate( + sessionRandom = ByteVector32("b".repeat(63) + "${signerId + 1}"), + secretShare = material.secretShares[signerId], + publicShare = material.publicShares[signerId], + tweakedThresholdPublicKey = cache.tweakedPublicKey, + message = message, + extraInput = null, + ) + } + val session = Session.create( + aggregatedNonce = IndividualNonce.aggregate(nonces.map { it.second }).right!!, + signerIds = signerIds.map { it.toUInt() }, + signerPublicShares = signerIds.map { material.publicShares[it] }, + nParticipants = participants, + threshold = threshold, + tweakCache = cache, + message = message, + ) + val partials = signerIds.mapIndexed { position, signerId -> + session.sign(nonces[position].first, material.secretShares[signerId], signerId.toUInt()).right!! + } + return session.aggregateSigs(partials).right!!.toByteArray().toHex() + } + + private fun signedBy(material: KeyMaterial, kind: Int, tags: Array>, content: String, createdAt: Long = 1_700_000_000): Event { + val author = SharedKeyDerivation.marmotGroupId(material.thresholdPublicKey.value.toHex()) + val id = EventHasher.hashId(author, createdAt, kind, tags, content) + return Event(id, author, createdAt, kind, tags, content, roomSignature(material, id)) + } + + /** The ancestor certifies the child with [guardians], and the child signs a guarded statement under them. */ + private fun guardedStatement( + guardians: List = GuardianDerivation.grant(thresholdPublicKey, roomId, emptyList(), guardedChildRoomId), + createdAt: Long = 1_700_000_000, + ): Event { + val certificate = signedBy( + keyMaterial, SubgroupBirthCertificateEvent.KIND, + SubgroupBirthCertificateEvent.assembleTags( + subgroupChatRoomId = guardedChildRoomId, parentChatRoomId = roomId, thresholdPublicKey = guardedChildKey, + adminPublicKeys = members, name = "Translation team", guardians = guardians, + ), + guardedChildRoomId, + ) + val account = GroupWalletDerivation.account(guardedChildKey, Chain.Regtest, guardians = guardians) + val template = GroupWalletStatementEvent.template(account, certificate, createdAt) + return signedBy(childMaterial, template.kind, template.tags, template.content, createdAt) + } + + private suspend fun tell(device: Device, statement: Event, from: HexKey = members[2], createdAt: Long = 1_700_000_100) { + val content = statement.toJson() + device.db.marmotInnerEventDao().upsert( + MarmotInnerEvent( + id = EventHasher.hashId(from, createdAt, GuardedWalletNoticeEvent.KIND, emptyArray(), content), + publicKey = from, kind = GuardedWalletNoticeEvent.KIND, createdAt = Instant.fromEpochSeconds(createdAt), + tags = emptyArray(), content = content, chatRoomId = roomId, + ) + ) + } + + @Test + fun `an ancestor believes a statement naming a key its own walk reaches, and nothing else`() { + val statement = guardedStatement() + + val wallet = assertNotNull(GuardianManager.verify(statement, roomId, thresholdPublicKey)) + assertEquals(guardedChildRoomId, wallet.descendantChatRoomId) + assertEquals(listOf(guardedChildRoomId), wallet.lineage) + assertEquals("Translation team", wallet.name) + assertTrue(wallet.account.isGuarded) + + val strangerKey = PrivateKey(ByteVector32(ByteArray(32) { 0x55 })).publicKey().toString() + val refusals = mapOf( + "a group that is not among its guardians" to GuardianManager.verify(statement, guardedChildRoomId, guardedChildKey), + "a key the ancestor's walk does not reach" to GuardianManager.verify( + guardedStatement(GuardianDerivation.grant(strangerKey, roomId, emptyList(), guardedChildRoomId)), roomId, thresholdPublicKey, + ), + "a statement the child's room did not sign" to GuardianManager.verify(Event(statement.id, statement.pubKey, statement.createdAt, statement.kind, statement.tags, statement.content, "0".repeat(128)), roomId, thresholdPublicKey), + "a plain statement" to run { + val plain = GroupWalletStatementEvent.template(GroupWalletDerivation.account(guardedChildKey, Chain.Regtest)) + GuardianManager.verify(signedBy(childMaterial, plain.kind, plain.tags, plain.content), roomId, thresholdPublicKey) + }, + ) + refusals.forEach { (name, verified) -> assertNull(verified, name) } + } + + @Test + fun `a notice in the ancestor's room is a guarded wallet it holds, under its first guardians`() = runBlocking { + val ancestor = device(members[0], signerIndex = 0) + val first = guardedStatement(createdAt = 1_700_000_000) + tell(ancestor, first) + // A later statement for the same account, naming other guardians, cannot + // move what the ancestor watches -- the earliest decides. + val second = guardedStatement( + GuardianDerivation.grant(thresholdPublicKey, roomId, emptyList(), guardedChildRoomId).map { it.copy(delay = 13) }, + createdAt = 1_700_000_500, + ) + tell(ancestor, second, createdAt = 1_700_000_600) + // And nonsense is read past, not believed. + ancestor.db.marmotInnerEventDao().upsert( + MarmotInnerEvent(id = "f".repeat(64), publicKey = members[2], kind = GuardedWalletNoticeEvent.KIND, + createdAt = Instant.fromEpochSeconds(1), tags = emptyArray(), content = "not an event", chatRoomId = roomId) + ) + + val held = GuardianManager.guardedWalletsOf(ancestor.db, roomId) + assertEquals(listOf(first.id), held.map { it.statement.id }) + assertEquals( + "Shared the guarded wallet of Translation team with this group.", + GuardianManager.describeNotice(ancestor.db, roomId, Event("1".repeat(64), members[2], 1, GuardedWalletNoticeEvent.KIND, emptyArray(), first.toJson(), "")) + ) + } + + @Test + fun `a member in both rooms carries the child's statement up, once`() = runBlocking { + val member = device(members[0], signerIndex = 0) + // This device is also in the child's room, and holds its signed statement there. + member.db.chatRoomDao().upsert(ChatRoom(id = guardedChildRoomId, userPublicKey = member.publicKey, subject = "Translation team", description = null, mlsGroupState = "00")) + member.db.groupKeyStateDao().upsert( + com.machankura.bennu.compose.database.model.GroupKeyState( + chatRoomId = guardedChildRoomId, dkgSessionId = "child-ceremony", thresholdPublicKey = guardedChildKey, + derivationPath = SharedKeyDerivation.formatPath(), announcedBy = guardedChildRoomId, + announcedAt = Instant.fromEpochSeconds(1_700_000_000), + ) + ) + val statement = guardedStatement() + member.db.groupSignedEventDao().upsert(GroupSignedEvent.fromEvent(statement, chatRoomId = guardedChildRoomId)) + + val shareable = GuardianManager.shareableFrom(member.db, guardedChildRoomId, Chain.Regtest).single() + assertEquals(statement.id, shareable.statement.id) + assertEquals(listOf(roomId), shareable.rooms.map { it.chatRoom.id }) + + assertEquals(1, GuardianManager.share(member.db, shareable.statement, shareable.rooms, member.publicKey)) + val queued = member.db.marmotInnerEventDao().getByChatRoomAndKinds(roomId, listOf(GuardedWalletNoticeEvent.KIND)).single() + assertEquals(member.publicKey, queued.publicKey) + assertNull(queued.marmotGroupEventId, "queued for the outbound pipeline, not yet sent") + + // Told is told: nothing left to share, and the ancestor's own device reads it back. + assertEquals(emptyList(), GuardianManager.shareableFrom(member.db, guardedChildRoomId, Chain.Regtest)) + assertEquals(listOf(statement.id), GuardianManager.guardedWalletsOf(member.db, roomId).map { it.statement.id }) + } }