From 8a3e98e4d6cb8a82837aa3cb38c7d38091471930 Mon Sep 17 00:00:00 2001 From: Kgothatso Ngako Date: Sat, 24 Oct 2026 07:49:59 +0200 Subject: [PATCH] feat(wallet): a member spends their guarded wallet alone (Phase 9, part 2) MemberWalletManager.signSpend checks a spend the way a group member checks a group's -- GroupSpend.check against the account the wallet rederives to -- signs every input on the key path with the member's key, asserts correctlySpends, and files it as a MemberWalletSpend. While member wallets are shut on mainnet a member's own spend there is held to the same cap as every group spend. MemberSendScreen is the group's SpendForm with a button that signs and sends; the line above it says there is no quorum after this. There is no session for GroupTransactionWatcher to follow, so the wallet screen follows the member's spends while it is open, sending again any Electrum has not heard of, and lists them. Co-Authored-By: Claude Opus 5.5 --- .../composeResources/values/strings.xml | 9 + .../DatabaseMemberWalletRepository.kt | 15 ++ .../compose/managers/MemberWalletManager.kt | 62 ++++++ .../repository/MemberWalletRepository.kt | 18 ++ .../compose/ui/composable/MemberSendScreen.kt | 154 +++++++++++++++ .../ui/composable/MemberWalletScreen.kt | 24 +++ .../ui/composable/navigation/BennuNavHost.kt | 19 ++ .../navigation/routes/MemberSendRoute.kt | 10 + .../ui/view/model/MemberSendViewModel.kt | 186 ++++++++++++++++++ .../ui/view/model/MemberWalletViewModel.kt | 38 +++- .../ui/view/state/MemberSendUIState.kt | 24 +++ .../ui/view/state/MemberWalletUIState.kt | 3 + .../compose/wallet/GroupOnchainWallets.kt | 13 ++ .../compose/wallet/GroupWalletRollout.kt | 7 + .../managers/MemberWalletSpendJvmTest.kt | 138 +++++++++++++ 15 files changed, 715 insertions(+), 5 deletions(-) create mode 100644 composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/MemberSendScreen.kt create mode 100644 composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/navigation/routes/MemberSendRoute.kt create mode 100644 composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/MemberSendViewModel.kt create mode 100644 composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/MemberSendUIState.kt create mode 100644 composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/MemberWalletSpendJvmTest.kt diff --git a/composeApp/src/commonMain/composeResources/values/strings.xml b/composeApp/src/commonMain/composeResources/values/strings.xml index 97502312..f73a2325 100644 --- a/composeApp/src/commonMain/composeResources/values/strings.xml +++ b/composeApp/src/commonMain/composeResources/values/strings.xml @@ -613,4 +613,13 @@ %1$s sats come back to this wallet as change. This wallet has nothing confirmed to spend. This wallet doesn't have that much confirmed. + Send from your guarded wallet + You sign this alone, and it is sent as soon as you press the button. + Sending needs this wallet's key on this device, a group's certificate for it, and a wallet of this profile's own to watch the chain with. + Sign and send + Sent. + Couldn't send. + Your spends + Sent, waiting for the network to report it + In the mempool diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/repository/DatabaseMemberWalletRepository.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/repository/DatabaseMemberWalletRepository.kt index 31aebf02..d43661e9 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/repository/DatabaseMemberWalletRepository.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/repository/DatabaseMemberWalletRepository.kt @@ -3,6 +3,11 @@ package com.machankura.bennu.compose.database.repository import co.touchlab.kermit.Logger import com.machankura.bennu.compose.database.BennuDatabase import com.machankura.bennu.compose.database.model.MemberWallet +import com.machankura.bennu.compose.database.model.MemberWalletSpend +import fr.acinq.bitcoin.Transaction +import fr.acinq.bitcoin.psbt.Psbt +import kotlinx.coroutines.flow.Flow +import kotlin.time.Instant import com.machankura.bennu.compose.database.model.intermdiate.LocalChatRoom import com.machankura.bennu.compose.identity.Identity import com.machankura.bennu.compose.managers.MemberWalletManager @@ -82,6 +87,16 @@ class DatabaseMemberWalletRepository( override suspend fun roomName(chatRoomId: String): String? = database.chatRoomDao().findChatRoomById(chatRoomId)?.chatRoom?.subject?.takeIf { it.isNotBlank() } + override suspend fun signSpend(walletId: String, psbt: Psbt): Transaction { + val owner = activeIdentity.value?.nostrPublicKey ?: throw IllegalStateException("No profile is active") + return MemberWalletManager.signSpend(database, owner, walletId, psbt) + } + + override suspend fun recordChain(txid: String, confirmations: Int?, broadcastAt: Instant?) = + MemberWalletManager.recordChain(database, txid, confirmations, broadcastAt) + + override fun observeSpends(walletId: String): Flow> = database.memberWalletDao().observeSpends(walletId) + companion object { private const val TAG = "DatabaseMemberWalletRepository" } diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/MemberWalletManager.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/MemberWalletManager.kt index 5622ce47..eff3f0db 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/MemberWalletManager.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/MemberWalletManager.kt @@ -4,6 +4,12 @@ import co.touchlab.kermit.Logger import com.machankura.bennu.compose.database.BennuDatabase import com.machankura.bennu.compose.database.model.FrostSigningSession import com.machankura.bennu.compose.database.model.MemberWallet +import com.machankura.bennu.compose.database.model.MemberWalletSpend +import com.machankura.bennu.compose.wallet.GroupSpend +import fr.acinq.bitcoin.ScriptFlags +import fr.acinq.bitcoin.Transaction +import fr.acinq.bitcoin.psbt.Psbt +import fr.acinq.secp256k1.Hex import com.machankura.bennu.compose.database.model.MarmotInnerEvent import com.machankura.bennu.compose.database.model.intermdiate.LocalChatRoom import com.machankura.bennu.compose.database.model.types.FrostSigningStage @@ -347,6 +353,62 @@ object MemberWalletManager { return MemberWalletDerivation.privateDescriptors(key, row.account) } + /** + * Signs [psbt] as [walletId]'s own key and files the spend, returning the + * finished transaction for the caller to broadcast. + * + * Checked the way a group member checks a group spend -- `GroupSpend.check` + * against the account the wallet rederives to, never against the PSBT's own + * claims -- because the builder is shared and so are its mistakes; and then + * `correctlySpends`, the last word on whether the network will take it. + * + * @throws IllegalStateException when the key is not here, the wallet is not + * certified, the spend fails a check or is over the cap + */ + suspend fun signSpend(database: BennuDatabase, ownerPublicKey: HexKey, walletId: String, psbt: Psbt, at: Instant = Clock.System.now()): Transaction { + val row = walletOf(database, ownerPublicKey, walletId) ?: throw IllegalStateException("No such wallet") + check(row.state == WalletState.OPEN) { "Only a certified wallet whose key is here can spend" } + val key = PrivateKey.fromHex(checkNotNull(row.stored).walletPrivateKey) + + val checked = when (val result = GroupSpend.check(psbt, row.account, GroupSpend.Spender.Owner)) { + is GroupSpend.Result.Ok -> result.checked + is GroupSpend.Result.Refused -> throw IllegalStateException("This spend ${result.reason}") + } + GroupWalletRollout.memberCapFor(row.chain)?.let { cap -> + check(checked.amountSent <= cap) { "This spend sends more than ${cap.sat} sats while member wallets are new" } + } + + val signed = checked.witnessed(checked.inputs.map { MemberWalletDerivation.sign(key, row.chain, it) }) + signed.correctlySpends(checked.inputs.associate { it.outPoint to it.txOut }, ScriptFlags.STANDARD_SCRIPT_VERIFY_FLAGS) + + database.memberWalletDao().upsertSpend( + MemberWalletSpend( + txid = signed.txid.toString(), + walletId = walletId, + psbt = GroupSpend.encode(psbt), + signedTransaction = Hex.encode(Transaction.write(signed)), + createdAt = at, + ) + ) + logger.i("Signed ${signed.txid} from wallet ${walletId.take(8)}") + return signed + } + + /** + * Files what the chain said of [txid]: handed to Electrum at [broadcastAt], + * and -- with [confirmations] non-null -- seen, and confirmed once it is at + * least one deep. + */ + suspend fun recordChain(database: BennuDatabase, txid: String, confirmations: Int?, broadcastAt: Instant? = null, at: Instant = Clock.System.now()) { + val spend = database.memberWalletDao().getSpend(txid) ?: return + val updated = spend.copy( + broadcastAt = broadcastAt ?: spend.broadcastAt, + seenAt = spend.seenAt ?: at.takeIf { confirmations != null }, + confirmedAt = spend.confirmedAt ?: at.takeIf { (confirmations ?: 0) >= 1 }, + ) + if (updated != spend) database.memberWalletDao().upsertSpend(updated) + } + // ---- The group's side ------------------------------------------------ /** diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/repository/MemberWalletRepository.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/repository/MemberWalletRepository.kt index b93214de..8238c2e8 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/repository/MemberWalletRepository.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/repository/MemberWalletRepository.kt @@ -1,6 +1,12 @@ package com.machankura.bennu.compose.repository import com.machankura.bennu.compose.database.model.MemberWallet +import com.machankura.bennu.compose.database.model.MemberWalletSpend +import fr.acinq.bitcoin.Transaction +import fr.acinq.bitcoin.psbt.Psbt +import kotlinx.coroutines.flow.Flow +import kotlinx.coroutines.flow.flowOf +import kotlin.time.Instant import com.machankura.bennu.compose.database.model.intermdiate.LocalChatRoom import com.machankura.bennu.compose.managers.MemberWalletManager import com.vitorpamplona.quartz.nip01Core.core.HexKey @@ -46,6 +52,15 @@ interface MemberWalletRepository { /** What [chatRoomId] is called on this device, or null when it has no room for it. */ suspend fun roomName(chatRoomId: String): String? + /** Signs [psbt] as [walletId]'s own key, files the spend, and returns the transaction to broadcast. */ + suspend fun signSpend(walletId: String, psbt: Psbt): Transaction + + /** Files what the chain said of a member's spend. */ + suspend fun recordChain(txid: String, confirmations: Int?, broadcastAt: Instant? = null) + + /** The spends the member signed from [walletId], newest first. */ + fun observeSpends(walletId: String): Flow> + companion object { val NO_OP = object : MemberWalletRepository { override suspend fun groupsOf(ownerPublicKey: HexKey): List = emptyList() @@ -60,6 +75,9 @@ interface MemberWalletRepository { override suspend fun discard(walletId: String) = Unit override suspend fun exportKey(walletId: String): Pair? = null override suspend fun roomName(chatRoomId: String): String? = null + override suspend fun signSpend(walletId: String, psbt: Psbt): Transaction = throw UnsupportedOperationException("no repository") + override suspend fun recordChain(txid: String, confirmations: Int?, broadcastAt: Instant?) = Unit + override fun observeSpends(walletId: String): Flow> = flowOf(emptyList()) } } } diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/MemberSendScreen.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/MemberSendScreen.kt new file mode 100644 index 00000000..d45bdd7c --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/MemberSendScreen.kt @@ -0,0 +1,154 @@ +package com.machankura.bennu.compose.ui.composable + +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.rememberScrollState +import androidx.compose.foundation.verticalScroll +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.AccountBalanceWallet +import androidx.compose.material.icons.filled.Send +import androidx.compose.material3.Button +import androidx.compose.material3.ExperimentalMaterial3Api +import androidx.compose.material3.Icon +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Scaffold +import androidx.compose.material3.SnackbarHost +import androidx.compose.material3.Text +import androidx.compose.material3.TopAppBar +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.rememberCoroutineScope +import androidx.compose.ui.Modifier +import androidx.compose.ui.text.style.TextOverflow +import androidx.lifecycle.viewmodel.compose.viewModel +import bennu.composeapp.generated.resources.Res +import bennu.composeapp.generated.resources.couldn_t_send +import bennu.composeapp.generated.resources.send_from_your_guarded_wallet +import bennu.composeapp.generated.resources.sending_from_this_wallet_needs_its_key_and_a_node +import bennu.composeapp.generated.resources.sent +import bennu.composeapp.generated.resources.sign_and_send +import bennu.composeapp.generated.resources.signed_by_you_alone_and_sent_at_once +import com.machankura.bennu.compose.repository.MemberWalletRepository +import com.machankura.bennu.compose.ui.composable.widgets.Decorative +import com.machankura.bennu.compose.ui.composable.widgets.EmptyState +import com.machankura.bennu.compose.ui.composable.widgets.ErrorState +import com.machankura.bennu.compose.ui.composable.widgets.LoadingDataIndicator +import com.machankura.bennu.compose.ui.composable.widgets.LocalSnackbarHostState +import com.machankura.bennu.compose.ui.composable.widgets.NavigateBackButton +import com.machankura.bennu.compose.ui.composable.widgets.ScreenStateTransition +import com.machankura.bennu.compose.ui.composable.widgets.rememberNotifier +import com.machankura.bennu.compose.ui.theme.readableContent +import com.machankura.bennu.compose.ui.theme.spacing +import com.machankura.bennu.compose.ui.view.model.MemberSendViewModel +import com.machankura.bennu.compose.ui.view.state.MemberSendUIState +import com.machankura.bennu.compose.wallet.GroupOnchainWallets +import com.machankura.bennu.compose.wallet.GroupSpendBuilder +import com.machankura.bennu.compose.wallet.GroupWalletRollout +import com.vitorpamplona.quartz.nip01Core.core.HexKey +import fr.acinq.bitcoin.Chain +import org.jetbrains.compose.resources.stringResource + +/** + * A spend from the member's own guarded wallet: the group's send form, and a + * button that signs with the member's key alone and sends. There is no quorum + * to stop a mistake after this, which the line above the button says. + */ +@OptIn(ExperimentalMaterial3Api::class) +@Composable +fun MemberSendScreen( + activeUserPublicKey: HexKey, + walletId: String, + chain: Chain, + initialUIState: MemberSendUIState = MemberSendUIState.Loading, + memberWalletRepository: MemberWalletRepository, + wallets: GroupOnchainWallets?, + onNavigateBack: () -> Unit, +) { + val viewModel: MemberSendViewModel = viewModel( + factory = MemberSendViewModel.factory( + ownerPublicKey = activeUserPublicKey, + walletId = walletId, + chain = chain, + initialUIState = initialUIState, + memberWalletRepository = memberWalletRepository, + wallets = wallets, + ) + ) + + LaunchedEffect(true) { + if (initialUIState == MemberSendUIState.Loading) viewModel.initiate() + } + + // The caller's scope, so "sent" outlives the screen going back. + val notify = rememberNotifier(rememberCoroutineScope()) + val sent = stringResource(Res.string.sent) + val couldNotSend = stringResource(Res.string.couldn_t_send) + + Scaffold( + snackbarHost = { SnackbarHost(LocalSnackbarHostState.current) }, + topBar = { + TopAppBar( + title = { Text(stringResource(Res.string.send_from_your_guarded_wallet), maxLines = 1, overflow = TextOverflow.Ellipsis) }, + navigationIcon = { NavigateBackButton(onNavigateBack) }, + ) + } + ) { padding -> + ScreenStateTransition(viewModel.uiState) { uiState -> + when (val state = uiState) { + // Nothing to retry: the wallet came from a navigation argument. + is MemberSendUIState.Error -> ErrorState(modifier = Modifier.padding(padding), message = state.message, onRetry = null) + + MemberSendUIState.Loading -> LoadingDataIndicator(modifier = Modifier.fillMaxWidth().padding(padding)) + + MemberSendUIState.Unavailable -> EmptyState( + modifier = Modifier.padding(padding).readableContent(), + message = stringResource(Res.string.sending_from_this_wallet_needs_its_key_and_a_node), + icon = Icons.Default.AccountBalanceWallet, + ) + + is MemberSendUIState.Ready -> Column( + modifier = Modifier.padding(padding).readableContent().fillMaxSize() + .verticalScroll(rememberScrollState()) + .padding(MaterialTheme.spacing.screenMargin), + verticalArrangement = Arrangement.spacedBy(MaterialTheme.spacing.itemGap), + ) { + val preview = viewModel.preview() + + SpendForm( + addressField = viewModel.addressField, + amountField = viewModel.amountField, + feerateField = viewModel.feerateField, + sendEverything = viewModel.sendEverything, + spendable = viewModel.spendable(), + cap = GroupWalletRollout.memberCapFor(chain), + preview = preview, + amountProblem = preview?.takeIf { viewModel.isAboutTheAmount(it) }, + coinsKnown = state.walletState != null, + chain = chain, + ownWallet = true, + ) + + Text( + text = stringResource(Res.string.signed_by_you_alone_and_sent_at_once), + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + + Button( + enabled = preview is GroupSpendBuilder.Result.Built && !viewModel.isActionPending.value, + onClick = { viewModel.send(onSent = { notify(sent); onNavigateBack() }, onFailure = { notify(couldNotSend) }) }, + ) { + Icon(Icons.Default.Send, contentDescription = Decorative) + Spacer(modifier = Modifier.width(MaterialTheme.spacing.relatedGap)) + Text(stringResource(Res.string.sign_and_send)) + } + } + } + } + } +} diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/MemberWalletScreen.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/MemberWalletScreen.kt index afbd1f17..bedda67b 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/MemberWalletScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/MemberWalletScreen.kt @@ -77,6 +77,10 @@ import bennu.composeapp.generated.resources.this_profile_cannot_watch_its_own_co import bennu.composeapp.generated.resources.waiting_for_someone_in_s_to_put_it_to_the_group import bennu.composeapp.generated.resources.whoever_holds_these_descriptors_holds_the_coins import bennu.composeapp.generated.resources.you_re_no_longer_in_s +import bennu.composeapp.generated.resources.your_spends +import bennu.composeapp.generated.resources.confirmed +import bennu.composeapp.generated.resources.in_the_mempool +import bennu.composeapp.generated.resources.sent_waiting_for_the_network import com.machankura.bennu.compose.managers.MemberWalletManager.WalletState import com.machankura.bennu.compose.repository.MemberWalletRepository import com.machankura.bennu.compose.text.grouped @@ -274,6 +278,26 @@ fun MemberWalletScreen( } } + if (state.spends.isNotEmpty()) { + item { Text(stringResource(Res.string.your_spends), style = MaterialTheme.typography.titleMedium) } + items(state.spends, key = { "spend-" + it.txid }) { spend -> + ListItem( + headlineContent = { Text(spend.txid, maxLines = 1, overflow = TextOverflow.Ellipsis) }, + supportingContent = { + Text( + stringResource( + when { + spend.confirmedAt != null -> Res.string.confirmed + spend.seenAt != null -> Res.string.in_the_mempool + else -> Res.string.sent_waiting_for_the_network + } + ) + ) + }, + ) + } + } + if (state.taken.isNotEmpty()) { item { Text(stringResource(Res.string.taken_by_guardians), style = MaterialTheme.typography.titleMedium) } items(state.taken, key = { "taken-" + it.txid + it.guardianName }) { line -> diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/navigation/BennuNavHost.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/navigation/BennuNavHost.kt index a28dff3b..8873e5c1 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/navigation/BennuNavHost.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/navigation/BennuNavHost.kt @@ -141,6 +141,8 @@ import com.machankura.bennu.compose.ui.composable.navigation.routes.GroupWalletR import com.machankura.bennu.compose.ui.composable.navigation.routes.GroupWalletAddressesRoute import com.machankura.bennu.compose.ui.composable.navigation.routes.NewMemberWalletRoute import com.machankura.bennu.compose.ui.composable.navigation.routes.MemberWalletRoute +import com.machankura.bennu.compose.ui.composable.navigation.routes.MemberSendRoute +import com.machankura.bennu.compose.ui.composable.MemberSendScreen import com.machankura.bennu.compose.ui.composable.MemberWalletScreen import com.machankura.bennu.compose.ui.composable.NewMemberWalletScreen import com.machankura.bennu.compose.database.repository.DatabaseMemberWalletRepository @@ -1168,6 +1170,23 @@ fun BennuNavHost( walletId = route.walletId, memberWalletRepository = databaseMemberWalletRepository, wallets = groupOnchainWallets, + onSend = { walletId -> + navController.navigate(route = MemberSendRoute(activeUserPublicKey = route.activeUserPublicKey, walletId = walletId)) + }, + onNavigateBack = { + navController.popBackStack() + } + ) + } + composable { backStackEntry -> + val route = backStackEntry.toRoute() + + MemberSendScreen( + activeUserPublicKey = route.activeUserPublicKey, + walletId = route.walletId, + chain = NodeParamsManager.chain, + memberWalletRepository = databaseMemberWalletRepository, + wallets = groupOnchainWallets, onNavigateBack = { navController.popBackStack() } diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/navigation/routes/MemberSendRoute.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/navigation/routes/MemberSendRoute.kt new file mode 100644 index 00000000..116b0ad3 --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/navigation/routes/MemberSendRoute.kt @@ -0,0 +1,10 @@ +package com.machankura.bennu.compose.ui.composable.navigation.routes + +import kotlinx.serialization.Serializable + +/** The form a member sends from their own guarded wallet with, signing alone. */ +@Serializable +data class MemberSendRoute( + val activeUserPublicKey: String, + val walletId: String, +): Route() diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/MemberSendViewModel.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/MemberSendViewModel.kt new file mode 100644 index 00000000..751e64b9 --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/MemberSendViewModel.kt @@ -0,0 +1,186 @@ +package com.machankura.bennu.compose.ui.view.model + +import androidx.compose.foundation.text.input.TextFieldState +import androidx.compose.foundation.text.input.setTextAndPlaceCursorAtEnd +import androidx.compose.runtime.MutableState +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.setValue +import androidx.lifecycle.ViewModel +import androidx.lifecycle.ViewModelProvider +import androidx.lifecycle.viewModelScope +import androidx.lifecycle.viewmodel.initializer +import androidx.lifecycle.viewmodel.viewModelFactory +import co.touchlab.kermit.Logger +import com.machankura.bennu.compose.database.model.MemberWalletSpend +import com.machankura.bennu.compose.managers.MemberWalletManager +import com.machankura.bennu.compose.repository.MemberWalletRepository +import com.machankura.bennu.compose.text.SatsInput +import com.machankura.bennu.compose.text.parseSats +import com.machankura.bennu.compose.ui.view.state.MemberSendUIState +import com.machankura.bennu.compose.wallet.GroupOnchainWallets +import com.machankura.bennu.compose.wallet.GroupSpend +import com.machankura.bennu.compose.wallet.GroupSpendBuilder +import com.machankura.bennu.compose.wallet.GroupWalletRollout +import com.vitorpamplona.quartz.nip01Core.core.HexKey +import fr.acinq.bitcoin.Chain +import fr.acinq.bitcoin.OutPoint +import fr.acinq.bitcoin.Satoshi +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.Job +import kotlinx.coroutines.flow.combine +import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext +import kotlin.time.Clock + +/** + * A spend from the member's own guarded wallet, built as they type and signed + * alone when they ask. + * + * The group's send form, read the same way -- the preview is the spend, so the + * fee shown is the fee paid -- with one difference that matters: there is no + * quorum after this. Pressing the button signs and broadcasts. + */ +class MemberSendViewModel( + private val ownerPublicKey: HexKey, + val walletId: String, + val chain: Chain, + initialUIState: MemberSendUIState, + private val memberWalletRepository: MemberWalletRepository, + private val wallets: GroupOnchainWallets?, +) : ViewModel() { + private val logger = Logger.withTag(TAG) + + var uiState: MemberSendUIState by mutableStateOf(initialUIState) + private set + + val addressField = TextFieldState() + val amountField = TextFieldState() + val feerateField = TextFieldState() + val sendEverything: MutableState = mutableStateOf(false) + + val isActionPending: MutableState = mutableStateOf(false) + + private var watching: Job? = null + + fun initiate() { + viewModelScope.launch(Dispatchers.IO) { + val wallet = memberWalletRepository.walletOf(ownerPublicKey, walletId) + if (wallet == null) { + uiState = MemberSendUIState.Error("Couldn't find this wallet") + return@launch + } + if (wallet.state != MemberWalletManager.WalletState.OPEN || wallets == null) { + uiState = MemberSendUIState.Unavailable + return@launch + } + + val ready = MemberSendUIState.Ready(wallet = wallet, walletState = null) + uiState = ready + + wallets.suggestedFeeratePerVbyte()?.let { suggested -> + withContext(Dispatchers.Main) { + if (feerateField.text.isEmpty()) feerateField.setTextAndPlaceCursorAtEnd(suggested.toString()) + } + } + + watching?.cancel() + watching = viewModelScope.launch(Dispatchers.IO) { + combine(wallets.walletFor(wallet.account).state, memberWalletRepository.observeSpends(walletId)) { state, spends -> + val (reserved, reservedChange) = reservationsOf(spends, ready) + ready.copy(walletState = state, reserved = reserved, reservedChange = reservedChange) + }.collect { uiState = it } + } + } + } + + /** + * What the member's own spends still on their way hold: their coins, and the + * change they pay back to. Electrum stops listing a coin once a spend of it + * is in the mempool, so this matters for the moment between signing and the + * server hearing of it -- a second send then would spend the same coin. + */ + private fun reservationsOf(spends: List, ready: MemberSendUIState.Ready): Pair, Set> { + val open = spends.filter { it.seenAt == null && it.replacedByTxid == null } + .mapNotNull { GroupSpend.decode(it.psbt) } + .mapNotNull { (GroupSpend.check(it, ready.wallet.account) as? GroupSpend.Result.Ok)?.checked } + return open.flatMap { spend -> spend.inputs.map { it.outPoint } }.toSet() to + open.flatMap { spend -> spend.outputs.mapNotNull { it.change?.index } }.toSet() + } + + fun amount(): SatsInput = parseSats(amountField.text) + + fun spendable(): Satoshi? { + val state = uiState as? MemberSendUIState.Ready ?: return null + return state.walletState?.let { GroupSpendBuilder.spendableBalance(it, state.reserved, GroupSpend.Spender.Owner) } + } + + fun isAboutTheAmount(result: GroupSpendBuilder.Result?): Boolean = + !sendEverything.value && ( + result is GroupSpendBuilder.Result.InvalidAmount || + result is GroupSpendBuilder.Result.OverCap || + result == GroupSpendBuilder.Result.NotEnough || + result == GroupSpendBuilder.Result.BelowDust + ) + + /** The spend the form describes, or null while it is incomplete -- the same build the group's form makes. */ + fun preview(): GroupSpendBuilder.Result? { + val state = uiState as? MemberSendUIState.Ready ?: return null + val walletState = state.walletState ?: return null + + val amount = if (sendEverything.value) { + null + } else { + when (val input = amount()) { + SatsInput.Empty -> return null + is SatsInput.Sats -> input.amount + else -> return GroupSpendBuilder.Result.InvalidAmount(input) + } + } + val feerate = feerateField.text.toString().trim().toLongOrNull()?.takeIf { it > 0 } ?: return null + val address = addressField.text.toString().trim().takeIf { it.isNotEmpty() } ?: return null + + val built = if (amount == null) { + GroupSpendBuilder.sendAll(walletState, address, feerate, state.reserved) + } else { + GroupSpendBuilder.send(walletState, address, amount, feerate, state.reserved, state.reservedChange) + } + return GroupSpendBuilder.capped(built, GroupWalletRollout.memberCapFor(chain)) + } + + /** Signs what the form describes and hands it to Electrum. [onSent] when it went, [onFailure] when it did not. */ + fun send(onSent: () -> Unit, onFailure: () -> Unit) { + val built = preview() as? GroupSpendBuilder.Result.Built ?: return + val wallets = wallets ?: return + if (isActionPending.value) return + isActionPending.value = true + + viewModelScope.launch(Dispatchers.IO) { + val sent = runCatching { + val signed = memberWalletRepository.signSpend(walletId, built.psbt) + wallets.broadcast(signed) + memberWalletRepository.recordChain(signed.txid.toString(), confirmations = null, broadcastAt = Clock.System.now()) + }.onFailure { logger.e("Couldn't send from wallet $walletId", it) }.isSuccess + + withContext(Dispatchers.Main) { + isActionPending.value = false + if (sent) onSent() else onFailure() + } + } + } + + companion object { + private const val TAG = "MemberSendViewModel" + + fun factory( + ownerPublicKey: HexKey, + walletId: String, + chain: Chain, + initialUIState: MemberSendUIState = MemberSendUIState.Loading, + memberWalletRepository: MemberWalletRepository, + wallets: GroupOnchainWallets?, + ): ViewModelProvider.Factory = viewModelFactory { + initializer { MemberSendViewModel(ownerPublicKey, walletId, chain, initialUIState, memberWalletRepository, wallets) } + } + } +} diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/MemberWalletViewModel.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/MemberWalletViewModel.kt index bb1cf196..0241d2ca 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/MemberWalletViewModel.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/MemberWalletViewModel.kt @@ -17,7 +17,11 @@ import com.machankura.bennu.compose.wallet.GroupOnchainWallets import com.vitorpamplona.quartz.nip01Core.core.HexKey import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.Job +import kotlinx.coroutines.flow.combine import kotlinx.coroutines.flow.distinctUntilChangedBy +import com.machankura.bennu.compose.database.model.MemberWalletSpend +import fr.acinq.bitcoin.Transaction +import kotlin.time.Clock import kotlinx.coroutines.launch import kotlinx.coroutines.withContext @@ -63,21 +67,45 @@ class MemberWalletViewModel( if (!wallet.isCertified || wallets == null) return@launch watching = viewModelScope.launch(Dispatchers.IO) { var taken = emptyList() - wallets.walletFor(wallet.account).state - .distinctUntilChangedBy { state -> state.utxos.map { it.utxo.outPoint } to state.tipHeight } - .collect { state -> - uiState = loaded.copy(walletState = state, taken = taken) + combine( + wallets.walletFor(wallet.account).state + .distinctUntilChangedBy { state -> state.utxos.map { it.utxo.outPoint } to state.tipHeight }, + memberWalletRepository.observeSpends(walletId), + ) { state, spends -> state to spends } + .collect { (state, spends) -> + uiState = loaded.copy(walletState = state, taken = taken, spends = spends) + follow(spends) // History, not a watch: a device asleep when a guardian took a // coin still finds it, since the chain keeps the record. taken = wallets.guardianSpends(state).map { spend -> TakenLine(spend.txid.toString(), memberWalletRepository.roomName(spend.guardian.chatRoomId), spend.amount) } - uiState = loaded.copy(walletState = state, taken = taken) + uiState = loaded.copy(walletState = state, taken = taken, spends = spends) } } } } + /** + * Asks the chain where each of the member's unsettled spends has got to, + * and sends again any Electrum has not heard of. There is no session for + * `GroupTransactionWatcher` to follow, so the wallet screen follows its own + * spends while it is open -- the economy the guardian-spend notice makes: a + * device that never opens the screen writes nothing, and the chain keeps the + * record for the next one that does. + */ + private suspend fun follow(spends: List) { + val wallets = wallets ?: return + spends.filter { it.confirmedAt == null && it.replacedByTxid == null }.forEach { spend -> + val tx = runCatching { Transaction.read(spend.signedTransaction) }.getOrNull() ?: return@forEach + val confirmations = wallets.confirmationsOf(tx) + val resent = if (confirmations == null) { + runCatching { wallets.broadcast(tx) }.getOrNull()?.let { Clock.System.now() } + } else null + memberWalletRepository.recordChain(spend.txid, confirmations, broadcastAt = resent) + } + } + fun askAgain(onAsked: () -> Unit, onFailure: () -> Unit) = act(onAsked, onFailure) { memberWalletRepository.askAgain(walletId) initiate() diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/MemberSendUIState.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/MemberSendUIState.kt new file mode 100644 index 00000000..8bf3fd34 --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/MemberSendUIState.kt @@ -0,0 +1,24 @@ +package com.machankura.bennu.compose.ui.view.state + +import com.machankura.bennu.compose.managers.MemberWalletManager +import com.machankura.bennu.compose.wallet.GroupWalletState +import fr.acinq.bitcoin.OutPoint + +sealed interface MemberSendUIState { + data object Loading : MemberSendUIState + + data class Error(val message: String) : MemberSendUIState + + /** A wallet this device can spend from: certified, its key here, and a node to see the coins with. */ + data object Unavailable : MemberSendUIState + + data class Ready( + val wallet: MemberWalletManager.MemberWalletRow, + /** Null until Electrum answers. */ + val walletState: GroupWalletState?, + /** The coins the member's own unsettled spends hold, which a new one leaves alone. */ + val reserved: Set = emptySet(), + /** The change indices those spends pay back to, which a new one pays past. */ + val reservedChange: Set = emptySet(), + ) : MemberSendUIState +} diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/MemberWalletUIState.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/MemberWalletUIState.kt index c1381b27..59986b66 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/MemberWalletUIState.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/MemberWalletUIState.kt @@ -1,5 +1,6 @@ package com.machankura.bennu.compose.ui.view.state +import com.machankura.bennu.compose.database.model.MemberWalletSpend import com.machankura.bennu.compose.managers.MemberWalletManager import com.machankura.bennu.compose.wallet.GroupWalletState import fr.acinq.bitcoin.Satoshi @@ -17,6 +18,8 @@ sealed interface MemberWalletUIState { val canWatch: Boolean, /** What the wallet's guardians took from it, read off the chain: never stored, found again on each look. */ val taken: List = emptyList(), + /** The spends the member signed from it, newest first. */ + val spends: List = emptyList(), /** How many groups guard it, for the line under the title. */ val reach: Int = wallet.account.guardians.size, ) : MemberWalletUIState diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/wallet/GroupOnchainWallets.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/wallet/GroupOnchainWallets.kt index 0e34b15e..51889918 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/wallet/GroupOnchainWallets.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/wallet/GroupOnchainWallets.kt @@ -90,6 +90,19 @@ class GroupOnchainWallets( mutex.withLock { transactions[txid] } ?: runCatching { electrum.getTx(txid) }.getOrNull()?.also { tx -> mutex.withLock { transactions[txid] = tx } } + /** + * Hands [tx] to Electrum -- for a spend a member signed alone, which has no + * session for `GroupTransactionWatcher` to follow. Electrum reports success + * whatever the server said, so this is not evidence it reached the network: + * [confirmationsOf] is. + */ + suspend fun broadcast(tx: Transaction) { + electrum.broadcastTransaction(tx) + } + + /** How deep [tx] is: 0 in the mempool, null while Electrum has not heard of it or cannot be asked. */ + suspend fun confirmationsOf(tx: Transaction): Int? = runCatching { electrum.getConfirmations(tx) }.getOrNull() + suspend fun stop() = mutex.withLock { wallets.values.forEach { it.stop() } wallets.clear() diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/wallet/GroupWalletRollout.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/wallet/GroupWalletRollout.kt index c3c519bd..bb192e65 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/wallet/GroupWalletRollout.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/wallet/GroupWalletRollout.kt @@ -57,4 +57,11 @@ object GroupWalletRollout { const val MEMBER_WALLETS_ON_MAINNET: Boolean = false fun offersMemberWalletsOn(chain: Chain): Boolean = MEMBER_WALLETS_ON_MAINNET || !chain.isMainnet() + + /** + * The most a member's own spend from their guarded wallet may send on + * [chain]: [MAINNET_CAP] on mainnet until [MEMBER_WALLETS_ON_MAINNET] lifts, + * since the member's spend is signed by a path no group spend goes through. + */ + fun memberCapFor(chain: Chain): Satoshi? = capFor(chain).takeIf { !MEMBER_WALLETS_ON_MAINNET } } diff --git a/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/MemberWalletSpendJvmTest.kt b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/MemberWalletSpendJvmTest.kt new file mode 100644 index 00000000..f7a61e7d --- /dev/null +++ b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/MemberWalletSpendJvmTest.kt @@ -0,0 +1,138 @@ +package com.machankura.bennu.compose.managers + +import androidx.room3.Room +import com.machankura.bennu.compose.database.BennuDatabase +import com.machankura.bennu.compose.database.builder.getRoomDatabase +import com.machankura.bennu.compose.database.model.GroupSignedEvent +import com.machankura.bennu.compose.database.model.MemberWallet +import com.machankura.bennu.compose.managers.GroupFixtures.fileKeyState +import com.machankura.bennu.compose.managers.GroupFixtures.guardedCertificate +import com.machankura.bennu.compose.managers.GroupFixtures.keyMaterial +import com.machankura.bennu.compose.managers.GroupFixtures.roomOf +import com.machankura.bennu.compose.managers.GroupFixtures.signedAsRoom +import com.machankura.bennu.compose.managers.GroupFixtures.signingRoom +import com.machankura.bennu.compose.nostr.wallet.MemberWalletCertificateEvent +import com.machankura.bennu.compose.wallet.GroupSpend +import com.machankura.bennu.compose.wallet.GroupSpendBuilder +import com.machankura.bennu.compose.wallet.GroupWalletState +import com.vitorpamplona.quartz.nip01Core.core.Event +import fr.acinq.bitcoin.ByteVector +import fr.acinq.bitcoin.ByteVector32 +import fr.acinq.bitcoin.Chain +import fr.acinq.bitcoin.OutPoint +import fr.acinq.bitcoin.PrivateKey +import fr.acinq.bitcoin.Satoshi +import fr.acinq.bitcoin.ScriptFlags +import fr.acinq.bitcoin.Transaction +import fr.acinq.bitcoin.TxId +import fr.acinq.bitcoin.TxIn +import fr.acinq.bitcoin.TxOut +import fr.acinq.lightning.blockchain.electrum.WalletState +import fr.acinq.secp256k1.Hex +import kotlinx.coroutines.runBlocking +import kotlin.test.AfterTest +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFailsWith +import kotlin.test.assertIs +import kotlin.test.assertNotNull +import kotlin.test.assertNull +import kotlin.time.Instant + +/** + * A member spending their own guarded wallet alone: the spend checked against + * the account the wallet rederives to, signed with the member's key, accepted + * by the script interpreter, and filed -- and refused for every wallet this + * device cannot sign for. + */ +class MemberWalletSpendJvmTest { + private val db: BennuDatabase = getRoomDatabase(Room.inMemoryDatabaseBuilder()) + + @AfterTest + fun closeDb() = db.close() + + private val chain = Chain.Regtest + + private fun privateKey(seed: Long): PrivateKey = PrivateKey(ByteVector32(Hex.decode(seed.toString(16).padStart(64, '0')))) + + private val parent = keyMaterial("9a9e") + private val group = keyMaterial("6a0b") + private val groupRoom = roomOf(group) + + private val member = privateKey(0x3e3be7) + private val memberPublicKey = member.xOnlyPublicKey().value.toHex() + + private val destination = "bcrt1qw508d6qejxtdg4y5r3zarvary0c5xw7kygt080" + + private suspend fun certifiedWallet(): MemberWallet { + signingRoom(db, group, members = listOf(memberPublicKey), holdsShare = false) + fileKeyState(db, group, guardedCertificate(parent, group)) + val wallet = MemberWalletManager.request(db, groupRoom, member, chain, label = null) + val template = MemberWalletCertificateEvent.template(Event.fromJson(wallet.requestJson)) + val signed = signedAsRoom(group, template.kind, template.tags, template.content, template.createdAt) + db.groupSignedEventDao().upsert(GroupSignedEvent.fromEvent(signed, chatRoomId = groupRoom, derivationPath = SharedKeyDerivation.formatPath(GroupFixtures.path), frostSigningSessionId = null)) + return wallet + } + + /** [account]'s wallet with one coin of [sats] at receive address [index], and an unused change address. */ + private fun stateWith(account: GroupWalletDerivation.Account, index: Int = 0, sats: Long = 80_000): GroupWalletState { + val derived = GroupWalletDerivation.derive(account, GroupWalletDerivation.RECEIVE, index.toLong()) + val funding = Transaction(2, listOf(TxIn(OutPoint(TxId(ByteVector32(ByteArray(32) { 7 })), 0), ByteVector.empty, 0xffffffffL)), listOf(TxOut(Satoshi(sats), derived.pubkeyScript)), 0) + val meta = WalletState.AddressMeta.Derived(index) + val receive = WalletState(mapOf(derived.address(chain) to WalletState.AddressState(meta, true, listOf(WalletState.Utxo(funding.txid, 0, 100, funding, meta))))) + val change = WalletState( + mapOf(GroupWalletDerivation.derive(account, GroupWalletDerivation.CHANGE, 0).address(chain) to WalletState.AddressState(WalletState.AddressMeta.Derived(0), false, emptyList())) + ) + return GroupWalletState(account, receive, change, tipHeight = 110) + } + + @Test + fun `a member signs alone, and the network would take it`(): Unit = runBlocking { + val wallet = certifiedWallet() + val account = assertNotNull(MemberWalletManager.walletOf(db, memberPublicKey, wallet.walletId)).account + val built = assertIs(GroupSpendBuilder.send(stateWith(account), destination, Satoshi(30_000), 3L, emptySet())) + + val signed = MemberWalletManager.signSpend(db, memberPublicKey, wallet.walletId, built.psbt, at = Instant.fromEpochSeconds(1_700_000_000)) + + val checked = assertIs(GroupSpend.check(built.psbt, account)).checked + signed.correctlySpends(checked.inputs.associate { it.outPoint to it.txOut }, ScriptFlags.STANDARD_SCRIPT_VERIFY_FLAGS) + signed.txIn.forEach { assertEquals(1, it.witness.stack.size, "the key path: the tree stays hidden") } + + val spend = assertNotNull(db.memberWalletDao().getSpend(signed.txid.toString())) + assertEquals(wallet.walletId, spend.walletId) + assertNull(spend.seenAt) + + MemberWalletManager.recordChain(db, spend.txid, confirmations = 0, at = Instant.fromEpochSeconds(1_700_000_100)) + assertEquals(Instant.fromEpochSeconds(1_700_000_100), db.memberWalletDao().getSpend(spend.txid)?.seenAt) + assertNull(db.memberWalletDao().getSpend(spend.txid)?.confirmedAt) + MemberWalletManager.recordChain(db, spend.txid, confirmations = 2, at = Instant.fromEpochSeconds(1_700_000_700)) + assertEquals(Instant.fromEpochSeconds(1_700_000_700), db.memberWalletDao().getSpend(spend.txid)?.confirmedAt) + assertEquals(Instant.fromEpochSeconds(1_700_000_100), db.memberWalletDao().getSpend(spend.txid)?.seenAt, "first seen stays first seen") + } + + @Test + fun `a spend of another wallet's coins is refused`(): Unit = runBlocking { + val wallet = certifiedWallet() + val other = MemberWalletDerivation.account(privateKey(0xb0b).publicKey(), chain, emptyList()) + val built = assertIs(GroupSpendBuilder.sendAll(stateWith(other), destination, 3L, emptySet())) + assertFailsWith { MemberWalletManager.signSpend(db, memberPublicKey, wallet.walletId, built.psbt) } + assertEquals(emptyList(), db.memberWalletDao().getSpends(wallet.walletId)) + } + + @Test + fun `nothing is signed before a group certifies the wallet, or without its key`(): Unit = runBlocking { + signingRoom(db, group, members = listOf(memberPublicKey), holdsShare = false) + fileKeyState(db, group, guardedCertificate(parent, group)) + val asked = MemberWalletManager.request(db, groupRoom, member, chain, label = null) + val account = assertNotNull(MemberWalletManager.walletOf(db, memberPublicKey, asked.walletId)).account + val built = assertIs(GroupSpendBuilder.sendAll(stateWith(account), destination, 3L, emptySet())) + assertFailsWith { MemberWalletManager.signSpend(db, memberPublicKey, asked.walletId, built.psbt) } + + // Certified, and the key on another device. + val template = MemberWalletCertificateEvent.template(Event.fromJson(asked.requestJson)) + val signed = signedAsRoom(group, template.kind, template.tags, template.content, template.createdAt) + db.groupSignedEventDao().upsert(GroupSignedEvent.fromEvent(signed, chatRoomId = groupRoom, derivationPath = SharedKeyDerivation.formatPath(GroupFixtures.path), frostSigningSessionId = null)) + db.memberWalletDao().delete(asked.walletId) + assertFailsWith { MemberWalletManager.signSpend(db, memberPublicKey, asked.walletId, built.psbt) } + } +}