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) }
+ }
+}