diff --git a/composeApp/src/commonMain/composeResources/values/strings.xml b/composeApp/src/commonMain/composeResources/values/strings.xml index 52c5e968..449eecf8 100644 --- a/composeApp/src/commonMain/composeResources/values/strings.xml +++ b/composeApp/src/commonMain/composeResources/values/strings.xml @@ -473,6 +473,11 @@ Spend from %1$s's guarded wallet Wallets of groups below this one. This group can spend a coin in them once it has %1$d confirmations. %1$s sats within this group's reach + Fund %1$s's guarded wallet + To + This group can spend these coins again once they have %1$d confirmations. + Finding an address in %1$s's wallet… + Wait for this group's open payments to %1$s to confirm. Tell the groups above Not yet shared with the groups above that you're in Share @@ -525,6 +530,7 @@ Fee rate in sats per byte Ask the group to send Sends %1$s sats, with a fee of %2$s sats. + Sends %1$s sats to %2$s's guarded wallet, with a fee of %3$s sats. %1$s sats come back to the group as change. That isn't an address on %1$s. The group has nothing confirmed to spend yet. diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/GroupSendScreen.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/GroupSendScreen.kt index 4df3ce63..d089fed7 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/GroupSendScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/GroupSendScreen.kt @@ -1,6 +1,17 @@ package com.machankura.bennu.compose.ui.composable import bennu.composeapp.generated.resources.while_the_wallet_is_new_at_most_s_sats +import androidx.compose.material3.OutlinedCard +import androidx.compose.ui.text.font.FontFamily +import bennu.composeapp.generated.resources.address_s +import bennu.composeapp.generated.resources.finding_an_address_in_s_s_wallet +import bennu.composeapp.generated.resources.fund_s_s_guarded_wallet +import bennu.composeapp.generated.resources.sends_s_sats_to_s_s_guarded_wallet_with_a_fee_of_s_sats +import bennu.composeapp.generated.resources.this_group_can_spend_these_coins_again +import bennu.composeapp.generated.resources.to +import bennu.composeapp.generated.resources.wait_for_this_group_s_open_payments_to_s +import com.machankura.bennu.compose.managers.GuardianDerivation +import com.machankura.bennu.compose.ui.view.state.FundingTarget import androidx.compose.foundation.selection.toggleable import androidx.compose.material3.minimumInteractiveComponentSize import androidx.compose.ui.semantics.Role @@ -112,6 +123,7 @@ fun GroupSendScreen( frostSigningRepository: FrostSigningRepository, wallets: GroupOnchainWallets?, guardedChatRoomId: String? = null, + fundChatRoomId: String? = null, onNavigateToRouteAndPopUpInclusive: (Route) -> Unit, onNavigateBack: () -> Unit, ) { @@ -125,6 +137,7 @@ fun GroupSendScreen( frostSigningRepository = frostSigningRepository, wallets = wallets, guardedChatRoomId = guardedChatRoomId, + fundChatRoomId = fundChatRoomId, ) ) @@ -141,11 +154,17 @@ fun GroupSendScreen( TopAppBar( title = { // Whose wallet is in the title: a guardian's spend takes a - // descendant's coins, and nothing else on the form says so. - val guardian = ((groupSendViewModel.groupSendUIState as? GroupSendUIState.Ready)?.spender as? GroupSpend.Spender.Guardian) + // descendant's coins, and nothing else on the form says so -- + // and a funding pays one, which the title says the same way. + val ready = groupSendViewModel.groupSendUIState as? GroupSendUIState.Ready + val guardian = ready?.spender as? GroupSpend.Spender.Guardian + val funded = ready?.funding?.wallet Text( - text = if (guardian == null) stringResource(Res.string.send_from_the_group_s_wallet) - else stringResource(Res.string.spend_from_s_s_guarded_wallet, guardian.name ?: stringResource(Res.string.a_subgroup)), + text = when { + guardian != null -> stringResource(Res.string.spend_from_s_s_guarded_wallet, guardian.name ?: stringResource(Res.string.a_subgroup)) + funded != null -> stringResource(Res.string.fund_s_s_guarded_wallet, funded.name ?: stringResource(Res.string.a_subgroup)) + else -> stringResource(Res.string.send_from_the_group_s_wallet) + }, maxLines = 1, overflow = TextOverflow.Ellipsis ) @@ -180,12 +199,17 @@ fun GroupSendScreen( // A problem with the amount is said on the amount field, beside what caused it. val amountProblem = preview?.takeIf { groupSendViewModel.isAboutTheAmount(it) } - OutlinedTextField( - modifier = Modifier.fillMaxWidth(), - state = groupSendViewModel.addressField, - lineLimits = TextFieldLineLimits.SingleLine, - label = { Text(stringResource(Res.string.address)) }, - ) + // A funding's destination is fixed, not typed: the title names + // the wallet, and an address field could make it pay another. + when (val funding = state.funding) { + null -> OutlinedTextField( + modifier = Modifier.fillMaxWidth(), + state = groupSendViewModel.addressField, + lineLimits = TextFieldLineLimits.SingleLine, + label = { Text(stringResource(Res.string.address)) }, + ) + else -> FundingDestination(funding) + } // The row is the target, so the label toggles too: one 48dp control with one name. Row( @@ -238,10 +262,13 @@ fun GroupSendScreen( ) // Still finding change is still finding coins: neither is anything to correct. + // A funded wallet's address not known yet is said on its card, not here. + val fundedName = state.funding?.wallet?.let { it.name ?: stringResource(Res.string.a_subgroup) } + val waitingOnFunding = state.funding != null && state.funding.address == null if (state.walletState == null || preview == GroupSpendBuilder.Result.FindingChange) { LoadingDataIndicator(fillScreen = false, text = stringResource(Res.string.finding_the_group_s_coins)) - } else if (amountProblem == null) { - preview?.let { SendPreview(it, chain) } + } else if (amountProblem == null && !waitingOnFunding) { + preview?.let { SendPreview(it, chain, fundedName) } } Text( @@ -279,13 +306,65 @@ fun GroupSendScreen( } } -/** What the form would build, or why it cannot. */ +/** + * Where a funding goes: the descendant's wallet, the address in it this send + * pays and its index, and what the group keeps over the coins once they land. + * While the address is not known yet, or every one is held, it says that instead. + */ @Composable -private fun SendPreview(result: GroupSpendBuilder.Result, chain: Chain) { +private fun FundingDestination(funding: FundingTarget) { + val name = funding.wallet.name ?: stringResource(Res.string.a_subgroup) + OutlinedCard(modifier = Modifier.fillMaxWidth()) { + Column( + modifier = Modifier.padding(MaterialTheme.spacing.containerPadding), + verticalArrangement = Arrangement.spacedBy(MaterialTheme.spacing.relatedGap), + ) { + Text(text = stringResource(Res.string.to), style = MaterialTheme.typography.labelMedium, color = MaterialTheme.colorScheme.onSurfaceVariant) + Text(text = stringResource(Res.string.fund_s_s_guarded_wallet, name), style = MaterialTheme.typography.titleMedium) + val address = funding.address + when { + address != null -> { + Text( + text = address.address, + style = MaterialTheme.typography.bodyMedium.copy(fontFamily = FontFamily.Monospace), + maxLines = 1, + overflow = TextOverflow.MiddleEllipsis, + ) + Text( + text = stringResource(Res.string.address_s, address.derivation.index.toString()), + style = MaterialTheme.typography.bodyMedium, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + funding.allHeld -> Text( + text = stringResource(Res.string.wait_for_this_group_s_open_payments_to_s, name), + style = MaterialTheme.typography.bodyMedium, + color = MaterialTheme.colorScheme.error, + ) + else -> LoadingDataIndicator(fillScreen = false, text = stringResource(Res.string.finding_an_address_in_s_s_wallet, name)) + } + // What funding a guarded wallet means for this group: the coins come + // back within its reach, through its leaf, after the lock. + Text( + text = stringResource(Res.string.this_group_can_spend_these_coins_again, GuardianDerivation.ANCESTOR_DELAY.toInt()), + style = MaterialTheme.typography.bodyMedium, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + } +} + +/** What the form would build, or why it cannot. [fundedName] names the wallet a funding pays. */ +@Composable +private fun SendPreview(result: GroupSpendBuilder.Result, chain: Chain, fundedName: String? = null) { when (result) { is GroupSpendBuilder.Result.Built -> Column(verticalArrangement = Arrangement.spacedBy(MaterialTheme.spacing.relatedGap)) { Text( - text = stringResource(Res.string.sends_s_sats_with_a_fee_of_s_sats, result.amount.grouped(), result.fee.grouped()), + text = if (result.funded != null && fundedName != null) { + stringResource(Res.string.sends_s_sats_to_s_s_guarded_wallet_with_a_fee_of_s_sats, result.amount.grouped(), fundedName, result.fee.grouped()) + } else { + stringResource(Res.string.sends_s_sats_with_a_fee_of_s_sats, result.amount.grouped(), result.fee.grouped()) + }, style = MaterialTheme.typography.bodyLarge, ) result.change?.let { change -> 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 7ea98d38..8d0a799c 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 @@ -1170,6 +1170,7 @@ fun BennuNavHost( frostSigningRepository = databaseFrostSigningRepository, wallets = groupOnchainWallets, guardedChatRoomId = route.guardedChatRoomId, + fundChatRoomId = route.fundChatRoomId, onNavigateToRouteAndPopUpInclusive = { signingRoute -> // Replace the form so back returns to the wallet rather // than to a spend that has already been proposed. diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/navigation/routes/GroupSendRoute.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/navigation/routes/GroupSendRoute.kt index b18b67d2..55d19763 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/navigation/routes/GroupSendRoute.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/navigation/routes/GroupSendRoute.kt @@ -6,6 +6,10 @@ import kotlinx.serialization.Serializable * The form a member proposes a spend from the group's wallet with -- or, with * [guardedChatRoomId], from that descendant's guarded wallet, through the * group's guardian leaf. + * + * [fundChatRoomId] is where the coins go instead of where they come from: the + * descendant whose guarded wallet a send from the group's own wallet pays. A + * route naming both is not one the form opens -- `docs/guarded-wallet-funding.md`, D6. */ @Serializable data class GroupSendRoute( @@ -13,4 +17,5 @@ data class GroupSendRoute( val chatRoomId: String, val relayHint: String?, val guardedChatRoomId: String? = null, + val fundChatRoomId: String? = null, ): Route() diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/GroupSendViewModel.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/GroupSendViewModel.kt index e3eb9088..97f983bb 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/GroupSendViewModel.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/GroupSendViewModel.kt @@ -20,6 +20,7 @@ import com.machankura.bennu.compose.repository.ChatRepository import com.machankura.bennu.compose.repository.FrostSigningRepository import com.machankura.bennu.compose.text.SatsInput import com.machankura.bennu.compose.text.parseSats +import com.machankura.bennu.compose.ui.view.state.FundingTarget import com.machankura.bennu.compose.ui.view.state.GroupSendUIState import com.machankura.bennu.compose.wallet.GroupOnchainWallets import com.machankura.bennu.compose.wallet.GroupSpendBuilder @@ -32,6 +33,7 @@ import kotlinx.coroutines.ExperimentalCoroutinesApi import kotlinx.coroutines.Job import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.combine +import kotlinx.coroutines.flow.flowOf import kotlinx.coroutines.flow.mapLatest import kotlinx.coroutines.launch import kotlinx.coroutines.withContext @@ -54,6 +56,8 @@ class GroupSendViewModel( private val wallets: GroupOnchainWallets?, /** The descendant whose guarded wallet this form spends from, or null for the room's own. */ val guardedChatRoomId: String? = null, + /** The descendant whose guarded wallet this form pays, or null for a payment to a typed address. */ + val fundChatRoomId: String? = null, ): ViewModel() { private val logger = Logger.withTag(TAG) @@ -77,20 +81,29 @@ class GroupSendViewModel( return@launch } + // Spending from one descendant's wallet into another's is a decision + // of its own, not one this form makes -- docs/guarded-wallet-funding.md, D6. + if (guardedChatRoomId != null && fundChatRoomId != null) { + groupSendUIState = GroupSendUIState.Unavailable + return@launch + } + // A descendant's guarded wallet, as this room was told it, with the // group as its guardian -- or the room's own wallet. - val guarded = guardedChatRoomId?.let { descendant -> - chatRepository.guardedWallets(chatRoomId).firstOrNull { - it.descendantChatRoomId.equals(descendant, ignoreCase = true) && it.chain == chain - } + val heldByRoom = if (guardedChatRoomId != null || fundChatRoomId != null) chatRepository.guardedWallets(chatRoomId) else emptyList() + fun held(descendant: String?) = descendant?.let { + heldByRoom.firstOrNull { wallet -> wallet.descendantChatRoomId.equals(it, ignoreCase = true) && wallet.chain == chain } } + val guarded = held(guardedChatRoomId) + // The wallet a send from the room's own pays, when it funds one. + val funded = held(fundChatRoomId) val wallet = when { guardedChatRoomId == null -> chatRepository.groupWallet(chatRoomId, chain) guarded == null -> null else -> GroupWallet(GroupSignedEvent.fromEvent(guarded.statement, chatRoomId = guarded.descendantChatRoomId), guarded.account) } val canSign = localChatRoom.chatRoom.mlsGroupState != null && chatRepository.canSign(chatRoomId) - if (wallet == null || !canSign || wallets == null) { + if (wallet == null || !canSign || wallets == null || (fundChatRoomId != null && funded == null)) { groupSendUIState = GroupSendUIState.Unavailable return@launch } @@ -102,6 +115,7 @@ class GroupSendViewModel( reserved = frostSigningRepository.reservedOutPoints(chatRoomId), reservedChange = frostSigningRepository.reservedChangeIndices(chatRoomId, wallet.account), spender = guarded?.spender() ?: GroupSpend.Spender.Owner, + funding = funded?.let { FundingTarget(it, walletState = null, reserved = frostSigningRepository.reservedFundingIndices(chatRoomId, it.account)) }, ) groupSendUIState = ready @@ -111,7 +125,7 @@ class GroupSendViewModel( } } - follow(ready, wallets.walletFor(wallet.account).state) + follow(ready, wallets.walletFor(wallet.account).state, funded?.let { wallets.walletFor(it.account).state }) } } @@ -126,18 +140,35 @@ class GroupSendViewModel( * One state from both, as the wallet screen does, so no frame shows new * coins against old reservations. Apart from [initiate] so that it can be * followed without an Electrum client. + * + * A send that funds a descendant's wallet follows [fundingState] too, and + * the addresses the room's open fundings hold: if the address it was going + * to pay is paid or taken while the form is open, the next one is shown. */ @OptIn(ExperimentalCoroutinesApi::class) - internal fun follow(ready: GroupSendUIState.Ready, chainState: Flow) { + internal fun follow( + ready: GroupSendUIState.Ready, + chainState: Flow, + fundingState: Flow? = null, + ) { val account = ready.wallet.account + val fundedAccount = ready.funding?.wallet?.account val reservations = frostSigningRepository.observeGroupTransactions(chatRoomId).mapLatest { - frostSigningRepository.reservedOutPoints(chatRoomId) to - frostSigningRepository.reservedChangeIndices(chatRoomId, account) + Triple( + frostSigningRepository.reservedOutPoints(chatRoomId), + frostSigningRepository.reservedChangeIndices(chatRoomId, account), + fundedAccount?.let { frostSigningRepository.reservedFundingIndices(chatRoomId, it) }.orEmpty(), + ) } watching?.cancel() watching = viewModelScope.launch(Dispatchers.IO) { - combine(chainState, reservations) { state, (reserved, reservedChange) -> - ready.copy(walletState = state, reserved = reserved, reservedChange = reservedChange) + combine(chainState, fundingState ?: flowOf(null), reservations) { state, funded, (reserved, reservedChange, reservedFunding) -> + ready.copy( + walletState = state, + reserved = reserved, + reservedChange = reservedChange, + funding = ready.funding?.copy(walletState = funded, reserved = reservedFunding), + ) }.collect { groupSendUIState = it } } } @@ -185,12 +216,17 @@ class GroupSendViewModel( } val feerate = feerateField.text.toString().trim().toLongOrNull()?.takeIf { it > 0 } ?: return null - val address = addressField.text.toString().trim().takeIf { it.isNotEmpty() } ?: return null + // A funding pays the address its target chose, never one typed: the + // title says whose wallet it is, and a typed one would make that a claim. + val destination = when (val funding = state.funding) { + null -> GroupSpendBuilder.Destination.Address(addressField.text.toString().trim().takeIf { it.isNotEmpty() } ?: return null) + else -> GroupSpendBuilder.Destination.Funding(funding.wallet.account, funding.address?.derivation ?: return null) + } val built = if (amount == null) { - GroupSpendBuilder.sendAll(walletState, address, feerate, state.reserved, state.spender) + GroupSpendBuilder.sendAll(walletState, destination, feerate, state.reserved, state.spender) } else { - GroupSpendBuilder.send(walletState, address, amount, feerate, state.reserved, state.reservedChange, state.spender) + GroupSpendBuilder.send(walletState, destination, amount, feerate, state.reserved, state.reservedChange, state.spender) } return GroupSpendBuilder.capped(built, GroupWalletRollout.capFor(chain)) } @@ -239,11 +275,12 @@ class GroupSendViewModel( frostSigningRepository: FrostSigningRepository, wallets: GroupOnchainWallets?, guardedChatRoomId: String? = null, + fundChatRoomId: String? = null, ): ViewModelProvider.Factory = viewModelFactory { initializer { GroupSendViewModel( activeUserPublicKey, chatRoomId, chain, initialGroupSendUIState, - chatRepository, frostSigningRepository, wallets, guardedChatRoomId, + chatRepository, frostSigningRepository, wallets, guardedChatRoomId, fundChatRoomId, ) } } diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/GroupSendUIState.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/GroupSendUIState.kt index b5b0969e..82dc3523 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/GroupSendUIState.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/GroupSendUIState.kt @@ -1,6 +1,8 @@ package com.machankura.bennu.compose.ui.view.state import com.machankura.bennu.compose.database.model.intermdiate.LocalChatRoom +import com.machankura.bennu.compose.managers.GuardianManager +import com.machankura.bennu.compose.wallet.GroupAddress import com.machankura.bennu.compose.nostr.wallet.GroupWallet import com.machankura.bennu.compose.wallet.GroupSpend import com.machankura.bennu.compose.wallet.GroupWalletState @@ -25,6 +27,8 @@ sealed interface GroupSendUIState { * the descendant's. */ val spender: GroupSpend.Spender = GroupSpend.Spender.Owner, + /** The descendant's guarded wallet this send pays, or null for a send to a typed address. */ + val funding: FundingTarget? = null, ): GroupSendUIState /** A room this device cannot propose from -- no wallet, no share, or no node. */ @@ -34,3 +38,21 @@ sealed interface GroupSendUIState { data object Loading: GroupSendUIState } + +/** + * A descendant's guarded wallet a send funds, with where it is up to: its chain + * state as this device watches it, and the receive indices the room's open + * fundings already hold. See `docs/guarded-wallet-funding.md`. + */ +data class FundingTarget( + val wallet: GuardianManager.GuardedWallet, + /** Null until Electrum has answered for the descendant's addresses. */ + val walletState: GroupWalletState?, + val reserved: Set = emptySet(), +) { + /** The address the send pays, moving on whenever the one before it is paid or held. */ + val address: GroupAddress? get() = walletState?.fundingAddress(reserved) + + /** Electrum has answered, and open fundings hold every address the wallet watches. */ + val allHeld: Boolean get() = walletState?.receiveAddress != null && address == null +} diff --git a/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/ui/view/model/GroupSendViewModelJvmTest.kt b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/ui/view/model/GroupSendViewModelJvmTest.kt index a7656d60..bd9cc020 100644 --- a/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/ui/view/model/GroupSendViewModelJvmTest.kt +++ b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/ui/view/model/GroupSendViewModelJvmTest.kt @@ -10,6 +10,9 @@ import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.flowOf import com.machankura.bennu.compose.database.model.intermdiate.LocalChatRoom import com.machankura.bennu.compose.managers.GroupWalletDerivation +import com.machankura.bennu.compose.managers.GuardianManager +import com.machankura.bennu.compose.ui.view.state.FundingTarget +import com.vitorpamplona.quartz.nip01Core.core.Event import com.machankura.bennu.compose.nostr.wallet.GroupWallet import com.machankura.bennu.compose.nostr.wallet.GroupWalletStatementEvent import com.machankura.bennu.compose.repository.ChatRepository @@ -180,9 +183,11 @@ class GroupSendViewModelJvmTest { val transactions = MutableStateFlow>(emptyList()) @Volatile var heldCoins: Set = emptySet() @Volatile var heldChange: Set = emptySet() + @Volatile var heldFunding: Set = emptySet() override fun observeGroupTransactions(chatRoomId: String): Flow> = transactions override suspend fun reservedOutPoints(chatRoomId: String): Set = heldCoins override suspend fun reservedChangeIndices(chatRoomId: String, account: GroupWalletDerivation.Account): Set = heldChange + override suspend fun reservedFundingIndices(chatRoomId: String, account: GroupWalletDerivation.Account): Set = heldFunding } /** Two confirmed coins, 60,000 and 40,000 sats, on the first two receive addresses. */ @@ -241,4 +246,115 @@ class GroupSendViewModelJvmTest { assertEquals(Satoshi(100_000), built.amount + built.fee) assertNull(built.change) } + + // ---- Funding a descendant's guarded wallet --------------------------------- + + private val descendantRoomId = "c".repeat(64) + private val descendant: GroupWalletDerivation.Account = GroupWalletDerivation.account( + PrivateKey(ByteVector32(Hex.decode("decaf".padStart(64, '0')))).publicKey().toString(), Chain.Regtest, + ) + private val guarded = GuardianManager.GuardedWallet( + ancestorChatRoomId = chatRoomId, + descendantChatRoomId = descendantRoomId, + statement = Event("1".repeat(64), descendantRoomId, 1_700_000_000, GroupWalletStatementEvent.KIND, emptyArray(), "", ""), + account = descendant, + certificate = Event("2".repeat(64), chatRoomId, 1_700_000_000, 0, arrayOf(arrayOf("name", "Savings")), "", ""), + lineage = listOf(descendantRoomId), + ) + + /** The descendant's receive branch as Electrum reports it: its first ten addresses watched, [paid] of them used. */ + private fun descendantState(paid: Set = emptySet()): GroupWalletState { + val receive = (0 until 10).associate { index -> + GroupWalletDerivation.derive(descendant, GroupWalletDerivation.RECEIVE, index.toLong()).address(Chain.Regtest) to + WalletState.AddressState(WalletState.AddressMeta.Derived(index), alreadyUsed = index in paid, utxos = emptyList()) + } + return GroupWalletState(descendant, WalletState(receive), WalletState.empty, tipHeight = 110) + } + + private fun fundingForm(signing: FrostSigningRepository, fundingState: Flow): GroupSendViewModel { + val ready = GroupSendUIState.Ready(localChatRoom, wallet, walletState = null, reserved = emptySet(), funding = FundingTarget(guarded, walletState = null)) + return viewModel(ready, signing = signing).apply { + follow(ready, flowOf(walletState), fundingState) + feerateField.setTextAndPlaceCursorAtEnd("4") + amountField.setTextAndPlaceCursorAtEnd("30,000") + } + } + + @Test + fun `a funding pays two past the descendant's current address, and says so in the PSBT`() { + val signing = RecordingSigning() + val model = fundingForm(signing, flowOf(descendantState())) + + val built = eventually { model.preview() as? GroupSpendBuilder.Result.Built } + assertEquals(2L, built.funded?.derived?.index) + assertEquals(GroupWalletDerivation.derive(descendant, GroupWalletDerivation.RECEIVE, 2).pubkeyScript, built.psbt.global.tx.txOut[0].publicKeyScript) + assertEquals(setOf(2L), GroupSpend.claimedFundingIndices(built.psbt, descendant)) + + // The address field plays no part: whatever is typed there, the funding goes where it goes. + model.addressField.setTextAndPlaceCursorAtEnd("bcrt1qw508d6qejxtdg4y5r3zarvary0c5xw7kygt080") + assertEquals(built.psbt, assertIs(model.preview()).psbt) + + model.propose(onSuccess = {}, onFailure = {}) + runBlocking { withTimeout(5_000) { while (signing.proposed == null) delay(10) } } + assertEquals(built.psbt, signing.proposed, "proposed as the room's own spend") + } + + @Test + fun `an open funding moves the next one on`() { + val signing = Reserving() + val model = fundingForm(signing, flowOf(descendantState())) + assertEquals(2L, eventually { (model.preview() as? GroupSpendBuilder.Result.Built)?.funded }.derived.index) + + signing.heldFunding = setOf(2L) + signing.transactions.value = listOf( + GroupTransaction(frostSigningSessionId = "theirs", chatRoomId = chatRoomId, chain = "regtest", account = 0, psbt = "", txid = "t".repeat(64)) + ) + assertEquals(3L, eventually { (model.preview() as? GroupSpendBuilder.Result.Built)?.funded?.takeIf { it.derived.index != 2L } }.derived.index) + } + + @Test + fun `a payment to the address while the form is open moves it on`() { + val chain = MutableStateFlow(descendantState()) + val model = fundingForm(RecordingSigning(), chain) + assertEquals(2L, eventually { (model.preview() as? GroupSpendBuilder.Result.Built)?.funded }.derived.index) + + chain.value = descendantState(paid = setOf(2)) + assertEquals(3L, eventually { (model.preview() as? GroupSpendBuilder.Result.Built)?.funded?.takeIf { it.derived.index != 2L } }.derived.index) + } + + @Test + fun `nothing is built while the descendant's addresses are not known, or every one is held`() { + val waiting = fundingForm(RecordingSigning(), flowOf(null)) + val state = eventually { (waiting.groupSendUIState as GroupSendUIState.Ready).takeIf { it.walletState != null } } + assertNull(waiting.preview()) + assertEquals(false, state.funding?.allHeld) + + val signing = Reserving().apply { heldFunding = (2L until 10L).toSet() } + val full = fundingForm(signing, flowOf(descendantState())) + val held = eventually { (full.groupSendUIState as GroupSendUIState.Ready).takeIf { it.funding?.walletState != null } } + assertEquals(true, held.funding?.allHeld) + assertNull(full.preview()) + } + + @Test + fun `a route naming a source and a destination is not opened, nor one funding a wallet the room does not hold`() { + var asked = 0 + val chat = object : ChatRepository by ChatRepository.NO_OP_CHAT_REPOSITORY { + override suspend fun getChatRoomByIdentifier(identifier: String) = localChatRoom + override suspend fun canSign(chatRoomId: String) = true + override suspend fun groupWallet(chatRoomId: String, chain: Chain) = wallet + override suspend fun guardedWallets(chatRoomId: String): List { asked++; return emptyList() } + } + val both = GroupSendViewModel("a".repeat(64), chatRoomId, Chain.Regtest, GroupSendUIState.Loading, chat, RecordingSigning(), wallets = null, + guardedChatRoomId = descendantRoomId, fundChatRoomId = descendantRoomId).apply { initiate() } + runBlocking { withTimeout(5_000) { while (both.groupSendUIState == GroupSendUIState.Loading) delay(10) } } + assertEquals(GroupSendUIState.Unavailable, both.groupSendUIState) + assertEquals(0, asked, "refused before either wallet is looked for") + + val unknown = GroupSendViewModel("a".repeat(64), chatRoomId, Chain.Regtest, GroupSendUIState.Loading, chat, RecordingSigning(), wallets = null, + fundChatRoomId = descendantRoomId).apply { initiate() } + runBlocking { withTimeout(5_000) { while (unknown.groupSendUIState == GroupSendUIState.Loading) delay(10) } } + assertEquals(GroupSendUIState.Unavailable, unknown.groupSendUIState) + assertEquals(1, asked) + } }