From 2b44ebcbbc21a7b7e019477af009ec6de84dac8b Mon Sep 17 00:00:00 2001 From: Kgothatso Ngako Date: Fri, 23 Oct 2026 15:40:43 +0200 Subject: [PATCH] feat(wallet): a subgroup's transcript names the guardian that spent from it (Phase 8) Whenever a guarded wallet's coins change, the wallet screen reads every used address's history off Electrum, recognises a guardian's leaf in the witness that spent a coin, and writes one transcript line per transaction saying which group above took how much -- the child's only notice, since nobody in its room signed it. Co-Authored-By: Claude Opus 5.5 --- .../compose/database/model/ChatMessage.kt | 8 ++ .../repository/DatabaseChatRepository.kt | 7 ++ .../bennu/compose/managers/GuardianManager.kt | 80 ++++++++++++++++ .../compose/repository/ChatRepository.kt | 8 ++ .../ui/view/model/GroupWalletViewModel.kt | 23 +++++ .../compose/wallet/GroupOnchainWallets.kt | 48 ++++++++++ .../managers/GuardianSigningJvmTest.kt | 38 ++++++++ .../bennu/compose/wallet/FakeElectrum.kt | 18 +++- .../wallet/GuardianSpendNoticeJvmTest.kt | 91 +++++++++++++++++++ 9 files changed, 320 insertions(+), 1 deletion(-) create mode 100644 composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/wallet/GuardianSpendNoticeJvmTest.kt diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/model/ChatMessage.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/model/ChatMessage.kt index e6a2c8be..8d442022 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/model/ChatMessage.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/model/ChatMessage.kt @@ -507,6 +507,13 @@ data class ChatMessage( */ const val TYPE_GUARDED_WALLET_SHARED = "guardedWalletShared" + /** + * One of this group's guardians spent from its guarded wallet through its + * leaf. Read off the chain by `GuardianManager.takenIn`, and the child's + * only notice of it: nobody in this room signed it. + */ + const val TYPE_GUARDIAN_SPEND = "guardianSpend" + val GROUP_IDENTITY_TYPES = setOf( TYPE_GROUP_PROFILE_SIGNED, TYPE_GROUP_RELAYS_SIGNED, @@ -516,6 +523,7 @@ data class ChatMessage( TYPE_GROUP_WALLET_OPENED, TYPE_GROUP_TRANSACTION_CONFIRMED, TYPE_GUARDED_WALLET_SHARED, + TYPE_GUARDIAN_SPEND, ) /** diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/repository/DatabaseChatRepository.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/repository/DatabaseChatRepository.kt index afbbe830..041a248c 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/repository/DatabaseChatRepository.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/repository/DatabaseChatRepository.kt @@ -230,6 +230,13 @@ class DatabaseChatRepository( 0 } + override suspend fun recordGuardianSpends(chatRoomId: String, taken: List): Int = try { + GuardianManager.recordTaken(database, chatRoomId, taken) + } catch (e: Throwable) { + logger.e("Error recording guardian spends from $chatRoomId's wallet", e) + 0 + } + override suspend fun groupSignedEvent(chatRoomId: String, id: HexKey): GroupSignedEvent? = try { database.groupSignedEventDao().getById(id)?.takeIf { it.chatRoomId == chatRoomId } } catch (e: Throwable) { diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/GuardianManager.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/GuardianManager.kt index a2ae3e63..fdd64988 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/GuardianManager.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/GuardianManager.kt @@ -2,6 +2,7 @@ package com.machankura.bennu.compose.managers import co.touchlab.kermit.Logger import com.machankura.bennu.compose.database.BennuDatabase +import com.machankura.bennu.compose.database.model.ChatMessage import com.machankura.bennu.compose.database.model.MarmotInnerEvent import com.machankura.bennu.compose.database.model.intermdiate.LocalChatRoom import com.machankura.bennu.compose.nostr.frost.GroupKeyStateEvent @@ -13,6 +14,12 @@ import com.vitorpamplona.quartz.nip01Core.core.Event import com.vitorpamplona.quartz.nip01Core.core.HexKey import com.vitorpamplona.quartz.nip01Core.crypto.EventHasher import fr.acinq.bitcoin.Chain +import fr.acinq.bitcoin.OutPoint +import fr.acinq.bitcoin.Satoshi +import fr.acinq.bitcoin.Transaction +import fr.acinq.bitcoin.TxId +import fr.acinq.bitcoin.TxOut +import fr.acinq.lightning.utils.sum import kotlin.time.Clock import kotlin.time.Instant @@ -233,6 +240,79 @@ object GuardianManager { return rooms.size } + /** Coins of a guarded wallet one of its guardians took, in one transaction. */ + data class Taken( + val txid: TxId, + val guardian: GuardianDerivation.Guardian, + val amount: Satoshi, + ) + + /** + * Which guardians of [account] took which of [coins] in [spending] -- one + * entry per guardian -- read off the witnesses alone. + * + * A guardian's input carries three things: a signature, a leaf, and the + * control block proving the leaf is in the address. The leaf is matched + * against the guardian leaves of the address the coin was at, so a leaf is + * named only by a guardian whose key it is; anything else -- the wallet's own + * key-path spend, a witness of another shape -- names nobody. + */ + fun takenIn( + spending: Transaction, + account: GroupWalletDerivation.Account, + coins: Map>, + ): List { + if (!account.isGuarded) return emptyList() + + return spending.txIn.mapNotNull { input -> + val (txOut, derivation) = coins[input.outPoint] ?: return@mapNotNull null + val stack = input.witness.stack.takeIf { it.size == 3 } ?: return@mapNotNull null + val leaves = GuardianDerivation.leaves(account.guardians, account.chain, account.account, derivation.change, derivation.index) + val position = leaves.indexOfFirst { it.script == stack[1] }.takeIf { it >= 0 } ?: return@mapNotNull null + account.guardians[position] to txOut.amount + } + .groupBy({ it.first }, { it.second }) + .map { (guardian, amounts) -> Taken(spending.txid, guardian, amounts.sum()) } + } + + /** + * Writes a transcript line in [chatRoomId] for each of [taken] it has no line + * for yet. Returns how many it wrote. + * + * The whole of the child's notice that an ancestor spent from its wallet -- + * there is no channel from the ancestor's room into this one -- so it is + * written by whichever device reads the chain first, and every device that + * reads it afterwards finds it already there. + */ + suspend fun recordTaken(database: BennuDatabase, chatRoomId: String, taken: List): Int { + val written = database.chatMessageDao().getChatMessagesByChatRoomId(chatRoomId) + .map { it.chatMessage } + .filter { it.messageType == ChatMessage.TYPE_GUARDIAN_SPEND } + .map { it.content } + + val fresh = taken.filter { spend -> written.none { it.contains(spend.txid.toString()) } } + fresh.forEach { spend -> + val name = database.chatRoomDao().findChatRoomById(spend.guardian.chatRoomId)?.chatRoom?.subject + ?.takeIf { it.isNotBlank() } + ?: "A group above this one" + database.chatMessageDao().upsert( + ChatMessage( + senderPublicKey = spend.guardian.chatRoomId, + isUserMessage = false, + giftWrapPayloadId = null, + marmotGroupEventId = null, + marmotInnerEventId = null, + chatRoomId = chatRoomId, + content = "$name took ${spend.amount.sat} sats from this wallet through its guardian leaf, " + + "in transaction ${spend.txid}.", + messageType = ChatMessage.TYPE_GUARDIAN_SPEND, + ) + ) + logger.i("${spend.guardian.chatRoomId} took ${spend.amount.sat} sats from $chatRoomId's guarded wallet in ${spend.txid}") + } + return fresh.size + } + /** * What a notice that arrived in [chatRoomId] says, for its transcript line -- * or null when it is not one this room can believe, which gets no line: a diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/repository/ChatRepository.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/repository/ChatRepository.kt index 6f4a9cae..8892ed81 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/repository/ChatRepository.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/repository/ChatRepository.kt @@ -137,6 +137,9 @@ interface ChatRepository { /** Tells the groups in [shareable] about its statement, as [userPublicKey]. Returns how many were told. */ suspend fun shareGuardedWallet(shareable: GuardianManager.Shareable, userPublicKey: HexKey): Int + /** Writes a transcript line for each guardian spend from this group's wallet it has none for yet. */ + suspend fun recordGuardianSpends(chatRoomId: String, taken: List): Int + /** * The kind:1s this group signed, newest first. * @@ -413,6 +416,11 @@ interface ChatRepository { userPublicKey: HexKey ): Int = 0 + override suspend fun recordGuardianSpends( + chatRoomId: String, + taken: List + ): Int = 0 + override suspend fun groupPosts(chatRoomId: String): List = emptyList() override suspend fun groupSignedEvent( diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/GroupWalletViewModel.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/GroupWalletViewModel.kt index 53aa94a9..8ead9bb5 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/GroupWalletViewModel.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/GroupWalletViewModel.kt @@ -13,6 +13,8 @@ import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.combine import kotlinx.coroutines.flow.flowOf import kotlinx.coroutines.flow.map +import kotlinx.coroutines.flow.distinctUntilChangedBy +import com.machankura.bennu.compose.managers.GroupWalletDerivation import androidx.compose.runtime.MutableState import androidx.compose.runtime.getValue import androidx.compose.runtime.mutableStateOf @@ -116,6 +118,7 @@ class GroupWalletViewModel( // state: any of them changing redraws the screen, and none may // overwrite another. val chainState = wallets?.walletFor(wallet.account)?.state ?: flowOf(null) + noticeGuardianSpends(wallet.account) watching = viewModelScope.launch(Dispatchers.IO) { combine( chainState, @@ -142,6 +145,26 @@ class GroupWalletViewModel( return combine(states) { it.toList() } } + private var noticing: Job? = null + + /** + * For a guarded wallet: each time its coins change, reads the chain for + * spends a guardian made from it and writes the transcript line for any that + * has none -- the group's only notice, since nobody in it signed them. + */ + private suspend fun noticeGuardianSpends(account: GroupWalletDerivation.Account) { + val wallets = wallets ?: return + if (!account.isGuarded) return + val onchain = wallets.walletFor(account) + + noticing?.cancel() + noticing = viewModelScope.launch(Dispatchers.IO) { + onchain.state + .distinctUntilChangedBy { state -> state.utxos.map { it.utxo.outPoint }.toSet() } + .collect { state -> chatRepository.recordGuardianSpends(chatRoomId, wallets.guardianSpends(state)) } + } + } + /** * Tells the groups above about [shareable]'s guarded wallet: one notice into * each of their rooms this device is in. What is told stays told, so the 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 bad97e3b..0e34b15e 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 @@ -1,6 +1,12 @@ package com.machankura.bennu.compose.wallet import com.machankura.bennu.compose.managers.GroupWalletDerivation +import com.machankura.bennu.compose.managers.GuardianManager +import fr.acinq.bitcoin.Crypto +import fr.acinq.bitcoin.OutPoint +import fr.acinq.bitcoin.Transaction +import fr.acinq.bitcoin.TxId +import fr.acinq.bitcoin.byteVector32 import fr.acinq.lightning.blockchain.electrum.IElectrumClient import fr.acinq.lightning.blockchain.fee.FeeratePerByte import kotlinx.coroutines.CoroutineScope @@ -42,6 +48,48 @@ class GroupOnchainWallets( suspend fun suggestedFeeratePerVbyte(): Long? = electrum.estimateFees(6)?.let { FeeratePerByte(it).feerate.sat }?.coerceAtLeast(1) + /** Transactions fetched for [guardianSpends], which never change once mined or seen. */ + private val transactions = mutableMapOf() + + /** + * Every spend a guardian of [state]'s account made from it, read off the + * history of each address the wallet has used. Empty for an unguarded + * account, and for whatever Electrum cannot answer right now -- the next look + * asks again. + * + * History rather than a watch on coins disappearing: a device asleep when the + * coin moved still finds it, since the chain keeps the record and nothing + * here has to have been running at the time. + */ + suspend fun guardianSpends(state: GroupWalletState): List { + val account = state.account + if (!account.isGuarded) return emptyList() + + val used = listOf(GroupWalletDerivation.RECEIVE to state.receive, GroupWalletDerivation.CHANGE to state.change) + .flatMap { (branch, wallet) -> + wallet.addresses.values.filter { it.alreadyUsed }.mapNotNull { address -> + address.meta.indexOrNull?.let { GroupWalletDerivation.derive(account, branch, it.toLong()) } + } + } + val ours = used.associateBy { it.pubkeyScript } + + val history = used.flatMap { derived -> + runCatching { electrum.getScriptHashHistory(Crypto.sha256(derived.pubkeyScript).byteVector32().reversed()) } + .getOrDefault(emptyList()) + .map { it.txid } + }.distinct().mapNotNull { txid -> transactionOf(txid) } + + val coins = history.flatMap { tx -> + tx.txOut.mapIndexedNotNull { index, out -> ours[out.publicKeyScript]?.let { OutPoint(tx, index.toLong()) to (out to it) } } + }.toMap() + + return history.flatMap { GuardianManager.takenIn(it, account, coins) } + } + + private suspend fun transactionOf(txid: TxId): Transaction? = + mutex.withLock { transactions[txid] } + ?: runCatching { electrum.getTx(txid) }.getOrNull()?.also { tx -> mutex.withLock { transactions[txid] = tx } } + suspend fun stop() = mutex.withLock { wallets.values.forEach { it.stop() } wallets.clear() diff --git a/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/GuardianSigningJvmTest.kt b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/GuardianSigningJvmTest.kt index d26f6c1d..bffa294e 100644 --- a/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/GuardianSigningJvmTest.kt +++ b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/GuardianSigningJvmTest.kt @@ -447,6 +447,44 @@ class GuardianSigningJvmTest { } } + @Test + fun `the child reads off the chain which guardian took its coins, and says so once`(): Unit = runBlocking { + val proposer = device(members[0], signerIndex = 0) + val other = device(members[1], signerIndex = 1) + val statement = guardedStatement() + tell(proposer, statement) + tell(other, statement) + + val guarded = assertNotNull(GuardianManager.guardedWalletFor(proposer.db, roomId, guardedChildRoomId, chain, 0)) + val funding = fundingOf(guarded.account) + val built = assertIs( + GroupSpendBuilder.sendAll(fundedState(guarded.account, funding, 100, 200), fr.acinq.bitcoin.Bitcoin.addressFromPublicKeyScript(chain.chainHash, elsewhere.toByteArray()).right!!, 2, emptySet(), guarded.spender()) + ) + val session = FrostSigningManager.proposeGuardianSpend(proposer.db, proposer.room, proposer.publicKey, built.psbt, guardedChildRoomId, chain) + pump(proposer, other) + FrostSigningManager.approve(other.db, other.room, session.id) + pump(proposer, other) + val signed = Transaction.read(assertNotNull(proposer.db.groupTransactionDao().getBySessionId(session.id)?.signedTransaction)) + + // What the child's device knows: its own coin, and the transaction that spent it. + val coins = mapOf(OutPoint(funding, 0) to (funding.txOut[0] to GroupWalletDerivation.derive(guarded.account, 0, 0))) + val taken = GuardianManager.takenIn(signed, guarded.account, coins) + assertEquals(listOf(GuardianManager.Taken(signed.txid, guarded.account.guardians[0], Satoshi(50_000))), taken) + + // The child's own key-path spend names nobody. + val ownSpend = signed.updateWitness(0, fr.acinq.bitcoin.ScriptWitness(listOf(ByteVector(ByteArray(64))))) + assertEquals(emptyList(), GuardianManager.takenIn(ownSpend, guarded.account, coins)) + + // The line, written once, in the child's room -- the ancestor's name from + // this device's own copy of its room. + proposer.db.chatRoomDao().upsert(ChatRoom(id = guardedChildRoomId, userPublicKey = proposer.publicKey, subject = "Translation team", description = null, mlsGroupState = "00")) + assertEquals(1, GuardianManager.recordTaken(proposer.db, guardedChildRoomId, taken)) + assertEquals(0, GuardianManager.recordTaken(proposer.db, guardedChildRoomId, taken), "a second reading of the chain writes nothing") + val line = proposer.db.chatMessageDao().getChatMessagesByChatRoomId(guardedChildRoomId).map { it.chatMessage } + .single { it.messageType == com.machankura.bennu.compose.database.model.ChatMessage.TYPE_GUARDIAN_SPEND } + assertTrue(line.content.startsWith("Council took 50000 sats from this wallet through its guardian leaf"), line.content) + } + @Test fun `a guardian's spend is refused for a wallet the room was not told about, or without the lock`(): Unit = runBlocking { val proposer = device(members[0], signerIndex = 0) diff --git a/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/wallet/FakeElectrum.kt b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/wallet/FakeElectrum.kt index f2d51fbe..83558bbc 100644 --- a/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/wallet/FakeElectrum.kt +++ b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/wallet/FakeElectrum.kt @@ -41,6 +41,9 @@ internal class FakeElectrum : IElectrumClient { /** How many transactions have touched each script: Electrum's status is over the history, not the unspents. */ private val history = mutableMapOf() + /** The transactions that touched each script, in order: what `get_history` answers. */ + private val historyTxs = mutableMapOf>() + private fun status(scriptHash: ByteVector32): String? = history[scriptHash]?.let { "used:$it" } /** Pays [script] in a fresh transaction, confirmed at [height] (0 for the mempool), and tells the wallet. */ @@ -55,6 +58,7 @@ internal class FakeElectrum : IElectrumClient { val hash = scriptHash(script) unspents[hash] = unspents[hash].orEmpty() + UnspentItem(tx.txid, 0, amount.sat, height) history[hash] = (history[hash] ?: 0) + 1 + historyTxs[hash] = historyTxs[hash].orEmpty() + tx.txid notifications.emit(ScriptHashSubscriptionResponse(hash, status(hash))) } @@ -66,6 +70,17 @@ internal class FakeElectrum : IElectrumClient { notifications.emit(ScriptHashSubscriptionResponse(hash, status(hash))) } + /** The transaction paying [script] most recently, as [pay] made it. */ + fun fundingOf(script: ByteVector): Transaction = txs.getValue(historyTxs.getValue(scriptHash(script)).last()) + + /** Spends what [script] holds with [tx] itself, which joins its history as a real spend would. */ + suspend fun spendWith(script: ByteVector, tx: Transaction) { + val hash = scriptHash(script) + txs[tx.txid] = tx + historyTxs[hash] = historyTxs[hash].orEmpty() + tx.txid + spend(script) + } + override suspend fun startScriptHashSubscription(scriptHash: ByteVector32): ScriptHashSubscriptionResponse { subscribed += scriptHash return ScriptHashSubscriptionResponse(scriptHash, status(scriptHash)) @@ -76,7 +91,8 @@ internal class FakeElectrum : IElectrumClient { override suspend fun getHeader(blockHeight: Int): BlockHeader? = null override suspend fun getHeaders(startHeight: Int, count: Int): List = emptyList() override suspend fun getMerkle(txId: TxId, blockHeight: Int, contextOpt: Transaction?): GetMerkleResponse? = null - override suspend fun getScriptHashHistory(scriptHash: ByteVector32): List = emptyList() + override suspend fun getScriptHashHistory(scriptHash: ByteVector32): List = + historyTxs[scriptHash].orEmpty().map { TransactionHistoryItem(100, it) } override suspend fun broadcastTransaction(tx: Transaction): TxId = tx.txid override suspend fun estimateFees(confirmations: Int): FeeratePerKw? = null override suspend fun startHeaderSubscription() = HeaderSubscriptionResponse(0, Block.RegtestGenesisBlock.header) diff --git a/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/wallet/GuardianSpendNoticeJvmTest.kt b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/wallet/GuardianSpendNoticeJvmTest.kt new file mode 100644 index 00000000..6ef16c35 --- /dev/null +++ b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/wallet/GuardianSpendNoticeJvmTest.kt @@ -0,0 +1,91 @@ +package com.machankura.bennu.compose.wallet + +import com.machankura.bennu.compose.managers.GroupWalletDerivation +import com.machankura.bennu.compose.managers.GuardianDerivation +import com.machankura.bennu.compose.managers.GuardianManager +import com.machankura.bennu.compose.managers.SharedKeyDerivation +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.Script +import fr.acinq.bitcoin.ScriptWitness +import fr.acinq.bitcoin.Transaction +import fr.acinq.bitcoin.TxIn +import fr.acinq.bitcoin.TxOut +import fr.acinq.lightning.blockchain.electrum.WalletState +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.SupervisorJob +import kotlinx.coroutines.cancel +import kotlinx.coroutines.runBlocking +import kotlin.test.AfterTest +import kotlin.test.Test +import kotlin.test.assertEquals + +/** + * A guarded wallet reading its own history for spends its guardians made -- + * the child's only notice of one, since nobody in its room signed it. + * + * The witnesses here are the right shape and carry no valid signature: what is + * under test is which leaf a spend used, which the chain records whether or not + * anybody checks the signature again. `GuardianSigningJvmTest` spends for real. + */ +class GuardianSpendNoticeJvmTest { + private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default) + + @AfterTest + fun stop() = scope.cancel() + + private fun key(seed: Int): String = PrivateKey(ByteVector32(ByteArray(32) { seed.toByte() })).publicKey().toString() + + private val chain = Chain.Regtest + private val parentRoom = SharedKeyDerivation.marmotGroupId(key(1)) + private val childKey = key(2) + private val childRoom = SharedKeyDerivation.marmotGroupId(childKey) + private val grant = GuardianDerivation.grant(key(1), parentRoom, emptyList(), childRoom) + private val account = GroupWalletDerivation.account(childKey, chain, guardians = grant) + private val coin = GroupWalletDerivation.derive(account, GroupWalletDerivation.RECEIVE, 0) + private val elsewhere = ByteVector(Script.write(Script.pay2wpkh(PrivateKey(ByteVector32(ByteArray(32) { 9 })).publicKey()))) + + /** The wallet after its one coin has been spent: the address used, nothing left on it. */ + private val spentState = GroupWalletState( + account, + WalletState(mapOf(coin.address(chain) to WalletState.AddressState(WalletState.AddressMeta.Derived(0), alreadyUsed = true, utxos = emptyList()))), + WalletState(emptyMap()), + tipHeight = 200, + ) + + private fun spending(funding: Transaction, witness: ScriptWitness) = Transaction( + 2, listOf(TxIn(OutPoint(funding, 0), ByteVector.empty, GuardianDerivation.ANCESTOR_DELAY, witness)), + listOf(TxOut(Satoshi(49_000), elsewhere)), 0, + ) + + @Test + fun `a spend through the parent's leaf is read off the address's history`(): Unit = runBlocking { + val electrum = FakeElectrum() + electrum.pay(coin.pubkeyScript, Satoshi(50_000)) + val funding = electrum.fundingOf(coin.pubkeyScript) + val leaf = GuardianDerivation.leaves(grant, chain, 0, coin.change, coin.index)[0] + val taken = spending(funding, Script.witnessScriptPathPay2tr(coin.internalKey, leaf, ScriptWitness(listOf(ByteVector(ByteArray(64)))), coin.tree!!)) + electrum.spendWith(coin.pubkeyScript, taken) + + val wallets = GroupOnchainWallets(electrum, scope) + assertEquals( + listOf(GuardianManager.Taken(taken.txid, grant[0], Satoshi(50_000))), + wallets.guardianSpends(spentState), + ) + } + + @Test + fun `the group's own key-path spend names no guardian`(): Unit = runBlocking { + val electrum = FakeElectrum() + electrum.pay(coin.pubkeyScript, Satoshi(50_000)) + val own = spending(electrum.fundingOf(coin.pubkeyScript), Script.witnessKeyPathPay2tr(fr.acinq.bitcoin.ByteVector64.Zeroes)) + electrum.spendWith(coin.pubkeyScript, own) + + assertEquals(emptyList(), GroupOnchainWallets(electrum, scope).guardianSpends(spentState)) + } +}