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