diff --git a/composeApp/src/commonMain/composeResources/values/strings.xml b/composeApp/src/commonMain/composeResources/values/strings.xml index 0eb11cab..64106570 100644 --- a/composeApp/src/commonMain/composeResources/values/strings.xml +++ b/composeApp/src/commonMain/composeResources/values/strings.xml @@ -657,6 +657,8 @@ Sats are whole numbers: there is nothing smaller than a sat to send. That is more sats than there will ever be. That isn't an amount in sats. + %1$s sats left over are too few to come back as change, and go to the fee. + The group has too many spends with change waiting for signatures. Wait for one to settle, or send everything. Couldn't ask the group to send. Sending needs a share of the group's key, and a wallet of your own on this profile to see the group's coins with. Nothing leaves the wallet until a quorum of members has seen this spend and signed it. diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/repository/DatabaseFrostSigningRepository.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/repository/DatabaseFrostSigningRepository.kt index 4b211f6b..d469f05b 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/repository/DatabaseFrostSigningRepository.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/repository/DatabaseFrostSigningRepository.kt @@ -21,6 +21,7 @@ import com.machankura.bennu.compose.database.model.intermdiate.FrostSignerTally import com.machankura.bennu.compose.database.model.intermdiate.LocalChatRoom import com.machankura.bennu.compose.database.model.intermdiate.LocalFrostSigningSession import com.machankura.bennu.compose.managers.FrostSigningManager +import com.machankura.bennu.compose.managers.GroupWalletDerivation import com.machankura.bennu.compose.nostr.dkg.DkgRitualEvents import com.machankura.bennu.compose.nostr.frost.FrostSigningEvents import com.machankura.bennu.compose.repository.FrostSigningRepository @@ -161,6 +162,13 @@ class DatabaseFrostSigningRepository( emptySet() } + override suspend fun reservedChangeIndices(chatRoomId: String, account: GroupWalletDerivation.Account): Set = try { + FrostSigningManager.reservedChangeIndices(database, chatRoomId, account) + } catch (e: Throwable) { + logger.e("Error reading the change addresses reserved in $chatRoomId", e) + emptySet() + } + override fun observeGroupTransactions(chatRoomId: String): Flow> = database.groupTransactionDao().observeByChatRoomId(chatRoomId) diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/FrostSigningManager.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/FrostSigningManager.kt index e0e43cf1..b56c419d 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/FrostSigningManager.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/FrostSigningManager.kt @@ -866,10 +866,30 @@ object FrostSigningManager { * the coins are still unspent as far as Electrum can say. */ suspend fun reservedOutPoints(database: BennuDatabase, chatRoomId: String): Set = + openSpends(database, chatRoomId) + .flatMap { psbt -> psbt.global.tx.txIn.map { it.outPoint } } + .toSet() + + /** + * The change addresses a room's open spends pay back to, under [account], + * which a new spend should not pay to as well. Held by the same sessions as + * [reservedOutPoints], for the same reason: until a spend is on chain, its + * change address reads as unused, and the next spend would pick it again. + */ + suspend fun reservedChangeIndices( + database: BennuDatabase, + chatRoomId: String, + account: GroupWalletDerivation.Account, + ): Set = + openSpends(database, chatRoomId) + .flatMap { GroupSpend.claimedChangeIndices(it, account) } + .toSet() + + /** The PSBT of every spend in the room whose session has not failed. */ + private suspend fun openSpends(database: BennuDatabase, chatRoomId: String): List = database.groupTransactionDao().getByChatRoomId(chatRoomId) .filter { database.frostSigningSessionDao().getSessionById(it.frostSigningSessionId)?.stage != FrostSigningStage.FAILED } - .flatMap { transaction -> GroupSpend.decode(transaction.psbt)?.global?.tx?.txIn?.map { it.outPoint }.orEmpty() } - .toSet() + .mapNotNull { GroupSpend.decode(it.psbt) } /** * A spend seen confirmed: recorded, and every other spend of the same coins diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/repository/FrostSigningRepository.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/repository/FrostSigningRepository.kt index 95b0df2c..34f0b0ef 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/repository/FrostSigningRepository.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/repository/FrostSigningRepository.kt @@ -1,6 +1,7 @@ package com.machankura.bennu.compose.repository import com.machankura.bennu.compose.database.model.GroupTransaction +import com.machankura.bennu.compose.managers.GroupWalletDerivation import com.machankura.bennu.compose.wallet.GroupSpend import fr.acinq.bitcoin.Chain import fr.acinq.bitcoin.OutPoint @@ -246,6 +247,9 @@ interface FrostSigningRepository { /** The coins the room's open spends are already spending. */ suspend fun reservedOutPoints(chatRoomId: String): Set + /** The change indices under [account] the room's open spends already pay back to. */ + suspend fun reservedChangeIndices(chatRoomId: String, account: GroupWalletDerivation.Account): Set + /** Every spend the room has proposed, newest first, as it moves from proposed to confirmed. */ fun observeGroupTransactions(chatRoomId: String): Flow> @@ -326,6 +330,7 @@ interface FrostSigningRepository { override suspend fun checkedSpend(sessionId: String): GroupSpend.Checked? = null override suspend fun reservedOutPoints(chatRoomId: String): Set = emptySet() + override suspend fun reservedChangeIndices(chatRoomId: String, account: GroupWalletDerivation.Account): Set = emptySet() override fun observeGroupTransactions(chatRoomId: String): Flow> = flowOf(emptyList()) 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 5bb5195c..934c81ae 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 @@ -57,6 +57,8 @@ import com.machankura.bennu.compose.nostr.wallet.GroupWalletStatementEvent import com.machankura.bennu.compose.repository.ChatRepository import com.machankura.bennu.compose.repository.FrostSigningRepository import bennu.composeapp.generated.resources.sats_are_whole_numbers +import bennu.composeapp.generated.resources.s_sats_left_over_go_to_the_fee +import bennu.composeapp.generated.resources.too_many_spends_are_open_with_change import bennu.composeapp.generated.resources.that_is_more_sats_than_there_will_ever_be import bennu.composeapp.generated.resources.that_isn_t_an_amount_in_sats import com.machankura.bennu.compose.text.GroupedSats @@ -208,12 +210,13 @@ fun GroupSendScreen( label = { Text(stringResource(Res.string.feerate_in_sats_per_byte)) }, ) - if (state.walletState == null) { - LoadingDataIndicator(fillScreen = false, text = stringResource(Res.string.finding_the_group_s_coins)) - } - + // Still finding change is still finding coins: neither is anything to correct. val preview = groupSendViewModel.preview() - preview?.let { SendPreview(it, chain) } + if (state.walletState == null || preview == GroupSpendBuilder.Result.FindingChange) { + LoadingDataIndicator(fillScreen = false, text = stringResource(Res.string.finding_the_group_s_coins)) + } else { + preview?.let { SendPreview(it, chain) } + } Text( text = stringResource(Res.string.nothing_leaves_until_a_quorum_signs), @@ -266,6 +269,13 @@ private fun SendPreview(result: GroupSpendBuilder.Result, chain: Chain) { color = MaterialTheme.colorScheme.onSurfaceVariant, ) } + if (result.absorbed.sat > 0) { + Text( + text = stringResource(Res.string.s_sats_left_over_go_to_the_fee, result.absorbed.grouped()), + style = MaterialTheme.typography.bodyMedium, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } } else -> Text( @@ -274,6 +284,7 @@ private fun SendPreview(result: GroupSpendBuilder.Result, chain: Chain) { stringResource(Res.string.that_isn_t_an_address_on_s, GroupWalletStatementEvent.chainName(chain)) GroupSpendBuilder.Result.NothingToSpend -> stringResource(Res.string.the_group_has_nothing_confirmed_to_spend) GroupSpendBuilder.Result.NotEnough -> stringResource(Res.string.the_group_doesn_t_have_that_much_confirmed) + GroupSpendBuilder.Result.TooManyOpen -> stringResource(Res.string.too_many_spends_are_open_with_change) is GroupSpendBuilder.Result.OverCap -> stringResource(Res.string.while_the_wallet_is_new_at_most_s_sats, result.cap.grouped()) is GroupSpendBuilder.Result.InvalidAmount -> when (result.input) { SatsInput.NotWhole -> stringResource(Res.string.sats_are_whole_numbers) 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 b77982c1..8ea223bd 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 @@ -78,6 +78,7 @@ class GroupSendViewModel( wallet = wallet, walletState = null, reserved = frostSigningRepository.reservedOutPoints(chatRoomId), + reservedChange = frostSigningRepository.reservedChangeIndices(chatRoomId, wallet.account), ) groupSendUIState = ready @@ -123,7 +124,7 @@ class GroupSendViewModel( val built = if (amount == null) { GroupSpendBuilder.sendAll(walletState, address, feerate, state.reserved) } else { - GroupSpendBuilder.send(walletState, address, amount, feerate, state.reserved) + GroupSpendBuilder.send(walletState, address, amount, feerate, state.reserved, state.reservedChange) } return GroupSpendBuilder.capped(built, GroupWalletRollout.capFor(chain)) } 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 b1736a00..6b2fef1a 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 @@ -16,6 +16,8 @@ sealed interface GroupSendUIState { val walletState: GroupWalletState?, /** The coins open spends already hold, which a new one leaves alone. */ val reserved: Set, + /** The change indices open spends already pay back to, which a new one pays past. */ + val reservedChange: Set = emptySet(), ): GroupSendUIState /** A room this device cannot propose from -- no wallet, no share, or no node. */ diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/wallet/GroupOnchainWallet.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/wallet/GroupOnchainWallet.kt index f728c5e0..766023ca 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/wallet/GroupOnchainWallet.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/wallet/GroupOnchainWallet.kt @@ -87,8 +87,13 @@ class GroupOnchainWallet( */ const val RECEIVE_LOOKAHEAD: UInt = 10u - /** Change addresses are only ever chosen by a spend, one at a time. */ - const val CHANGE_LOOKAHEAD: UInt = 3u + /** + * Change addresses watched, counting the first unused one. Each open + * spend with change holds one until it confirms, and several members + * can each have one open, so this is how many such spends a group can + * have at once before the next is told to wait. + */ + const val CHANGE_LOOKAHEAD: UInt = 10u } } @@ -140,8 +145,22 @@ data class GroupWalletState( */ val receiveAddress: String? get() = receive.firstUnusedDerivedAddress?.first - /** The change index a spend should pay back to, or null until Electrum has answered. */ - val nextChangeIndex: Long? get() = change.firstUnusedDerivedAddress?.second?.index?.toLong() + /** Whether Electrum has answered for any change address yet: before it has, there is no next one to name. */ + val changeKnown: Boolean get() = change.addresses.values.any { !it.alreadyUsed } + + /** + * The change index a spend should pay back to: the lowest this wallet + * watches that is unused and not in [reserved] -- the indices open spends + * already pay to. Null when there is none: before Electrum has answered, + * or when open spends hold every one inside the watched window, past which + * change would land on an address nobody is watching. + */ + fun nextChangeIndex(reserved: Set = emptySet()): Long? = + change.addresses.values + .filterNot { it.alreadyUsed } + .mapNotNull { it.meta.indexOrNull?.toLong() } + .filterNot { it in reserved } + .minOrNull() /** How many confirmations [utxo] has: 0 in the mempool, and 0 until the tip is known. */ fun confirmations(utxo: GroupUtxo): Int { diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/wallet/GroupSpend.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/wallet/GroupSpend.kt index 3d4c7219..f27490c5 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/wallet/GroupSpend.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/wallet/GroupSpend.kt @@ -194,6 +194,20 @@ object GroupSpend { return Result.Ok(Checked(account = account, psbt = psbt, inputs = inputs, outputs = outputs, fee = fee, weight = weight)) } + /** + * The change indices under [account] that [psbt]'s outputs claim: what an + * open spend holds, so the next one pays its change somewhere else. Claims, + * not checked derivations -- a spend this device would refuse still keeps + * its index from being handed out twice, and holding one too many costs + * nothing. + */ + fun claimedChangeIndices(psbt: Psbt, account: GroupWalletDerivation.Account): Set = + psbt.outputs + .flatMap { it.taprootDerivationPaths.values } + .filter { it.masterKeyFingerprint == account.fingerprint } + .mapNotNull { path -> path.keyPath.path.takeIf { it.size == 2 && it[0] == GroupWalletDerivation.CHANGE }?.get(1) } + .toSet() + /** * The one derivation under [account] a PSBT field names, or null when it names * none, several, or one this wallet will not walk. diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/wallet/GroupSpendBuilder.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/wallet/GroupSpendBuilder.kt index f0e3babf..b27368cc 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/wallet/GroupSpendBuilder.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/wallet/GroupSpendBuilder.kt @@ -28,9 +28,20 @@ object GroupSpendBuilder { val DUST: Satoshi = Satoshi(546) sealed interface Result { - data class Built(val psbt: Psbt, val amount: Satoshi, val fee: Satoshi, val change: Satoshi?) : Result + data class Built( + val psbt: Psbt, + val amount: Satoshi, + val fee: Satoshi, + val change: Satoshi?, + /** What [fee] holds beyond the feerate: change too small to send back, paid to the miner instead. */ + val absorbed: Satoshi = Satoshi(0), + ) : Result data object NotAnAddress : Result data object NothingToSpend : Result + /** Electrum has not yet said which change addresses are used, so there is none to name. */ + data object FindingChange : Result + /** Open spends already pay change to every change address the wallet watches. */ + data object TooManyOpen : Result data object NotEnough : Result data object BelowDust : Result /** A bump has to pay more than the spend it replaces. */ @@ -65,7 +76,8 @@ object GroupSpendBuilder { /** * [amount] to [address], largest coins first, with what is left over paid - * back to the next change address -- or to fees, when it would be dust. + * back to the next change address no open spend holds -- or to fees, when + * it would be dust. */ fun send( state: GroupWalletState, @@ -73,14 +85,16 @@ object GroupSpendBuilder { amount: Satoshi, feeratePerVbyte: Long, reserved: Set, + reservedChange: Set = emptySet(), ): Result { val script = scriptOf(state, address) ?: return Result.NotAnAddress if (amount < DUST) return Result.BelowDust - val changeIndex = state.nextChangeIndex ?: return Result.NothingToSpend - val change = GroupWalletDerivation.derive(state.account, GroupWalletDerivation.CHANGE, changeIndex) - val coins = spendable(state, reserved).sortedByDescending { it.amount.sat }.ifEmpty { return Result.NothingToSpend } + if (!state.changeKnown) return Result.FindingChange + val changeIndex = state.nextChangeIndex(reservedChange) ?: return Result.TooManyOpen + val change = GroupWalletDerivation.derive(state.account, GroupWalletDerivation.CHANGE, changeIndex) + val chosen = mutableListOf() for (coin in coins) { chosen += coin @@ -97,7 +111,10 @@ object GroupSpendBuilder { val withoutChange = feeOf(chosen, listOf(script), feeratePerVbyte) if (total - amount >= withoutChange) { val tx = transaction(chosen, listOf(TxOut(amount, script))) - return Result.Built(psbtOf(state, tx, chosen, emptyMap()), amount, total - amount, change = null) + return Result.Built( + psbtOf(state, tx, chosen, emptyMap()), amount, total - amount, change = null, + absorbed = total - amount - withoutChange, + ) } } return Result.NotEnough diff --git a/composeApp/src/commonTest/kotlin/com/machankura/bennu/compose/wallet/GroupSpendBuilderTest.kt b/composeApp/src/commonTest/kotlin/com/machankura/bennu/compose/wallet/GroupSpendBuilderTest.kt index 6431d0f7..d7dcd885 100644 --- a/composeApp/src/commonTest/kotlin/com/machankura/bennu/compose/wallet/GroupSpendBuilderTest.kt +++ b/composeApp/src/commonTest/kotlin/com/machankura/bennu/compose/wallet/GroupSpendBuilderTest.kt @@ -46,9 +46,12 @@ class GroupSpendBuilderTest { ) } - private fun state(vararg coins: Pair): GroupWalletState { - val unusedChange = GroupWalletDerivation.derive(account, GroupWalletDerivation.CHANGE, 0) - val change = WalletState(mapOf(unusedChange.address(Chain.Regtest) to WalletState.AddressState(WalletState.AddressMeta.Derived(0), false, emptyList()))) + /** [coins] on the receive branch, and [changeWindow] unused change addresses watched -- none, before Electrum has answered. */ + private fun state(vararg coins: Pair, changeWindow: Int = 1): GroupWalletState { + val change = WalletState((0 until changeWindow).associate { index -> + GroupWalletDerivation.derive(account, GroupWalletDerivation.CHANGE, index.toLong()).address(Chain.Regtest) to + WalletState.AddressState(WalletState.AddressMeta.Derived(index), false, emptyList()) + }) return GroupWalletState(account, WalletState(coins.toMap()), change, tipHeight = 110) } @@ -92,14 +95,54 @@ class GroupSpendBuilderTest { assertEquals(GroupWalletDerivation.CHANGE, change.change!!.change) assertEquals(built.change, change.txOut.amount) assertEquals(Satoshi(30_000), spend.amountSent) + assertEquals(Satoshi(0), built.absorbed, "with change, the fee is the feerate's and nothing more") + } + + @Test + fun `change goes past the addresses open spends already pay to`() { + val result = GroupSpendBuilder.send( + state(coin(0, 60_000), changeWindow = 3), destination, Satoshi(30_000), feerate, emptySet(), reservedChange = setOf(0L), + ) + val built = assertIs(result) + + assertEquals(1L, checked(result).outputs.single { it.isChange }.change!!.index) + assertEquals(setOf(1L), GroupSpend.claimedChangeIndices(built.psbt, account), "and the spend after it reads index 1 as held") + } + + @Test + fun `with every watched change address held, a spend with change waits`() { + val wallet = state(coin(0, 60_000), changeWindow = 2) + + assertIs( + GroupSpendBuilder.send(wallet, destination, Satoshi(30_000), feerate, emptySet(), reservedChange = setOf(0L, 1L)) + ) + assertIs( + GroupSpendBuilder.sendAll(wallet, destination, feerate, emptySet()), "send-all has no change to place" + ) + } + + @Test + fun `before the change branch has answered, the builder is finding change rather than empty-handed`() { + val wallet = state(coin(0, 60_000), changeWindow = 0) + + assertIs(GroupSpendBuilder.send(wallet, destination, Satoshi(30_000), feerate, emptySet())) + assertIs( + GroupSpendBuilder.send(state(changeWindow = 0), destination, Satoshi(30_000), feerate, emptySet()), + "no coins is no coins, whatever change is doing", + ) } @Test fun `change that would be dust goes to fees instead`() { - val spend = checked(GroupSpendBuilder.send(state(coin(0, 30_800)), destination, Satoshi(30_000), feerate, emptySet())) + val result = GroupSpendBuilder.send(state(coin(0, 30_800)), destination, Satoshi(30_000), feerate, emptySet()) + val spend = checked(result) assertTrue(spend.outputs.none { it.isChange }) assertEquals(Satoshi(800), spend.fee) + val atTheFeerate = Satoshi(feerate * ((spend.weight + 3) / 4)) + val absorbed = assertIs(result).absorbed + assertTrue(absorbed.sat > 0) + assertEquals(spend.fee, atTheFeerate + absorbed, "what the screen says went to the fee is all that did") } @Test diff --git a/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/GroupSpendSigningJvmTest.kt b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/GroupSpendSigningJvmTest.kt index dfc9fc3d..2b7e6b0a 100644 --- a/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/GroupSpendSigningJvmTest.kt +++ b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/GroupSpendSigningJvmTest.kt @@ -18,6 +18,9 @@ import com.machankura.bennu.compose.nostr.dkg.DkgRitualEvents import com.machankura.bennu.compose.nostr.frost.FrostSigningEvents import com.machankura.bennu.compose.nostr.wallet.GroupWalletStatementEvent import com.machankura.bennu.compose.wallet.GroupSpend +import com.machankura.bennu.compose.text.ProposedSpend +import com.machankura.bennu.compose.wallet.GroupSpendBuilder +import com.machankura.bennu.compose.wallet.GroupWalletState import com.vitorpamplona.quartz.nip01Core.core.Event import com.vitorpamplona.quartz.nip01Core.core.HexKey import com.vitorpamplona.quartz.nip01Core.crypto.EventHasher @@ -37,11 +40,13 @@ import fr.acinq.bitcoin.TxOut import fr.acinq.bitcoin.crypto.frost.Frost import fr.acinq.bitcoin.crypto.frost.KeyMaterial import fr.acinq.bitcoin.psbt.Psbt +import fr.acinq.lightning.blockchain.electrum.WalletState import kotlinx.coroutines.runBlocking import kotlin.random.Random import kotlin.test.AfterTest import kotlin.test.Test import kotlin.test.assertEquals +import kotlin.test.assertIs import kotlin.test.assertNotEquals import kotlin.test.assertNotNull import kotlin.test.assertNull @@ -352,9 +357,89 @@ class GroupSpendSigningJvmTest { val coins = setOf(OutPoint(funding, 0), OutPoint(funding, 1)) assertEquals(coins, FrostSigningManager.reservedOutPoints(other.db, roomId)) + assertEquals(setOf(0L), FrostSigningManager.reservedChangeIndices(other.db, roomId, account), "and its change address") // Abandoned however it was -- the stage is all the reservation reads. other.db.frostSigningSessionDao().upsert(other.session(session.id)!!.copy(stage = FrostSigningStage.FAILED)) assertEquals(emptySet(), FrostSigningManager.reservedOutPoints(other.db, roomId), "a failed spend releases its coins") + assertEquals(emptySet(), FrostSigningManager.reservedChangeIndices(other.db, roomId, account), "and its change address") + } + + /** The wallet as Electrum would report it holding [funding], with [changeWindow] change addresses watched and unused. */ + private fun fundedState(changeWindow: Int = 3): GroupWalletState { + fun derived(branch: Long, index: Int) = GroupWalletDerivation.derive(account, branch, index.toLong()) + val receive = listOf(first, second).mapIndexed { index, derivation -> + val meta = WalletState.AddressMeta.Derived(index) + derivation.address(chain) to WalletState.AddressState( + meta, alreadyUsed = true, utxos = listOf(WalletState.Utxo(funding.txid, index, 100, funding, meta)), + ) + }.toMap() + val change = (0 until changeWindow).associate { index -> + derived(GroupWalletDerivation.CHANGE, index).address(chain) to + WalletState.AddressState(WalletState.AddressMeta.Derived(index), alreadyUsed = false, utxos = emptyList()) + } + return GroupWalletState(account, WalletState(receive), WalletState(change), tipHeight = 110) + } + + @Test + fun `an amount the form built is signed by the group, its change is the group's on every device, and it comes back`() = runBlocking { + val proposer = device(members[0], signerIndex = 0) + val other = device(members[1], signerIndex = 1) + openWallet(proposer, other) + + // A first spend is open and holds change index 0, so the form pays past it. + FrostSigningManager.proposeSpend(proposer.db, proposer.room, proposer.publicKey, psbt(), chain) + pump(proposer, other) + val heldChange = FrostSigningManager.reservedChangeIndices(proposer.db, roomId, account) + assertEquals(setOf(0L), heldChange) + + // The second spends coins the first does not hold: a fresh funding of its own. + val more = Transaction( + 2, listOf(TxIn(OutPoint(TxId(ByteVector32(ByteArray(32) { 0x43 })), 0), ByteVector.empty, 0xffffffffL)), + listOf(TxOut(Satoshi(80_000), first.pubkeyScript)), 0, + ) + val wallet = fundedState().let { state -> + val meta = WalletState.AddressMeta.Derived(0) + val receive = state.receive.addresses + (first.address(chain) to WalletState.AddressState( + meta, alreadyUsed = true, utxos = listOf(WalletState.Utxo(more.txid, 0, 100, more, meta)), + )) + state.copy(receive = WalletState(receive)) + } + val reserved = FrostSigningManager.reservedOutPoints(proposer.db, roomId) + val built = assertIs( + GroupSpendBuilder.send(wallet, ProposedSpend.addressOf(elsewhere, chain), Satoshi(30_000), 3, reserved, heldChange) + ) + + val session = FrostSigningManager.proposeSpend(proposer.db, proposer.room, proposer.publicKey, built.psbt, chain) + pump(proposer, other) + FrostSigningManager.approve(other.db, other.room, session.id) + pump(proposer, other) + + // On the device that did not build it: the change derives, so it is change. + val seen = assertNotNull(FrostSigningManager.checkedSpend(other.db, session.id)) + val changeOutput = seen.outputs.single { it.isChange } + assertEquals(1L, changeOutput.change!!.index, "past the index the open spend holds") + assertEquals(built.change, changeOutput.txOut.amount) + assertEquals(Satoshi(30_000), seen.amountSent) + assertEquals(setOf(0L, 1L), FrostSigningManager.reservedChangeIndices(other.db, roomId, account)) + + listOf(proposer, other).forEach { device -> + assertEquals(FrostSigningStage.COMPLETE, device.session(session.id)?.stage) + val signed = Transaction.read(assertNotNull(device.transaction(session.id)?.signedTransaction)) + signed.correctlySpends(mapOf(OutPoint(more, 0) to more.txOut[0]), ScriptFlags.STANDARD_SCRIPT_VERIFY_FLAGS) + } + + // Confirmed, the change is a coin the wallet counts, on the branch it watches. + val signed = Transaction.read(other.transaction(session.id)!!.signedTransaction!!) + val changeMeta = WalletState.AddressMeta.Derived(1) + val changeAddress = changeOutput.change!!.address(chain) + val after = wallet.copy( + receive = WalletState(wallet.receive.addresses - first.address(chain)), + change = WalletState(wallet.change.addresses + (changeAddress to WalletState.AddressState( + changeMeta, alreadyUsed = true, utxos = listOf(WalletState.Utxo(signed.txid, changeOutput.index, 111, signed, changeMeta)), + ))), + ) + assertEquals(changeOutput.change, after.derivationOf(changeOutput.txOut.publicKeyScript)) + assertEquals(Satoshi(40_000) + built.change!!, after.confirmedBalance, "the second funding coin, and the change") } } diff --git a/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/wallet/GroupOnchainWalletJvmTest.kt b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/wallet/GroupOnchainWalletJvmTest.kt index 769eaec8..62627d0c 100644 --- a/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/wallet/GroupOnchainWalletJvmTest.kt +++ b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/wallet/GroupOnchainWalletJvmTest.kt @@ -124,10 +124,10 @@ class GroupOnchainWalletJvmTest { val electrum = FakeElectrum() val wallet = GroupOnchainWallet(account, electrum, scope) - eventually { wallet.state.first { it.nextChangeIndex == 0L } } + eventually { wallet.state.first { it.nextChangeIndex() == 0L } } eventually { electrum.pay(change(0).pubkeyScript, Satoshi(7_000), height = 0) } - val state = eventually { wallet.state.first { it.nextChangeIndex == 1L && it.receiveAddress != null } } + val state = eventually { wallet.state.first { it.nextChangeIndex() == 1L && it.receiveAddress != null } } assertEquals(Satoshi(7_000), state.pendingBalance, "in the mempool, so pending") assertEquals(Satoshi(0), state.confirmedBalance) assertEquals(receive(0).address(Chain.Regtest), state.receiveAddress, "a change address is never offered for receiving") @@ -172,4 +172,19 @@ class GroupOnchainWalletJvmTest { } assertTrue(FakeElectrum.scriptHash(receive(9).pubkeyScript) in electrum.subscribed) } + + @Test + fun `every change address an open spend can be given is one the wallet watches`() { + val electrum = FakeElectrum() + val wallet = GroupOnchainWallet(account, electrum, scope) + val lookAhead = GroupOnchainWallet.CHANGE_LOOKAHEAD.toLong() + + val state = eventually { wallet.state.first { it.change.addresses.size == lookAhead.toInt() } } + assertTrue(FakeElectrum.scriptHash(change(lookAhead - 1).pubkeyScript) in electrum.subscribed) + + // Each open spend holds the next; the one after the last has nowhere watched to go. + val held = (0 until lookAhead).toSet() + assertEquals(lookAhead - 1, state.nextChangeIndex(held - (lookAhead - 1))) + assertEquals(null, state.nextChangeIndex(held)) + } } diff --git a/docs/group-send-an-amount.md b/docs/group-send-an-amount.md index d3286a9a..b31c6e0b 100644 --- a/docs/group-send-an-amount.md +++ b/docs/group-send-an-amount.md @@ -9,7 +9,7 @@ Read [group-chain-wallet.md](./group-chain-wallet.md) first, Phases 8 and 10 in particular. This plan is that note's third rollout gate, and it starts from the code as it stands at `96055da5`. -**Phase 1 built; Phases 2-7 not.** Written against `GroupSendScreen`, `GroupSendViewModel`, +**Phases 1 and 3 built; 2 and 4-7 not.** Written against `GroupSendScreen`, `GroupSendViewModel`, `GroupSpendBuilder`, `GroupSpend` and `GroupWalletRollout` as they are at that commit. @@ -188,62 +188,71 @@ removed it (Phase 6). ## Phase 3: change goes to an address the group can find -**One and a half days.** This fixes problems 3 and 4 above. It is the only phase -that touches the builder's choices, so it is the one that needs the most tests. +**One and a half days. Built.** This fixes problems 3 and 4 above, and the +silent dust in 5. It is the only phase that changes what the builder chooses. -- **Change indices are reserved like coins.** Next to - `FrostSigningManager.reservedOutPoints`, add `reservedChangeIndices(database, - chatRoomId): Set`. It decodes the PSBT of every `GroupTransaction` whose - session is not `FAILED`, and collects each output's change derivation. It - covers the same sessions as `reservedOutPoints`, for the same reason. Expose - it on `FrostSigningRepository`, and carry it on `GroupSendUIState.Ready` next - to `reserved`. -- **`GroupWalletState.nextChangeIndex(reserved: Set)`** returns the first - change index that is unused and not reserved. `GroupSpendBuilder.send` takes - that set and calls this. -- **Inside the watched window, or refused.** `CHANGE_LOOKAHEAD` is 3, and its - comment says *"change addresses are only ever chosen by a spend, one at a - time"*, which reservation makes untrue. The change wallet watches three - addresses past the first unused one. So a fifth open spend with change would - pay an address that Electrum is not watching. That is not a loss, because the - address derives, but the change would be missing from the balance until the - window moves. Two changes: - 1. raise `CHANGE_LOOKAHEAD` to 10, the same as receive, since several members - can now each hold an open spend with change; - 2. when the next free index is past the watched window, `send` returns a new - `Result.TooManyOpen`. The screen says to wait for an open spend to - settle, or to send everything. +- **Change indices are reserved like coins.** + `FrostSigningManager.reservedChangeIndices(database, chatRoomId, account)` + sits next to `reservedOutPoints`, and both read one private `openSpends`: + the PSBT of every `GroupTransaction` whose session has not `FAILED`. The + indices come from `GroupSpend.claimedChangeIndices`, which reads each + output's claimed path under the account's fingerprint. It reads *claims*, + not checked derivations, because holding an index too many costs nothing. + The account is a parameter because the plan's `(database, chatRoomId)` + signature could not tell one account's change from another's. The value is + exposed on `FrostSigningRepository` and carried on `GroupSendUIState.Ready` + as `reservedChange`. +- **`GroupWalletState.nextChangeIndex(reserved)`** is now a function. It + returns the lowest change index the wallet *watches* that is unused and not + reserved. The old `nextChangeIndex` property was the first unused index, and + `changeKnown` separates "no answer yet" from "all held". +- **The window, checked.** The plan read `CHANGE_LOOKAHEAD` as "watched past + the first unused address". `ElectrumMiniWallet.maybeGenerateNext` actually + keeps `lastDerived ≥ firstUnused + lookAhead − 1`, so `lookAhead` counts the + first unused address itself: at 3, three change addresses in all. Rather than + depend on that arithmetic, `nextChangeIndex` chooses only among the addresses + the wallet has actually generated, which is the watched set by definition. + So change can never be sent to an address nobody is watching, whatever the + look-ahead is. `CHANGE_LOOKAHEAD` is raised to 10, so a group can have ten + spends with change open at once. Past that, `send` returns `TooManyOpen`, + and the preview says to wait for one to settle or to send everything. + Send-all never needs a change address, so it is never refused this way. +- **Still finding is not nothing.** When there are no coins, the result is + `NothingToSpend` as before. When there are coins but no change address has + been answered for, the result is `FindingChange`, and the form shows the + *Finding the group's coins* indicator instead of an error. +- **Dust change is shown.** `Result.Built.absorbed` is what the fee holds beyond + the fee rate. It is zero for `sendAll`, for a build with change, and for a + bump. When it is positive, the preview adds *"N sats left over are too few + to come back as change, and go to the fee."* This line was meant for Phase 4, + but the new result cases meant `SendPreview` had to change in this phase, so + it went in now. - Check the window against `ElectrumMiniWallet`'s generator before trusting - either number. The wallet note's comment says the look-ahead counts past the - first *unused* address, and this phase depends on that being right. -- **The change branch not loaded yet is "still finding", not "nothing".** When - the change `WalletState` has no addresses yet, `send` returns a new - `Result.FindingChange`, and the form shows it with the same indicator as - `walletState == null` (*Finding the group's coins*), not as an error. -- **Dust change shows up in the preview.** Add `absorbed: Satoshi` to - `Result.Built`: what the build added to the fee because the change would have - been dust. It is zero for `sendAll`, for a build with change, and for a bump. +**Tests.** `GroupSpendBuilderTest` adds three: +- with index 0 held, change goes to 1, and the built PSBT claims 1; +- with every watched index held, the result is `TooManyOpen`, while send-all + still builds; +- with no change branch yet, the result is `FindingChange`, while no coins is + still `NothingToSpend`. -**Tests**, extending `GroupSpendBuilderTest`: +The dust test now asserts that `absorbed` plus the fee at the fee rate is the +fee. `GroupOnchainWalletJvmTest` asserts that the change window is +`CHANGE_LOOKAHEAD` addresses, all subscribed, and that holding all of them +leaves `null`. -- with change index 0 reserved, `send` pays change to index 1, and `GroupSpend.check` - labels it change; -- reserving every index in the watched window gives `TooManyOpen`; -- an empty change branch gives `FindingChange`, not `NothingToSpend`; -- the dust case's `absorbed` plus the fee at the rate equals its fee. +**The end-to-end case the removed gate was waiting for** is in +`GroupSpendSigningJvmTest`, not `GroupWalletSpendRoundTest` as planned: the +round test has no database or manager, and this case needs both. One spend is +left open, holding change index 0. Then `GroupSpendBuilder.send` builds a +second spend from a fresh coin, and two devices sign it to `COMPLETE`. The +test asserts: +- the device that did not build it labels index 1 as change; +- both devices' transactions pass `correctlySpends`; +- once confirmed, the change coin counts in `confirmedBalance`, and + `derivationOf` finds it. -And extending `GroupWalletSpendRoundTest` with **the end-to-end case the removed -gate was waiting for**: two devices, an amount with change, signed to `COMPLETE`. -Assert that the change output is labelled change on the device that did not -propose it, and that once the change coin is in the wallet state it counts in -`confirmedBalance`. That is the test version of "nobody reported a mislabelled -change output", and with no test-network release before mainnet, it is the -only version there is before the feature ships. - -`reservedChangeIndices` gets its own jvmTest next to whatever tests -`reservedOutPoints`. A `FAILED` session releases its index, and a `COMPLETE` -one keeps it until Electrum reports the address used. +The same file's reservation test now also asserts that a failed session +releases its change index. ---