From 4c6cc9d1a0f34cfef0cc84306cdf844b7416183a Mon Sep 17 00:00:00 2001 From: Kgothatso Ngako Date: Sat, 24 Oct 2026 06:53:38 +0200 Subject: [PATCH 01/21] docs: plan a group funding a descendant's guarded wallet Co-Authored-By: Claude Opus 5.5 --- docs/README.md | 5 + docs/guarded-wallet-funding.md | 515 +++++++++++++++++++++++++++++++++ 2 files changed, 520 insertions(+) create mode 100644 docs/guarded-wallet-funding.md diff --git a/docs/README.md b/docs/README.md index 0b691620..192e7ccf 100644 --- a/docs/README.md +++ b/docs/README.md @@ -15,6 +15,7 @@ silent, or a decision that looked arbitrary and was not. | [group-send-an-amount.md](./group-send-an-amount.md) | sending an amount in sats from the group's wallet, with change — why the gate as written could never lift and is removed in favour of the mainnet cap, the decimal point the gated form multiplies by ten, and change addresses reserved like coins | | [group-wallet-guardians.md](./group-wallet-guardians.md) | letting an ancestor group spend from a subgroup's wallet through a taproot leaf — why the parent signs the guardian keys into the child's certificate, why every inherited key is derived one step further per child, and why every ancestor waits 12 blocks | | [subgroup-wallet-policy.md](./subgroup-wallet-policy.md) | the parent deciding, at a subgroup's birth, whether its wallet is guarded or unguarded — why the choice is signed three times, why *unguarded* means no keys in the certificate, why a guarded group's subgroups are all guarded, and why the rule is every honest client's rather than the chain's | +| [guarded-wallet-funding.md](./guarded-wallet-funding.md) | a group paying into a descendant's guarded wallet — why the address is the first unreserved one from `current + 2`, why the claim rides in the PSBT output's derivation and every signer rederives it, and how the guarded wallet row makes room for *Fund* beside *Spend* | | [group-wallet-addresses.md](./group-wallet-addresses.md) | listing the group wallet's receive addresses as Phoenix lists its swap-in ones — why the list stops at the current address plus two, why a paid address past that still shows, and why a used address can be copied but never shown as a QR code | | [frost-session-resend.md](./frost-session-resend.md) | asking the members who never got a signing proposal to look again — why a proposer can repeat only what it wrote, why a member's availability signal needs no repeating, and the one half that has to come from the silent member's own device | | [marmot-membership.md](./marmot-membership.md) | how members join an MLS group, and the epoch race that makes a missing member look like a successful invite | @@ -57,6 +58,10 @@ The subgroup-wallet-policy note is a phased plan that has been built. It reads as the guardians note's *whose choice it is* reversed: read that section, then this note's Phase 0, whose five decisions shape every phase after it, and its table of where the build chose differently before the code. +The guarded-wallet-funding note is a phased plan that has not been built. It +reads as the guardians note run the other way, coins in rather than out: read +that note and the address note's *Why `+ 2`* first, then its seven decisions +before its phases. The Material Design note is a phased plan that has not been built, and is the only one about what the app looks like rather than what it does; read the jvm-target note first if you want to know why its adaptive-layout phase exists. diff --git a/docs/guarded-wallet-funding.md b/docs/guarded-wallet-funding.md new file mode 100644 index 00000000..46a0ee3c --- /dev/null +++ b/docs/guarded-wallet-funding.md @@ -0,0 +1,515 @@ +# Funding a guarded wallet: a group paying into a descendant's wallet + +An ancestor group can already *take* from a descendant's guarded wallet. This +plan is about the other direction: **the group pays coins from its own wallet +into the descendant's guarded wallet, using an address its own devices derive +and every signer checks.** It is a send from the group's wallet with the +destination filled in, as the request guessed. What the request did not settle +is what that destination should be, how a signer can tell it is really the +descendant's address and not one the proposer typed, and how the guarded +wallet row on the wallet screen fits a second button. This plan answers those +three. + +Read [group-wallet-guardians.md](./group-wallet-guardians.md), +[group-send-an-amount.md](./group-send-an-amount.md) and +[group-wallet-addresses.md](./group-wallet-addresses.md) first. This plan uses +the forwarded statement from the first, the send form and its reservations from +the second, and the "current plus two" rule from the third. It changes no +format, no derivation and no schema. + +**Not built.** Written against the code as it stood at `8cb6f04e`, schema v29, +with the `lightning-kmp-app` submodule at `e0d2b82`. + +The headline: **the group already watches every guarded wallet below it, so its +devices already know which of that wallet's receive addresses are unused. A +funding spend pays the first unreserved address from `current + 2` upward, and +the PSBT output carries that address's derivation under the descendant's +account, the same field change already uses. Every signer derives that address +again from the forwarded statement it already holds, and then shows the spend as +*Fund Thandi's group's guarded wallet* rather than as a bare address. If the +derivation does not reach the address, the signer refuses the spend.** + +--- + +## What is already there + +Funding needs no new knowledge, because the ancestor already has it: + +| what funding needs | where it already is | +|---|---| +| the descendant's account xpub and script tree | the forwarded guarded statement, checked by `GuardianManager.verify` and listed by `guardedWalletsOf` | +| which of its receive addresses are used | `GroupWalletViewModel` already subscribes to `wallets.walletFor(guarded.account)` for every guarded row; `GroupWalletState.receiveAddresses` reads that state | +| coins to send, change, reservations, the mainnet cap | `GroupSendViewModel` and `GroupSpendBuilder`, unchanged for the room's own wallet | +| a place in the PSBT to say *this output is under that account at that index* | `taprootDerivationPaths` on an output, which `GroupSpend.psbtOf` already writes for change | +| a signer who rebuilds a claim rather than trusting it | `GroupSpend.check`, step 5: change is change only if it derives | + +So the work is: choosing the address, writing the claim, checking it, and +showing it. There is no protocol work. + +--- + +## Phase 0 — decisions, before any code + +Seven, each with a recommendation. The phases assume the recommended answer. + +### D1. Pre-fill the address field, or replace it? + +**Recommended: replace it with a fixed destination card.** The request guessed +"pre-fill the spend screen", and that is close. But an editable field that +starts with the descendant's address and can then be changed makes the title +(*Fund X's guarded wallet*) a claim the form cannot keep. A member who wants to +send somewhere else already has *Send*. In fund mode the form shows: + +``` +┌──────────────────────────────────────────────┐ +│ To Thandi's group's guarded wallet │ +│ bc1p8q…x7kd · address 5 │ +│ │ +│ This group can spend these coins again once │ +│ they have 12 confirmations. │ +└──────────────────────────────────────────────┘ + Send everything ( ) + Amount in sats [ ] sats + Feerate in sats per byte [ ] + Sends 50,000 sats to Thandi's group's + guarded wallet with a fee of 420 sats + [ Ask the group to send ] +``` + +The amount, feerate, send-everything and preview all work as they do now. + +### D2. Which address? + +**Recommended: the lowest index from `current + ADDRESSES_AHEAD` upward that no +open spend in this room already pays, and below `current + RECEIVE_LOOKAHEAD`.** + +- **Not `current`.** The child's own members are handing out `current` to their + own payers right now; that is the reason the address list exists. Every + device computes the same `current`, the ancestor's included, so funding to it + is the address-reuse hazard + [group-wallet-addresses.md](./group-wallet-addresses.md#the-bound) describes, + caused by an ancestor this time. +- **From `current + 2` upward.** The child's members start at `current` and go + up through the next two. Starting the ancestor at the top of that window and + going higher keeps the two sides out of each other's way. Only one index is + shared (`current + 2`), and only when a third child member is handing out + addresses at the same moment. +- **Reserved like change.** Until the funding confirms, its address still reads + as unused, so a second funding proposal would pick the same address. Open + spends' claimed funding indices are held exactly as + `reservedChangeIndices` holds change (Phase 3). +- **Bounded by the look-ahead.** The child watches `current … current + 9`. An + address past that would be paid and the child would not see it until its own + look-ahead caught up. With eight slots (`current + 2 … current + 9`), a + room with that many open fundings into one wallet is told to wait, the way + `TooManyOpen` already handles change. + +### D3. How does the proposal say where the money goes? + +**Recommended: in the PSBT, as the output's `tap_bip32_derivation` under the +descendant's account fingerprint, with no new nostr tag.** That is the field a +change output already carries, read with the same code, and it is where +[the guardian spend chose to put its claim](./group-wallet-guardians.md) +for the same reason: a second place to say it would be a second thing to +disagree. An old client's `check` sees a derivation whose fingerprint is not its +account's, treats the output as a plain payment, and shows the address, which is +the right thing for an old client to do. + +### D4. What does a signer do with the claim? + +**Recommended: one rule for each of three cases.** + +| the output's claim | the signer's device | result | +|---|---|---| +| a fingerprint of a guarded wallet it holds, at an index that derives to this output's script | shows *Fund X's guarded wallet* | signed as usual | +| a fingerprint of a guarded wallet it holds, at an index that does **not** derive to the script | refuses the proposal before it is shown | the same refusal step 5 gives a change claim that does not derive | +| a fingerprint it does not recognise (no forwarded statement on this device, or a wallet it never verified) | ignores the claim and shows the bare address | as today | + +The second row is what makes the label safe: no proposer can put a friendly +name on a payment to an address the descendant does not own. The third row +means a member who never got the forwarded statement still sees the truth, +just less of it. + +### D5. A rollout gate? + +**Recommended: none.** A funding spend is a send from the group's own wallet to +an address, and it is already held to `GroupWalletRollout.MAINNET_CAP`. A +mixed-version group loses nothing: old signers see a payment to an address, +which is exactly what it is. + +### D6. What can be funded, and from what? + +**Recommended: only guarded wallets of groups below this one that this room +holds a verified statement for, and only from the room's own wallet.** + +- Unguarded subgroups: no. Their statements are never forwarded upward, so the + ancestor has no xpub to derive an address from. *What is left* covers this. +- Siblings, ancestors, unrelated groups: no. There is no statement for them in + this room, and *Send* with a pasted address works. +- From a guarded wallet into another guarded wallet (a guardian moving coins + between two descendants): no. `GroupSendRoute` already uses + `guardedChatRoomId` to mean the *source*. A route naming both a source and a + destination is refused (Phase 4). Rebalancing is its own decision. + +### D7. Does the child learn who paid it? + +**Recommended: not in this plan.** The child sees a coin arrive at an address it +did not hand out, on its address list as *Paid · 50,000 sats*. Saying *from the +parent* means sending a notice down the hierarchy, which no flow does today. +Only a member who sits in both rooms could carry it, and the child could verify +only that the transaction pays its own address, not who funded it. *What is +left* has the shape of it. + +--- + +## Phase 1 — choosing the address, pure + +**Half a day, most of it tests.** + +In `wallet/GroupOnchainWallet.kt`, beside `receiveAddresses`: + +```kotlin +/** + * The receive address an ancestor pays when it funds this wallet: the lowest + * unused index from [GroupOnchainWallet.ADDRESSES_AHEAD] past the current one + * that [reserved] does not already hold, and that the wallet still watches -- + * or null before Electrum has answered, and when every such index is held. + * See `docs/guarded-wallet-funding.md`, D2. + */ +fun fundingAddress(reserved: Set): GroupAddress? +``` + +It reads the same `current` as `receiveAddresses`, so the two never disagree, +and it skips any index that is already `alreadyUsed` (the gap rule from the +address note: a watch-only wallet may have been paid above `current`). + +In `wallet/GroupSpend.kt`, beside `claimedChangeIndices`: + +```kotlin +/** The receive indices under [account] that [psbt]'s outputs claim to fund. Claims, not checks, as for change. */ +fun claimedFundingIndices(psbt: Psbt, account: GroupWalletDerivation.Account): Set +``` + +**Tests**, in `GroupOnchainWalletJvmTest` against `FakeElectrum`: + +- a fresh wallet funds `/0/2`; +- with `/0/2` reserved it funds `/0/3`; with `/0/2 … /0/9` reserved it returns null; +- paying `/0/0` moves the funding address to `/0/3`; +- a payment to `/0/4` while `/0/0` is current is skipped: `/0/2`, then `/0/3`, then `/0/5`; +- the address is null until Electrum has answered, as `receiveAddress` is; +- every index returned is one `receive.addresses` has generated. This fails if + the bound and the look-ahead ever drift apart. + +--- + +## Phase 2 — the builder writes the claim + +**Half a day.** + +`GroupSpendBuilder.send` and `sendAll` take a destination rather than an +address string: + +```kotlin +sealed interface Destination { + /** What the member typed: whatever it is, it is not the group's to vouch for. */ + data class Address(val address: String) : Destination + /** A descendant's guarded wallet, at the receive address Phase 1 chose. */ + data class Funding(val account: GroupWalletDerivation.Account, val derived: GroupWalletDerivation.Derived) : Destination +} +``` + +`Funding` pays `derived.pubkeyScript`, the guarded address with its tree. There +is no string round trip, so `NotAnAddress` cannot happen for it. +`GroupSpend.psbtOf` gains a `funding: Map>` beside +`change`, and writes each one with `pathOf(derived, descendantAccount)`. This +is the same call change uses, with the descendant's fingerprint instead of the +room's. `Built` gains `funded: Funding?` so the preview can say where it goes. + +**Tests**, in `commonTest` beside the builder's existing ones: + +- a funding output's derivation survives `Psbt.write` / `Psbt.read` with its + fingerprint intact, for a fingerprint whose top bit is set. This is the + unsigned-read bug the guardians note fixed, checked again on a new field; +- `GroupSpend.check` against the room's own account accepts the PSBT and lists + the funding output among `payments`, not as change; +- a `send` to a typed address builds exactly the PSBT it built before. + +--- + +## Phase 3 — every signer checks the claim, and says it + +**A day and a half.** This is the phase that makes the label safe, so it lands +before any button that produces one. + +**The check.** A pure function in `GroupSpend`, separate from `check` so that +`check` stays about the room's own account: + +```kotlin +data class Funding(val outputIndex: Int, val wallet: GuardianManager.GuardedWallet, val derived: GroupWalletDerivation.Derived) + +sealed interface FundingReading { + data class Ok(val fundings: List) : FundingReading + data class Refused(val reason: String) : FundingReading +} + +/** D4's three rows, over [checked]'s payments, against the guarded wallets this room holds. */ +fun fundingsOf(checked: Checked, guarded: List): FundingReading +``` + +Fingerprints are four bytes, so two held wallets can share one. Every wallet +with a matching fingerprint is tried, and the claim is refused only if none of +them derives to the script. + +**Where it runs:** + +- `FrostSigningManager.acceptSpendProposal`, straight after `GroupSpend.check`. + A `Refused` drops the proposal with the reason logged, as a failed `check` + does. Guardian spends (`spender is Guardian`) are checked too, since a + guardian could pay one descendant from another's coins once D6 is revisited. +- `FrostSigningManager.checkedSpend`, so the approval screen and the proposal + list read the same answer. `Checked` gains `fundings: List = + emptyList()`, filled here rather than in `check`. +- `FrostSigningManager.reservedFundingIndices(database, chatRoomId, account)`, + over `openSpends` like `reservedChangeIndices`, with a + `FrostSigningRepository` method for the form. + +**What it says.** `ProposedSpend.summarize` reads `spend.fundings`: + +| spend | label | detail | +|---|---|---| +| one payment, a funding | *Fund Thandi's group's guarded wallet* | *Send 50,000 sats to Thandi's group's guarded wallet, address 5* | +| several payments, one a funding | *Spend from the group's wallet* | *Send 70,000 sats to 2 addresses, 50,000 of them to Thandi's group's guarded wallet* | +| no funding | unchanged | unchanged | + +That one function feeds the signing screen, the room's proposal list +(`ProposalListViewModel`) and the wallet screen's *Spends* rows +(`SpendRowCard`), so all three change together. A name is the descendant's +certified name, `GuardedWallet.name`, falling back to *a subgroup* as the +guardian spend's label does. + +**Tests**, a jvmTest in the shape of `GuardianSpendRoundTest`, with a parent +and child ceremony and the child's statement forwarded: + +- a true claim is accepted and summarised as *Fund … guarded wallet*; +- a claim at the wrong index is refused at `acceptSpendProposal`, and no session + is written; +- the same PSBT read by a member whose device holds no forwarded statement is + accepted and shown as a bare address; +- an open funding's index is reserved, and a failed one's is released. + +--- + +## Phase 4 — the form in fund mode + +**A day.** + +**The route.** `GroupSendRoute` gains `fundChatRoomId: String? = null`: the +descendant whose guarded wallet this send pays. It is a second field, not a +second meaning for `guardedChatRoomId`, which names where coins come *from*. A +route with both set is `GroupSendUIState.Unavailable` (D6). + +**The view model.** `GroupSendViewModel.initiate` finds the guarded wallet the +same way it already does for a guardian spend +(`chatRepository.guardedWallets(chatRoomId)`, matched on room and chain). The +wallet being spent is still the room's own. `Ready` gains: + +```kotlin +/** The descendant's guarded wallet this send pays, with where it is up to -- or null for a send to a typed address. */ +val funding: FundingTarget? = null + +data class FundingTarget( + val wallet: GuardianManager.GuardedWallet, + val walletState: GroupWalletState?, + val reserved: Set, +) { + val address: GroupAddress? get() = walletState?.fundingAddress(reserved) +} +``` + +`follow` combines a third flow, `wallets.walletFor(guarded.account).state`, +with the two it already has, and re-reads `reservedFundingIndices` whenever +the room's transactions change. If somebody pays the chosen address while the +form is open, the next emission moves the destination to the next index, and +the preview follows. That is why the card shows the index: a member who sees it +change knows why. `preview()` builds with `Destination.Funding` when `funding` +is set, and returns null while its address is null. + +**The screen** (`GroupSendScreen`): + +- the title becomes *Fund %1$s's guarded wallet*, beside the existing guardian + title, for the same reason that one is there: the title is where the form says + whose money moves where; +- `OutlinedTextField(addressField)` is replaced by the destination card from + D1: an `OutlinedCard` with *To* in `labelMedium`, the wallet's name in + `titleMedium`, the address in the monospace style with + `TextOverflow.MiddleEllipsis` and *address %1$d*, and under it, in + `bodyMedium`/`onSurfaceVariant`, *This group can spend these coins again once + they have %1$d confirmations.* with `ANCESTOR_DELAY`. That sentence answers + the request's last question: what is worth saying while funding a guarded + wallet is that the money stays within the group's reach; +- while the address is null, a `LoadingDataIndicator(fillScreen = false)` with + *Finding an address in %1$s's wallet…* in the card's place, and a null address + once Electrum has answered (D2's eight slots all held) shows *Wait for this + group's open payments to %1$s to confirm* in `error`; +- `SendPreview` says *Sends %1$s sats to %2$s's guarded wallet with a fee of + %3$s sats* for a funding; +- the propose button is unchanged and calls `proposeSpend`, because this is the + room's own spend. + +**Tests**, in `GroupSendViewModelJvmTest`, with `follow` and the fake chain: + +- the preview builds to `/0/2` of the descendant's account, with the claim; +- an open funding at `/0/2` makes the next one go to `/0/3`; +- paying `/0/2` while the form is open moves it to `/0/3`; +- both `guardedChatRoomId` and `fundChatRoomId` set gives `Unavailable`. + +--- + +## Phase 5 — *Fund* on the wallet screen, without crowding the row + +**A day.** + +**Where the button goes.** On each row of the *Guarded wallets* section +(`guardianItems` in `GroupWalletScreen.kt`), next to *Spend*, as the request +asks. Today the row is a `ListItem` with *Spend* as a `TextButton` in +`trailingContent`. A second button there would squeeze the headline (the +group's name, already ellipsised), and at large text sizes the two buttons +would leave the name a few characters. So the actions move out of the trailing +slot and below the content, in the row's own card: + +``` + today after +┌─────────────────────────────────────┐ ┌─────────────────────────────────────┐ +│ ▣ Thandi's group's… [ Spend ] │ │ ▣ Thandi's group's savings │ +│ 12,000 sats within this group's… │ │ 12,000 sats within this group's │ +└─────────────────────────────────────┘ │ reach · 50,000 sats arriving │ + │ [ Fund ] [ Spend ]│ + └─────────────────────────────────────┘ +``` + +- **An `OutlinedCard` per guarded wallet**, holding the existing `ListItem` + (with no `trailingContent`) and then the actions. A card is how M3 groups + content with the actions that apply to it. With several wallets listed, a bare + row of buttons under each `ListItem` would leave it unclear which wallet a + button belongs to. +- **The actions in a `FlowRow`**, aligned to the end with + `Arrangement.spacedBy(MaterialTheme.spacing.targetGap, Alignment.End)`, so at + 200% text the two buttons wrap onto two lines instead of truncating. This is + `SpendRowCard`'s *Send again* / *Bump the fee* row, with wrapping added. + `FlowRow` is new to this codebase. It is in `foundation.layout`, and the audit + counts it as neither spacing nor a dimension. +- **Both `TextButton`s**, equal weight: neither is the obvious primary action + for every wallet, and a filled *Fund* would read as a recommendation. *Fund* + first and *Spend* second, so money in reads before money out. +- **Each button names its wallet to a screen reader.** Two rows of *Fund* / + *Spend* are four identical labels when read without the layout. Each gets + `Modifier.semantics { contentDescription = … }` with *Fund %1$s's guarded + wallet* / *Spend from %1$s's guarded wallet*. The second string already + exists. This fixes the *Spend* button as it is today too. +- **Each button has its own gate**, so a row can show either one alone. *Fund* + appears only in the `Loaded` state (the room has a wallet of its own to pay + from), behind `canSign && canWatch`, the same gates as the room's *Send*. + The `NotOpened` branch passes `onFund = null`, because a group with no wallet + has nothing to fund with. *Spend* keeps the gates it has. +- **What is arriving.** After a funding, `withinReach` stays the same for two + hours, which looks like the money vanished. `GuardedWalletRow` gains + `arriving: Satoshi?`: coins in the wallet with fewer than `ANCESTOR_DELAY` + confirmations. The supporting line adds *· %1$s sats arriving* when it is + non-zero. It counts every such coin, not only this group's funding. That is + true, and it is all the ancestor can know. + +`toGuardianFund` sits beside `toGuardianSpend` in `GroupWalletScreen` and +navigates to `GroupSendRoute(…, fundChatRoomId = row.wallet.descendantChatRoomId)`. + +**Strings**, sentence case, in the guardian block of `strings.xml`: `fund`, +`fund_s_s_guarded_wallet`, `to`, `address_d`, +`this_group_can_spend_these_coins_again_once_they_have_d_confirmations`, +`finding_an_address_in_s_s_wallet`, `wait_for_this_group_s_open_payments_to_s_to_confirm`, +`sends_s_sats_to_s_s_guarded_wallet_with_a_fee_of_s_sats`, `s_sats_arriving`. +Apostrophes are written plain, as `spend_from_s_s_guarded_wallet` is, because +Compose Resources does not unescape `\'`. + +**Tests**: a `GroupWalletViewModelJvmTest` case that `arriving` counts an +unconfirmed coin and drops it at 12 confirmations. The layout is checked by +`m3Audit`, which has to stay at 0 on every budget, and by looking at it at +compact width and at 200% text. + +--- + +## Phase 6 — the notes + +**An hour.** + +- This note becomes **Built**, with a table of where the build chose + differently. +- A row in [README.md](./README.md), and a sentence in its reading order after + the guardians and policy notes. +- [group-wallet-guardians.md](./group-wallet-guardians.md)'s *What this does not + do* says guardians cannot constrain where coins go. It gains a line pointing + here for the direction that is supported: coins coming in. +- [group-wallet-addresses.md](./group-wallet-addresses.md)'s *Why `+ 2`* gains a + sentence: an ancestor funding the wallet starts at the top of that window + and goes up. + +Each phase is one commit, checked with +`./gradlew :composeApp:m3Audit` and +`./gradlew :composeApp:compileDebugKotlinAndroid :composeApp:jvmTest`. Before +Phase 6's status line says built, a funding should be made by hand on signet +between two real devices, one in each room, and the child's address list +checked to show it at `current + 2`. + +--- + +## What this does not do + +**It does not fund an unguarded subgroup.** The parent has no xpub for it. The +child could forward its plain statement upward the way a guarded one is, but +that gives the parent a full view of a wallet whose point is that the parent +has no part in it, so it is a decision of its own. + +**It does not fund a subgroup that has not opened a wallet.** There is no +statement and so no address. The guarded row only exists once one is forwarded. + +**It does not tell the child who paid.** See D7. + +**It does not stop the child spending the coins at once.** Funding is a gift +into a wallet whose own quorum holds the key path. The 12-block delay is on the +ancestor's leaf, not the child's key. The destination card says what the +ancestor keeps (a way back after 12 confirmations), and it says nothing that +suggests the coins are locked for the child. + +**It does not make the address private from the child's members.** It is one of +the child's own addresses. They see the payment and its amount, and anyone in +both rooms can match it to the parent's spend. + +--- + +## What is left, when someone wants it + +- **A notice to the child.** A member in both rooms, on seeing a funding of this + room confirm, posts a transcript line in the child's room: *Parent group sent + 50,000 sats to this wallet*. The child's devices check that the transaction + pays one of their addresses, and attribute it to the member who posted it, + since the child cannot check that the parent sent it. This is the reverse of + the upward forwarding, and it needs the same overlap one level at a time. +- **Funding an unguarded child**, behind the decision in *What this does not do*. +- **Moving coins between two guarded descendants** in one guardian spend: a + source and a destination on one route, D6's third bullet. +- **A guarded wallet's own screen**, reached by tapping its card, with its + coins, its address list and both actions. The card's two buttons are enough + for now. A third action would be the time to build it. + +--- + +## Appendix — what was considered and rejected + +| idea | why not | +|---|---| +| pre-fill the address field and leave it editable | the label would be a claim the form cannot keep; *Send* is already there for any other address (D1) | +| fund `current` | it is the address the child's own members are handing out (D2) | +| a nostr tag `["funds", , ]` on the proposal | the PSBT already has a field for *this output is under that account*, read by code that exists; a second place would be a second thing to disagree (D3) | +| recognise a funding by scanning every payment against the descendant's addresses, with no claim | it costs a derivation per address per output per signer, it misses an address past the window, and it would quietly label a typed address that happens to be the child's. The claim states what the proposer meant, and the signer checks it | +| refuse a claim the signer cannot verify | it would make a funding unsignable by every member who missed the forwarded statement, for no safety gain: the bare address is the truth (D4) | +| *Fund* in an overflow menu on the row | it hides the one action this plan adds, behind an icon whose meaning nobody can guess; there are only two actions | +| *Fund* in the trailing slot beside *Spend* | the name, the only thing that says which wallet a row is, shrinks to a few characters at large text sizes | +| *Fund* as a filled button | neither action is the one every member wants; a filled button would be a recommendation the app cannot make | From 620cd438a8c3d160cff4ae109d6ca7ecd57ac651 Mon Sep 17 00:00:00 2001 From: Kgothatso Ngako Date: Sat, 24 Oct 2026 07:09:44 +0200 Subject: [PATCH 02/21] docs: plan a guarded wallet a group keeps for one member The member's device makes a random key, works out every ancestor leaf and both descriptors, and only then asks the group. The group's quorum signs a member wallet certificate of its own kind (30334) rather than a birth certificate, since every reader of 30329 assumes a room. Ancestors list the wallet as @name, and the group's page opens the member's profile. Co-Authored-By: Claude Opus 5.5 --- docs/README.md | 5 + docs/member-guarded-wallets.md | 943 +++++++++++++++++++++++++++++++++ 2 files changed, 948 insertions(+) create mode 100644 docs/member-guarded-wallets.md diff --git a/docs/README.md b/docs/README.md index 0b691620..03f314b8 100644 --- a/docs/README.md +++ b/docs/README.md @@ -15,6 +15,7 @@ silent, or a decision that looked arbitrary and was not. | [group-send-an-amount.md](./group-send-an-amount.md) | sending an amount in sats from the group's wallet, with change — why the gate as written could never lift and is removed in favour of the mainnet cap, the decimal point the gated form multiplies by ten, and change addresses reserved like coins | | [group-wallet-guardians.md](./group-wallet-guardians.md) | letting an ancestor group spend from a subgroup's wallet through a taproot leaf — why the parent signs the guardian keys into the child's certificate, why every inherited key is derived one step further per child, and why every ancestor waits 12 blocks | | [subgroup-wallet-policy.md](./subgroup-wallet-policy.md) | the parent deciding, at a subgroup's birth, whether its wallet is guarded or unguarded — why the choice is signed three times, why *unguarded* means no keys in the certificate, why a guarded group's subgroups are all guarded, and why the rule is every honest client's rather than the chain's | +| [member-guarded-wallets.md](./member-guarded-wallets.md) | a guarded wallet a group keeps for one member — why the member makes the key and the leaves before asking, why the group signs a certificate of its own kind rather than a birth certificate, and why a member's wallet shows as `@name` and opens their profile | | [group-wallet-addresses.md](./group-wallet-addresses.md) | listing the group wallet's receive addresses as Phoenix lists its swap-in ones — why the list stops at the current address plus two, why a paid address past that still shows, and why a used address can be copied but never shown as a QR code | | [frost-session-resend.md](./frost-session-resend.md) | asking the members who never got a signing proposal to look again — why a proposer can repeat only what it wrote, why a member's availability signal needs no repeating, and the one half that has to come from the silent member's own device | | [marmot-membership.md](./marmot-membership.md) | how members join an MLS group, and the epoch race that makes a missing member look like a successful invite | @@ -53,6 +54,10 @@ Phases 4 and 5 first, and its own table of where the build chose differently before the code. The group-wallet-guardians note is a phased plan that has been built; it assumes the subgroups and group-chain-wallet notes, and changes one sentence in each. +The member-guarded-wallets note is a phased plan that has not been built. It +takes the guardians note's derivation unchanged and gives the key path to one +person: read that note and the policy note's D2 first, then this note's table +of why a birth certificate will not do, and its Phase 0. The subgroup-wallet-policy note is a phased plan that has been built. It reads as the guardians note's *whose choice it is* reversed: read that section, then this note's Phase 0, whose five decisions shape every phase diff --git a/docs/member-guarded-wallets.md b/docs/member-guarded-wallets.md new file mode 100644 index 00000000..5e46a350 --- /dev/null +++ b/docs/member-guarded-wallets.md @@ -0,0 +1,943 @@ +# Member wallets: a guarded wallet a group keeps for one person + +Today a guarded wallet belongs to a group. A subgroup's quorum holds the key +path, and every ancestor holds a leaf that can take any coin 12 blocks after it +confirmed. This plan gives the same shape to **one member**. The key path is a +key only that member holds, and the leaves are the group's and the group's own +guardians', exactly as they would be for a guarded subgroup of that group. The +member spends alone, at any time, with one Schnorr signature. The group can step +in, and so can every group above it. + +**The member proposes it.** Their device generates a random private key, works +out every ancestor leaf, builds the descriptors, stores the key, and only then +puts a request into the group's room. The group's quorum checks all of it and +signs a **member wallet certificate**: the group's signature saying it guards +this key for this person. That certificate is what the member's device opens the +wallet on, what every guardian watches, and what is forwarded upward so the +groups above can find the coins. + +Read [subgroups.md](./subgroups.md), +[group-wallet-guardians.md](./group-wallet-guardians.md) and +[subgroup-wallet-policy.md](./subgroup-wallet-policy.md) first. This plan reuses +the guardian derivation from the second without changing it. It reuses the +grant, the leaf, the tree, the signing cache, the forwarding notice and the +guardian spend. What is new is who holds the key path, and the artefact the group +signs to agree to it. + +**Not built.** Written against the code as it stood at `8cb6f04e`, schema v29. + +--- + +## Should it be a birth certificate? + +The question this plan has to settle first. The answer is in two parts. + +**It needs a group-signed artefact, yes.** An ancestor believes a guarded wallet +only on signatures it can check itself. For a subgroup those are the parent's +signature on the certificate and the child's on the statement. A member wallet +needs the group's signature for the same reason: without it, the groups above +have only the forwarder's word that the group agreed to guard this key. + +**It must not be a 30329.** A `SubgroupBirthCertificateEvent` says *this room is +my child*, and every reader of that kind assumes there is a room: + +| reader | what it would do with a member's wallet in a 30329 | +|---|---| +| `SubgroupBirthCertificateEvent.certifies`, check 4 | requires `marmotGroupId(subgroup_key, frost_path) == content`. A wallet key is not a room, so the certificate either never verifies, or its content is set to the id that key *would* make, and then it is a room to everything below | +| `SubgroupManager.subgroupsOf`, `DatabaseDkgRepository`'s observer | lists every 30329 as a subgroup. The member's wallet would show in the parent's *Subgroups* section as *certified, not yet created*, forever, on every build, old ones included | +| `ChatMessage.applyInnerEvent`'s 30329 arm | writes a "subgroup was born" line in the transcript | +| `ProposedEvent.summaryOf`'s 30329 arm | asks the signers to approve "a subgroup, for Alice" | +| `SubgroupManager.refuseCertificate` | applies D4 of the policy note: a guarded group may only make guarded *subgroups*. That rule is about rooms, and its `name` and `p` tags are a founding roster that a wallet does not have | +| `GroupWalletStatementEvent.Reading.guardiansCheckOut` | expects the certificate to certify the room whose key signed the statement | +| `DkgRitualViewModel`'s `firstCarrying(30329)` | resumes a subgroup ceremony from the certificate it finds | + +So the member wallet certificate is **its own kind, 30334**. It shares the +guardian tags, the grant function and the forwarding notice with the subgroup +path, and none of the lineage meaning. Nothing that reads 30329 ever sees it. + +**How it shows on the group's pages**, as the question guessed: + +- On `ChatRoomDetailScreen` it is **not** a subgroup row. It gets a section of its + own, *Members' guarded wallets*, under *Subgroups*. A row there is a person, and + tapping it opens that person's profile (`ProfilePreviewRoute`), the same place + a tap on a member row already goes. It does not open a chat room, because there + is none. +- In the *Guarded wallets* list on an ancestor's wallet screen, a subgroup's + wallet stays `#groupName`. A member's wallet is `@username`. +- On the member's own profile, each wallet is named for the group that guards + it: *Guarded by #Ekklesia*. + +--- + +## The shape + +``` +k random 32 bytes, generated on the member's device never leaves it +P_W = k·G the wallet key +W = taggedHash("bennu/member-wallet/id/v1", serP(P_W)) the wallet's id: 32 bytes, nobody's key + +account = GroupWalletDerivation.account(P_W, chain, 0, grant) unchanged, P_W in place of a threshold key +grant = GuardianDerivation.grant(K_G, G, guardians(G), W) unchanged, W in place of a child room id +``` + +An address of the member's wallet, beside a guarded subgroup's: + +``` + guarded subgroup C of G member wallet W under G +key path account(K_C)/change/index account(P_W)/change/index +leaf 1 R_G / i(C) / n/a/change/index R_G / i(W) / n/a/change/index +leaf 2… g / i(C) / … for g in guardians(G), nearest first -- the same list, one step further for W +``` + +So a member's wallet under `G` is guarded **exactly as a guarded subgroup of `G` +would be**: the same ancestors, the same 12-block lock, the same caterpillar, and +the same descriptor shape, which Bitcoin Core imports. Every ancestor signs for +its leaf with the `GuardianDerivation.signingCache` it already uses, walking the +line of descent down to `W` instead of down to a room. + +### Why `W` is a hash and not the key + +A room id here *is* a public key, and `GroupKeyStateEvent.isSignedByRoom` asks +whether that key signed something. If `W` were `xonly(P_W)`, the member could +sign events that read as *signed by room W*. A `W` that nobody holds a key for +cannot be mistaken for a room by anything that checks signatures. The tag keeps it +apart from every other hash in the app. It is 32 bytes, so `childIndex` takes it +as it stands. + +### Why a random key, and only one wallet per key + +The member asked for this, and the derivation gives a second reason. Every step +below `P_W` is an unhardened public tweak, and every guardian holds the account +xpub, with its chain code. So a guardian who learns the private key of **one** +address can recover `k`. That is ordinary BIP32, and it is the same rule the +wallet note states for a group's threshold key. It means `k` has to be a key that +is good for nothing else: + +- **not the nostr key.** A leak would hand over the member's identity. A signer + behind NIP-55 cannot apply taproot tweaks in any case. And a wallet key equal to + an npub would tie the chain to the relay graph; +- **not a key from the profile's seed.** An nsec or npub profile has no seed + ([nsec-sign-in.md](./nsec-sign-in.md)). This is the first wallet such a profile + could hold. + +One key gives one wallet, on one network, at account 0. A second wallet is a +second key. + +### The member's own spend + +Key path, one signature, nothing to coordinate: + +``` +d = k + I[0:32] the account step, as a private key +d' = CKDpriv(CKDpriv(d, change), index) unhardened, matching CKDpub on the other side +sig = signSchnorr(sighash, d', TaprootTweak.ScriptTweak(merkleRoot(tree))) +``` + +`k` itself signs exactly one thing: the proof of possession in the request, +under its own tagged hash (Phase 3). It is never an output key, because the +account step always tweaks it first. + +--- + +## Who agrees to what + +Three parties, and each one signs what it is agreeing to: + +1. **The member agrees to be guarded.** The request is an inner event signed with + their nostr key, so it is bound to their identity. It is also signed with `k`, + which proves they hold the wallet key. It names the group, the wallet key, the + guardians and the descriptors their own device worked out. Consent comes first + here, which is the reverse of a subgroup, because the member already exists and + holds their key before anyone grants anything. +2. **The group's quorum agrees to guard it.** Each signer's device recomputes + the grant from the group's own key and certificate, checks the request against + it byte for byte, and checks that the person asking is a member. The + certificate embeds the request whole, so anyone who reads the certificate can + see that the member asked. +3. **The ancestors are not asked**, in the same way they are not asked when a + guarded subgroup is born. Each inherited key is the group's own grant passed one + step further. The group's quorum already holds the power to pass it to a + subgroup, and nothing here gives the ancestors any power they did not already + have. + +### What "full control" means, and what the member gives up + +The member can spend every coin, at any time, alone. No script stops a key-path +spend. The group, and every group above it, can also take any coin that has sat +confirmed for 12 blocks, without asking and without warning. That is the +guardians note's *the child gives up a real thing*, said about one person. The +consent screen says it in these words before a key is made (Phase 6). + +The groups above see the wallet too. The certificate carries the member's npub +and the account xpub, so every member of every guarding group can see its whole +balance and know whose it is. That also goes on the consent screen. + +--- + +## The order, and why it is forced + +``` + 1. the member's device reads K_G and guardians(G); generates k; derives W, the grant, the account + and both descriptors; stores k nothing has left the device + 2. the member publishes the request into G's room the proposal + 3. any signer of G opens a FROST session over the certificate the request determines + 4. G's quorum signs it; every device in G files the certificate the wallet exists + 5. a member in G and P forwards it into P as a 30333 notice, and so on up the ancestors find it +``` + +Step 2 comes after step 1 because the member asked for it to. It also has to: the +request carries the leaves, and the leaves are a function of `W`, so of `k`. Step +3 needs a signer, because a FROST session can only be opened by a device holding a +share (`proposeSigningBatch` throws without a `signerIdOf`). Step 4 is when +addresses are first offered. A wallet that the guardians have not agreed to guard +should not be handed out to be paid. + +--- + +## Phase 0 — decisions, before any code + +### D1. A new kind, not a birth certificate + +**Decided by the table above.** The certificate is 30334 and the request is +30335, the next free numbers after the notice at 30333. Phase 2's key notice +takes 30336. + +### D2. Who puts the request to the group? + +**Recommended: any signer, by tapping *Put to the group*.** The member's request +appears on every share-holder's device beside the proposals already waiting for +them. The first to tap it opens the FROST session, and proposing counts as their +own approval, as it does for every session. If the member is a signer, their +device opens the session directly and needs no sponsor. + +The certificate is a pure function of the request, and its `created_at` is the +request's. So two signers who tap at the same moment open two sessions over **one +event id**, and `GroupSignedEvent` keeps one row. A sponsor cannot change +anything, because every other signer rebuilds the certificate from the request +and drops a proposal that differs by a byte. + +The alternative is to let the member coordinate the FROST session without +holding a share. It is a better fit to the words "the individual proposes", and +FROST allows a coordinator who is not a signer. But `FrostSigningManager.advance` +returns at its first line without a `secretShare`, `proposeSigningBatch` +requires a `signerIdOf`, and the session row's `signApprovedAt` assumes the +proposer signs. Changing all three means touching the one manager every signature +in the app goes through, to save one tap. That is rejected for now, and written +up under the appendix. + +### D3. Which members may ask? + +**Recommended: any member of the group whose profile can sign and can watch the +chain.** Not only admins. The group has to be a Marmot room with a threshold key. +A read-only profile cannot sign the request. A profile with no Electrum client +(`GroupOnchainWallets` is null for it) could not see its own coins, so it is not +offered a wallet it cannot see. + +### D4. What the member's device has to know, and the member who joined late + +The grant needs `K_G` and the guardian keys in `G`'s own certificate. Today both +are read off `G`'s verified key state, and only ceremony participants hold one. A +member welcomed after the founding has neither. That is +[subgroups.md](./subgroups.md#what-this-does-not-do)'s gap, and it would leave +most ordinary members unable to ask. + +**Recommended: Phase 2, a key notice.** A member's device that holds no key state +for `G` posts a request for one. Any device that does hold one answers with the +signed `GroupKeyStateEvent`, whole, in a 30336. The asking device does **not** +file it as key state: the chronicle note's reason for keeping key states out of +the chronicle still holds. It reads `K_G` and the certificate out of the notice on +every use, after `GroupKeyStateManager.stateFrom`'s checks. This is safe for one +reason: `G` is `marmotGroupId(K_G)`, so no validly signed state, however old, can +name a different key. + +An answer is not needed when `G` has a guarded wallet: its statement carries +`G`'s certificate, and so `K_G` too. That is a fallback, not the route, because a +root group has neither. + +If D4 is deferred, Phases 1 and 3 to 12 still stand. The entrance is then hidden +for a member with no key state, and the screen says why. + +### D5. How many wallets, and what are they called? + +**Recommended: as many as the member likes, one key each, one network each, +account 0, with an optional label** (*Savings*). The label goes in the request, +and so into the certificate. The person's name does **not**. Rows show `@` plus +the member's live profile name (`Profile.humanReadableNameOrPubkey()`). The +certificate fixes the npub. A person renaming themselves is not drift in a +historical record, because there is no founding name to drift from. + +### D6. Where the key lives, and how it is backed up + +**Recommended: in the database, scoped to the profile, as `DkgSession.secretShare` +already is**: a `MemberWallet` row keyed by `W`, with the owner's npub. It is +**never** a foreign key to `ChatRoom`. Deleting the group's room on this device +must not delete a private key that coins may sit behind. That is the same +argument `parentChatRoomId` makes against a cascade, with money at the end of it. + +Backups: + +- the member wallet screen offers **Export key**, behind a confirmation, as a + `tr(xprv…/0/*,{…})` descriptor any wallet that imports taproot descriptors can + sweep from; +- **the group is the recovery path.** A member who loses the device loses `k`, + and their guardians can still take every coin after 12 blocks and pay it to the + member's new wallet. The screen says so, because it is the honest upside of being + guarded; +- `wipeDatabase()` ("end this", and signing out) has to warn when a member wallet + holds coins and its key is on this device only (Phase 8). + +### D7. Which guardians, and can the member leave some out? + +**Decided: exactly `SubgroupManager.grantFor(G, W)`**, the list a guarded subgroup +of `G` would get. A member cannot drop an ancestor or choose their own: signers +compare the whole list. Under a root group, or one whose certificate is +*unguarded*, that is `G` alone, by D2 of the policy note. Under a *guarded* `G` it +is `G` and every group above it. A member who wants no guardians has a plain +wallet already. That is the profile's own wallet, and it is outside this plan. + +### D8. Rollout + +**Recommended: `GroupWalletRollout.MEMBER_WALLETS_ON_MAINNET = false`**, lifted +after a signet run (Phase 12) in which a three-level hierarchy watches one +member's wallet and the root makes a guardian spend from it. The member's own +spends go through a single-signer path the app has never had. So until the gate +lifts, a member's own spend from this device on mainnet is held to `MAINNET_CAP`. +Guardian spends from a member wallet are already held to it. + +--- + +## Phase 1 — the derivation and the member's signature, pure + +New `managers/MemberWalletDerivation.kt`, beside `GuardianDerivation`: + +```kotlin +object MemberWalletDerivation { + /** `taggedHash("bennu/member-wallet/id/v1", serP(walletKey))`, hex. Frozen once a certificate carries one. */ + fun walletId(walletKey: PublicKey): String + + /** The account the member's key opens under [guardians]: `GroupWalletDerivation.account` over [walletKey]. */ + fun account(walletKey: PublicKey, chain: Chain, guardians: List): GroupWalletDerivation.Account + + /** The private key of the address at `change/index`: the account step, then CKDpriv twice. */ + fun privateKeyAt(walletPrivateKey: PrivateKey, chain: Chain, change: Long, index: Long): PrivateKey + + /** The signature an input of a checked spend needs: [privateKeyAt] under the address's script-path tweak. */ + fun sign(walletPrivateKey: PrivateKey, input: GroupSpend.SpentInput, account: GroupWalletDerivation.Account): ByteVector64 +} +``` + +`GroupWalletDerivation.account` already takes any public key. The only change +there is its parameter's name and kdoc. It says *threshold key*, and from now on +it is "the key the key path belongs to". + +**Tests**, commonTest: + +- `privateKeyAt(k)`'s public key is `derive(account, change, index).internalKey` + at ten indices on both branches; +- a signature from `sign` verifies against the address's output key, and + `correctlySpends` accepts a key-path spend of a guarded address built by + `GroupSpendBuilder`; +- `GuardianDerivation.grant(K_G, G, inherited, W)` reaches the keys a guardian's + `signingCache` reaches for `lineage = [… , W]`, so an ancestor can sign every + leaf of a member wallet; +- `walletId` vectors, and a check that `W` is not `xonly(P_W)`; +- the descriptor passes bitcoin-kmp's checksum and matches + `GroupWalletDerivation.Account.receiveDescriptor`. + +Nothing calls it yet. + +--- + +## Phase 2 — every member can know the group's key (D4) + +New `nostr/wallet/GroupKeyNoticeEvent.kt`, kind **30336**, in two shapes: + +``` +asking: kind 30336, content "", ["h", G] +answering: kind 30336, content , ["h", G], ["e", ] +``` + +- `MemberWalletManager.groupKeyFor(database, G)` returns `K_G` and the + certificate, read off this device's verified key state, then off `G`'s guarded + wallet statement, then off the newest answer in `G`'s room that passes + `stateFrom`. It is never written into `GroupKeyState`. +- **Answering.** A device that holds a verified state answers an asking notice + that has no answer yet. To keep a room of signers from all answering at once, + only the share-holder whose npub sorts first among those the device knows about + answers straight away. The rest answer if nothing has arrived after a minute. + Duplicates are harmless. +- `ChatMessage.applyInnerEvent` gets a 30336 arm that writes **no** line. It is + plumbing, and without the arm an older build would show a raw-JSON bubble, which + is reason enough to ship it early. + +**Tests**: an answer carrying a state for another room is ignored; an answer +whose certificate does not read is ignored; an old state for the same room still +gives the right `K_G`; nothing is filed into `GroupKeyState`. + +--- + +## Phase 3 — the request, pure + +New `nostr/wallet/MemberWalletRequestEvent.kt`, kind **30335**, an inner event +in `G`'s MLS room and signed by the member's nostr key. It never goes to a relay, +for the reason the statement never does: it carries an xpub. + +``` +kind: 30335 +pubkey: +content: +tags: + ["h", G] the group asked; a request is not replayable into another room + ["wallet", W] + ["wallet_key", ] + ["chain", "mainnet" | "signet" | …] GroupWalletStatementEvent.chainName + ["guardian", , , , "12"] one per guardian, nearest first -- GuardianTag reused + ["descriptor", tr(…,{…}), "receive"] + ["descriptor", tr(…,{…}), "change"] + ["label", "Savings"] optional + ["possession", ] +``` + +The possession signature is over +`taggedHash("bennu/member-wallet/possession/v1", xonly(npub) ‖ G ‖ serP(P_W) ‖ chainHash)`. +That message includes everything that has to bind the key to one person in one +group on one network. Without it, Bob could ask for a certificate on Alice's +wallet key under his own name, and every list above would show her coins as +`@bob`'s. + +`read(event): Reading?` and `Reading.verified(): MemberWalletDerivation.Account?` +check: + +1. the nostr signature, and that the event is 30335; +2. `W == walletId(P_W)`; +3. the possession signature under `P_W`; +4. the first guardian is `G` itself, so a request cannot leave out the group it + asks; +5. `account(P_W, chain, guardians)` rederives the xpub and both descriptors byte + for byte. + +This is everything a reader can check without `G`'s key. The grant is Phase 7's, +because only a device that holds `K_G` can check it. + +**Tests**: a request round-trips; each of the five checks fails on its own +mutation; a request with no label reads; two `wallet` tags do not read. + +--- + +## Phase 4 — the certificate, pure + +New `nostr/wallet/MemberWalletCertificateEvent.kt`, kind **30334**, signed by +`G`'s room through FROST: + +``` +kind: 30334 +pubkey: G set by the signing session +created_at: the request's created_at so every sponsor proposes one event id +content: W +tags: + ["d", W] addressable: newest per wallet wins, all of them identical + ["p", ] + ["wallet_key", ] + ["chain", …] + ["guardian", …] as in the request + ["descriptor", …, "receive"] + ["descriptor", …, "change"] + ["label", …] if the request had one + ["request", ] +``` + +- `template(request: Event): EventTemplate`. The **only** way a certificate is + built. A sponsor passes the request and nothing else. +- `verify(certificate, groupChatRoomId): Verified?`, standalone and with no + database: + 1. 30334, and `isSignedByRoom(certificate, G)`; + 2. the embedded request passes Phase 3's `verified()`, and its `h` is `G`; + 3. the certificate is exactly `template(request)` with `G` as author. One + comparison covers every tag, so no tag can say one thing in the request and + another in the certificate; + 4. the `p` tag is the request's author. + + `Verified` carries the npub, `W`, the label and the account. It is what the + member's device, every guardian and every forwarded notice open the wallet on. + +The request is embedded rather than looked up, as the certificate is embedded in a +guarded statement. That makes the certificate self-contained for an ancestor who +was never in `G`'s room, and it means *the member asked* is checked from the +group's signature rather than taken on trust. + +**Tests**: a certificate verifies; one signed by another room, one whose request +is from another group, one whose `p` is not the request's author, and one with a +guardian swapped relative to its request each fail. +`SubgroupBirthCertificateEvent.certifies` is false for a 30334, and +`SubgroupManager.subgroupsOf` ignores one stored in the parent. That last test +exists to fail the day somebody reads both kinds in one query. + +--- + +## Phase 5 — schema 29 → 30 + +One new table. Room auto-migrates a new table, so the entry joins the list in +`BennuDatabase`. + +```kotlin +@Entity(indices = [Index("ownerPublicKey"), Index("guardingChatRoomId")]) +data class MemberWallet( + @PrimaryKey val walletId: String, // W + val ownerPublicKey: HexKey, // the profile it belongs to: one database holds every profile + val guardingChatRoomId: String, // G -- a plain column, never a foreign key (D6) + val chain: String, + val walletPrivateKey: HexKey, // k + val label: String?, + val requestJson: String, // the signed 30335, kept so a declined request can be asked again + val createdAt: Instant, +) +``` + +No *certified* column. A wallet is certified when `G`'s `GroupSignedEvent` rows +hold a 30334 for `W` that passes `verify`. That is read again each time, as +`GroupWallet` reads statements. A column would be a second copy that could +disagree with the signature. + +`MemberWalletDao`: `getByOwner`, `observeByOwner`, `getById`, `upsert`, and a +`delete` the manager calls only for a wallet that was never certified (Phase 8). + +Spends get a second table, `MemberWalletSpend`, in Phase 9, where they are first +needed. + +--- + +## Phase 6 — the member asks + +New `managers/MemberWalletManager.kt`: + +```kotlin +object MemberWalletManager { + /** Steps 1 and 2: makes the key, works out the leaves, stores the key, and only then publishes the request. */ + suspend fun request(database: BennuDatabase, groupRoom: LocalChatRoom, identity: Identity, chain: Chain, label: String?): MemberWallet + + /** Every wallet [ownerPublicKey] holds a key for here, or that a group this device is in has certified for them. */ + suspend fun walletsOf(database: BennuDatabase, ownerPublicKey: HexKey): List +} +``` + +`request` checks the request it built with Phase 3's `verified()`, and checks the +grant against `groupKeyFor`, **before** it publishes. A request this device would +refuse should never be shown to a quorum. It stores the row before it publishes, +so a crash between the two leaves a key and no request rather than a request and +no key. + +### The entrances + +- **The member's own profile** (`ActiveProfileScreen`): a *Guarded wallets* + section (Phase 8) with *New guarded wallet*, which opens a picker of the groups + this profile is in that have a key. +- **The group's detail screen**: *Ask this group to guard a wallet for you*, in + the new *Members' guarded wallets* section (Phase 11). It opens the same screen + with the group already chosen. + +Both lead to `NewMemberWalletScreen` (route `NewMemberWalletRoute(activeUserPublicKey, chatRoomId?)`, +with a `NavigateBackButton`). It is a consent screen first and a form second: + +| line | says | +|---|---| +| headline | *A wallet only you can spend from, guarded by #Ekklesia* | +| who can step in | *#Ekklesia and the N groups above it can take any coin that has been confirmed for 12 blocks, without asking you* | +| who can see it | *Members of those groups will see this wallet's balance, and that it is yours* | +| recovery | *If you lose this device, those groups can still move your coins for you* | +| label | an optional text field | +| action | *Ask #Ekklesia* | + +`N` is `grant.size - 1`. Strings go in `strings.xml`, in sentence case, with +`%1$s` and `%2$d`. CLAUDE.md applies in full. + +### Refusals, at the screen and again in `request` + +| refused | because | +|---|---| +| a read-only profile | it cannot sign the request (`LocalCanSign`) | +| no Electrum client for the profile | it could not see its own coins (D3) | +| the group has no key, or is not a Marmot room | there is nobody to sign the certificate, and no room to carry it | +| `groupKeyFor` is null | the grant cannot be worked out. Offer *Ask the group for its key* (Phase 2) | +| `grantFor` is null | `G`'s certificate carries guardian keys this build cannot read. Today that surfaces at the end of a ceremony, and here it is refused up front | +| `MEMBER_WALLETS_ON_MAINNET` is shut and the chain is mainnet | D8 | + +**Tests**, jvmTest: `request` stores before it publishes; the published request +passes `verified()` and its guardians equal `grantFor`; each refusal above holds; +a member with no key state succeeds once an answer from Phase 2 is in the room. + +--- + +## Phase 7 — the group signs, and every signer checks + +### Every signer refuses a certificate the group did not agree to + +`FrostSigningManager.acceptProposal` gets a third check beside the certificate +and statement checks it already has (`:569`, `:591`). It is +`MemberWalletManager.refuseCertificate(database, chatRoomId, thresholdPublicKey, rebuilt)`, +for every rebuilt 30334, and it runs before anything is shown: + +- `MemberWalletCertificateEvent.verify` fails → *is not a certificate this group + could have been asked for*; +- the request's `h` is not this room → *was asked of another group*; +- the request's author is not a participant of this room (a `Participant` row + with `deletedAt == null`) → *was asked by somebody who is not a member*; +- the guardians are not `SubgroupManager.grantFor(chatRoomId, thresholdPublicKey, W)` + → *grants guardian keys this group does not*. This is `refuseCertificate`'s key + check with `W` in place of the subgroup's room id, and it reuses the same + function. + +The group's policy, read off its own certificate, decides only *which* keys the +grant carries (D7). It never refuses a member wallet. Even an unguarded group +can guard its members. + +### Sponsoring + +- `MemberWalletManager.putToGroup(database, groupRoom, userPublicKey, request)` + is `FrostSigningManager.proposeSigning(kind = 30334, template(request))`. It + returns the open session instead when one already carries that event id. +- `ChatMessageListViewModel.observeProposalsAwaitingYou` also lists requests that + have no certificate and no open session, on share-holders' devices. Each gets a + *Put to the group* action, which counts as the sponsor's approval, and the + dialog says so. + +### What the group reads + +- `ProposedEvent.summaryOf` gets a 30334 arm: *Guard a wallet for @alice + (Savings). This group and the N above it will be able to take its coins once + they are 12 blocks old. Only @alice can spend from it before then.* +- `ChatMessage.applyInnerEvent` arms: + - 30335 writes *@alice asked this group to guard a wallet for her*, and nothing + else happens. It is a request, not a decision; + - 30334, when it comes through `applySignedEvent`, writes *This group now + guards a wallet for @alice*. + + Without these arms, both kinds fall to `else ->` and show raw JSON. That is the + failure mode [member-chronicle.md](./member-chronicle.md) names, and it is + avoidable here. + +**Tests**, jvmTest, in the shape of `SubgroupManagerJvmTest`: a certificate whose +guardians omit an ancestor, swap one or reorder them is refused; a request from a +removed member is refused; a request replayed from another group is refused; two +sponsors produce one `GroupSignedEvent`; an unguarded group's certificate carries +only its own key and is accepted. + +--- + +## Phase 8 — the member's wallet + +### Opening + +`MemberWalletManager.walletsOf` joins two sources: + +1. `MemberWallet` rows for this profile, the wallets whose key is on this device; +2. 30334s in the signed events of every room this device is in whose `p` is this + profile's npub, which includes wallets this profile made on **another device**. + +Each source gives a `MemberWalletRow`: + +| state | when | the profile row's supporting line | +|---|---|---| +| `Asked` | a key and request here, no session, no certificate | *Waiting for someone in #Ekklesia to put it to the group* | +| `Signing` | an open session over the certificate | *#Ekklesia is signing* | +| `NotSigned` | the session failed or was declined, and there is no certificate | *#Ekklesia did not sign. Ask again, or discard* | +| `Open` | a certificate, and the key is here | the balance | +| `WatchOnly` | a certificate, and the key is not here | the balance, *key on another device* | + +*Ask again* republishes the stored request, unchanged. *Discard* deletes the row, +and is offered only before a certificate exists. No address has been offered by +then, so no coin can be behind the key. + +### The profile section + +`ActiveProfileScreen` gets *Guarded wallets* between the profile's own rows and +*Switch profile*. There is one `ListItem` per `MemberWalletRow`, with the headline +*#Ekklesia*, or *#Ekklesia · Savings*, and the supporting line from the table. A +`ListItem` is clickable, so it gets `minimumInteractiveComponentSize()`. *New +guarded wallet* sits under the list. An empty list shows `EmptyState` with its own +message, *You have no guarded wallets*. + +The list is never published. A kind 0 is public, and the xpub must never leave an +encryption. + +### `MemberWalletScreen` + +Route `MemberWalletRoute(activeUserPublicKey, walletId)`, a pushed screen with a +`NavigateBackButton`. It reuses `GroupWalletScreen`'s composables wherever they +are already separate: `BalanceCard`, `CoinRow`, and the address list as +`GroupWalletAddressesScreen` draws it (current address plus two, so a guardian's +watch never falls behind the addresses handed out). It adds: + +- *Guarded by #Ekklesia and N more*, with the 12-block line; +- **guardian spends**: `GuardianManager.takenIn` over the wallet's history, + rendered *#Ekklesia took 50,000 sats in …*. They are read off the chain on each + pass, as a subgroup's are, and stored nowhere; +- *Send* (Phase 9), and for an `Open` wallet *Export key* (D6); +- the four states, wrapped in `ScreenStateTransition`. + +### Losing the key by accident + +`wipeDatabase()`'s callers ("end this" on `CreateProfileScreen`, and the sign-out +dialogs) check for an `Open` member wallet with a balance whose key exists only +here. If there is one, they say so and offer *Export key* before going on. + +**Tests**, `MemberWalletViewModelJvmTest`: each row of the state table; a +certificate for this npub with no key here reads `WatchOnly`; *Discard* is not +offered once a certificate exists. + +--- + +## Phase 9 — the member spends + +- `MemberWalletSpendViewModel` builds with `GroupSpendBuilder`, checks with + `GroupSpend.check(psbt, account, Spender.Owner)`, which is unchanged, signs each + `SpentInput` with `MemberWalletDerivation.sign`, witnesses with + `Checked.witnessed`, and asserts `correctlySpends` before it broadcasts. +- The form is `GroupSendScreen`'s. If its fields are not already a separate + composable, extracting them is this phase's first commit, so the member's form + cannot drift from the group's (the decimal-point bug in + [group-send-an-amount.md](./group-send-an-amount.md) is the reason). +- `MemberWalletSpend` table (schema 30 → 31, or folded into Phase 5's bump if + both land in one release): `txid` PK, `walletId`, `psbt`, `signedTransaction`, + `broadcastAt`, `seenAt`, `confirmedAt`, `replacedByTxid`. It is the subset of + `GroupTransaction` a spend with no session needs. `GroupTransaction` cannot hold + it, because its foreign keys are to a session and a room. +- `GroupTransactionWatcher`'s follow and conflict logic, generalised over the + row's type, or copied once with a comment pointing at the original if the + generic version reads worse. *Bump the fee* signs a replacement locally. +- Change goes to the wallet's own change branch, reserved as + `reservedChangeIndices` does for a group. +- `capFor(chain)` applies while D8's gate is shut. + +**Tests**: a spend of two coins and change passes `correctlySpends`; a spend to +a foreign change output is refused by `check`, as it is for a group; a bump +replaces and settles. + +--- + +## Phase 10 — the guardians see `@alice` + +The guardian side is built. What changes is what a guarded wallet can be. + +### `GuardianManager.GuardedWallet` learns its subject + +```kotlin +sealed interface GuardedSubject { + /** The id the line of descent ends in: a room id, or a member wallet's W. */ + val id: String + data class Subgroup(override val id: String, val name: String?) : GuardedSubject + data class Member(override val id: String, val ownerPublicKey: HexKey, val label: String?) : GuardedSubject +} +``` + +`descendantChatRoomId` becomes `subject.id`. `statement` becomes `signedEvent`, +which is the 30331 for a subgroup and the 30334 for a member. `certificate` stays +the subgroup's alone. `spender()`, `position` and `lineage` do not change, because +`GuardianDerivation.lineage(guardians, W, ancestor)` already works for any +32-byte id. + +### Reading + +- `verify` dispatches on kind: 30331 takes today's path, and 30334 takes + `MemberWalletCertificateEvent.verify` plus the same ancestor walk (rule 4 of + `verify`'s kdoc). +- `guardedWalletsOf(G)` reads `G`'s **own** 30334 `GroupSignedEvent`s beside the + 30333 notices it was forwarded. The direct guardian holds the certificate it + signed, so it needs no notice to learn of it. +- `shareableFrom(G)` includes `G`'s member certificates, so a member of `G` who + sits in `P` sees them under *Tell the groups above*, and one tap forwards them. + The 30333 notice carries a 30334 as its content. An older build's `verify` + returns null for that kind, so it shows no line and lists nothing. +- `describeNotice` gets *Shared @alice's guarded wallet with this group*. + +### Spending + +`proposeGuardianSpend` and its `["guarded", ]` tag already take an id, and +`guardedWalletFor` looks it up. With `W` in that slot, nothing in `GroupSpend`'s +guardian arm changes. `GroupTransaction.guardedChatRoomId` holds `W` for a member +wallet. The column keeps its name, because a rename is a migration for a word, and +its kdoc says *the room or member wallet*. + +### Showing it + +`GroupWalletScreen.guardianItems` gives the headline by subject: + +```kotlin +when (val subject = row.wallet.subject) { + is GuardedSubject.Subgroup -> subject.name ?: stringResource(Res.string.a_subgroup) // "#Translation" + is GuardedSubject.Member -> stringResource(Res.string.at_s, profileName(subject.ownerPublicKey)) // "@alice" +} +``` + +The profile name comes from `ProfileDao`, falling back to a shortened npub. +`GuardedWalletRow` carries the profile, so the composable does no lookups. A +member wallet with a label shows it in the supporting line, before the *within +reach* amount. + +**Tests**, `GuardianSigningJvmTest`-shaped: a parent's shares sign a leaf of a +member wallet, and `correctlySpends` accepts it at sequence 12 and refuses it at +11; a root two levels up does the same through a forwarded notice; a notice +carrying a 30334 whose guardian entry for this group is not the key its walk +reaches is ignored; `guardedWalletsOf` returns both kinds, sorted by display name. + +--- + +## Phase 11 — the group's page and the person's page + +### `ChatRoomDetailScreen` + +There is a new section, **Members' guarded wallets**, under *Subgroups*. Its rows +are `MemberWalletRow`s read from the room's 30334s: + +- leading: the member's avatar; +- headline: `@alice`, and `@alice · Savings` when there is a label; +- supporting: *Asked by @alice, not yet signed* for a request with no certificate, + and otherwise nothing more. The balance belongs to the wallet screen; +- tap: `ProfilePreviewRoute(activeUserPublicKey, ownerPublicKey)`, as member + rows already do (`:575`). + +Below the rows, for a member who may ask (D3), is *Ask this group to guard a +wallet for you*. An empty section with the button hidden is not shown at all. + +### `ProfilePreviewScreen` + +There is a new section, **Wallets your groups guard**, listing every guarded +wallet this device knows of whose subject is that npub. These come from each +group's own certificates and from forwarded notices, so a root sees a +grandchild's member. Each row reads *Guarded by #Ekklesia*, with the amount within +this group's reach, and *Spend* for a share-holder, which opens +`GroupSendRoute(chatRoomId = , guardedChatRoomId = W)`, the +guardian spend that exists today. When the profile shown is the active one, the +section is the Phase 8 list instead. + +This is where the question's "navigate to the individual user profile instead of +the group chat" ends up. A subgroup is somewhere you go into. A person is someone +you look at. + +**Tests**: the detail screen's state lists a certified wallet and a pending +request separately from the subgroups; the preview's state lists wallets from two +guardian rooms for one npub. + +--- + +## Phase 12 — the gate, docs, and the emulators + +- `GroupWalletRollout.MEMBER_WALLETS_ON_MAINNET` and `offersMemberWalletsOn(chain)`, + with the condition that lifts them (D8). They gate the entrances in Phase 6 and + Phase 11's button only. A device with the gate shut still accepts, shows and + signs a certificate somebody else asked for. A gate decides what this device + offers, never what a quorum may decide. +- [group-wallet-guardians.md](./group-wallet-guardians.md): *What this does not + do* gets a pointer here. *How an ancestor finds the coins* says the forwarded + thing may be a member certificate. +- [subgroups.md](./subgroups.md): one line under the certificate's tag table + saying a member wallet is not a subgroup and has its own kind. +- [README.md](./README.md): the row, and a sentence on reading order. +- This note: *Built*, and a table of where the build chose differently. + +By hand, signet, three emulators, a root `R`, its guarded subgroup `M`, and Alice +in `M` but not in `R`: + +1. Alice, holding no key state for `M`, asks for `M`'s key. An `M` signer's device + answers it, and her *New guarded wallet* opens. +2. The consent screen names `#M` and one group above it. She asks, and `M`'s + transcript says so. +3. An `M` signer taps *Put to the group*, and a second approves. Alice's profile + row goes from *waiting* to *signing* to a balance of 0. +4. `M`'s detail screen lists `@alice` under *Members' guarded wallets*, and the + row opens her profile. +5. Pay her receive address. A member in both `M` and `R` taps *Share*. `R`'s + wallet screen lists `@alice` beside `#M`. +6. Alice spends part of it alone. `correctlySpends` holds, and her change is + watched by `M` and `R`. +7. After 12 blocks, `R` takes the rest through its leaf. Alice's wallet screen + says *#R took …*. +8. Alice's second phone, on the same profile, lists the wallet as *key on another + device*. +9. A request edited to drop `R`'s key, sent from a debug build, is dropped by + every `M` signer, and the reason is in the log. + +```bash +./gradlew :composeApp:compileDebugKotlinAndroid :composeApp:jvmTest +``` + +```bash +./gradlew :composeApp:m3Audit +``` + +--- + +## Order and size + +| phase | touches | ships | +|---|---|---| +| 1 | `MemberWalletDerivation` and its tests | dark | +| 2 | key notice, its dispatch arm | dark, but useful on its own | +| 3 | the request, pure | dark | +| 4 | the certificate, pure | dark | +| 5 | schema 30 | dark | +| 7 | signer checks, sponsoring, transcript arms | **before 6**: binding on every device that did not draw the screen | +| 6 | the member asks | **the switch** | +| 8 | the member's wallet and profile section | with 6 | +| 9 | the member spends | with 6. A wallet that can receive and not send is a trap | +| 10 | guardians list and spend from it | with 6 | +| 11 | detail and profile pages | any time after 7 | +| 12 | gate, docs, emulator run | last | + +Phases 1 to 5 and 7 can land before anyone can ask for anything, and 7 should. +It is what makes every signer check the grant and every older-build bubble go +away, so it wants to be on every member's phone before the first request exists. +That is the policy note's reasoning about its own Phase 7, applied again. + +**The mixed-version risk, placed once more.** A signer on a build before Phase 7 +sees *Event of kind 30334* with nothing checked, and could sign a certificate with +a guardian missing. That does not cost the member coins, because they still hold +the key path. But it can drop a group above from a wallet it is meant to guard. +The remedy is the familiar one: everybody in a group that guards members should be +on a build from Phase 7 onward before the gate opens. + +--- + +## What this does not do + +**It does not make the guard cryptographic beyond the leaf.** The member's key is +the member's, and they can move every coin to a plain wallet at any time. What +the group gets is the right to take coins that have sat for 12 blocks, which is +the same thing a guarded subgroup's ancestors get, and nothing more. + +**It does not guard a wallet that already exists.** The profile's own wallet, +and any wallet made elsewhere, stay as they are. Being guarded means a new key. + +**It does not end when the member leaves the group.** The leaf is in every +address. A member who leaves keeps a wallet the group can still take from, and the +way out is to spend everything to a new wallet. The profile row says *You are no +longer in #Ekklesia* when that is so. + +**It does not let the group revoke.** There is nothing to revoke. The +certificate is a signature that exists forever, and the group can only stop +watching. + +**It does not reach a member who cannot watch the chain** (D3), and it does not +reach a read-only profile at all. + +**It does not survive a re-keyed group**, for the reason the guardians note +gives. The leaf is bound to `K_G`. + +**It does not spend from several member wallets at once.** Each wallet is one +key, and a spend is from one wallet. + +--- + +## Appendix — what was considered and rejected + +| idea | why not | +|---|---| +| a 30329 birth certificate for the person | every reader of 30329 assumes a room. See the table at the top | +| the member coordinating the FROST session without a share | the closest fit to "the individual proposes", and FROST allows it. But `advance`, `proposeSigningBatch` and `signApprovedAt` all assume the coordinator signs, and this is the one manager every signature goes through. Worth revisiting if a second feature wants a non-signing coordinator | +| the group's signers computing the leaves | the member asked to incorporate them before sharing, and a member who checks nothing is agreeing to a tree they never saw | +| the member's nostr key as the wallet key | leaks the identity through any one address's key, does not work for a NIP-55 signer, and links the npub to the chain | +| a key from the profile's seed, hardened | backed up by the mnemonic for free, but an nsec or npub profile has none. The group is the recovery path anyway (D6) | +| `W = xonly(P_W)` | `W` would then be a key, and an event "signed by W" would read as signed by a room | +| a member's wallet as a 1-member subgroup | a ceremony, a key state, a Marmot room and a three-admin floor, to hold one person's key. The point of a member wallet is that it is *not* a group | +| filing the key notice into `GroupKeyState` | it would give every late member a key state and quietly change what `thresholdKeyFor` answers for them across the app. Reading it in one place, for one purpose, keeps the change where it is needed | +| choosing which ancestors guard it | the grant is a function, and a choice is a second thing signers would have to agree on. A guarded subgroup of `G` has no choice either | +| listing member wallets in the subgroups section | a row there navigates into a room, and its title is a founding name. A person is neither | From 5240ab24be07147d6f9029c91ced7c9849b7dd0b Mon Sep 17 00:00:00 2001 From: Kgothatso Ngako Date: Sat, 24 Oct 2026 07:17:05 +0200 Subject: [PATCH 03/21] feat(wallet): a member's guarded wallet derives and signs from one key (Phase 1) MemberWalletDerivation holds the private side of a guarded wallet whose key path is one member's random key: the wallet id W, the account step added to the scalar, CKDpriv to each address, and a key-path signature under the address's script-path tweak. The public side is the group wallet's derivation unchanged; GroupWalletDerivation.accountStep is split out so both add the same tweak. Co-Authored-By: Claude Opus 5.5 --- .../compose/managers/GroupWalletDerivation.kt | 30 +++- .../managers/MemberWalletDerivation.kt | 126 ++++++++++++++ .../managers/MemberWalletDerivationTest.kt | 155 ++++++++++++++++++ 3 files changed, 302 insertions(+), 9 deletions(-) create mode 100644 composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/MemberWalletDerivation.kt create mode 100644 composeApp/src/commonTest/kotlin/com/machankura/bennu/compose/managers/MemberWalletDerivationTest.kt diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/GroupWalletDerivation.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/GroupWalletDerivation.kt index a843c700..cea9dd47 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/GroupWalletDerivation.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/GroupWalletDerivation.kt @@ -199,16 +199,10 @@ object GroupWalletDerivation { val root = PublicKey(ByteVector(thresholdPublicKey.hexToByteArray())) require(root.isValid()) { "the threshold key is not a valid point" } - val i = Crypto.hmac512( - ACCOUNT_TAG.encodeToByteArray(), - root.value.toByteArray() + chain.chainHash.value.toByteArray() + Pack.writeInt32BE(account.toInt()) - ) - val tweak = i.copyOfRange(0, 32) - val chainCode = i.copyOfRange(32, 64) - require(Crypto.isPrivKeyValid(tweak)) { "the account step for account $account landed on an invalid scalar" } + val (tweak, chainCode) = accountStep(root, chain, account) val accountKey = root + PrivateKey(tweak).publicKey() - val cache = plainTweak(TweakCache.create(root), ByteVector32(tweak), "the account step") + val cache = plainTweak(TweakCache.create(root), tweak, "the account step") // The cache tracks the full point; the point arithmetic above is the // reference it has to agree with, or every session for this account signs // for a key nobody's coins are at. @@ -219,7 +213,7 @@ object GroupWalletDerivation { account = account, extendedPublicKey = DeterministicWallet.ExtendedPublicKey( publickeybytes = accountKey.value, - chaincode = ByteVector32(chainCode), + chaincode = chainCode, depth = 0, path = KeyPath.empty, parent = 0L, @@ -229,6 +223,24 @@ object GroupWalletDerivation { ) } + /** + * The account step's tweak and chain code for [root]: `I[0:32]` and + * `I[32:64]` of the tagged HMAC over the key, the network and the account. + * + * Split out for the one holder of a key path who has its private key -- a + * member wallet, `MemberWalletDerivation` -- which adds the same tweak to + * the scalar that [account] adds to the point. + */ + internal fun accountStep(root: PublicKey, chain: Chain, account: Long): Pair { + val i = Crypto.hmac512( + ACCOUNT_TAG.encodeToByteArray(), + root.value.toByteArray() + chain.chainHash.value.toByteArray() + Pack.writeInt32BE(account.toInt()) + ) + val tweak = i.copyOfRange(0, 32) + require(Crypto.isPrivKeyValid(tweak)) { "the account step for account $account landed on an invalid scalar" } + return ByteVector32(tweak) to ByteVector32(i.copyOfRange(32, 64)) + } + /** * The address at `//` under [account]. * diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/MemberWalletDerivation.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/MemberWalletDerivation.kt new file mode 100644 index 00000000..fe45cab5 --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/MemberWalletDerivation.kt @@ -0,0 +1,126 @@ +package com.machankura.bennu.compose.managers + +import com.machankura.bennu.compose.wallet.GroupSpend +import com.vitorpamplona.quartz.nip01Core.core.HexKey +import com.vitorpamplona.quartz.nip01Core.core.hexToByteArray +import com.vitorpamplona.quartz.nip01Core.core.toHexKey +import com.vitorpamplona.quartz.utils.RandomInstance +import fr.acinq.bitcoin.ByteVector32 +import fr.acinq.bitcoin.ByteVector64 +import fr.acinq.bitcoin.Chain +import fr.acinq.bitcoin.Crypto +import fr.acinq.bitcoin.DeterministicWallet +import fr.acinq.bitcoin.KeyPath +import fr.acinq.bitcoin.PrivateKey +import fr.acinq.bitcoin.PublicKey + +/** + * The keys of a wallet one member holds and a group guards: a guarded wallet + * whose key path is the member's own key rather than a group's threshold key. + * + * Everything public is the group wallet's derivation with the member's key in + * the threshold key's place, and the guardian derivation with the wallet's id in + * a child room's place: + * + * ``` + * k random, generated on the member's device and never sent + * P_W = k·G the wallet key + * W = taggedHash("bennu/member-wallet/id/v1", serP(P_W)) the wallet's id + * account = GroupWalletDerivation.account(P_W, chain, 0, grant) + * grant = GuardianDerivation.grant(K_G, G, guardians(G), W) + * ``` + * + * So a member's wallet under G is guarded exactly as a guarded subgroup of G + * would be. What is new is only the private side: the member holds `k`, so + * every tweak the account and the address add to the point is added to the + * scalar too, and a spend is one Schnorr signature. See + * `docs/member-guarded-wallets.md`. + * + * ### Why `W` is a hash and not the key + * + * A room id here is a public key, and `GroupKeyStateEvent.isSignedByRoom` asks + * whether that key signed something. A `W` nobody holds a key for cannot be + * mistaken for a room by anything that checks signatures. + * + * ### The rule this inherits + * + * Every step below `P_W` is an unhardened public tweak, and every guardian holds + * the account xpub. A guardian who learns the private key of one address can + * therefore recover `k`. That is why `k` is random and good for one wallet only: + * never the nostr key, never a key from the profile's seed. + */ +object MemberWalletDerivation { + /** The tag of a wallet id's hash. Frozen the moment a certificate carries one: a rename moves every leaf. */ + private const val ID_TAG = "bennu/member-wallet/id/v1" + + /** + * The account a member wallet always opens at. One wallet is one key, so a + * second account would be a second wallet under a key that already has one. + */ + const val ACCOUNT: Long = 0L + + /** A fresh wallet key, from the platform's secure random. */ + fun generate(): PrivateKey { + while (true) { + val candidate = PrivateKey(ByteVector32(RandomInstance.bytes(32))) + if (candidate.isValid()) return candidate + } + } + + /** `W`: the tagged hash of the wallet key's compressed form, hex. */ + fun walletId(walletKey: PublicKey): String = + Crypto.taggedHash(walletKey.value.toByteArray(), ID_TAG).toByteArray().toHexKey() + + fun walletId(walletKey: HexKey): String = walletId(PublicKey(walletKey.hexToByteArray())) + + /** + * The account [walletKey] opens on [chain] under [guardians]: + * `GroupWalletDerivation.account` over the member's key. + */ + fun account(walletKey: PublicKey, chain: Chain, guardians: List): GroupWalletDerivation.Account = + GroupWalletDerivation.account(walletKey.toString(), chain, ACCOUNT, guardians) + + /** + * The account key as a private extended key: [walletPrivateKey] plus the + * scalar `GroupWalletDerivation.account` adds to the point, with the same + * chain code. Plain addition, so there is no parity to get wrong until the + * taproot tweak at the very end. + */ + fun accountPrivateKey(walletPrivateKey: PrivateKey, chain: Chain): DeterministicWallet.ExtendedPrivateKey { + val (tweak, chainCode) = GroupWalletDerivation.accountStep(walletPrivateKey.publicKey(), chain, ACCOUNT) + return DeterministicWallet.ExtendedPrivateKey( + secretkeybytes = (walletPrivateKey + PrivateKey(tweak)).value, + chaincode = chainCode, + depth = 0, + path = KeyPath.empty, + parent = 0L, + ) + } + + /** The private key of the internal key at `change/index`: CKDpriv twice below [accountPrivateKey]. */ + fun privateKeyAt(walletPrivateKey: PrivateKey, chain: Chain, change: Long, index: Long): PrivateKey { + require(change == GroupWalletDerivation.RECEIVE || change == GroupWalletDerivation.CHANGE) { "change must be 0 or 1, not $change" } + require(index in 0L..GroupWalletDerivation.MAX_INDEX) { "index $index is not an unhardened index" } + return accountPrivateKey(walletPrivateKey, chain).derivePrivateKey(listOf(change, index)).privateKey + } + + /** + * The signature [input] of a checked spend needs from the wallet's own key: + * the address's private key under the address's taproot tweak, over the + * input's key-path sighash. + * + * Refuses a guardian's input -- the member never signs through a leaf -- and + * an input whose address is not one this key reaches, so a signature made + * here always verifies against the key the coin is at. + */ + fun sign(walletPrivateKey: PrivateKey, chain: Chain, input: GroupSpend.SpentInput): ByteVector64 { + require(input.leaf == null) { "a member signs on the key path, never through a guardian's leaf" } + val derivation = input.derivation + val privateKey = privateKeyAt(walletPrivateKey, chain, derivation.change, derivation.index) + require(privateKey.xOnlyPublicKey() == derivation.internalKey) { "this key does not reach the address at ${derivation.change}/${derivation.index}" } + + val signature = Crypto.signSchnorr(input.sighash, privateKey, derivation.taprootTweak) + require(Crypto.verifySignatureSchnorr(input.sighash, signature, input.signingKey)) { "the signature does not verify against the coin's key" } + return signature + } +} diff --git a/composeApp/src/commonTest/kotlin/com/machankura/bennu/compose/managers/MemberWalletDerivationTest.kt b/composeApp/src/commonTest/kotlin/com/machankura/bennu/compose/managers/MemberWalletDerivationTest.kt new file mode 100644 index 00000000..ed73802f --- /dev/null +++ b/composeApp/src/commonTest/kotlin/com/machankura/bennu/compose/managers/MemberWalletDerivationTest.kt @@ -0,0 +1,155 @@ +package com.machankura.bennu.compose.managers + +import com.machankura.bennu.compose.wallet.GroupSpend +import com.machankura.bennu.compose.wallet.GroupSpendBuilder +import com.machankura.bennu.compose.wallet.GroupWalletState +import fr.acinq.bitcoin.ByteVector +import fr.acinq.bitcoin.ByteVector32 +import fr.acinq.bitcoin.Chain +import fr.acinq.bitcoin.Descriptor +import fr.acinq.bitcoin.OutPoint +import fr.acinq.bitcoin.PrivateKey +import fr.acinq.bitcoin.Satoshi +import fr.acinq.bitcoin.ScriptFlags +import fr.acinq.bitcoin.Transaction +import fr.acinq.bitcoin.TxId +import fr.acinq.bitcoin.TxIn +import fr.acinq.bitcoin.TxOut +import fr.acinq.lightning.blockchain.electrum.WalletState +import fr.acinq.secp256k1.Hex +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFails +import kotlin.test.assertIs +import kotlin.test.assertNotEquals +import kotlin.test.assertTrue + +/** + * A member's guarded wallet, from the member's side: the private key reaches + * every address the public derivation does, and a spend signed with it is one + * the script interpreter accepts. The guardians' side -- that an ancestor signs + * every leaf of a member's wallet -- is the last test. + */ +class MemberWalletDerivationTest { + private val chain = Chain.Regtest + + private fun privateKey(seed: Long): PrivateKey = PrivateKey(ByteVector32(Hex.decode(seed.toString(16).padStart(64, '0')))) + + private val walletPrivateKey = privateKey(0xa11ce) + private val walletKey = walletPrivateKey.publicKey() + private val walletId = MemberWalletDerivation.walletId(walletKey) + + private val groupKey = privateKey(0x6a0b).publicKey().toString() + private val groupRoom = SharedKeyDerivation.marmotGroupId(groupKey) + private val parentKey = privateKey(0x9a9e).publicKey().toString() + private val parentRoom = SharedKeyDerivation.marmotGroupId(parentKey) + + /** The group's own grant from its parent, then the group's grant to the member's wallet: two guardians. */ + private val grant: List = run { + val groupsOwn = GuardianDerivation.grant(parentKey, parentRoom, emptyList(), groupRoom) + GuardianDerivation.grant(groupKey, groupRoom, groupsOwn, walletId) + } + + private val account = MemberWalletDerivation.account(walletKey, chain, grant) + + @Test + fun `the wallet id is a hash of the key and not the key`() { + assertEquals(64, walletId.length) + assertNotEquals(walletKey.xOnly().value.toHex(), walletId) + assertEquals(walletId, MemberWalletDerivation.walletId(walletKey.toString())) + assertNotEquals(walletId, MemberWalletDerivation.walletId(privateKey(0xb0b).publicKey())) + // A wallet id is a valid child index, as a room id is. + GuardianDerivation.childIndex(walletId) + } + + @Test + fun `the private key reaches every address the public derivation does`() { + for (change in listOf(GroupWalletDerivation.RECEIVE, GroupWalletDerivation.CHANGE)) { + for (index in listOf(0L, 1L, 2L, 7L, 1_000L)) { + val derived = GroupWalletDerivation.derive(account, change, index) + val privateKey = MemberWalletDerivation.privateKeyAt(walletPrivateKey, chain, change, index) + assertEquals(derived.internalKey, privateKey.xOnlyPublicKey(), "at $change/$index") + } + } + } + + @Test + fun `the account private key extends to the account xpub`() { + val extended = MemberWalletDerivation.accountPrivateKey(walletPrivateKey, chain) + assertEquals(account.extendedPublicKey, extended.extendedPublicKey) + assertNotEquals(walletKey, extended.publicKey, "the wallet key itself is never the account key") + } + + @Test + fun `the descriptors carry the tree and check out`() { + assertTrue(account.isGuarded) + val descriptor = account.receiveDescriptor + val (body, checksum) = descriptor.split('#') + assertEquals(Descriptor.checksum(body), checksum) + assertTrue(body.contains("and_v(v:pk("), "a leaf per guardian") + assertEquals(2, Regex("older\\(12\\)").findAll(body).count()) + } + + private fun coin(index: Int, sats: Long): Pair { + val derived = GroupWalletDerivation.derive(account, GroupWalletDerivation.RECEIVE, index.toLong()) + val tx = Transaction( + 2, + listOf(TxIn(OutPoint(TxId(ByteVector32(ByteArray(32) { (index + 1).toByte() })), 0), ByteVector.empty, 0xffffffffL)), + listOf(TxOut(Satoshi(sats), derived.pubkeyScript)), + 0, + ) + val meta = WalletState.AddressMeta.Derived(index) + return derived.address(chain) to WalletState.AddressState(meta, alreadyUsed = true, utxos = listOf(WalletState.Utxo(tx.txid, 0, 100, tx, meta))) + } + + private fun state(vararg coins: Pair): GroupWalletState { + val change = WalletState( + mapOf( + GroupWalletDerivation.derive(account, GroupWalletDerivation.CHANGE, 0).address(chain) to + WalletState.AddressState(WalletState.AddressMeta.Derived(0), false, emptyList()) + ) + ) + return GroupWalletState(account, WalletState(coins.toMap()), change, tipHeight = 110) + } + + private fun checked(result: GroupSpendBuilder.Result): GroupSpend.Checked { + val built = assertIs(result) + return assertIs(GroupSpend.check(built.psbt, account)).checked + } + + @Test + fun `a spend the member signs alone is one the network accepts`() { + val spend = checked( + GroupSpendBuilder.sendAll(state(coin(0, 60_000), coin(3, 40_000)), "bcrt1qw508d6qejxtdg4y5r3zarvary0c5xw7kygt080", 5L, emptySet()) + ) + val signatures = spend.inputs.map { MemberWalletDerivation.sign(walletPrivateKey, chain, it) } + val signed = spend.witnessed(signatures) + + assertEquals(2, signed.txIn.size) + signed.txIn.forEach { assertEquals(1, it.witness.stack.size, "a key-path spend reveals no tree") } + signed.correctlySpends(spend.inputs.associate { it.outPoint to it.txOut }, ScriptFlags.STANDARD_SCRIPT_VERIFY_FLAGS) + } + + @Test + fun `another key does not sign the member's coins`() { + val spend = checked( + GroupSpendBuilder.sendAll(state(coin(0, 60_000)), "bcrt1qw508d6qejxtdg4y5r3zarvary0c5xw7kygt080", 5L, emptySet()) + ) + assertFails { MemberWalletDerivation.sign(privateKey(0xb0b), chain, spend.inputs.single()) } + } + + @Test + fun `every guardian reaches its leaf in the member's wallet`() { + // The group itself, then its parent two generations up: the walk each + // signs a leaf with ends at the wallet id, as it would end at a room. + val groupLineage = GuardianDerivation.lineage(grant, walletId, groupRoom)!! + assertEquals(listOf(walletId), groupLineage) + val parentLineage = GuardianDerivation.lineage(grant, walletId, parentRoom)!! + assertEquals(listOf(groupRoom, walletId), parentLineage) + + listOf(groupKey to groupLineage, parentKey to parentLineage).forEachIndexed { position, (key, lineage) -> + val signing = GuardianDerivation.signingCache(key, lineage, chain, MemberWalletDerivation.ACCOUNT, 0, 4) + assertEquals(GuardianDerivation.leafKey(grant[position], chain, MemberWalletDerivation.ACCOUNT, 0, 4), signing.leafKey) + } + } +} From 3ec9fe098417d498c0905f72ab2c2779f3a388ab Mon Sep 17 00:00:00 2001 From: Kgothatso Ngako Date: Sat, 24 Oct 2026 07:21:31 +0200 Subject: [PATCH 04/21] feat(wallet): a member with no key state can learn what the group signs with (Phase 2) A member welcomed after a group's founding holds no key state, so cannot work out the leaves a guarded wallet of theirs would carry. They ask with a 30336 GroupKeyNoticeEvent; any member holding the verified key state answers with the threshold key, its path and the group's certificate. The answer is believed only for what checks itself -- the key rederives the room, the certificate certifies it and names that key -- and is read where it is used, never filed as key state. It carries the key rather than the signed key state because the key state's row keeps what it said and not the event. Co-Authored-By: Claude Opus 5.5 --- .../compose/database/model/ChatMessage.kt | 20 +++ .../compose/managers/MemberWalletManager.kt | 134 ++++++++++++++++ .../nostr/wallet/GroupKeyNoticeEvent.kt | 125 +++++++++++++++ .../bennu/compose/managers/GroupFixtures.kt | 150 ++++++++++++++++++ .../compose/managers/GroupKeyNoticeJvmTest.kt | 139 ++++++++++++++++ 5 files changed, 568 insertions(+) create mode 100644 composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/MemberWalletManager.kt create mode 100644 composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/nostr/wallet/GroupKeyNoticeEvent.kt create mode 100644 composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/GroupFixtures.kt create mode 100644 composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/GroupKeyNoticeJvmTest.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 129fe10c..bbbdf40b 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 @@ -12,6 +12,8 @@ import com.machankura.bennu.compose.database.model.traits.TimestampedEntity import com.machankura.bennu.compose.database.model.traits.UserViewableEntity import com.machankura.bennu.compose.exceptions.MarmotUnprocessableInnerEventException import com.machankura.bennu.compose.managers.ChronicleManager +import com.machankura.bennu.compose.managers.MemberWalletManager +import com.machankura.bennu.compose.nostr.wallet.GroupKeyNoticeEvent import com.machankura.bennu.compose.managers.GroupKeyStateManager import com.machankura.bennu.compose.managers.GroupWalletManager import com.machankura.bennu.compose.managers.GuardianManager @@ -980,6 +982,24 @@ data class ChatMessage( return null } + // A member asking what the group signs with, so their device + // can work out a guarded wallet's leaves, or a member + // answering. Plumbing, so no line either way: the row above + // is the record, and an answer is checked each time it is + // read. Answered like the chronicle's request -- by any + // member holding the key state, none elected. + // docs/member-guarded-wallets.md, Phase 2. + if (event.kind == GroupKeyNoticeEvent.KIND) { + MemberWalletManager.answerKeyRequest( + database = database, + chatRoomId = groupEventResult.groupId, + request = event, + userPublicKey = activeKeyPair.pubKey.toHex(), + ) + + return null + } + applyInnerEvent( database = database, groupId = groupEventResult.groupId, diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/MemberWalletManager.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/MemberWalletManager.kt new file mode 100644 index 00000000..12b1c90f --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/MemberWalletManager.kt @@ -0,0 +1,134 @@ +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.MarmotInnerEvent +import com.machankura.bennu.compose.nostr.wallet.GroupKeyNoticeEvent +import com.vitorpamplona.quartz.nip01Core.core.Event +import com.vitorpamplona.quartz.nip01Core.core.HexKey +import com.vitorpamplona.quartz.nip01Core.crypto.EventHasher +import kotlin.time.Clock +import kotlin.time.Instant + +/** + * A member's guarded wallet, from the asking to the guarding: + * `docs/member-guarded-wallets.md`. + * + * The member's device makes a random key, works out every ancestor leaf, stores + * the key and only then asks the group. A signer puts the request to the group, + * the group's quorum signs a certificate saying it guards that key for that + * person, and the certificate is what every device opens the wallet on. + */ +object MemberWalletManager { + private const val TAG = "MemberWalletManager" + + private val logger = Logger.withTag(TAG) + + /** + * The key [chatRoomId] signs with and the certificate it was born with -- + * what a member's grant is worked out from -- or null when this device knows + * neither. + * + * This device's own verified key state first. Behind it, the newest answer to + * a key notice in the room that checks out: a member welcomed after the + * founding holds no key state, and asks (`askForGroupKey`). Never filed as + * key state -- see [GroupKeyNoticeEvent]. + */ + suspend fun groupKeyFor(database: BennuDatabase, chatRoomId: String): GroupKeyNoticeEvent.GroupKey? { + GroupKeyStateManager.keyStateFor(database, chatRoomId)?.takeIf { it.verifies() }?.let { state -> + return GroupKeyNoticeEvent.GroupKey( + chatRoomId = state.chatRoomId, + thresholdPublicKey = state.thresholdPublicKey, + certificate = state.birthCertificateJson?.let { Event.fromJsonOrNull(it) }, + ) + } + + return noticesIn(database, chatRoomId) + .sortedByDescending { it.createdAt } + .firstNotNullOfOrNull { GroupKeyNoticeEvent.read(it, chatRoomId) } + } + + /** + * Asks [chatRoomId] for its key, as [userPublicKey]. Returns false, asking + * nothing, when this device already knows it or has asked and not been + * answered: a second question would get the same answer. + */ + suspend fun askForGroupKey(database: BennuDatabase, chatRoomId: String, userPublicKey: HexKey): Boolean { + if (groupKeyFor(database, chatRoomId) != null) return false + + val notices = noticesIn(database, chatRoomId) + val answered = notices.mapNotNull { GroupKeyNoticeEvent.answers(it) }.toSet() + if (notices.any { GroupKeyNoticeEvent.isAsking(it) && it.pubKey == userPublicKey && it.id !in answered }) return false + + queue(database, chatRoomId, userPublicKey, GroupKeyNoticeEvent.askingTags(chatRoomId), content = "") + logger.i("Asked $chatRoomId for its key") + return true + } + + /** + * Answers [request], an asking notice that arrived in [chatRoomId], as + * [userPublicKey] -- when this device holds the room's verified key state and + * nobody has answered it yet. Returns whether it answered. + * + * Any member holding the state may answer, and none is elected to: a + * duplicate answer costs bandwidth and nothing else, since every answer is + * checked on its own and they all say the same thing. The chronicle's + * request is answered the same way. + */ + suspend fun answerKeyRequest(database: BennuDatabase, chatRoomId: String, request: Event, userPublicKey: HexKey): Boolean { + if (!GroupKeyNoticeEvent.isAsking(request) || request.pubKey == userPublicKey) return false + val state = GroupKeyStateManager.keyStateFor(database, chatRoomId)?.takeIf { it.verifies() } ?: return false + val path = state.pathIndices() ?: return false + if (noticesIn(database, chatRoomId).any { GroupKeyNoticeEvent.answers(it) == request.id }) return false + + val groupKey = GroupKeyNoticeEvent.GroupKey( + chatRoomId = state.chatRoomId, + thresholdPublicKey = state.thresholdPublicKey, + certificate = state.birthCertificateJson?.let { Event.fromJsonOrNull(it) }, + ) + queue(database, chatRoomId, userPublicKey, GroupKeyNoticeEvent.answeringTags(request.id, groupKey, path), content = state.thresholdPublicKey) + logger.i("Answered ${request.pubKey.take(8)}'s request for $chatRoomId's key") + return true + } + + private suspend fun noticesIn(database: BennuDatabase, chatRoomId: String): List = + database.marmotInnerEventDao() + .getByChatRoomAndKinds(chatRoomId, listOf(GroupKeyNoticeEvent.KIND)) + .map { it.asEvent() } + + /** + * A stored inner event as the event it was, unsigned: an inner event's + * authority is the MLS frame it arrived in, not a signature, so `sig` is + * empty here as it is everywhere inner events are read back. + */ + internal fun MarmotInnerEvent.asEvent(): Event = + Event(id = id, pubKey = publicKey, createdAt = createdAt.epochSeconds, kind = kind, tags = tags, content = content, sig = "") + + /** + * Queues one inner event in [chatRoomId] for the outbound pipeline, the way + * every inner event is: a row, which `encryptAndSendMarmotInnerEvent` sends. + */ + internal suspend fun queue( + database: BennuDatabase, + chatRoomId: String, + userPublicKey: HexKey, + tags: Array>, + content: String, + kind: Int = GroupKeyNoticeEvent.KIND, + createdAt: Instant = Clock.System.now(), + ): HexKey { + val id = EventHasher.hashId(userPublicKey, createdAt.epochSeconds, kind, tags, content) + database.marmotInnerEventDao().upsert( + MarmotInnerEvent( + id = id, + publicKey = userPublicKey, + kind = kind, + createdAt = createdAt, + tags = tags, + content = content, + chatRoomId = chatRoomId, + ) + ) + return id + } +} diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/nostr/wallet/GroupKeyNoticeEvent.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/nostr/wallet/GroupKeyNoticeEvent.kt new file mode 100644 index 00000000..e35f563f --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/nostr/wallet/GroupKeyNoticeEvent.kt @@ -0,0 +1,125 @@ +package com.machankura.bennu.compose.nostr.wallet + +import com.machankura.bennu.compose.managers.GuardianDerivation +import com.machankura.bennu.compose.managers.SharedKeyDerivation +import com.machankura.bennu.compose.nostr.subgroup.SubgroupBirthCertificateEvent +import com.machankura.bennu.compose.nostr.subgroup.tags.SubgroupBirthCertificateTag +import com.vitorpamplona.quartz.nip01Core.core.Event +import com.vitorpamplona.quartz.nip01Core.core.HexKey +import com.vitorpamplona.quartz.nip01Core.core.Kind + +/** + * A member asking the group for its key, and a member answering -- the two + * things a guarded wallet's grant is worked out from. + * + * A member's guarded wallet carries the group's leaf and its ancestors' leaves, + * and the member's own device works them out before it asks the group to guard + * anything: `GuardianDerivation.grant` over the group's threshold key and the + * guardian keys in the group's own birth certificate. Both are read off the + * group's verified key state, which only ceremony participants hold. A member + * welcomed later has neither. See `docs/member-guarded-wallets.md`, D4. + * + * ``` + * member without a key state --[ 30336, no content ]-> the room "what does this group sign with?" + * member holding one --[ 30336, the key + its cert ]-> the room + * the asking device checks the answer on its own + * ``` + * + * ### Nothing the answerer says is taken on its word + * + * The answer carries the threshold key, the path, and the certificate if the + * group has one, and every one of them checks itself: the key at the path + * rederives the room's id, and the certificate certifies that room and names + * that key. A forged answer cannot name another key, and one that leaves out or + * swaps the certificate gives a grant every signer refuses, because each signer + * works the grant out again from its own key state. + * + * The signed key state itself is not carried: its row keeps what it said and not + * the event, and nothing in it is needed beyond what checks itself. + * + * ### Never filed as key state + * + * An answer is read in one place, for one purpose, every time it is used. Filing + * it into `GroupKeyState` would give every late member a key state and quietly + * change what `GroupWalletManager.thresholdKeyFor` answers for them across the + * app. + * + * ### Why 30336 + * + * After the member wallet's certificate (30334) and request (30335). + */ +object GroupKeyNoticeEvent { + val KIND: Kind = 30336 + + private const val ROOM_TAG = "h" + private const val REQUEST_TAG = "e" + private const val PATH_TAG = "frost_path" + + /** What a group signs with, as a member's device has checked it. */ + data class GroupKey( + val chatRoomId: String, + val thresholdPublicKey: HexKey, + /** The group's own birth certificate, or null for a group nobody's subgroup. */ + val certificate: Event?, + ) { + /** The guardian keys the group's certificate grants it, nearest first: what it passes down. */ + val guardians: List + get() = certificate?.let { SubgroupBirthCertificateEvent.parseGuardians(it.tags) }.orEmpty() + } + + /** The asking shape's tags. */ + fun askingTags(chatRoomId: String): Array> = arrayOf(arrayOf(ROOM_TAG, chatRoomId)) + + /** The answering shape's tags, answering [requestId]. The content is [GroupKey.thresholdPublicKey]. */ + fun answeringTags(requestId: HexKey, groupKey: GroupKey, path: List): Array> = + listOfNotNull( + arrayOf(ROOM_TAG, groupKey.chatRoomId), + arrayOf(REQUEST_TAG, requestId), + arrayOf(PATH_TAG, SharedKeyDerivation.formatPath(path)), + groupKey.certificate?.let { SubgroupBirthCertificateTag.assemble(it) }, + ).toTypedArray() + + /** Whether [event] asks rather than answers. */ + fun isAsking(event: Event): Boolean = event.kind == KIND && event.content.isBlank() + + /** The asking notice [event] answers, or null when it answers none. */ + fun answers(event: Event): HexKey? = + event.takeIf { it.kind == KIND && it.content.isNotBlank() }?.tags + ?.firstOrNull { it.size >= 2 && it[0] == REQUEST_TAG }?.get(1) + + /** + * The key [event] says [chatRoomId] signs with, or null when it is not an + * answer or does not check out: + * + * 1. it is an answer, and names [chatRoomId]; + * 2. the key at the path it names rederives [chatRoomId]; + * 3. a certificate it carries certifies [chatRoomId], names that key, and + * reads -- its guardian keys and its wallet policy both. One present and + * unreadable is refused rather than read as none, for the reason + * `GroupKeyStateManager.stateFrom` refuses it. + */ + fun read(event: Event, chatRoomId: String): GroupKey? = runCatching { + if (event.kind != KIND || event.content.isBlank()) return null + fun value(name: String): String? = event.tags.firstOrNull { it.size >= 2 && it[0] == name }?.get(1) + if (!value(ROOM_TAG).equals(chatRoomId, ignoreCase = true)) return null + + val thresholdPublicKey = event.content.trim().lowercase() + val path = value(PATH_TAG)?.let { SharedKeyDerivation.parsePathString(it) } ?: return null + if (!SharedKeyDerivation.marmotGroupId(thresholdPublicKey, path).equals(chatRoomId, ignoreCase = true)) return null + + val certificateTags = event.tags.filter { it.isNotEmpty() && it[0] == SubgroupBirthCertificateTag.TAG_NAME } + if (certificateTags.size > 1) return null + val certificate = certificateTags.singleOrNull()?.let { tag -> + SubgroupBirthCertificateTag.parse(tag)?.certificate ?: return null + } + if (certificate != null) { + val parentChatRoomId = SubgroupBirthCertificateEvent.parseParentChatRoomId(certificate.tags) ?: return null + if (!SubgroupBirthCertificateEvent.certifies(certificate, chatRoomId, parentChatRoomId)) return null + if (!SubgroupBirthCertificateEvent.parseThresholdPublicKey(certificate.tags).equals(thresholdPublicKey, ignoreCase = true)) return null + SubgroupBirthCertificateEvent.parseGuardians(certificate.tags) ?: return null + SubgroupBirthCertificateEvent.parseWalletPolicy(certificate.tags) ?: return null + } + + GroupKey(chatRoomId = chatRoomId.lowercase(), thresholdPublicKey = thresholdPublicKey, certificate = certificate) + }.getOrNull() +} diff --git a/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/GroupFixtures.kt b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/GroupFixtures.kt new file mode 100644 index 00000000..766c88fb --- /dev/null +++ b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/GroupFixtures.kt @@ -0,0 +1,150 @@ +package com.machankura.bennu.compose.managers + +import com.machankura.bennu.compose.database.BennuDatabase +import com.machankura.bennu.compose.database.model.ChatRoom +import com.machankura.bennu.compose.database.model.GroupKeyState +import com.machankura.bennu.compose.database.model.NostrEvent +import com.machankura.bennu.compose.database.model.Profile +import com.machankura.bennu.compose.extensions.toHex +import com.machankura.bennu.compose.nostr.subgroup.SubgroupBirthCertificateEvent +import com.machankura.bennu.compose.nostr.subgroup.SubgroupWalletPolicy +import com.vitorpamplona.quartz.nip01Core.core.Event +import com.vitorpamplona.quartz.nip01Core.core.HexKey +import com.vitorpamplona.quartz.nip01Core.core.hexToByteArray +import com.vitorpamplona.quartz.nip01Core.crypto.EventHasher +import fr.acinq.bitcoin.ByteVector +import fr.acinq.bitcoin.ByteVector32 +import fr.acinq.bitcoin.PrivateKey +import fr.acinq.bitcoin.crypto.frost.Frost +import fr.acinq.bitcoin.crypto.frost.IndividualNonce +import fr.acinq.bitcoin.crypto.frost.KeyMaterial +import fr.acinq.bitcoin.crypto.frost.SecretNonce +import fr.acinq.bitcoin.crypto.frost.Session +import kotlin.time.Instant + +/** + * Groups with real keys, for the tests that need a group's signature on + * something: a trusted-dealer key per group, its room id, and a 2-of-3 FROST + * signature as the room. The shape `SubgroupManagerJvmTest` builds inline, kept + * in one place for the member-wallet tests, which need a parent, a group and a + * certificate between them in nearly every case. + */ +internal object GroupFixtures { + private const val PARTICIPANTS = 3 + private const val THRESHOLD = 2 + + val path: List = SharedKeyDerivation.MARMOT_ADMIN_GROUP_PATH + + fun keyMaterial(secret: String): KeyMaterial = Frost.trustedDealerKeygen( + thresholdSecretKey = PrivateKey(ByteVector32(secret.padStart(64, '0'))), + nParticipants = PARTICIPANTS, + threshold = THRESHOLD, + ) + + fun thresholdKeyOf(material: KeyMaterial): HexKey = material.thresholdPublicKey.value.toHex() + + fun roomOf(material: KeyMaterial): String = SharedKeyDerivation.marmotGroupId(thresholdKeyOf(material), path) + + /** [kind] over [tags] and [content], signed by [material]'s quorum as its room. */ + fun signedAsRoom(material: KeyMaterial, kind: Int, tags: Array>, content: String, createdAt: Long = 1_700_000_000): Event { + val pubKey = roomOf(material) + val id = EventHasher.hashId(pubKey = pubKey, createdAt = createdAt, kind = kind, tags = tags, content = content) + return Event(id = id, pubKey = pubKey, createdAt = createdAt, kind = kind, tags = tags, content = content, sig = signature(material, id)) + } + + /** + * [parent]'s certificate for [child], granting [guardians] under [policy] -- + * the grant is the caller's, so a test can hand over a wrong one. + */ + fun birthCertificate( + parent: KeyMaterial, + child: KeyMaterial, + guardians: List, + policy: SubgroupWalletPolicy? = if (guardians.isEmpty()) SubgroupWalletPolicy.UNGUARDED else SubgroupWalletPolicy.GUARDED, + admins: List = listOf("a".repeat(64)), + ): Event = signedAsRoom( + material = parent, + kind = SubgroupBirthCertificateEvent.KIND, + tags = SubgroupBirthCertificateEvent.assembleTags( + subgroupChatRoomId = roomOf(child), + parentChatRoomId = roomOf(parent), + thresholdPublicKey = thresholdKeyOf(child), + adminPublicKeys = admins, + name = "#Child", + path = path, + guardians = guardians, + walletPolicy = policy, + ), + content = roomOf(child), + ) + + /** [parent]'s guarded certificate for [child], with exactly the grant a parent with no parent makes. */ + fun guardedCertificate(parent: KeyMaterial, child: KeyMaterial): Event = + birthCertificate(parent, child, GuardianDerivation.grant(thresholdKeyOf(parent), roomOf(parent), emptyList(), roomOf(child))) + + /** [material]'s verified key state on this device, carrying [certificate] when it is somebody's subgroup. */ + suspend fun fileKeyState(db: BennuDatabase, material: KeyMaterial, certificate: Event? = null) { + seedRoom(db, roomOf(material)) + db.groupKeyStateDao().upsert( + GroupKeyState( + chatRoomId = roomOf(material), + dkgSessionId = "ceremony-" + roomOf(material).take(8), + thresholdPublicKey = thresholdKeyOf(material), + derivationPath = SharedKeyDerivation.formatPath(path), + announcedBy = roomOf(material), + announcedAt = Instant.fromEpochSeconds(1_700_000_000), + parentChatRoomId = certificate?.let { SubgroupBirthCertificateEvent.parseParentChatRoomId(it.tags) }, + birthCertificateJson = certificate?.toJson(), + ) + ) + } + + /** The device's own profile, which every room row names. */ + val owner: HexKey = "0e".repeat(32) + + suspend fun seedProfile(db: BennuDatabase, publicKey: HexKey, name: String = "member") { + if (db.profileDao().getProfileByPublicKey(publicKey) != null) return + val nostrEventId = publicKey.take(63) + "f" + db.nostrEventDao().upsert( + NostrEvent(id = nostrEventId, pubKey = publicKey, kind = 0, tags = emptyArray(), content = "{}", sig = "0".repeat(128)) + ) + db.profileDao().upsert(Profile(publicKey = publicKey, userName = name, nostrEventId = nostrEventId)) + } + + /** A room row for [chatRoomId], if there is none: what a key state, a signed event or a session hangs off. */ + suspend fun seedRoom(db: BennuDatabase, chatRoomId: String, subject: String? = null) { + seedProfile(db, owner) + if (db.chatRoomDao().findChatRoomById(chatRoomId) != null) return + db.chatRoomDao().upsert(ChatRoom(id = chatRoomId, userPublicKey = owner, subject = subject, description = null, mlsGroupState = null)) + } + + private fun signature(material: KeyMaterial, eventId: String): String { + val cache = SharedKeyDerivation.derive(thresholdKeyOf(material), path).cache + val message = ByteVector(eventId.hexToByteArray()) + val signerIds = listOf(0, 1) + + val nonces = signerIds.map { signerId -> + SecretNonce.generate( + sessionRandom = ByteVector32("a".repeat(63) + "${signerId + 1}"), + secretShare = material.secretShares[signerId], + publicShare = material.publicShares[signerId], + tweakedThresholdPublicKey = cache.tweakedPublicKey, + message = message, + extraInput = null, + ) + } + val session = Session.create( + aggregatedNonce = IndividualNonce.aggregate(nonces.map { it.second }).right!!, + signerIds = signerIds.map { it.toUInt() }, + signerPublicShares = signerIds.map { material.publicShares[it] }, + nParticipants = PARTICIPANTS, + threshold = THRESHOLD, + tweakCache = cache, + message = message, + ) + val partials = signerIds.mapIndexed { position, signerId -> + session.sign(nonces[position].first, material.secretShares[signerId], signerId.toUInt()).right!! + } + return session.aggregateSigs(partials).right!!.toByteArray().toHex() + } +} diff --git a/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/GroupKeyNoticeJvmTest.kt b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/GroupKeyNoticeJvmTest.kt new file mode 100644 index 00000000..f3e4961f --- /dev/null +++ b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/GroupKeyNoticeJvmTest.kt @@ -0,0 +1,139 @@ +package com.machankura.bennu.compose.managers + +import androidx.room3.Room +import com.machankura.bennu.compose.database.BennuDatabase +import com.machankura.bennu.compose.database.builder.getRoomDatabase +import com.machankura.bennu.compose.database.model.MarmotInnerEvent +import com.machankura.bennu.compose.managers.GroupFixtures.fileKeyState +import com.machankura.bennu.compose.managers.GroupFixtures.guardedCertificate +import com.machankura.bennu.compose.managers.GroupFixtures.keyMaterial +import com.machankura.bennu.compose.managers.GroupFixtures.roomOf +import com.machankura.bennu.compose.managers.GroupFixtures.thresholdKeyOf +import com.machankura.bennu.compose.managers.MemberWalletManager.asEvent +import com.machankura.bennu.compose.nostr.subgroup.SubgroupBirthCertificateEvent +import com.machankura.bennu.compose.nostr.wallet.GroupKeyNoticeEvent +import com.vitorpamplona.quartz.nip01Core.core.Event +import com.vitorpamplona.quartz.nip01Core.core.toHexKey +import com.vitorpamplona.quartz.nip01Core.crypto.EventHasher +import com.vitorpamplona.quartz.nip01Core.crypto.KeyPair +import kotlinx.coroutines.runBlocking +import kotlin.test.AfterTest +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFalse +import kotlin.test.assertNotNull +import kotlin.test.assertNull +import kotlin.test.assertTrue +import kotlin.time.Instant + +/** + * A member who holds no key state asking what the group signs with, and a member + * who holds one answering -- two devices, two databases, the inner-event rows + * carried from one to the other as the MLS room would carry them. + * + * The negative cases carry the weight: an answer is believed only for what it + * can prove about itself, and never filed as the room's key state. + */ +class GroupKeyNoticeJvmTest { + private val asking: BennuDatabase = getRoomDatabase(Room.inMemoryDatabaseBuilder()) + private val answering: BennuDatabase = getRoomDatabase(Room.inMemoryDatabaseBuilder()) + + @AfterTest + fun closeDbs() { + asking.close() + answering.close() + } + + private val parent = keyMaterial("9a9e") + private val group = keyMaterial("6a0b") + private val stranger = keyMaterial("57a9") + private val groupRoom = roomOf(group) + private val certificate = guardedCertificate(parent, group) + + private val member = KeyPair().pubKey.toHexKey() + private val signer = KeyPair().pubKey.toHexKey() + + /** Carries every row of [kind] in the group's room from [from] to [to], as the room would. */ + private suspend fun deliver(from: BennuDatabase, to: BennuDatabase) = + from.marmotInnerEventDao().getByChatRoomAndKinds(groupRoom, listOf(GroupKeyNoticeEvent.KIND)).forEach { to.marmotInnerEventDao().upsert(it) } + + @Test + fun `a member with no key state asks, is answered, and learns the key and the certificate`(): Unit = runBlocking { + fileKeyState(answering, group, certificate) + + assertNull(MemberWalletManager.groupKeyFor(asking, groupRoom)) + assertTrue(MemberWalletManager.askForGroupKey(asking, groupRoom, member)) + assertFalse(MemberWalletManager.askForGroupKey(asking, groupRoom, member), "asked and not yet answered") + + deliver(asking, answering) + val request = answering.marmotInnerEventDao().getByChatRoomAndKinds(groupRoom, listOf(GroupKeyNoticeEvent.KIND)).single().asEvent() + assertTrue(MemberWalletManager.answerKeyRequest(answering, groupRoom, request, signer)) + assertFalse(MemberWalletManager.answerKeyRequest(answering, groupRoom, request, signer), "answered once") + + deliver(answering, asking) + val groupKey = assertNotNull(MemberWalletManager.groupKeyFor(asking, groupRoom)) + assertEquals(thresholdKeyOf(group), groupKey.thresholdPublicKey) + assertEquals(certificate.id, groupKey.certificate?.id) + assertEquals(SubgroupBirthCertificateEvent.parseGuardians(certificate.tags), groupKey.guardians) + + assertNull(asking.groupKeyStateDao().getByChatRoomId(groupRoom), "an answer is never filed as key state") + assertFalse(MemberWalletManager.askForGroupKey(asking, groupRoom, member), "nothing left to ask") + } + + @Test + fun `a device that holds no key state answers nothing`(): Unit = runBlocking { + MemberWalletManager.askForGroupKey(asking, groupRoom, member) + deliver(asking, answering) + val request = answering.marmotInnerEventDao().getByChatRoomAndKinds(groupRoom, listOf(GroupKeyNoticeEvent.KIND)).single().asEvent() + + assertFalse(MemberWalletManager.answerKeyRequest(answering, groupRoom, request, signer)) + } + + private fun answer(content: String, tags: Array>): Event { + val pubKey = signer + val id = EventHasher.hashId(pubKey, 1_700_000_000, GroupKeyNoticeEvent.KIND, tags, content) + return Event(id, pubKey, 1_700_000_000, GroupKeyNoticeEvent.KIND, tags, content, "") + } + + private fun answerFor(groupKey: GroupKeyNoticeEvent.GroupKey): Event = + answer(groupKey.thresholdPublicKey, GroupKeyNoticeEvent.answeringTags("e".repeat(64), groupKey, GroupFixtures.path)) + + @Test + fun `an answer is believed only for what it proves`() { + val honest = GroupKeyNoticeEvent.GroupKey(groupRoom, thresholdKeyOf(group), certificate) + assertNotNull(GroupKeyNoticeEvent.read(answerFor(honest), groupRoom)) + + // Another group's key does not derive this room. + assertNull(GroupKeyNoticeEvent.read(answerFor(honest.copy(thresholdPublicKey = thresholdKeyOf(stranger))), groupRoom)) + // An answer about another room is not one about this room. + assertNull(GroupKeyNoticeEvent.read(answerFor(honest), roomOf(stranger))) + // A certificate for another child does not certify this one. + val elsewhere = guardedCertificate(parent, stranger) + assertNull(GroupKeyNoticeEvent.read(answerFor(honest.copy(certificate = elsewhere)), groupRoom)) + // A certificate whose signature is not the parent's. + val forged = Event(certificate.id, certificate.pubKey, certificate.createdAt, certificate.kind, certificate.tags, certificate.content, "0".repeat(128)) + assertNull(GroupKeyNoticeEvent.read(answerFor(honest.copy(certificate = forged)), groupRoom)) + // The asking shape is not an answer. + assertNull(GroupKeyNoticeEvent.read(answer("", GroupKeyNoticeEvent.askingTags(groupRoom)), groupRoom)) + // A root group's answer, with no certificate, reads with no guardians. + val root = GroupKeyNoticeEvent.read(answerFor(GroupKeyNoticeEvent.GroupKey(roomOf(parent), thresholdKeyOf(parent), null)), roomOf(parent)) + assertEquals(emptyList(), assertNotNull(root).guardians) + } + + @Test + fun `an answer that does not check out leaves the member asking`(): Unit = runBlocking { + val forged = answerFor(GroupKeyNoticeEvent.GroupKey(groupRoom, thresholdKeyOf(stranger), null)) + asking.marmotInnerEventDao().upsert( + MarmotInnerEvent( + id = forged.id, + publicKey = forged.pubKey, + kind = forged.kind, + createdAt = Instant.fromEpochSeconds(forged.createdAt), + tags = forged.tags, + content = forged.content, + chatRoomId = groupRoom, + ) + ) + assertNull(MemberWalletManager.groupKeyFor(asking, groupRoom)) + } +} From 39c3e128fb2a6dc93371c4b71ee2149747b8a0f8 Mon Sep 17 00:00:00 2001 From: Kgothatso Ngako Date: Sat, 24 Oct 2026 07:21:57 +0200 Subject: [PATCH 05/21] feat(wallet): an ancestor funds a guarded wallet two past its current address (Phase 1) GroupWalletState.fundingAddress picks the lowest unused, unreserved receive index from current + ADDRESSES_AHEAD up to the end of the watched window, and GroupSpend.claimedFundingIndices reads what open fundings already hold. Co-Authored-By: Claude Opus 5.5 --- .../compose/wallet/GroupOnchainWallet.kt | 29 +++++++ .../bennu/compose/wallet/GroupSpend.kt | 13 ++++ .../wallet/GroupOnchainWalletJvmTest.kt | 76 +++++++++++++++++++ 3 files changed, 118 insertions(+) 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 6b51bf65..b7294d5e 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 @@ -230,6 +230,35 @@ data class GroupWalletState( } } + /** + * The receive address an ancestor pays when it funds this wallet: the lowest + * unused index from [GroupOnchainWallet.ADDRESSES_AHEAD] past the current one + * that [reserved] -- the indices open fundings already pay -- does not hold, + * and that the wallet watches. Null before Electrum has answered, for the + * reason [receiveAddress] is, and when every such index is held. + * + * Not the current address: the wallet's own members are handing that one + * out, and every device computes the same one. Starting at the top of the + * address list's window and going up keeps an ancestor out of their way. + * See `docs/guarded-wallet-funding.md`, D2. + */ + fun fundingAddress(reserved: Set = emptySet()): GroupAddress? { + val current = receive.firstUnusedDerivedAddress?.second?.index ?: return null + val window = (current + GroupOnchainWallet.ADDRESSES_AHEAD) until (current + GroupOnchainWallet.RECEIVE_LOOKAHEAD.toInt()) + val (address, index) = receive.addresses.entries + .filterNot { it.value.alreadyUsed } + .mapNotNull { (address, addressState) -> addressState.meta.indexOrNull?.let { address to it } } + .filter { (_, index) -> index in window && index.toLong() !in reserved } + .minByOrNull { (_, index) -> index } + ?: return null + return GroupAddress( + derivation = GroupWalletDerivation.derive(account, GroupWalletDerivation.RECEIVE, index.toLong()), + address = address, + status = GroupAddress.Status.NEXT, + balance = Satoshi(0), + ) + } + /** 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 } 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 22204027..77eeb3e5 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 @@ -298,6 +298,19 @@ object GroupSpend { .mapNotNull { path -> path.keyPath.path.takeIf { it.size == 2 && it[0] == GroupWalletDerivation.CHANGE }?.get(1) } .toSet() + /** + * The receive indices under [account] -- a descendant's guarded wallet -- + * that [psbt]'s outputs claim to fund: what an open funding holds, so the + * next one pays a different address. Claims, as [claimedChangeIndices] are, + * for the same reason. See `docs/guarded-wallet-funding.md`. + */ + fun claimedFundingIndices(psbt: Psbt, account: GroupWalletDerivation.Account): Set = + psbt.outputs + .flatMap { it.taprootDerivationPaths.values } + .filter { isOurs(it, account) } + .mapNotNull { path -> path.keyPath.path.takeIf { it.size == 2 && it[0] == GroupWalletDerivation.RECEIVE }?.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/jvmTest/kotlin/com/machankura/bennu/compose/wallet/GroupOnchainWalletJvmTest.kt b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/wallet/GroupOnchainWalletJvmTest.kt index 61150c11..d1915e8b 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 @@ -7,6 +7,7 @@ import fr.acinq.bitcoin.Chain import fr.acinq.bitcoin.PrivateKey import fr.acinq.bitcoin.Satoshi import fr.acinq.lightning.blockchain.electrum.HeaderSubscriptionResponse +import fr.acinq.lightning.blockchain.electrum.WalletState import fr.acinq.secp256k1.Hex import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.Dispatchers @@ -242,4 +243,79 @@ class GroupOnchainWalletJvmTest { assertEquals(Satoshi(7_000), used.balance) assertEquals(before.listed(), state.listed()) } + + @Test + fun `a fresh wallet is funded two past the current address`() { + val wallet = GroupOnchainWallet(account, FakeElectrum(), scope) + + val state = eventually { wallet.state.first { it.receive.addresses.size == GroupOnchainWallet.RECEIVE_LOOKAHEAD.toInt() } } + val funding = state.fundingAddress()!! + assertEquals(receive(2), funding.derivation) + assertEquals(receive(2).address(Chain.Regtest), funding.address) + assertEquals(GroupAddress.Status.NEXT, funding.status) + } + + @Test + fun `an open funding holds its address and the window ends where the watching does`() { + val wallet = GroupOnchainWallet(account, FakeElectrum(), scope) + val lookAhead = GroupOnchainWallet.RECEIVE_LOOKAHEAD.toLong() + + val state = eventually { wallet.state.first { it.receive.addresses.size == lookAhead.toInt() } } + assertEquals(receive(3), state.fundingAddress(setOf(2L))!!.derivation) + val held = (GroupOnchainWallet.ADDRESSES_AHEAD.toLong() until lookAhead).toSet() + assertEquals(receive(lookAhead - 1), state.fundingAddress(held - (lookAhead - 1))!!.derivation) + assertNull(state.fundingAddress(held), "past the last watched address the child would not see the payment") + } + + @Test + fun `being paid moves the funding address on`() { + val electrum = FakeElectrum() + val wallet = GroupOnchainWallet(account, electrum, scope) + + eventually { wallet.state.first { it.receiveAddress != null } } + eventually { electrum.pay(receive(0).pubkeyScript, Satoshi(25_000)) } + + val state = eventually { wallet.state.first { it.receiveAddress == receive(1).address(Chain.Regtest) } } + assertEquals(receive(3), state.fundingAddress()!!.derivation) + } + + @Test + fun `a paid address above the current one is never funded`() { + val electrum = FakeElectrum() + val wallet = GroupOnchainWallet(account, electrum, scope) + + eventually { wallet.state.first { it.receiveAddress != null } } + eventually { electrum.pay(receive(4).pubkeyScript, Satoshi(10_000)) } + + val state = eventually { wallet.state.first { it.receiveAddresses?.any { it.status == GroupAddress.Status.USED } == true } } + assertEquals(receive(0).address(Chain.Regtest), state.receiveAddress) + assertEquals(receive(2), state.fundingAddress()!!.derivation) + assertEquals(receive(3), state.fundingAddress(setOf(2L))!!.derivation) + assertEquals(receive(5), state.fundingAddress(setOf(2L, 3L))!!.derivation) + } + + @Test + fun `no funding address before Electrum has answered`() { + val state = GroupWalletState(account, WalletState.empty, WalletState.empty, tipHeight = null) + assertNull(state.fundingAddress()) + } + + @Test + fun `every funding address is one the wallet watches`() { + val electrum = FakeElectrum() + val wallet = GroupOnchainWallet(account, electrum, scope) + + eventually { wallet.state.first { it.receiveAddress != null } } + eventually { electrum.pay(receive(0).pubkeyScript, Satoshi(1_000)) } + + val state = eventually { wallet.state.first { it.receiveAddress == receive(1).address(Chain.Regtest) } } + val watched = state.receive.addresses.keys + var reserved = emptySet() + while (true) { + val funding = state.fundingAddress(reserved) ?: break + assertTrue(funding.address in watched, "${funding.derivation.index} is funded but not watched") + reserved = reserved + funding.derivation.index + } + assertEquals(GroupOnchainWallet.RECEIVE_LOOKAHEAD.toInt() - GroupOnchainWallet.ADDRESSES_AHEAD, reserved.size) + } } From 58af30b8bff85850cf8fb0e1bef559e876ee2cea Mon Sep 17 00:00:00 2001 From: Kgothatso Ngako Date: Sat, 24 Oct 2026 07:24:25 +0200 Subject: [PATCH 06/21] feat(wallet): a member's request for a guarded wallet, signed twice (Phase 3) MemberWalletRequestEvent (30335) is the first thing that leaves the member's device: the wallet key, its id, every guardian leaf and both descriptors, signed by the member's nostr key and -- over a tagged possession message -- by the wallet key itself. verified() checks all of it that can be checked without the group's key, down to the descriptors byte for byte. An inner event is an unsigned rumor, so the room carries the signed request whole as an inner event's content, as a 30333 notice carries a statement; carried() takes it out only from the member who signed it. Co-Authored-By: Claude Opus 5.5 --- .../nostr/wallet/MemberWalletRequestEvent.kt | 232 ++++++++++++++++++ .../wallet/MemberWalletRequestEventTest.kt | 127 ++++++++++ 2 files changed, 359 insertions(+) create mode 100644 composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/nostr/wallet/MemberWalletRequestEvent.kt create mode 100644 composeApp/src/commonTest/kotlin/com/machankura/bennu/compose/nostr/wallet/MemberWalletRequestEventTest.kt diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/nostr/wallet/MemberWalletRequestEvent.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/nostr/wallet/MemberWalletRequestEvent.kt new file mode 100644 index 00000000..912edf7f --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/nostr/wallet/MemberWalletRequestEvent.kt @@ -0,0 +1,232 @@ +package com.machankura.bennu.compose.nostr.wallet + +import com.machankura.bennu.compose.managers.GroupWalletDerivation +import com.machankura.bennu.compose.managers.GuardianDerivation +import com.machankura.bennu.compose.managers.MemberWalletDerivation +import com.machankura.bennu.compose.nostr.frost.GroupKeyStateEvent +import com.machankura.bennu.compose.nostr.subgroup.tags.GuardianTag +import com.vitorpamplona.quartz.nip01Core.core.Event +import com.vitorpamplona.quartz.nip01Core.core.HexKey +import com.vitorpamplona.quartz.nip01Core.core.Kind +import com.vitorpamplona.quartz.nip01Core.core.hexToByteArray +import com.vitorpamplona.quartz.nip01Core.crypto.EventHasher +import fr.acinq.bitcoin.ByteVector32 +import fr.acinq.bitcoin.ByteVector64 +import fr.acinq.bitcoin.Chain +import fr.acinq.bitcoin.Crypto +import fr.acinq.bitcoin.PrivateKey +import fr.acinq.bitcoin.PublicKey +import kotlin.time.Clock + +/** + * A member asking their group to guard a wallet only they can spend from. + * + * The member's device has already made the wallet's key, worked out every + * ancestor's leaf and both descriptors, and stored the key. This is the first + * thing that leaves the device, and it carries all of it, so the group signs off + * on a wallet the member has already built rather than one it builds for them. + * See `docs/member-guarded-wallets.md`, Phase 3. + * + * ``` + * kind: 30335 + * pubkey: + * content: + * tags: + * ["h", G] the group asked + * ["wallet", W] + * ["wallet_key", ] + * ["chain", "mainnet" | "signet" | …] + * ["guardian", , , , "12"] one per guardian, nearest first + * ["descriptor", tr(…,{…}), "receive"] + * ["descriptor", tr(…,{…}), "change"] + * ["label", "Savings"] optional + * ["possession", ] + * ``` + * + * ### Signed twice + * + * By the member's nostr key, so it is bound to who asked, and -- in the + * `possession` tag -- by the wallet key itself, over [possessionMessage], so the + * member is shown to hold the key they are asking about. Without the second, Bob + * could ask for a certificate on Alice's wallet key under his own name. + * + * `k` signs exactly that one message, under its own tagged hash. It is never an + * output key: the account step always tweaks it first. + * + * ### Carried whole + * + * An inner event is an unsigned rumor -- its authority is the MLS frame -- and the + * row it travels in keeps no signature. This one's signature has to survive the + * room, because the group's certificate embeds it for ancestors who were never + * in the room. So the room carries an inner event of this kind whose content is + * the signed request, whole, as a 30333 notice carries a statement: [carried]. + * + * ### Never on a relay + * + * It carries an xpub, which is every address and the whole balance. + * + * ### Why 30335 + * + * After the certificate it asks for, at 30334. + */ +object MemberWalletRequestEvent { + val KIND: Kind = 30335 + + private const val ROOM_TAG = "h" + private const val WALLET_TAG = "wallet" + private const val WALLET_KEY_TAG = "wallet_key" + private const val CHAIN_TAG = "chain" + private const val DESCRIPTOR_TAG = "descriptor" + private const val RECEIVE_MARKER = "receive" + private const val CHANGE_MARKER = "change" + private const val LABEL_TAG = "label" + private const val POSSESSION_TAG = "possession" + + /** The tag of the possession signature's message. Frozen once a request carries one. */ + private const val POSSESSION_HASH_TAG = "bennu/member-wallet/possession/v1" + + /** The longest label a request carries: a name for a wallet, not a note. */ + const val MAX_LABEL_LENGTH = 64 + + /** What a request says, read but not yet believed. [verified] is what believes it. */ + data class Reading( + val memberPublicKey: HexKey, + val groupChatRoomId: String, + val walletId: String, + val walletKey: PublicKey, + val chain: Chain, + val xpub: String, + val receiveDescriptor: String, + val changeDescriptor: String, + val guardians: List, + val label: String?, + val possession: ByteVector64, + ) + + /** A request that checks out on everything a reader can check without the group's key. */ + data class Verified( + val request: Event, + val reading: Reading, + /** The account the request opens, rederived from the wallet key -- never what it said. */ + val account: GroupWalletDerivation.Account, + ) + + /** + * What `k` signs: the member, the group, the wallet key and the network -- + * everything that has to bind one key to one person in one group on one chain. + */ + fun possessionMessage(memberPublicKey: HexKey, groupChatRoomId: String, walletKey: PublicKey, chain: Chain): ByteVector32 = + Crypto.taggedHash( + memberPublicKey.lowercase().hexToByteArray() + + groupChatRoomId.lowercase().hexToByteArray() + + walletKey.value.toByteArray() + + chain.chainHash.value.toByteArray(), + POSSESSION_HASH_TAG, + ) + + /** + * The request for [account] -- opened under the wallet key [walletPrivateKey] + * holds -- of [groupChatRoomId], signed as the member [memberPrivateKey] holds. + */ + fun build( + memberPrivateKey: PrivateKey, + groupChatRoomId: String, + walletPrivateKey: PrivateKey, + account: GroupWalletDerivation.Account, + label: String?, + createdAt: Long = Clock.System.now().epochSeconds, + ): Event { + val memberPublicKey = memberPrivateKey.xOnlyPublicKey().value.toHex() + val walletKey = walletPrivateKey.publicKey() + require(account.extendedPublicKey == MemberWalletDerivation.account(walletKey, account.chain, account.guardians).extendedPublicKey) { + "the account is not the wallet key's" + } + val possession = Crypto.signSchnorr(possessionMessage(memberPublicKey, groupChatRoomId, walletKey, account.chain), walletPrivateKey, null) + + val tags = listOfNotNull( + arrayOf(ROOM_TAG, groupChatRoomId.lowercase()), + arrayOf(WALLET_TAG, MemberWalletDerivation.walletId(walletKey)), + arrayOf(WALLET_KEY_TAG, walletKey.toString()), + arrayOf(CHAIN_TAG, GroupWalletStatementEvent.chainName(account.chain)), + *account.guardians.map(GuardianTag::assemble).toTypedArray(), + arrayOf(DESCRIPTOR_TAG, account.receiveDescriptor, RECEIVE_MARKER), + arrayOf(DESCRIPTOR_TAG, account.changeDescriptor, CHANGE_MARKER), + label?.trim()?.takeIf { it.isNotEmpty() }?.let { arrayOf(LABEL_TAG, it.take(MAX_LABEL_LENGTH)) }, + arrayOf(POSSESSION_TAG, possession.toHex()), + ).toTypedArray() + + val id = EventHasher.hashId(memberPublicKey, createdAt, KIND, tags, account.xpub) + val sig = Crypto.signSchnorr(ByteVector32(id), memberPrivateKey, null) + return Event(id = id, pubKey = memberPublicKey, createdAt = createdAt, kind = KIND, tags = tags, content = account.xpub, sig = sig.toHex()) + } + + /** The request's fields, or null when any is missing, doubled or the wrong shape. Nothing is verified here. */ + fun read(event: Event): Reading? = runCatching { + if (event.kind != KIND) return null + fun single(name: String): String? = + event.tags.filter { it.isNotEmpty() && it[0] == name }.takeIf { it.size == 1 }?.single()?.takeIf { it.size >= 2 }?.get(1) + fun descriptor(marker: String): String? = + event.tags.filter { it.size >= 3 && it[0] == DESCRIPTOR_TAG && it[2] == marker }.singleOrNull()?.get(1) + + val labels = event.tags.filter { it.isNotEmpty() && it[0] == LABEL_TAG } + if (labels.size > 1) return null + val label = labels.singleOrNull()?.getOrNull(1)?.takeIf { it.isNotBlank() && it.length <= MAX_LABEL_LENGTH } + if (labels.isNotEmpty() && label == null) return null + + Reading( + memberPublicKey = event.pubKey.lowercase(), + groupChatRoomId = single(ROOM_TAG)?.lowercase() ?: return null, + walletId = single(WALLET_TAG)?.lowercase() ?: return null, + walletKey = single(WALLET_KEY_TAG)?.let { PublicKey.fromHex(it) }?.takeIf { it.isValid() } ?: return null, + chain = single(CHAIN_TAG)?.let(GroupWalletStatementEvent::chainNamed) ?: return null, + xpub = event.content.takeIf { it.isNotBlank() } ?: return null, + receiveDescriptor = descriptor(RECEIVE_MARKER) ?: return null, + changeDescriptor = descriptor(CHANGE_MARKER) ?: return null, + guardians = GuardianTag.parseAll(event.tags)?.takeIf { it.isNotEmpty() } ?: return null, + label = label, + possession = single(POSSESSION_TAG)?.let { ByteVector64(it) } ?: return null, + ) + }.getOrNull() + + /** + * [event] believed, on everything a reader can check without the group's key: + * + * 1. it is a request, signed by the member it names; + * 2. its wallet id is the wallet key's; + * 3. the wallet key signed the possession message; + * 4. its nearest guardian is the group it asks, so a request cannot leave + * out the one group it is asking; + * 5. the wallet key, under those guardians, rederives the xpub and both + * descriptors byte for byte. + * + * Whether the guardians are the ones the group grants is not here: only a + * device holding the group's key can say, and the group's signers do. + */ + fun verified(event: Event): Verified? = runCatching { + val reading = read(event) ?: return null + if (!GroupKeyStateEvent.isSignedByRoom(event, reading.memberPublicKey)) return null + if (MemberWalletDerivation.walletId(reading.walletKey) != reading.walletId) return null + + val message = possessionMessage(reading.memberPublicKey, reading.groupChatRoomId, reading.walletKey, reading.chain) + if (!Crypto.verifySignatureSchnorr(message, reading.possession, reading.walletKey.xOnly())) return null + + if (!reading.guardians.first().chatRoomId.equals(reading.groupChatRoomId, ignoreCase = true)) return null + + val account = MemberWalletDerivation.account(reading.walletKey, reading.chain, reading.guardians) + if (account.xpub != reading.xpub || account.receiveDescriptor != reading.receiveDescriptor || account.changeDescriptor != reading.changeDescriptor) return null + + Verified(request = event, reading = reading, account = account) + }.getOrNull() + + /** + * The signed request an inner event of this kind carries -- or null when its + * content is not one, or was sent by somebody other than the member who + * signed it. A request is passed on by nobody: whoever puts it in the room + * is the one asking. + */ + fun carried(inner: Event): Event? { + if (inner.kind != KIND) return null + val request = Event.fromJsonOrNull(inner.content)?.takeIf { it.kind == KIND } ?: return null + return request.takeIf { it.pubKey.equals(inner.pubKey, ignoreCase = true) } + } +} diff --git a/composeApp/src/commonTest/kotlin/com/machankura/bennu/compose/nostr/wallet/MemberWalletRequestEventTest.kt b/composeApp/src/commonTest/kotlin/com/machankura/bennu/compose/nostr/wallet/MemberWalletRequestEventTest.kt new file mode 100644 index 00000000..8977a5b0 --- /dev/null +++ b/composeApp/src/commonTest/kotlin/com/machankura/bennu/compose/nostr/wallet/MemberWalletRequestEventTest.kt @@ -0,0 +1,127 @@ +package com.machankura.bennu.compose.nostr.wallet + +import com.machankura.bennu.compose.managers.GuardianDerivation +import com.machankura.bennu.compose.managers.MemberWalletDerivation +import com.machankura.bennu.compose.managers.SharedKeyDerivation +import com.vitorpamplona.quartz.nip01Core.core.Event +import com.vitorpamplona.quartz.nip01Core.crypto.EventHasher +import fr.acinq.bitcoin.ByteVector32 +import fr.acinq.bitcoin.Chain +import fr.acinq.bitcoin.Crypto +import fr.acinq.bitcoin.PrivateKey +import fr.acinq.secp256k1.Hex +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertNotNull +import kotlin.test.assertNull + +/** + * A member's request, read and believed on everything that can be checked + * without the group's key -- one mutation per check, each of which has to be + * enough on its own to refuse it. + */ +class MemberWalletRequestEventTest { + private val chain = Chain.Regtest + + private fun privateKey(seed: Long): PrivateKey = PrivateKey(ByteVector32(Hex.decode(seed.toString(16).padStart(64, '0')))) + + private val member = privateKey(0x3e3be7) + private val walletPrivateKey = privateKey(0xa11ce) + private val walletKey = walletPrivateKey.publicKey() + private val walletId = MemberWalletDerivation.walletId(walletKey) + + private val groupKey = privateKey(0x6a0b).publicKey().toString() + private val groupRoom = SharedKeyDerivation.marmotGroupId(groupKey) + private val parentKey = privateKey(0x9a9e).publicKey().toString() + private val parentRoom = SharedKeyDerivation.marmotGroupId(parentKey) + + private val grant = GuardianDerivation.grant( + groupKey, groupRoom, GuardianDerivation.grant(parentKey, parentRoom, emptyList(), groupRoom), walletId, + ) + private val account = MemberWalletDerivation.account(walletKey, chain, grant) + + private fun request(label: String? = "Savings", group: String = groupRoom) = + MemberWalletRequestEvent.build(member, group, walletPrivateKey, account, label, createdAt = 1_700_000_000) + + /** [event] with [tags], re-signed by the member, so only the tags are wrong. */ + private fun resigned(event: Event, tags: Array> = event.tags, content: String = event.content): Event { + val id = EventHasher.hashId(event.pubKey, event.createdAt, event.kind, tags, content) + val sig = Crypto.signSchnorr(ByteVector32(id), member, null).toHex() + return Event(id, event.pubKey, event.createdAt, event.kind, tags, content, sig) + } + + private fun Event.replacing(name: String, vararg value: String): Array> = + tags.map { if (it[0] == name) arrayOf(name, *value) else it }.toTypedArray() + + @Test + fun `a request reads and is believed`() { + val verified = assertNotNull(MemberWalletRequestEvent.verified(request())) + assertEquals(member.xOnlyPublicKey().value.toHex(), verified.reading.memberPublicKey) + assertEquals(groupRoom, verified.reading.groupChatRoomId) + assertEquals(walletId, verified.reading.walletId) + assertEquals(grant, verified.reading.guardians) + assertEquals("Savings", verified.reading.label) + assertEquals(account, verified.account) + } + + @Test + fun `a request with no label reads`() { + assertNull(assertNotNull(MemberWalletRequestEvent.verified(request(label = null))).reading.label) + assertNull(MemberWalletRequestEvent.verified(request(label = " ")).let { it?.reading?.label }) + } + + @Test + fun `a request somebody else signed is refused`() { + val signedByAnother = request().let { Event(it.id, it.pubKey, it.createdAt, it.kind, it.tags, it.content, "0".repeat(128)) } + assertNull(MemberWalletRequestEvent.verified(signedByAnother)) + } + + @Test + fun `a wallet id that is not the key's is refused`() { + val event = request() + assertNull(MemberWalletRequestEvent.verified(resigned(event, event.replacing("wallet", "f".repeat(64))))) + } + + @Test + fun `a possession signature by another key is refused`() { + val event = request() + val other = Crypto.signSchnorr(ByteVector32("ab".repeat(32)), privateKey(0xb0b), null).toHex() + assertNull(MemberWalletRequestEvent.verified(resigned(event, event.replacing("possession", other)))) + } + + @Test + fun `a request that leaves out the group it asks is refused`() { + // Signed for the group, but asking a stranger: the nearest guardian is not the group asked. + val event = request() + val stranger = SharedKeyDerivation.marmotGroupId(privateKey(0x57a9).publicKey().toString()) + assertNull(MemberWalletRequestEvent.verified(resigned(event, event.replacing("h", stranger)))) + } + + @Test + fun `a descriptor that does not rederive is refused`() { + val event = request() + val plain = MemberWalletDerivation.account(walletKey, chain, emptyList()) + val tags = event.tags.map { if (it[0] == "descriptor" && it[2] == "receive") arrayOf("descriptor", plain.receiveDescriptor, "receive") else it } + assertNull(MemberWalletRequestEvent.verified(resigned(event, tags.toTypedArray()))) + // The xpub does not depend on the guardians, so it is another key's that does not rederive. + val another = MemberWalletDerivation.account(privateKey(0xb0b).publicKey(), chain, grant) + assertNull(MemberWalletRequestEvent.verified(resigned(event, content = another.xpub))) + } + + @Test + fun `two wallet tags, or none, do not read`() { + val event = request() + assertNull(MemberWalletRequestEvent.read(resigned(event, event.tags + arrayOf(arrayOf("wallet", walletId))))) + assertNull(MemberWalletRequestEvent.read(resigned(event, event.tags.filterNot { it[0] == "wallet" }.toTypedArray()))) + } + + @Test + fun `a request travels whole, sent only by the member who signed it`() { + val signed = request() + fun inner(sender: String) = Event("1".repeat(64), sender, signed.createdAt, MemberWalletRequestEvent.KIND, emptyArray(), signed.toJson(), "") + + assertEquals(signed.id, MemberWalletRequestEvent.carried(inner(signed.pubKey))?.id) + assertNotNull(MemberWalletRequestEvent.verified(MemberWalletRequestEvent.carried(inner(signed.pubKey))!!), "the signature survives the trip") + assertNull(MemberWalletRequestEvent.carried(inner("2".repeat(64))), "nobody passes a request on") + } +} From fcf4b8e104652e158f919f2e03b5066b55ffab5f Mon Sep 17 00:00:00 2001 From: Kgothatso Ngako Date: Sat, 24 Oct 2026 07:24:44 +0200 Subject: [PATCH 07/21] feat(wallet): a spend can fund a guarded wallet, and its PSBT says where (Phase 2) GroupSpendBuilder.send and sendAll take a Destination: a typed address, or a Funding of a descendant's guarded wallet at the address fundingAddress chose. The funding output carries its tap_bip32_derivation under the descendant's account, the field change already uses, so it is never taken for change and a signer holding that wallet can derive it again. Co-Authored-By: Claude Opus 5.5 --- .../bennu/compose/wallet/GroupSpend.kt | 12 +- .../bennu/compose/wallet/GroupSpendBuilder.kt | 77 +++++++++-- .../compose/wallet/GroupSpendFundingTest.kt | 127 ++++++++++++++++++ 3 files changed, 205 insertions(+), 11 deletions(-) create mode 100644 composeApp/src/commonTest/kotlin/com/machankura/bennu/compose/wallet/GroupSpendFundingTest.kt 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 77eeb3e5..08f705b7 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 @@ -349,12 +349,18 @@ object GroupSpend { * The PSBT a proposer sends: [tx] with every input's spent output and * derivation, and every change output's derivation, so that a signer is * *told* what is change -- and [check] is how they decide whether to believe it. + * + * A [funding] output -- one paying a descendant's guarded wallet -- carries + * its derivation the same way, under the descendant's account rather than + * this one, so it is never mistaken for change and a signer holding that + * wallet can derive it again. See `docs/guarded-wallet-funding.md`. */ fun psbtOf( tx: Transaction, spent: List>, change: Map, account: GroupWalletDerivation.Account, + funding: Map> = emptyMap(), ): Psbt { require(spent.size == tx.txIn.size) { "one spent output per input" } @@ -367,11 +373,13 @@ object GroupSpend { ).right ?: throw IllegalArgumentException("could not describe input $index") } - return change.entries.fold(withInputs) { psbt, (index, derivation) -> + val outputs = change.mapValues { (_, derivation) -> account to derivation } + funding + return outputs.entries.fold(withInputs) { psbt, (index, claim) -> + val (owner, derivation) = claim psbt.updateWitnessOutput( outputIndex = index, taprootInternalKey = derivation.internalKey, - taprootDerivationPaths = mapOf(derivation.internalKey to pathOf(derivation, account)), + taprootDerivationPaths = mapOf(derivation.internalKey to pathOf(derivation, owner)), ).right ?: throw IllegalArgumentException("could not describe output $index") } } 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 b4725d19..cf84d8c9 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 @@ -27,11 +27,28 @@ import fr.acinq.lightning.utils.sum * [GroupSpend.Spender.Guardian] -- takes only coins its leaf's lock has already * let go of, puts that lock on every input, and weighs each input by its leaf * and control block. Its change, if any, goes back to the descendant. + * + * A spend can also *fund* a descendant's guarded wallet: a [Destination.Funding] + * pays the receive address `GroupWalletState.fundingAddress` chose, and the PSBT + * says so on that output, in the derivation field change already uses, so every + * signer can derive it again. See `docs/guarded-wallet-funding.md`. */ object GroupSpendBuilder { /** Phoenix's floor, kept: an output below it is one no node will relay. */ val DUST: Satoshi = Satoshi(546) + /** Where a spend's payment goes. */ + sealed interface Destination { + /** What the member typed: whatever it is, it is not the group's to vouch for. */ + data class Address(val address: String) : Destination + + /** + * A descendant's guarded wallet, at [derived] under its [account] -- the + * receive address `GroupWalletState.fundingAddress` chose. + */ + data class Funding(val account: GroupWalletDerivation.Account, val derived: GroupWalletDerivation.Derived) : Destination + } + sealed interface Result { data class Built( val psbt: Psbt, @@ -40,6 +57,8 @@ object GroupSpendBuilder { 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), + /** The guarded wallet the payment funds, or null for a payment to a typed address. */ + val funded: Destination.Funding? = null, ) : Result data object NotAnAddress : Result data object NothingToSpend : Result @@ -72,8 +91,18 @@ object GroupSpendBuilder { feeratePerVbyte: Long, reserved: Set, spender: GroupSpend.Spender = GroupSpend.Spender.Owner, + ): Result = sendAll(state, Destination.Address(address), feeratePerVbyte, reserved, spender) + + /** Every confirmed, unreserved coin, to [destination], less the fee. */ + fun sendAll( + state: GroupWalletState, + destination: Destination, + feeratePerVbyte: Long, + reserved: Set, + spender: GroupSpend.Spender = GroupSpend.Spender.Owner, ): Result { - val script = scriptOf(state, address) ?: return Result.NotAnAddress + val script = scriptOf(state, destination) ?: return Result.NotAnAddress + val funded = destination as? Destination.Funding val coins = spendable(state, reserved, spender).ifEmpty { return Result.NothingToSpend } val total = coins.map { it.amount }.sum() @@ -82,7 +111,7 @@ object GroupSpendBuilder { if (amount < DUST) return Result.BelowDust val tx = transaction(state, coins, listOf(TxOut(amount, script)), spender) - return Result.Built(psbtOf(state, tx, coins, change = emptyMap()), amount, fee, change = null) + return Result.Built(psbtOf(state, tx, coins, change = emptyMap(), funded), amount, fee, change = null, funded = funded) } /** @@ -98,8 +127,20 @@ object GroupSpendBuilder { reserved: Set, reservedChange: Set = emptySet(), spender: GroupSpend.Spender = GroupSpend.Spender.Owner, + ): Result = send(state, Destination.Address(address), amount, feeratePerVbyte, reserved, reservedChange, spender) + + /** [amount] to [destination], as [send] to an address does. */ + fun send( + state: GroupWalletState, + destination: Destination, + amount: Satoshi, + feeratePerVbyte: Long, + reserved: Set, + reservedChange: Set = emptySet(), + spender: GroupSpend.Spender = GroupSpend.Spender.Owner, ): Result { - val script = scriptOf(state, address) ?: return Result.NotAnAddress + val script = scriptOf(state, destination) ?: return Result.NotAnAddress + val funded = destination as? Destination.Funding if (amount < DUST) return Result.BelowDust val coins = spendable(state, reserved, spender).sortedByDescending { it.amount.sat }.ifEmpty { return Result.NothingToSpend } @@ -116,7 +157,7 @@ object GroupSpendBuilder { if (leftover >= DUST) { val tx = transaction(state, chosen, listOf(TxOut(amount, script), TxOut(leftover, change.pubkeyScript)), spender) - return Result.Built(psbtOf(state, tx, chosen, mapOf(1 to change)), amount, withChange, leftover) + return Result.Built(psbtOf(state, tx, chosen, mapOf(1 to change), funded), amount, withChange, leftover, funded = funded) } // Enough to pay without change: the remainder, under dust, goes to fees. @@ -124,8 +165,9 @@ object GroupSpendBuilder { if (total - amount >= withoutChange) { val tx = transaction(state, chosen, listOf(TxOut(amount, script)), spender) return Result.Built( - psbtOf(state, tx, chosen, emptyMap()), amount, total - amount, change = null, + psbtOf(state, tx, chosen, emptyMap(), funded), amount, total - amount, change = null, absorbed = total - amount - withoutChange, + funded = funded, ) } } @@ -191,9 +233,17 @@ object GroupSpendBuilder { private fun lockOf(state: GroupWalletState, spender: GroupSpend.Spender): Long? = (spender as? GroupSpend.Spender.Guardian)?.let { state.account.guardians[it.position].delay } - private fun scriptOf(state: GroupWalletState, address: String): ByteVector? = - Bitcoin.addressToPublicKeyScript(state.account.chain.chainHash, address.trim()).right + /** + * What [destination] pays: a typed address's script, or the funded wallet's + * own derivation -- never a string round trip, so a funding is always an + * address. Null for text that is not an address on this network, and for a + * funding on another network. + */ + private fun scriptOf(state: GroupWalletState, destination: Destination): ByteVector? = when (destination) { + is Destination.Address -> Bitcoin.addressToPublicKeyScript(state.account.chain.chainHash, destination.address.trim()).right ?.let { ByteVector(Script.write(it)) } + is Destination.Funding -> destination.derived.pubkeyScript.takeIf { destination.account.chain == state.account.chain } + } private fun transaction(state: GroupWalletState, coins: List, outputs: List, spender: GroupSpend.Spender) = Transaction( version = 2, @@ -226,6 +276,15 @@ object GroupSpendBuilder { return Satoshi(feeratePerVbyte * ((weight + 3) / 4)) } - private fun psbtOf(state: GroupWalletState, tx: Transaction, coins: List, change: Map) = - GroupSpend.psbtOf(tx, coins.map { it.utxo.txOut to it.derivation }, change, state.account) + /** The payment is always output 0, so a funding's claim goes there. */ + private fun psbtOf( + state: GroupWalletState, + tx: Transaction, + coins: List, + change: Map, + funded: Destination.Funding?, + ) = GroupSpend.psbtOf( + tx, coins.map { it.utxo.txOut to it.derivation }, change, state.account, + funding = funded?.let { mapOf(0 to (it.account to it.derived)) }.orEmpty(), + ) } diff --git a/composeApp/src/commonTest/kotlin/com/machankura/bennu/compose/wallet/GroupSpendFundingTest.kt b/composeApp/src/commonTest/kotlin/com/machankura/bennu/compose/wallet/GroupSpendFundingTest.kt new file mode 100644 index 00000000..1fc0c296 --- /dev/null +++ b/composeApp/src/commonTest/kotlin/com/machankura/bennu/compose/wallet/GroupSpendFundingTest.kt @@ -0,0 +1,127 @@ +package com.machankura.bennu.compose.wallet + +import com.machankura.bennu.compose.managers.GroupWalletDerivation +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.Transaction +import fr.acinq.bitcoin.TxId +import fr.acinq.bitcoin.TxIn +import fr.acinq.bitcoin.TxOut +import fr.acinq.lightning.blockchain.electrum.WalletState +import fr.acinq.secp256k1.Hex +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertIs +import kotlin.test.assertNull +import kotlin.test.assertTrue + +/** + * A spend that funds a descendant's wallet: the payment carries its place under + * the descendant's account, and that claim has to survive the wire and never + * be taken for change. See `docs/guarded-wallet-funding.md`, Phase 2. + */ +class GroupSpendFundingTest { + private fun accountFrom(seed: Int): GroupWalletDerivation.Account = GroupWalletDerivation.account( + PrivateKey(ByteVector32(Hex.decode(seed.toString(16).padStart(64, '0')))).publicKey().toString(), + Chain.Regtest, + ) + + private val account = accountFrom(0x1c0ffee) + + /** The first descendant account, counting up, whose fingerprint has its top bit set: the one the wire reads back signed. */ + private val descendant: GroupWalletDerivation.Account = generateSequence(1) { it + 1 } + .map { accountFrom(it) } + .first { it.fingerprint >= 0x80000000L } + + private val funding = GroupSpendBuilder.Destination.Funding( + descendant, GroupWalletDerivation.derive(descendant, GroupWalletDerivation.RECEIVE, 7), + ) + private val typed = "bcrt1qw508d6qejxtdg4y5r3zarvary0c5xw7kygt080" + private val feerate = 5L + + private fun coin(index: Int, sats: Long): Pair { + val derived = GroupWalletDerivation.derive(account, GroupWalletDerivation.RECEIVE, index.toLong()) + val tx = Transaction( + 2, + listOf(TxIn(OutPoint(TxId(ByteVector32(ByteArray(32) { index.toByte() })), 0), ByteVector.empty, 0xffffffffL)), + listOf(TxOut(Satoshi(sats), derived.pubkeyScript)), + 0, + ) + val meta = WalletState.AddressMeta.Derived(index) + return derived.address(Chain.Regtest) to WalletState.AddressState( + meta, alreadyUsed = true, utxos = listOf(WalletState.Utxo(tx.txid, 0, 100, tx, meta)), + ) + } + + private fun state(vararg coins: Pair): GroupWalletState { + val change = WalletState(mapOf( + GroupWalletDerivation.derive(account, GroupWalletDerivation.CHANGE, 0).address(Chain.Regtest) to + WalletState.AddressState(WalletState.AddressMeta.Derived(0), false, emptyList()) + )) + return GroupWalletState(account, WalletState(coins.toMap()), change, tipHeight = 110) + } + + @Test + fun `a funding's claim survives the wire for a high fingerprint`() { + val built = assertIs( + GroupSpendBuilder.send(state(coin(0, 60_000)), funding, Satoshi(30_000), feerate, emptySet()) + ) + assertEquals(funding, built.funded) + assertEquals(funding.derived.pubkeyScript, built.psbt.global.tx.txOut[0].publicKeyScript) + + assertTrue(descendant.fingerprint >= 0x80000000L) + val received = GroupSpend.decode(GroupSpend.encode(built.psbt))!! + assertEquals(setOf(7L), GroupSpend.claimedFundingIndices(received, descendant)) + assertEquals(setOf(0L), GroupSpend.claimedChangeIndices(received, account), "the change is still the room's own") + assertEquals(emptySet(), GroupSpend.claimedFundingIndices(received, account), "the room's own account funds nothing") + } + + @Test + fun `a funding is a payment, not change`() { + val built = assertIs( + GroupSpendBuilder.send(state(coin(0, 60_000)), funding, Satoshi(30_000), feerate, emptySet()) + ) + val received = GroupSpend.decode(GroupSpend.encode(built.psbt))!! + + val checked = assertIs(GroupSpend.check(received, account)).checked + assertEquals(listOf(false, true), checked.outputs.map { it.isChange }) + assertEquals(Satoshi(30_000), checked.amountSent) + } + + @Test + fun `sending everything can fund too`() { + val built = assertIs( + GroupSpendBuilder.sendAll(state(coin(0, 60_000), coin(1, 40_000)), funding, feerate, emptySet()) + ) + assertEquals(funding, built.funded) + assertEquals(setOf(7L), GroupSpend.claimedFundingIndices(built.psbt, descendant)) + assertIs(GroupSpend.check(built.psbt, account)) + } + + @Test + fun `a send to a typed address claims nothing about its payment`() { + val built = assertIs( + GroupSpendBuilder.send(state(coin(0, 60_000)), typed, Satoshi(30_000), feerate, emptySet()) + ) + assertNull(built.funded) + assertTrue(built.psbt.outputs[0].taprootDerivationPaths.isEmpty()) + assertEquals(1, built.psbt.outputs[1].taprootDerivationPaths.size, "change is described as it always was") + } + + @Test + fun `a wallet on another network is not one to fund`() { + val elsewhere = GroupWalletDerivation.account( + PrivateKey(ByteVector32(Hex.decode("decaf".padStart(64, '0')))).publicKey().toString(), + Chain.Signet, + ) + val across = GroupSpendBuilder.Destination.Funding(elsewhere, GroupWalletDerivation.derive(elsewhere, GroupWalletDerivation.RECEIVE, 0)) + assertEquals( + GroupSpendBuilder.Result.NotAnAddress, + GroupSpendBuilder.send(state(coin(0, 60_000)), across, Satoshi(30_000), feerate, emptySet()), + ) + } +} From 52390e27cfb06f80714674049fff9cf85fd63307 Mon Sep 17 00:00:00 2001 From: Kgothatso Ngako Date: Sat, 24 Oct 2026 07:25:51 +0200 Subject: [PATCH 08/21] feat(wallet): the certificate a group signs to guard a member's wallet (Phase 4) MemberWalletCertificateEvent (30334) is the group's signature over a member's request, which it embeds whole so an ancestor never in the room can check that the member asked. template(request) is the only way one is built and verify() checks a certificate is exactly that template, so a sponsor chooses nothing and two sponsors propose one event id. Its own kind rather than a 30329: every reader of birth certificates assumes a room, and a test fails the day subgroupsOf reads both. Co-Authored-By: Claude Opus 5.5 --- .../wallet/MemberWalletCertificateEvent.kt | 153 ++++++++++++++++++ .../MemberWalletCertificateEventJvmTest.kt | 134 +++++++++++++++ 2 files changed, 287 insertions(+) create mode 100644 composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/nostr/wallet/MemberWalletCertificateEvent.kt create mode 100644 composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/nostr/wallet/MemberWalletCertificateEventJvmTest.kt diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/nostr/wallet/MemberWalletCertificateEvent.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/nostr/wallet/MemberWalletCertificateEvent.kt new file mode 100644 index 00000000..ddfc1e94 --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/nostr/wallet/MemberWalletCertificateEvent.kt @@ -0,0 +1,153 @@ +package com.machankura.bennu.compose.nostr.wallet + +import com.machankura.bennu.compose.managers.GroupWalletDerivation +import com.machankura.bennu.compose.nostr.frost.GroupKeyStateEvent +import com.vitorpamplona.quartz.nip01Core.core.Event +import com.vitorpamplona.quartz.nip01Core.core.HexKey +import com.vitorpamplona.quartz.nip01Core.core.Kind +import com.vitorpamplona.quartz.nip01Core.signers.EventTemplate + +/** + * A group saying it guards a wallet for one of its members: the group's + * signature over the member's request, and what every device opens the wallet + * on. + * + * ``` + * member --[ 30335 request, signed by them ]-> the group's room + * any signer --[ 30320 proposal over a 30334 ]-> the group's room + * ...a signing session... + * everyone holds the signed 30334 "this group guards W for this person" + * ``` + * + * ``` + * kind: 30334 + * pubkey: G set by the signing session + * created_at: the request's created_at so every sponsor proposes one event id + * content: W + * tags: + * ["d", W] + * ["p", ] + * ["wallet_key", ] + * ["chain", …] + * ["guardian", …] as in the request + * ["descriptor", …, "receive"] + * ["descriptor", …, "change"] + * ["label", …] if the request had one + * ["request", ] + * ``` + * + * ### Not a birth certificate + * + * A `SubgroupBirthCertificateEvent` says *this room is my child*, and every + * reader of 30329 assumes a room -- its `certifies` rederives one from the key, + * `SubgroupManager.subgroupsOf` lists one, the transcript announces one being + * born. A member's wallet is not a room, so it has its own kind and none of the + * lineage meaning. `docs/member-guarded-wallets.md`, "Should it be a birth + * certificate?". + * + * ### Built from the request and nothing else + * + * [template] is the only way a certificate is made, and [verify] checks one is + * exactly [template] of the request it carries. So the sponsor who puts a + * request to the group chooses nothing, two sponsors propose one event id, and + * no tag can say one thing in the request and another in the certificate. + * + * The request is embedded rather than looked up, as a guarded statement embeds + * its birth certificate: an ancestor who was never in the group's room can + * check that the member asked, from the group's signature alone. + * + * ### Never on a relay + * + * It carries an xpub. + * + * ### Why 30334 + * + * The first free number past the guarded-wallet notice (30333), which carries + * it upward to the groups above. + */ +object MemberWalletCertificateEvent { + val KIND: Kind = 30334 + + private const val D_TAG = "d" + private const val MEMBER_TAG = "p" + private const val REQUEST_TAG = "request" + + /** A certificate believed: who it guards a wallet for, and the wallet it opens. */ + data class Verified( + val certificate: Event, + val request: Event, + val groupChatRoomId: String, + val memberPublicKey: HexKey, + val walletId: String, + val label: String?, + /** The account the request rederived to, guardians and all. */ + val account: GroupWalletDerivation.Account, + ) + + /** + * The certificate [request] asks for: the request's own tags, minus the + * possession signature it already carries whole, under the wallet id. + */ + fun template(request: Event): EventTemplate<*> { + val reading = requireNotNull(MemberWalletRequestEvent.read(request)) { "not a request" } + val carried = request.tags.filterNot { it.isNotEmpty() && it[0] in setOf("h", "wallet", "possession") } + + return EventTemplate( + createdAt = request.createdAt, + kind = KIND, + tags = ( + listOf( + arrayOf(D_TAG, reading.walletId), + arrayOf(MEMBER_TAG, reading.memberPublicKey), + ) + carried + listOf(arrayOf(REQUEST_TAG, request.toJson())) + ).toTypedArray(), + content = reading.walletId, + ) + } + + /** The request [certificate] carries, or null. Nothing is verified here. */ + fun requestOf(certificate: Event): Event? = + certificate.tags.filter { it.size >= 2 && it[0] == REQUEST_TAG }.singleOrNull()?.let { Event.fromJsonOrNull(it[1]) } + + /** The member [certificate] names, or null. Nothing is verified here. */ + fun memberOf(certificate: Event): HexKey? = + certificate.tags.firstOrNull { it.size >= 2 && it[0] == MEMBER_TAG }?.get(1) + + /** + * [certificate] believed as [groupChatRoomId]'s, with no database: + * + * 1. it is a 30334, and the room signed it; + * 2. the request it carries is believed (`MemberWalletRequestEvent.verified`) + * and asked this room; + * 3. it is exactly [template] of that request -- every tag, the content and + * the time; + * 4. so its `p` is the member who asked. + * + * Whether the guardians are the ones the group grants is what the group's + * signers checked before signing. A reader trusts the group's quorum for + * that, and it is no new trust: that quorum can already take every coin. + */ + fun verify(certificate: Event, groupChatRoomId: String): Verified? = runCatching { + if (certificate.kind != KIND) return null + if (!GroupKeyStateEvent.isSignedByRoom(certificate, groupChatRoomId)) return null + + val request = requestOf(certificate) ?: return null + val verified = MemberWalletRequestEvent.verified(request) ?: return null + if (!verified.reading.groupChatRoomId.equals(groupChatRoomId, ignoreCase = true)) return null + + val expected = template(request) + if (certificate.createdAt != expected.createdAt) return null + if (certificate.content != expected.content) return null + if (certificate.tags.map { it.toList() } != expected.tags.map { it.toList() }) return null + + Verified( + certificate = certificate, + request = request, + groupChatRoomId = groupChatRoomId.lowercase(), + memberPublicKey = verified.reading.memberPublicKey, + walletId = verified.reading.walletId, + label = verified.reading.label, + account = verified.account, + ) + }.getOrNull() +} diff --git a/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/nostr/wallet/MemberWalletCertificateEventJvmTest.kt b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/nostr/wallet/MemberWalletCertificateEventJvmTest.kt new file mode 100644 index 00000000..27e0b859 --- /dev/null +++ b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/nostr/wallet/MemberWalletCertificateEventJvmTest.kt @@ -0,0 +1,134 @@ +package com.machankura.bennu.compose.nostr.wallet + +import androidx.room3.Room +import com.machankura.bennu.compose.database.BennuDatabase +import com.machankura.bennu.compose.database.builder.getRoomDatabase +import com.machankura.bennu.compose.database.model.GroupSignedEvent +import com.machankura.bennu.compose.managers.GroupFixtures +import com.machankura.bennu.compose.managers.GroupFixtures.keyMaterial +import com.machankura.bennu.compose.managers.GroupFixtures.roomOf +import com.machankura.bennu.compose.managers.GroupFixtures.signedAsRoom +import com.machankura.bennu.compose.managers.GroupFixtures.thresholdKeyOf +import com.machankura.bennu.compose.managers.GuardianDerivation +import com.machankura.bennu.compose.managers.MemberWalletDerivation +import com.machankura.bennu.compose.managers.SharedKeyDerivation +import com.machankura.bennu.compose.managers.SubgroupManager +import com.machankura.bennu.compose.nostr.subgroup.SubgroupBirthCertificateEvent +import com.machankura.bennu.compose.nostr.subgroup.tags.GuardianTag +import com.vitorpamplona.quartz.nip01Core.core.Event +import fr.acinq.bitcoin.ByteVector32 +import fr.acinq.bitcoin.Chain +import fr.acinq.bitcoin.PrivateKey +import fr.acinq.bitcoin.crypto.frost.KeyMaterial +import fr.acinq.secp256k1.Hex +import kotlinx.coroutines.runBlocking +import kotlin.test.AfterTest +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFalse +import kotlin.test.assertNotNull +import kotlin.test.assertNull +import kotlin.test.assertTrue + +/** + * A group's certificate that it guards a member's wallet: believed when it is + * exactly the group's signature over the request it carries, and never mistaken + * for a birth certificate by anything that reads those. + */ +class MemberWalletCertificateEventJvmTest { + private val db: BennuDatabase = getRoomDatabase(Room.inMemoryDatabaseBuilder()) + + @AfterTest + fun closeDb() = db.close() + + private val chain = Chain.Regtest + + private fun privateKey(seed: Long): PrivateKey = PrivateKey(ByteVector32(Hex.decode(seed.toString(16).padStart(64, '0')))) + + private val group = keyMaterial("6a0b") + private val stranger = keyMaterial("57a9") + private val groupRoom = roomOf(group) + + private val member = privateKey(0x3e3be7) + private val walletPrivateKey = privateKey(0xa11ce) + private val walletKey = walletPrivateKey.publicKey() + private val walletId = MemberWalletDerivation.walletId(walletKey) + + private fun request(guardians: List = GuardianDerivation.grant(thresholdKeyOf(group), groupRoom, emptyList(), walletId)) = + MemberWalletRequestEvent.build( + memberPrivateKey = member, + groupChatRoomId = groupRoom, + walletPrivateKey = walletPrivateKey, + account = MemberWalletDerivation.account(walletKey, chain, guardians), + label = "Savings", + createdAt = 1_700_000_000, + ) + + private fun certified(request: Event = request(), signer: KeyMaterial = group): Event { + val template = MemberWalletCertificateEvent.template(request) + return signedAsRoom(signer, MemberWalletCertificateEvent.KIND, template.tags, template.content, createdAt = template.createdAt) + } + + private fun Event.withTags(tags: Array>, signer: KeyMaterial = group): Event = + signedAsRoom(signer, kind, tags, content, createdAt) + + @Test + fun `a certificate the group signed over the request is believed`() { + val verified = assertNotNull(MemberWalletCertificateEvent.verify(certified(), groupRoom)) + assertEquals(member.xOnlyPublicKey().value.toHex(), verified.memberPublicKey) + assertEquals(walletId, verified.walletId) + assertEquals("Savings", verified.label) + assertEquals(groupRoom, verified.groupChatRoomId) + assertTrue(verified.account.isGuarded) + } + + @Test + fun `two sponsors propose one event`() { + assertEquals(certified().id, certified().id) + } + + @Test + fun `a certificate another room signed is refused`() { + assertNull(MemberWalletCertificateEvent.verify(certified(signer = stranger), groupRoom)) + } + + @Test + fun `a certificate over a request to another group is refused`() { + // The stranger signs a request that asked the group: the request is real, the group is not the one asked. + val strangerRoom = roomOf(stranger) + assertNull(MemberWalletCertificateEvent.verify(certified(signer = stranger), strangerRoom)) + } + + @Test + fun `a certificate naming another member is refused`() { + val certificate = certified() + val other = privateKey(0xb0b).xOnlyPublicKey().value.toHex() + val tags = certificate.tags.map { if (it[0] == "p") arrayOf("p", other) else it }.toTypedArray() + assertNull(MemberWalletCertificateEvent.verify(certificate.withTags(tags), groupRoom)) + } + + @Test + fun `a guardian swapped against its request is refused`() { + val certificate = certified() + val swapped = GuardianDerivation.grant(thresholdKeyOf(stranger), groupRoom, emptyList(), walletId).single() + val tags = certificate.tags.map { if (it[0] == "guardian") GuardianTag.assemble(swapped) else it }.toTypedArray() + assertNull(MemberWalletCertificateEvent.verify(certificate.withTags(tags), groupRoom)) + } + + @Test + fun `a member wallet certificate is never a subgroup`(): Unit = runBlocking { + val certificate = certified() + assertFalse(SubgroupBirthCertificateEvent.certifies(certificate, walletId, groupRoom)) + + GroupFixtures.seedRoom(db, groupRoom) + db.groupSignedEventDao().upsert( + GroupSignedEvent.fromEvent( + event = certificate, + chatRoomId = groupRoom, + derivationPath = SharedKeyDerivation.formatPath(GroupFixtures.path), + frostSigningSessionId = null, + ) + ) + assertEquals(emptyList(), SubgroupManager.subgroupsOf(db, groupRoom), "a reader of 30329 never sees a 30334") + } +} From d6c2b1b20e22c7e11f78b9ee64f1a54ec647f7fa Mon Sep 17 00:00:00 2001 From: Kgothatso Ngako Date: Sat, 24 Oct 2026 07:27:33 +0200 Subject: [PATCH 09/21] feat(db): schema 30 keeps a member wallet's key and its spends (Phase 5) MemberWallet holds the random key of a guarded wallet one member holds and a group guards, with the request that asked for it; MemberWalletSpend the transactions the member signed alone. Whether a wallet is certified is read off the group's signed events each time, so there is no column for it. Neither table has a foreign key: deleting a group's room on this device must never delete a key that coins may sit behind. Co-Authored-By: Claude Opus 5.5 --- .../30.json | 4726 +++++++++++++++++ .../bennu/compose/database/BennuDatabase.kt | 15 +- .../compose/database/dao/MemberWalletDao.kt | 46 + .../compose/database/model/MemberWallet.kt | 68 + .../database/model/MemberWalletSpend.kt | 53 + .../database/dao/MemberWalletDaoJvmTest.kt | 76 + 6 files changed, 4983 insertions(+), 1 deletion(-) create mode 100644 composeApp/schemas/com.machankura.bennu.compose.database.BennuDatabase/30.json create mode 100644 composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/dao/MemberWalletDao.kt create mode 100644 composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/model/MemberWallet.kt create mode 100644 composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/model/MemberWalletSpend.kt create mode 100644 composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/database/dao/MemberWalletDaoJvmTest.kt diff --git a/composeApp/schemas/com.machankura.bennu.compose.database.BennuDatabase/30.json b/composeApp/schemas/com.machankura.bennu.compose.database.BennuDatabase/30.json new file mode 100644 index 00000000..de9606ce --- /dev/null +++ b/composeApp/schemas/com.machankura.bennu.compose.database.BennuDatabase/30.json @@ -0,0 +1,4726 @@ +{ + "formatVersion": 1, + "database": { + "version": 30, + "identityHash": "47aa631ec4032d9b2c00bf0b38689864", + "entities": [ + { + "tableName": "BroadcastNostrEventReceipt", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `nostrEventId` TEXT NOT NULL, `unsignedNostrEventId` INTEGER, `isAccepted` INTEGER NOT NULL, `isSync` INTEGER NOT NULL, `relayURL` TEXT NOT NULL, `messages` TEXT, FOREIGN KEY(`nostrEventId`) REFERENCES `NostrEvent`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`unsignedNostrEventId`) REFERENCES `UnsignedNostrEvent`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "nostrEventId", + "columnName": "nostrEventId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "unsignedNostrEventId", + "columnName": "unsignedNostrEventId", + "affinity": "INTEGER" + }, + { + "fieldPath": "isAccepted", + "columnName": "isAccepted", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "isSync", + "columnName": "isSync", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "relayURL", + "columnName": "relayURL", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "messages", + "columnName": "messages", + "affinity": "TEXT" + } + ], + "primaryKey": { + "autoGenerate": true, + "columnNames": [ + "id" + ] + }, + "indices": [ + { + "name": "index_BroadcastNostrEventReceipt_nostrEventId", + "unique": false, + "columnNames": [ + "nostrEventId" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_BroadcastNostrEventReceipt_nostrEventId` ON `${TABLE_NAME}` (`nostrEventId`)" + }, + { + "name": "index_BroadcastNostrEventReceipt_isAccepted", + "unique": false, + "columnNames": [ + "isAccepted" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_BroadcastNostrEventReceipt_isAccepted` ON `${TABLE_NAME}` (`isAccepted`)" + } + ], + "foreignKeys": [ + { + "table": "NostrEvent", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "nostrEventId" + ], + "referencedColumns": [ + "id" + ] + }, + { + "table": "UnsignedNostrEvent", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "unsignedNostrEventId" + ], + "referencedColumns": [ + "id" + ] + } + ] + }, + { + "tableName": "BroadcastNostrEventRequest", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `nostrEventId` TEXT NOT NULL, `unsignedNostrEventId` INTEGER, `status` TEXT NOT NULL, `relayURL` TEXT NOT NULL, `createdAt` INTEGER NOT NULL, `updatedAt` INTEGER NOT NULL, FOREIGN KEY(`nostrEventId`) REFERENCES `NostrEvent`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`unsignedNostrEventId`) REFERENCES `UnsignedNostrEvent`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "nostrEventId", + "columnName": "nostrEventId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "unsignedNostrEventId", + "columnName": "unsignedNostrEventId", + "affinity": "INTEGER" + }, + { + "fieldPath": "status", + "columnName": "status", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "relayURL", + "columnName": "relayURL", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updatedAt", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": true, + "columnNames": [ + "id" + ] + }, + "indices": [ + { + "name": "index_BroadcastNostrEventRequest_nostrEventId", + "unique": false, + "columnNames": [ + "nostrEventId" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_BroadcastNostrEventRequest_nostrEventId` ON `${TABLE_NAME}` (`nostrEventId`)" + }, + { + "name": "index_BroadcastNostrEventRequest_status", + "unique": false, + "columnNames": [ + "status" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_BroadcastNostrEventRequest_status` ON `${TABLE_NAME}` (`status`)" + } + ], + "foreignKeys": [ + { + "table": "NostrEvent", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "nostrEventId" + ], + "referencedColumns": [ + "id" + ] + }, + { + "table": "UnsignedNostrEvent", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "unsignedNostrEventId" + ], + "referencedColumns": [ + "id" + ] + } + ] + }, + { + "tableName": "Connection", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`sourcePublicKey` TEXT NOT NULL, `destinationPublicKey` TEXT NOT NULL, `nostrEventId` TEXT NOT NULL, `createdAt` INTEGER NOT NULL, `updatedAt` INTEGER NOT NULL, `savedAt` INTEGER NOT NULL, `deletedAt` INTEGER, `broadcastedAt` INTEGER, PRIMARY KEY(`sourcePublicKey`, `destinationPublicKey`), FOREIGN KEY(`sourcePublicKey`) REFERENCES `Profile`(`publicKey`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`destinationPublicKey`) REFERENCES `Profile`(`publicKey`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "sourcePublicKey", + "columnName": "sourcePublicKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "destinationPublicKey", + "columnName": "destinationPublicKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "nostrEventId", + "columnName": "nostrEventId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updatedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "savedAt", + "columnName": "savedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "deletedAt", + "columnName": "deletedAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "broadcastedAt", + "columnName": "broadcastedAt", + "affinity": "INTEGER" + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "sourcePublicKey", + "destinationPublicKey" + ] + }, + "foreignKeys": [ + { + "table": "Profile", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "sourcePublicKey" + ], + "referencedColumns": [ + "publicKey" + ] + }, + { + "table": "Profile", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "destinationPublicKey" + ], + "referencedColumns": [ + "publicKey" + ] + } + ] + }, + { + "tableName": "ChatMessage", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `senderPublicKey` TEXT NOT NULL, `isUserMessage` INTEGER NOT NULL, `giftWrapPayloadId` TEXT, `marmotGroupEventId` TEXT, `marmotInnerEventId` TEXT, `chatRoomId` TEXT NOT NULL, `replyToMessageId` INTEGER, `quotedMessageId` INTEGER, `content` TEXT NOT NULL, `messageType` TEXT NOT NULL, `directMessageRecipientPublicKey` TEXT, `frostSigningSessionId` TEXT, `dkgSessionId` TEXT, `createdAt` INTEGER NOT NULL, `updatedAt` INTEGER NOT NULL, `savedAt` INTEGER NOT NULL, `viewedAt` INTEGER, `deletedAt` INTEGER, FOREIGN KEY(`chatRoomId`) REFERENCES `ChatRoom`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`giftWrapPayloadId`) REFERENCES `GiftWrapPayload`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`marmotGroupEventId`) REFERENCES `MarmotGroupEvent`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`marmotInnerEventId`) REFERENCES `MarmotInnerEvent`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "senderPublicKey", + "columnName": "senderPublicKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "isUserMessage", + "columnName": "isUserMessage", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "giftWrapPayloadId", + "columnName": "giftWrapPayloadId", + "affinity": "TEXT" + }, + { + "fieldPath": "marmotGroupEventId", + "columnName": "marmotGroupEventId", + "affinity": "TEXT" + }, + { + "fieldPath": "marmotInnerEventId", + "columnName": "marmotInnerEventId", + "affinity": "TEXT" + }, + { + "fieldPath": "chatRoomId", + "columnName": "chatRoomId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "replyToMessageId", + "columnName": "replyToMessageId", + "affinity": "INTEGER" + }, + { + "fieldPath": "quotedMessageId", + "columnName": "quotedMessageId", + "affinity": "INTEGER" + }, + { + "fieldPath": "content", + "columnName": "content", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "messageType", + "columnName": "messageType", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "directMessageRecipientPublicKey", + "columnName": "directMessageRecipientPublicKey", + "affinity": "TEXT" + }, + { + "fieldPath": "frostSigningSessionId", + "columnName": "frostSigningSessionId", + "affinity": "TEXT" + }, + { + "fieldPath": "dkgSessionId", + "columnName": "dkgSessionId", + "affinity": "TEXT" + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updatedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "savedAt", + "columnName": "savedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "viewedAt", + "columnName": "viewedAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "deletedAt", + "columnName": "deletedAt", + "affinity": "INTEGER" + } + ], + "primaryKey": { + "autoGenerate": true, + "columnNames": [ + "id" + ] + }, + "indices": [ + { + "name": "index_ChatMessage_chatRoomId", + "unique": false, + "columnNames": [ + "chatRoomId" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_ChatMessage_chatRoomId` ON `${TABLE_NAME}` (`chatRoomId`)" + } + ], + "foreignKeys": [ + { + "table": "ChatRoom", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "chatRoomId" + ], + "referencedColumns": [ + "id" + ] + }, + { + "table": "GiftWrapPayload", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "giftWrapPayloadId" + ], + "referencedColumns": [ + "id" + ] + }, + { + "table": "MarmotGroupEvent", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "marmotGroupEventId" + ], + "referencedColumns": [ + "id" + ] + }, + { + "table": "MarmotInnerEvent", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "marmotInnerEventId" + ], + "referencedColumns": [ + "id" + ] + } + ] + }, + { + "tableName": "ChatMessageBroadcastNostrEventRequestRelation", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `chatMessageId` INTEGER NOT NULL, `broadcastNostrEventRequestId` INTEGER NOT NULL, `createdAt` INTEGER NOT NULL, `updatedAt` INTEGER NOT NULL, `savedAt` INTEGER NOT NULL, FOREIGN KEY(`chatMessageId`) REFERENCES `ChatMessage`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`broadcastNostrEventRequestId`) REFERENCES `BroadcastNostrEventRequest`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "chatMessageId", + "columnName": "chatMessageId", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "broadcastNostrEventRequestId", + "columnName": "broadcastNostrEventRequestId", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updatedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "savedAt", + "columnName": "savedAt", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": true, + "columnNames": [ + "id" + ] + }, + "foreignKeys": [ + { + "table": "ChatMessage", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "chatMessageId" + ], + "referencedColumns": [ + "id" + ] + }, + { + "table": "BroadcastNostrEventRequest", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "broadcastNostrEventRequestId" + ], + "referencedColumns": [ + "id" + ] + } + ] + }, + { + "tableName": "ChatMessageBroadcastNostrEventReceiptRelation", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `chatMessageId` INTEGER NOT NULL, `broadcastNostrEventReceiptId` INTEGER NOT NULL, `createdAt` INTEGER NOT NULL, `updatedAt` INTEGER NOT NULL, `savedAt` INTEGER NOT NULL, FOREIGN KEY(`chatMessageId`) REFERENCES `ChatMessage`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`broadcastNostrEventReceiptId`) REFERENCES `BroadcastNostrEventReceipt`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "chatMessageId", + "columnName": "chatMessageId", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "broadcastNostrEventReceiptId", + "columnName": "broadcastNostrEventReceiptId", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updatedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "savedAt", + "columnName": "savedAt", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": true, + "columnNames": [ + "id" + ] + }, + "foreignKeys": [ + { + "table": "ChatMessage", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "chatMessageId" + ], + "referencedColumns": [ + "id" + ] + }, + { + "table": "BroadcastNostrEventReceipt", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "broadcastNostrEventReceiptId" + ], + "referencedColumns": [ + "id" + ] + } + ] + }, + { + "tableName": "ChatMessageNostrEventRelation", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `chatMessageId` INTEGER NOT NULL, `nostrEventId` TEXT NOT NULL, `createdAt` INTEGER NOT NULL, `updatedAt` INTEGER NOT NULL, `savedAt` INTEGER NOT NULL, FOREIGN KEY(`chatMessageId`) REFERENCES `ChatMessage`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`nostrEventId`) REFERENCES `NostrEvent`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "chatMessageId", + "columnName": "chatMessageId", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "nostrEventId", + "columnName": "nostrEventId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updatedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "savedAt", + "columnName": "savedAt", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": true, + "columnNames": [ + "id" + ] + }, + "foreignKeys": [ + { + "table": "ChatMessage", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "chatMessageId" + ], + "referencedColumns": [ + "id" + ] + }, + { + "table": "NostrEvent", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "nostrEventId" + ], + "referencedColumns": [ + "id" + ] + } + ] + }, + { + "tableName": "ChatRoom", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `userPublicKey` TEXT NOT NULL, `subject` TEXT, `description` TEXT, `mlsGroupState` TEXT, `initialGiftWrapPayloadId` TEXT, `leftGroupAt` INTEGER, `joinedGroupAt` INTEGER, `chronicleRequestedAt` INTEGER, `parentChatRoomId` TEXT, `createdAt` INTEGER NOT NULL, `updatedAt` INTEGER NOT NULL, `savedAt` INTEGER NOT NULL, `viewedAt` INTEGER, `deletedAt` INTEGER, PRIMARY KEY(`id`), FOREIGN KEY(`userPublicKey`) REFERENCES `Profile`(`publicKey`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`initialGiftWrapPayloadId`) REFERENCES `GiftWrapPayload`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "userPublicKey", + "columnName": "userPublicKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "subject", + "columnName": "subject", + "affinity": "TEXT" + }, + { + "fieldPath": "description", + "columnName": "description", + "affinity": "TEXT" + }, + { + "fieldPath": "mlsGroupState", + "columnName": "mlsGroupState", + "affinity": "TEXT" + }, + { + "fieldPath": "initialGiftWrapPayloadId", + "columnName": "initialGiftWrapPayloadId", + "affinity": "TEXT" + }, + { + "fieldPath": "leftGroupAt", + "columnName": "leftGroupAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "joinedGroupAt", + "columnName": "joinedGroupAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "chronicleRequestedAt", + "columnName": "chronicleRequestedAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "parentChatRoomId", + "columnName": "parentChatRoomId", + "affinity": "TEXT" + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updatedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "savedAt", + "columnName": "savedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "viewedAt", + "columnName": "viewedAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "deletedAt", + "columnName": "deletedAt", + "affinity": "INTEGER" + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "id" + ] + }, + "foreignKeys": [ + { + "table": "Profile", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "userPublicKey" + ], + "referencedColumns": [ + "publicKey" + ] + }, + { + "table": "GiftWrapPayload", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "initialGiftWrapPayloadId" + ], + "referencedColumns": [ + "id" + ] + } + ] + }, + { + "tableName": "DkgParticipantMessage", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`sessionId` TEXT NOT NULL, `participantPublicKey` TEXT NOT NULL, `kind` INTEGER NOT NULL, `payload` TEXT NOT NULL, `createdAt` INTEGER NOT NULL, PRIMARY KEY(`sessionId`, `participantPublicKey`, `kind`), FOREIGN KEY(`sessionId`) REFERENCES `DkgSession`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "sessionId", + "columnName": "sessionId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "participantPublicKey", + "columnName": "participantPublicKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "kind", + "columnName": "kind", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "payload", + "columnName": "payload", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "sessionId", + "participantPublicKey", + "kind" + ] + }, + "indices": [ + { + "name": "index_DkgParticipantMessage_sessionId", + "unique": false, + "columnNames": [ + "sessionId" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_DkgParticipantMessage_sessionId` ON `${TABLE_NAME}` (`sessionId`)" + } + ], + "foreignKeys": [ + { + "table": "DkgSession", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "sessionId" + ], + "referencedColumns": [ + "id" + ] + } + ] + }, + { + "tableName": "DkgSession", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `chatRoomId` TEXT NOT NULL, `coordinatorPublicKey` TEXT NOT NULL, `userPublicKey` TEXT NOT NULL, `threshold` INTEGER NOT NULL, `participantCount` INTEGER NOT NULL, `participantPublicKeys` TEXT, `subject` TEXT, `walletPolicy` TEXT, `stage` TEXT NOT NULL, `hostPublicKey` TEXT NOT NULL, `round1Random` TEXT NOT NULL, `round2AuxRandom` TEXT NOT NULL, `coordinatorRound1` TEXT, `certificate` TEXT, `thresholdPublicKey` TEXT, `secretShare` TEXT, `publicShares` TEXT, `recoveryData` TEXT, `failureReason` TEXT, `hostKeyApprovedAt` INTEGER, `round1ApprovedAt` INTEGER, `round2ApprovedAt` INTEGER, `approvalRequestedThrough` TEXT, `parentChatRoomId` TEXT, `createdAt` INTEGER NOT NULL, `updatedAt` INTEGER NOT NULL, `savedAt` INTEGER NOT NULL, PRIMARY KEY(`id`), FOREIGN KEY(`chatRoomId`) REFERENCES `ChatRoom`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "chatRoomId", + "columnName": "chatRoomId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "coordinatorPublicKey", + "columnName": "coordinatorPublicKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "userPublicKey", + "columnName": "userPublicKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "threshold", + "columnName": "threshold", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "participantCount", + "columnName": "participantCount", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "participantPublicKeys", + "columnName": "participantPublicKeys", + "affinity": "TEXT" + }, + { + "fieldPath": "subject", + "columnName": "subject", + "affinity": "TEXT" + }, + { + "fieldPath": "walletPolicy", + "columnName": "walletPolicy", + "affinity": "TEXT" + }, + { + "fieldPath": "stage", + "columnName": "stage", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "hostPublicKey", + "columnName": "hostPublicKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "round1Random", + "columnName": "round1Random", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "round2AuxRandom", + "columnName": "round2AuxRandom", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "coordinatorRound1", + "columnName": "coordinatorRound1", + "affinity": "TEXT" + }, + { + "fieldPath": "certificate", + "columnName": "certificate", + "affinity": "TEXT" + }, + { + "fieldPath": "thresholdPublicKey", + "columnName": "thresholdPublicKey", + "affinity": "TEXT" + }, + { + "fieldPath": "secretShare", + "columnName": "secretShare", + "affinity": "TEXT" + }, + { + "fieldPath": "publicShares", + "columnName": "publicShares", + "affinity": "TEXT" + }, + { + "fieldPath": "recoveryData", + "columnName": "recoveryData", + "affinity": "TEXT" + }, + { + "fieldPath": "failureReason", + "columnName": "failureReason", + "affinity": "TEXT" + }, + { + "fieldPath": "hostKeyApprovedAt", + "columnName": "hostKeyApprovedAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "round1ApprovedAt", + "columnName": "round1ApprovedAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "round2ApprovedAt", + "columnName": "round2ApprovedAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "approvalRequestedThrough", + "columnName": "approvalRequestedThrough", + "affinity": "TEXT" + }, + { + "fieldPath": "parentChatRoomId", + "columnName": "parentChatRoomId", + "affinity": "TEXT" + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updatedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "savedAt", + "columnName": "savedAt", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "id" + ] + }, + "indices": [ + { + "name": "index_DkgSession_chatRoomId", + "unique": false, + "columnNames": [ + "chatRoomId" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_DkgSession_chatRoomId` ON `${TABLE_NAME}` (`chatRoomId`)" + } + ], + "foreignKeys": [ + { + "table": "ChatRoom", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "chatRoomId" + ], + "referencedColumns": [ + "id" + ] + } + ] + }, + { + "tableName": "FrostSignerMessage", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`sessionId` TEXT NOT NULL, `signerPublicKey` TEXT NOT NULL, `kind` INTEGER NOT NULL, `payload` TEXT NOT NULL, `createdAt` INTEGER NOT NULL, PRIMARY KEY(`sessionId`, `signerPublicKey`, `kind`), FOREIGN KEY(`sessionId`) REFERENCES `FrostSigningSession`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "sessionId", + "columnName": "sessionId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "signerPublicKey", + "columnName": "signerPublicKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "kind", + "columnName": "kind", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "payload", + "columnName": "payload", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "sessionId", + "signerPublicKey", + "kind" + ] + }, + "indices": [ + { + "name": "index_FrostSignerMessage_sessionId", + "unique": false, + "columnNames": [ + "sessionId" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_FrostSignerMessage_sessionId` ON `${TABLE_NAME}` (`sessionId`)" + } + ], + "foreignKeys": [ + { + "table": "FrostSigningSession", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "sessionId" + ], + "referencedColumns": [ + "id" + ] + } + ] + }, + { + "tableName": "FrostSigningItem", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`sessionId` TEXT NOT NULL, `itemIndex` INTEGER NOT NULL, `unsignedEventJson` TEXT NOT NULL, `eventId` TEXT NOT NULL, `nonceRandom` TEXT NOT NULL, `aggregatedNonce` TEXT, `signature` TEXT, `inputIndex` INTEGER, PRIMARY KEY(`sessionId`, `itemIndex`), FOREIGN KEY(`sessionId`) REFERENCES `FrostSigningSession`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "sessionId", + "columnName": "sessionId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "itemIndex", + "columnName": "itemIndex", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "unsignedEventJson", + "columnName": "unsignedEventJson", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "eventId", + "columnName": "eventId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "nonceRandom", + "columnName": "nonceRandom", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "aggregatedNonce", + "columnName": "aggregatedNonce", + "affinity": "TEXT" + }, + { + "fieldPath": "signature", + "columnName": "signature", + "affinity": "TEXT" + }, + { + "fieldPath": "inputIndex", + "columnName": "inputIndex", + "affinity": "INTEGER" + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "sessionId", + "itemIndex" + ] + }, + "indices": [ + { + "name": "index_FrostSigningItem_sessionId", + "unique": false, + "columnNames": [ + "sessionId" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_FrostSigningItem_sessionId` ON `${TABLE_NAME}` (`sessionId`)" + } + ], + "foreignKeys": [ + { + "table": "FrostSigningSession", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "sessionId" + ], + "referencedColumns": [ + "id" + ] + } + ] + }, + { + "tableName": "FrostSigningSession", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `chatRoomId` TEXT NOT NULL, `coordinatorPublicKey` TEXT NOT NULL, `userPublicKey` TEXT NOT NULL, `dkgSessionId` TEXT NOT NULL, `threshold` INTEGER NOT NULL, `participantCount` INTEGER NOT NULL, `signerId` INTEGER NOT NULL, `derivationPath` TEXT, `stage` TEXT NOT NULL, `signerIds` TEXT, `failureReason` TEXT, `signApprovedAt` INTEGER, `signDeclinedAt` INTEGER, `approvalRequestedAt` INTEGER, `resentAt` INTEGER, `subject` TEXT NOT NULL DEFAULT 'EVENTS', `createdAt` INTEGER NOT NULL, `updatedAt` INTEGER NOT NULL, `savedAt` INTEGER NOT NULL, PRIMARY KEY(`id`), FOREIGN KEY(`chatRoomId`) REFERENCES `ChatRoom`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "chatRoomId", + "columnName": "chatRoomId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "coordinatorPublicKey", + "columnName": "coordinatorPublicKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "userPublicKey", + "columnName": "userPublicKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "dkgSessionId", + "columnName": "dkgSessionId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "threshold", + "columnName": "threshold", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "participantCount", + "columnName": "participantCount", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "signerId", + "columnName": "signerId", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "derivationPath", + "columnName": "derivationPath", + "affinity": "TEXT" + }, + { + "fieldPath": "stage", + "columnName": "stage", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "signerIds", + "columnName": "signerIds", + "affinity": "TEXT" + }, + { + "fieldPath": "failureReason", + "columnName": "failureReason", + "affinity": "TEXT" + }, + { + "fieldPath": "signApprovedAt", + "columnName": "signApprovedAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "signDeclinedAt", + "columnName": "signDeclinedAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "approvalRequestedAt", + "columnName": "approvalRequestedAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "resentAt", + "columnName": "resentAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "subject", + "columnName": "subject", + "affinity": "TEXT", + "notNull": true, + "defaultValue": "'EVENTS'" + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updatedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "savedAt", + "columnName": "savedAt", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "id" + ] + }, + "indices": [ + { + "name": "index_FrostSigningSession_chatRoomId", + "unique": false, + "columnNames": [ + "chatRoomId" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_FrostSigningSession_chatRoomId` ON `${TABLE_NAME}` (`chatRoomId`)" + }, + { + "name": "index_FrostSigningSession_dkgSessionId", + "unique": false, + "columnNames": [ + "dkgSessionId" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_FrostSigningSession_dkgSessionId` ON `${TABLE_NAME}` (`dkgSessionId`)" + } + ], + "foreignKeys": [ + { + "table": "ChatRoom", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "chatRoomId" + ], + "referencedColumns": [ + "id" + ] + } + ] + }, + { + "tableName": "GiftWrapMessage", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `publicKey` TEXT NOT NULL, `kind` INTEGER NOT NULL, `receiverPublicKey` TEXT NOT NULL, `receiverRelayHit` TEXT, `content` TEXT NOT NULL, `signature` TEXT NOT NULL, `nostrEventId` TEXT NOT NULL, `createdAt` INTEGER NOT NULL, `updatedAt` INTEGER NOT NULL, `savedAt` INTEGER NOT NULL, `viewedAt` INTEGER, `deletedAt` INTEGER, PRIMARY KEY(`id`), FOREIGN KEY(`nostrEventId`) REFERENCES `NostrEvent`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "publicKey", + "columnName": "publicKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "kind", + "columnName": "kind", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "receiverPublicKey", + "columnName": "receiverPublicKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "receiverRelayHit", + "columnName": "receiverRelayHit", + "affinity": "TEXT" + }, + { + "fieldPath": "content", + "columnName": "content", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "signature", + "columnName": "signature", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "nostrEventId", + "columnName": "nostrEventId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updatedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "savedAt", + "columnName": "savedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "viewedAt", + "columnName": "viewedAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "deletedAt", + "columnName": "deletedAt", + "affinity": "INTEGER" + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "id" + ] + }, + "foreignKeys": [ + { + "table": "NostrEvent", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "nostrEventId" + ], + "referencedColumns": [ + "id" + ] + } + ] + }, + { + "tableName": "GiftWrapSeal", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `publicKey` TEXT NOT NULL, `kind` INTEGER NOT NULL, `tags` TEXT NOT NULL, `content` TEXT NOT NULL, `signature` TEXT NOT NULL, `giftWrapMessageId` TEXT, `createdAt` INTEGER NOT NULL, `updatedAt` INTEGER NOT NULL, `savedAt` INTEGER NOT NULL, `viewedAt` INTEGER, `deletedAt` INTEGER, PRIMARY KEY(`id`), FOREIGN KEY(`giftWrapMessageId`) REFERENCES `GiftWrapMessage`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "publicKey", + "columnName": "publicKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "kind", + "columnName": "kind", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "tags", + "columnName": "tags", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "content", + "columnName": "content", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "signature", + "columnName": "signature", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "giftWrapMessageId", + "columnName": "giftWrapMessageId", + "affinity": "TEXT" + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updatedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "savedAt", + "columnName": "savedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "viewedAt", + "columnName": "viewedAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "deletedAt", + "columnName": "deletedAt", + "affinity": "INTEGER" + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "id" + ] + }, + "foreignKeys": [ + { + "table": "GiftWrapMessage", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "giftWrapMessageId" + ], + "referencedColumns": [ + "id" + ] + } + ] + }, + { + "tableName": "GiftWrapPayload", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `publicKey` TEXT NOT NULL, `chatRoomId` TEXT NOT NULL, `kind` INTEGER NOT NULL, `tags` TEXT NOT NULL, `content` TEXT NOT NULL, `quotedEventId` TEXT, `giftWrapSealId` TEXT, `createdAt` INTEGER NOT NULL, `updatedAt` INTEGER NOT NULL, `savedAt` INTEGER NOT NULL, `viewedAt` INTEGER, `deletedAt` INTEGER, PRIMARY KEY(`id`), FOREIGN KEY(`giftWrapSealId`) REFERENCES `GiftWrapSeal`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "publicKey", + "columnName": "publicKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "chatRoomId", + "columnName": "chatRoomId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "kind", + "columnName": "kind", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "tags", + "columnName": "tags", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "content", + "columnName": "content", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "quotedEventId", + "columnName": "quotedEventId", + "affinity": "TEXT" + }, + { + "fieldPath": "giftWrapSealId", + "columnName": "giftWrapSealId", + "affinity": "TEXT" + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updatedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "savedAt", + "columnName": "savedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "viewedAt", + "columnName": "viewedAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "deletedAt", + "columnName": "deletedAt", + "affinity": "INTEGER" + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "id" + ] + }, + "foreignKeys": [ + { + "table": "GiftWrapSeal", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "giftWrapSealId" + ], + "referencedColumns": [ + "id" + ] + } + ] + }, + { + "tableName": "GroupKeyState", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`chatRoomId` TEXT NOT NULL, `dkgSessionId` TEXT NOT NULL, `thresholdPublicKey` TEXT NOT NULL, `derivationPath` TEXT NOT NULL, `announcedBy` TEXT NOT NULL, `announcedAt` INTEGER NOT NULL, `parentChatRoomId` TEXT, `birthCertificateJson` TEXT, `createdAt` INTEGER NOT NULL, `updatedAt` INTEGER NOT NULL, `savedAt` INTEGER NOT NULL, PRIMARY KEY(`chatRoomId`), FOREIGN KEY(`chatRoomId`) REFERENCES `ChatRoom`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "chatRoomId", + "columnName": "chatRoomId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "dkgSessionId", + "columnName": "dkgSessionId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "thresholdPublicKey", + "columnName": "thresholdPublicKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "derivationPath", + "columnName": "derivationPath", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "announcedBy", + "columnName": "announcedBy", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "announcedAt", + "columnName": "announcedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "parentChatRoomId", + "columnName": "parentChatRoomId", + "affinity": "TEXT" + }, + { + "fieldPath": "birthCertificateJson", + "columnName": "birthCertificateJson", + "affinity": "TEXT" + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updatedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "savedAt", + "columnName": "savedAt", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "chatRoomId" + ] + }, + "indices": [ + { + "name": "index_GroupKeyState_dkgSessionId", + "unique": false, + "columnNames": [ + "dkgSessionId" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_GroupKeyState_dkgSessionId` ON `${TABLE_NAME}` (`dkgSessionId`)" + } + ], + "foreignKeys": [ + { + "table": "ChatRoom", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "chatRoomId" + ], + "referencedColumns": [ + "id" + ] + } + ] + }, + { + "tableName": "GroupSignedEvent", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `chatRoomId` TEXT NOT NULL, `publicKey` TEXT NOT NULL, `kind` INTEGER NOT NULL, `tags` TEXT NOT NULL, `content` TEXT NOT NULL, `signature` TEXT NOT NULL, `derivationPath` TEXT, `frostSigningSessionId` TEXT, `createdAt` INTEGER NOT NULL, `updatedAt` INTEGER NOT NULL, `savedAt` INTEGER NOT NULL, PRIMARY KEY(`id`), FOREIGN KEY(`chatRoomId`) REFERENCES `ChatRoom`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "chatRoomId", + "columnName": "chatRoomId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "publicKey", + "columnName": "publicKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "kind", + "columnName": "kind", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "tags", + "columnName": "tags", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "content", + "columnName": "content", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "signature", + "columnName": "signature", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "derivationPath", + "columnName": "derivationPath", + "affinity": "TEXT" + }, + { + "fieldPath": "frostSigningSessionId", + "columnName": "frostSigningSessionId", + "affinity": "TEXT" + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updatedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "savedAt", + "columnName": "savedAt", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "id" + ] + }, + "indices": [ + { + "name": "index_GroupSignedEvent_chatRoomId", + "unique": false, + "columnNames": [ + "chatRoomId" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_GroupSignedEvent_chatRoomId` ON `${TABLE_NAME}` (`chatRoomId`)" + }, + { + "name": "index_GroupSignedEvent_kind", + "unique": false, + "columnNames": [ + "kind" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_GroupSignedEvent_kind` ON `${TABLE_NAME}` (`kind`)" + }, + { + "name": "index_GroupSignedEvent_frostSigningSessionId", + "unique": false, + "columnNames": [ + "frostSigningSessionId" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_GroupSignedEvent_frostSigningSessionId` ON `${TABLE_NAME}` (`frostSigningSessionId`)" + } + ], + "foreignKeys": [ + { + "table": "ChatRoom", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "chatRoomId" + ], + "referencedColumns": [ + "id" + ] + } + ] + }, + { + "tableName": "GroupTransaction", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`frostSigningSessionId` TEXT NOT NULL, `chatRoomId` TEXT NOT NULL, `chain` TEXT NOT NULL, `account` INTEGER NOT NULL, `guardedChatRoomId` TEXT, `psbt` TEXT NOT NULL, `txid` TEXT NOT NULL, `signedTransaction` TEXT, `broadcastAt` INTEGER, `seenAt` INTEGER, `confirmedAt` INTEGER, `replacedByTxid` TEXT, `createdAt` INTEGER NOT NULL, PRIMARY KEY(`frostSigningSessionId`), FOREIGN KEY(`frostSigningSessionId`) REFERENCES `FrostSigningSession`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`chatRoomId`) REFERENCES `ChatRoom`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "frostSigningSessionId", + "columnName": "frostSigningSessionId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "chatRoomId", + "columnName": "chatRoomId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "chain", + "columnName": "chain", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "account", + "columnName": "account", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "guardedChatRoomId", + "columnName": "guardedChatRoomId", + "affinity": "TEXT" + }, + { + "fieldPath": "psbt", + "columnName": "psbt", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "txid", + "columnName": "txid", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "signedTransaction", + "columnName": "signedTransaction", + "affinity": "TEXT" + }, + { + "fieldPath": "broadcastAt", + "columnName": "broadcastAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "seenAt", + "columnName": "seenAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "confirmedAt", + "columnName": "confirmedAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "replacedByTxid", + "columnName": "replacedByTxid", + "affinity": "TEXT" + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "frostSigningSessionId" + ] + }, + "indices": [ + { + "name": "index_GroupTransaction_chatRoomId", + "unique": false, + "columnNames": [ + "chatRoomId" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_GroupTransaction_chatRoomId` ON `${TABLE_NAME}` (`chatRoomId`)" + }, + { + "name": "index_GroupTransaction_txid", + "unique": false, + "columnNames": [ + "txid" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_GroupTransaction_txid` ON `${TABLE_NAME}` (`txid`)" + } + ], + "foreignKeys": [ + { + "table": "FrostSigningSession", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "frostSigningSessionId" + ], + "referencedColumns": [ + "id" + ] + }, + { + "table": "ChatRoom", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "chatRoomId" + ], + "referencedColumns": [ + "id" + ] + } + ] + }, + { + "tableName": "InReplyToRelation", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`replyingNostrEventId` TEXT NOT NULL, `inReplyToNostrEventId` TEXT NOT NULL, `inReplyToProfilePublicKey` TEXT, `inReplyToRootNostrEventId` TEXT, `inReplyToRootProfilePublicKey` TEXT, `createdAt` INTEGER NOT NULL, `updatedAt` INTEGER NOT NULL, `savedAt` INTEGER NOT NULL, `viewedAt` INTEGER, `deletedAt` INTEGER, PRIMARY KEY(`replyingNostrEventId`, `inReplyToNostrEventId`), FOREIGN KEY(`inReplyToProfilePublicKey`) REFERENCES `Profile`(`publicKey`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`inReplyToRootProfilePublicKey`) REFERENCES `Profile`(`publicKey`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`replyingNostrEventId`) REFERENCES `NostrEvent`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`inReplyToNostrEventId`) REFERENCES `NostrEvent`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`inReplyToRootNostrEventId`) REFERENCES `NostrEvent`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "replyingNostrEventId", + "columnName": "replyingNostrEventId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "inReplyToNostrEventId", + "columnName": "inReplyToNostrEventId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "inReplyToProfilePublicKey", + "columnName": "inReplyToProfilePublicKey", + "affinity": "TEXT" + }, + { + "fieldPath": "inReplyToRootNostrEventId", + "columnName": "inReplyToRootNostrEventId", + "affinity": "TEXT" + }, + { + "fieldPath": "inReplyToRootProfilePublicKey", + "columnName": "inReplyToRootProfilePublicKey", + "affinity": "TEXT" + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updatedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "savedAt", + "columnName": "savedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "viewedAt", + "columnName": "viewedAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "deletedAt", + "columnName": "deletedAt", + "affinity": "INTEGER" + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "replyingNostrEventId", + "inReplyToNostrEventId" + ] + }, + "foreignKeys": [ + { + "table": "Profile", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "inReplyToProfilePublicKey" + ], + "referencedColumns": [ + "publicKey" + ] + }, + { + "table": "Profile", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "inReplyToRootProfilePublicKey" + ], + "referencedColumns": [ + "publicKey" + ] + }, + { + "table": "NostrEvent", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "replyingNostrEventId" + ], + "referencedColumns": [ + "id" + ] + }, + { + "table": "NostrEvent", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "inReplyToNostrEventId" + ], + "referencedColumns": [ + "id" + ] + }, + { + "table": "NostrEvent", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "inReplyToRootNostrEventId" + ], + "referencedColumns": [ + "id" + ] + } + ] + }, + { + "tableName": "MarmotCommitResult", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `userPublicKey` TEXT NOT NULL, `peerKeyPackageEventId` TEXT NOT NULL, `chatRoomId` TEXT NOT NULL, `isOneMemberInitialGroupCreation` INTEGER NOT NULL, `commitBytes` BLOB NOT NULL, `welcomeBytes` BLOB, `groupInfoBytes` BLOB, `framedCommitBytes` BLOB NOT NULL, `preCommitExporterSecret` BLOB NOT NULL, `obligationId` TEXT, `createdAt` INTEGER NOT NULL, `updatedAt` INTEGER NOT NULL, `savedAt` INTEGER NOT NULL, `viewedAt` INTEGER, `deletedAt` INTEGER, PRIMARY KEY(`id`))", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "userPublicKey", + "columnName": "userPublicKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "peerKeyPackageEventId", + "columnName": "peerKeyPackageEventId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "chatRoomId", + "columnName": "chatRoomId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "isOneMemberInitialGroupCreation", + "columnName": "isOneMemberInitialGroupCreation", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "commitBytes", + "columnName": "commitBytes", + "affinity": "BLOB", + "notNull": true + }, + { + "fieldPath": "welcomeBytes", + "columnName": "welcomeBytes", + "affinity": "BLOB" + }, + { + "fieldPath": "groupInfoBytes", + "columnName": "groupInfoBytes", + "affinity": "BLOB" + }, + { + "fieldPath": "framedCommitBytes", + "columnName": "framedCommitBytes", + "affinity": "BLOB", + "notNull": true + }, + { + "fieldPath": "preCommitExporterSecret", + "columnName": "preCommitExporterSecret", + "affinity": "BLOB", + "notNull": true + }, + { + "fieldPath": "obligationId", + "columnName": "obligationId", + "affinity": "TEXT" + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updatedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "savedAt", + "columnName": "savedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "viewedAt", + "columnName": "viewedAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "deletedAt", + "columnName": "deletedAt", + "affinity": "INTEGER" + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "id" + ] + } + }, + { + "tableName": "MarmotGroupEvent", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `userPublicKey` TEXT NOT NULL, `publicKey` TEXT NOT NULL, `chatRoomId` TEXT NOT NULL, `signature` TEXT NOT NULL, `encryptedContent` TEXT NOT NULL, `expiresAt` INTEGER, `createdAt` INTEGER NOT NULL, `updatedAt` INTEGER NOT NULL, `savedAt` INTEGER NOT NULL, `deletedAt` INTEGER, `broadcastedAt` INTEGER, PRIMARY KEY(`id`), FOREIGN KEY(`id`) REFERENCES `NostrEvent`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "userPublicKey", + "columnName": "userPublicKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "publicKey", + "columnName": "publicKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "chatRoomId", + "columnName": "chatRoomId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "signature", + "columnName": "signature", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "encryptedContent", + "columnName": "encryptedContent", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "expiresAt", + "columnName": "expiresAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updatedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "savedAt", + "columnName": "savedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "deletedAt", + "columnName": "deletedAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "broadcastedAt", + "columnName": "broadcastedAt", + "affinity": "INTEGER" + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "id" + ] + }, + "foreignKeys": [ + { + "table": "NostrEvent", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "id" + ], + "referencedColumns": [ + "id" + ] + } + ] + }, + { + "tableName": "MarmotInnerEvent", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `publicKey` TEXT NOT NULL, `chatRoomId` TEXT NOT NULL, `kind` INTEGER NOT NULL, `tags` TEXT NOT NULL, `content` TEXT NOT NULL, `quotedEventId` TEXT, `marmotGroupEventId` TEXT, `directMessageRecipientPublicKey` TEXT, `createdAt` INTEGER NOT NULL, `updatedAt` INTEGER NOT NULL, `savedAt` INTEGER NOT NULL, `viewedAt` INTEGER, `deletedAt` INTEGER, PRIMARY KEY(`id`), FOREIGN KEY(`marmotGroupEventId`) REFERENCES `MarmotGroupEvent`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "publicKey", + "columnName": "publicKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "chatRoomId", + "columnName": "chatRoomId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "kind", + "columnName": "kind", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "tags", + "columnName": "tags", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "content", + "columnName": "content", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "quotedEventId", + "columnName": "quotedEventId", + "affinity": "TEXT" + }, + { + "fieldPath": "marmotGroupEventId", + "columnName": "marmotGroupEventId", + "affinity": "TEXT" + }, + { + "fieldPath": "directMessageRecipientPublicKey", + "columnName": "directMessageRecipientPublicKey", + "affinity": "TEXT" + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updatedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "savedAt", + "columnName": "savedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "viewedAt", + "columnName": "viewedAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "deletedAt", + "columnName": "deletedAt", + "affinity": "INTEGER" + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "id" + ] + }, + "foreignKeys": [ + { + "table": "MarmotGroupEvent", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "marmotGroupEventId" + ], + "referencedColumns": [ + "id" + ] + } + ] + }, + { + "tableName": "MarmotKeyPackage", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `publicKey` TEXT NOT NULL, `tlsEncodedMarmotKeyPackage` BLOB NOT NULL, `profile` TEXT, `createdAt` INTEGER NOT NULL, `updatedAt` INTEGER NOT NULL, `savedAt` INTEGER NOT NULL, `deletedAt` INTEGER, `broadcastedAt` INTEGER, PRIMARY KEY(`id`), FOREIGN KEY(`publicKey`) REFERENCES `Profile`(`publicKey`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "publicKey", + "columnName": "publicKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "tlsEncodedMarmotKeyPackage", + "columnName": "tlsEncodedMarmotKeyPackage", + "affinity": "BLOB", + "notNull": true + }, + { + "fieldPath": "profile", + "columnName": "profile", + "affinity": "TEXT" + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updatedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "savedAt", + "columnName": "savedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "deletedAt", + "columnName": "deletedAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "broadcastedAt", + "columnName": "broadcastedAt", + "affinity": "INTEGER" + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "id" + ] + }, + "foreignKeys": [ + { + "table": "Profile", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "publicKey" + ], + "referencedColumns": [ + "publicKey" + ] + } + ] + }, + { + "tableName": "MarmotKeyPackageBundle", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `publicKey` TEXT NOT NULL, `tlsEncodedMarmotKeyPackage` BLOB NOT NULL, `ncryptsecInitPrivateKey` TEXT NOT NULL, `ncryptsecEncryptionPrivateKey` TEXT NOT NULL, `ncryptsecSignaturePrivateKey` TEXT NOT NULL, `consumed` INTEGER NOT NULL, `rotated` INTEGER NOT NULL, `profile` TEXT, `dTag` TEXT, `createdAt` INTEGER NOT NULL, `updatedAt` INTEGER NOT NULL, `savedAt` INTEGER NOT NULL, `deletedAt` INTEGER, `broadcastedAt` INTEGER, PRIMARY KEY(`id`))", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "publicKey", + "columnName": "publicKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "tlsEncodedMarmotKeyPackage", + "columnName": "tlsEncodedMarmotKeyPackage", + "affinity": "BLOB", + "notNull": true + }, + { + "fieldPath": "ncryptsecInitPrivateKey", + "columnName": "ncryptsecInitPrivateKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "ncryptsecEncryptionPrivateKey", + "columnName": "ncryptsecEncryptionPrivateKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "ncryptsecSignaturePrivateKey", + "columnName": "ncryptsecSignaturePrivateKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "consumed", + "columnName": "consumed", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "rotated", + "columnName": "rotated", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "profile", + "columnName": "profile", + "affinity": "TEXT" + }, + { + "fieldPath": "dTag", + "columnName": "dTag", + "affinity": "TEXT" + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updatedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "savedAt", + "columnName": "savedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "deletedAt", + "columnName": "deletedAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "broadcastedAt", + "columnName": "broadcastedAt", + "affinity": "INTEGER" + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "id" + ] + }, + "indices": [ + { + "name": "index_MarmotKeyPackageBundle_publicKey", + "unique": false, + "columnNames": [ + "publicKey" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_MarmotKeyPackageBundle_publicKey` ON `${TABLE_NAME}` (`publicKey`)" + } + ] + }, + { + "tableName": "MarmotRouting", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`routingId` TEXT NOT NULL, `chatRoomId` TEXT NOT NULL, `activeFromEpoch` INTEGER NOT NULL, `retiredAtEpoch` INTEGER, PRIMARY KEY(`routingId`), FOREIGN KEY(`chatRoomId`) REFERENCES `ChatRoom`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "routingId", + "columnName": "routingId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "chatRoomId", + "columnName": "chatRoomId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "activeFromEpoch", + "columnName": "activeFromEpoch", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "retiredAtEpoch", + "columnName": "retiredAtEpoch", + "affinity": "INTEGER" + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "routingId" + ] + }, + "indices": [ + { + "name": "index_MarmotRouting_chatRoomId", + "unique": false, + "columnNames": [ + "chatRoomId" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_MarmotRouting_chatRoomId` ON `${TABLE_NAME}` (`chatRoomId`)" + } + ], + "foreignKeys": [ + { + "table": "ChatRoom", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "chatRoomId" + ], + "referencedColumns": [ + "id" + ] + } + ] + }, + { + "tableName": "MarmotPublishObligation", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`obligationId` TEXT NOT NULL, `bytes` BLOB NOT NULL, PRIMARY KEY(`obligationId`))", + "fields": [ + { + "fieldPath": "obligationId", + "columnName": "obligationId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "bytes", + "columnName": "bytes", + "affinity": "BLOB", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "obligationId" + ] + } + }, + { + "tableName": "MarmotOutboundGate", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`groupId` TEXT NOT NULL, `gate` TEXT NOT NULL, PRIMARY KEY(`groupId`))", + "fields": [ + { + "fieldPath": "groupId", + "columnName": "groupId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "gate", + "columnName": "gate", + "affinity": "TEXT", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "groupId" + ] + } + }, + { + "tableName": "MarmotRetainedEpochSecret", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`chatRoomId` TEXT NOT NULL, `epoch` INTEGER NOT NULL, `senderDataSecret` BLOB NOT NULL, `encryptionSecret` BLOB NOT NULL, `leafCount` INTEGER NOT NULL, `exporterSecret` BLOB NOT NULL, `createdAt` INTEGER NOT NULL, `updatedAt` INTEGER NOT NULL, `savedAt` INTEGER NOT NULL, PRIMARY KEY(`chatRoomId`, `epoch`), FOREIGN KEY(`chatRoomId`) REFERENCES `ChatRoom`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "chatRoomId", + "columnName": "chatRoomId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "epoch", + "columnName": "epoch", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "senderDataSecret", + "columnName": "senderDataSecret", + "affinity": "BLOB", + "notNull": true + }, + { + "fieldPath": "encryptionSecret", + "columnName": "encryptionSecret", + "affinity": "BLOB", + "notNull": true + }, + { + "fieldPath": "leafCount", + "columnName": "leafCount", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "exporterSecret", + "columnName": "exporterSecret", + "affinity": "BLOB", + "notNull": true + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updatedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "savedAt", + "columnName": "savedAt", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "chatRoomId", + "epoch" + ] + }, + "foreignKeys": [ + { + "table": "ChatRoom", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "chatRoomId" + ], + "referencedColumns": [ + "id" + ] + } + ] + }, + { + "tableName": "MemberWallet", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`walletId` TEXT NOT NULL, `ownerPublicKey` TEXT NOT NULL, `guardingChatRoomId` TEXT NOT NULL, `chain` TEXT NOT NULL, `walletPrivateKey` TEXT NOT NULL, `label` TEXT, `requestJson` TEXT NOT NULL, `createdAt` INTEGER NOT NULL, PRIMARY KEY(`walletId`))", + "fields": [ + { + "fieldPath": "walletId", + "columnName": "walletId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "ownerPublicKey", + "columnName": "ownerPublicKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "guardingChatRoomId", + "columnName": "guardingChatRoomId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "chain", + "columnName": "chain", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "walletPrivateKey", + "columnName": "walletPrivateKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "label", + "columnName": "label", + "affinity": "TEXT" + }, + { + "fieldPath": "requestJson", + "columnName": "requestJson", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "walletId" + ] + }, + "indices": [ + { + "name": "index_MemberWallet_ownerPublicKey", + "unique": false, + "columnNames": [ + "ownerPublicKey" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_MemberWallet_ownerPublicKey` ON `${TABLE_NAME}` (`ownerPublicKey`)" + }, + { + "name": "index_MemberWallet_guardingChatRoomId", + "unique": false, + "columnNames": [ + "guardingChatRoomId" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_MemberWallet_guardingChatRoomId` ON `${TABLE_NAME}` (`guardingChatRoomId`)" + } + ] + }, + { + "tableName": "MemberWalletSpend", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`txid` TEXT NOT NULL, `walletId` TEXT NOT NULL, `psbt` TEXT NOT NULL, `signedTransaction` TEXT NOT NULL, `broadcastAt` INTEGER, `seenAt` INTEGER, `confirmedAt` INTEGER, `replacedByTxid` TEXT, `createdAt` INTEGER NOT NULL, PRIMARY KEY(`txid`))", + "fields": [ + { + "fieldPath": "txid", + "columnName": "txid", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "walletId", + "columnName": "walletId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "psbt", + "columnName": "psbt", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "signedTransaction", + "columnName": "signedTransaction", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "broadcastAt", + "columnName": "broadcastAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "seenAt", + "columnName": "seenAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "confirmedAt", + "columnName": "confirmedAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "replacedByTxid", + "columnName": "replacedByTxid", + "affinity": "TEXT" + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "txid" + ] + }, + "indices": [ + { + "name": "index_MemberWalletSpend_walletId", + "unique": false, + "columnNames": [ + "walletId" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_MemberWalletSpend_walletId` ON `${TABLE_NAME}` (`walletId`)" + } + ] + }, + { + "tableName": "Mention", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `mentionedPublicKey` TEXT NOT NULL, `mentioningNostrEventId` TEXT, `relayUrl` TEXT, `createdAt` INTEGER NOT NULL, `updatedAt` INTEGER NOT NULL, `savedAt` INTEGER NOT NULL, `deletedAt` INTEGER, `broadcastedAt` INTEGER, FOREIGN KEY(`mentionedPublicKey`) REFERENCES `Profile`(`publicKey`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`mentioningNostrEventId`) REFERENCES `NostrEvent`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "mentionedPublicKey", + "columnName": "mentionedPublicKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "mentioningNostrEventId", + "columnName": "mentioningNostrEventId", + "affinity": "TEXT" + }, + { + "fieldPath": "relayUrl", + "columnName": "relayUrl", + "affinity": "TEXT" + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updatedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "savedAt", + "columnName": "savedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "deletedAt", + "columnName": "deletedAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "broadcastedAt", + "columnName": "broadcastedAt", + "affinity": "INTEGER" + } + ], + "primaryKey": { + "autoGenerate": true, + "columnNames": [ + "id" + ] + }, + "foreignKeys": [ + { + "table": "Profile", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "mentionedPublicKey" + ], + "referencedColumns": [ + "publicKey" + ] + }, + { + "table": "NostrEvent", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "mentioningNostrEventId" + ], + "referencedColumns": [ + "id" + ] + } + ] + }, + { + "tableName": "NegentropySynchronizeRequest", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `uuid` TEXT NOT NULL, `purpose` TEXT NOT NULL, `status` TEXT NOT NULL, `relayURL` TEXT NOT NULL, `isRecommendedRelay` INTEGER NOT NULL, `level` INTEGER NOT NULL, `synchronizationFilter` TEXT NOT NULL, `ownerPublicKey` TEXT, `nostrEventId` TEXT, `createdAt` INTEGER NOT NULL, `updatedAt` INTEGER NOT NULL, PRIMARY KEY(`id`), FOREIGN KEY(`nostrEventId`) REFERENCES `NostrEvent`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "uuid", + "columnName": "uuid", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "purpose", + "columnName": "purpose", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "status", + "columnName": "status", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "relayURL", + "columnName": "relayURL", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "isRecommendedRelay", + "columnName": "isRecommendedRelay", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "level", + "columnName": "level", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "synchronizationFilter", + "columnName": "synchronizationFilter", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "ownerPublicKey", + "columnName": "ownerPublicKey", + "affinity": "TEXT" + }, + { + "fieldPath": "nostrEventId", + "columnName": "nostrEventId", + "affinity": "TEXT" + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updatedAt", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "id" + ] + }, + "indices": [ + { + "name": "index_NegentropySynchronizeRequest_nostrEventId", + "unique": false, + "columnNames": [ + "nostrEventId" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_NegentropySynchronizeRequest_nostrEventId` ON `${TABLE_NAME}` (`nostrEventId`)" + }, + { + "name": "index_NegentropySynchronizeRequest_status", + "unique": false, + "columnNames": [ + "status" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_NegentropySynchronizeRequest_status` ON `${TABLE_NAME}` (`status`)" + } + ], + "foreignKeys": [ + { + "table": "NostrEvent", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "nostrEventId" + ], + "referencedColumns": [ + "id" + ] + } + ] + }, + { + "tableName": "NegentropySynchronizeResult", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `relayURL` TEXT NOT NULL, `status` TEXT NOT NULL, `negentropySynchronizeRequestId` TEXT NOT NULL, `createdAt` INTEGER NOT NULL, `updatedAt` INTEGER NOT NULL, PRIMARY KEY(`id`), FOREIGN KEY(`negentropySynchronizeRequestId`) REFERENCES `SynchronizeNostrEventResult`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "relayURL", + "columnName": "relayURL", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "status", + "columnName": "status", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "negentropySynchronizeRequestId", + "columnName": "negentropySynchronizeRequestId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updatedAt", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "id" + ] + }, + "foreignKeys": [ + { + "table": "SynchronizeNostrEventResult", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "negentropySynchronizeRequestId" + ], + "referencedColumns": [ + "id" + ] + } + ] + }, + { + "tableName": "NostrEvent", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `pubKey` TEXT NOT NULL, `kind` INTEGER NOT NULL, `tags` TEXT NOT NULL, `content` TEXT NOT NULL, `sig` TEXT NOT NULL, `relayUrl` TEXT, `quotedNostrEventId` TEXT, `quotedAuthorPublicKey` TEXT, `inReplyToNostrEventId` TEXT, `inReplyToAuthorPublicKey` TEXT, `inReplyToRootNostrEventId` TEXT, `inReplyToRootAuthorPublicKey` TEXT, `repostedNostrEventId` TEXT, `repostedAuthorPublicKey` TEXT, `unsignedNostrEventId` INTEGER, `createdAt` INTEGER NOT NULL, `updatedAt` INTEGER NOT NULL, `savedAt` INTEGER NOT NULL, `deletedAt` INTEGER, `broadcastedAt` INTEGER, PRIMARY KEY(`id`))", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "pubKey", + "columnName": "pubKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "kind", + "columnName": "kind", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "tags", + "columnName": "tags", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "content", + "columnName": "content", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "sig", + "columnName": "sig", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "relayUrl", + "columnName": "relayUrl", + "affinity": "TEXT" + }, + { + "fieldPath": "quotedNostrEventId", + "columnName": "quotedNostrEventId", + "affinity": "TEXT" + }, + { + "fieldPath": "quotedAuthorPublicKey", + "columnName": "quotedAuthorPublicKey", + "affinity": "TEXT" + }, + { + "fieldPath": "inReplyToNostrEventId", + "columnName": "inReplyToNostrEventId", + "affinity": "TEXT" + }, + { + "fieldPath": "inReplyToAuthorPublicKey", + "columnName": "inReplyToAuthorPublicKey", + "affinity": "TEXT" + }, + { + "fieldPath": "inReplyToRootNostrEventId", + "columnName": "inReplyToRootNostrEventId", + "affinity": "TEXT" + }, + { + "fieldPath": "inReplyToRootAuthorPublicKey", + "columnName": "inReplyToRootAuthorPublicKey", + "affinity": "TEXT" + }, + { + "fieldPath": "repostedNostrEventId", + "columnName": "repostedNostrEventId", + "affinity": "TEXT" + }, + { + "fieldPath": "repostedAuthorPublicKey", + "columnName": "repostedAuthorPublicKey", + "affinity": "TEXT" + }, + { + "fieldPath": "unsignedNostrEventId", + "columnName": "unsignedNostrEventId", + "affinity": "INTEGER" + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updatedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "savedAt", + "columnName": "savedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "deletedAt", + "columnName": "deletedAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "broadcastedAt", + "columnName": "broadcastedAt", + "affinity": "INTEGER" + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "id" + ] + }, + "indices": [ + { + "name": "index_NostrEvent_kind", + "unique": false, + "columnNames": [ + "kind" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_NostrEvent_kind` ON `${TABLE_NAME}` (`kind`)" + }, + { + "name": "index_NostrEvent_pubKey", + "unique": false, + "columnNames": [ + "pubKey" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_NostrEvent_pubKey` ON `${TABLE_NAME}` (`pubKey`)" + }, + { + "name": "index_NostrEvent_quotedNostrEventId", + "unique": false, + "columnNames": [ + "quotedNostrEventId" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_NostrEvent_quotedNostrEventId` ON `${TABLE_NAME}` (`quotedNostrEventId`)" + }, + { + "name": "index_NostrEvent_inReplyToNostrEventId", + "unique": false, + "columnNames": [ + "inReplyToNostrEventId" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_NostrEvent_inReplyToNostrEventId` ON `${TABLE_NAME}` (`inReplyToNostrEventId`)" + }, + { + "name": "index_NostrEvent_inReplyToRootNostrEventId", + "unique": false, + "columnNames": [ + "inReplyToRootNostrEventId" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_NostrEvent_inReplyToRootNostrEventId` ON `${TABLE_NAME}` (`inReplyToRootNostrEventId`)" + } + ] + }, + { + "tableName": "NostrEventRelay", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`relayURL` TEXT NOT NULL, `nostrEventId` TEXT NOT NULL, `createdAt` INTEGER NOT NULL, `updatedAt` INTEGER NOT NULL, PRIMARY KEY(`nostrEventId`, `relayURL`), FOREIGN KEY(`nostrEventId`) REFERENCES `NostrEvent`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "relayURL", + "columnName": "relayURL", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "nostrEventId", + "columnName": "nostrEventId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updatedAt", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "nostrEventId", + "relayURL" + ] + }, + "indices": [ + { + "name": "index_NostrEventRelay_relayURL", + "unique": false, + "columnNames": [ + "relayURL" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_NostrEventRelay_relayURL` ON `${TABLE_NAME}` (`relayURL`)" + } + ], + "foreignKeys": [ + { + "table": "NostrEvent", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "nostrEventId" + ], + "referencedColumns": [ + "id" + ] + } + ] + }, + { + "tableName": "Participant", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `participantPublicKey` TEXT NOT NULL, `chatRoomId` TEXT NOT NULL, `relayHint` TEXT, `adminAt` INTEGER, `createdAt` INTEGER NOT NULL, `updatedAt` INTEGER NOT NULL, `savedAt` INTEGER NOT NULL, `deletedAt` INTEGER, `broadcastedAt` INTEGER, FOREIGN KEY(`participantPublicKey`) REFERENCES `Profile`(`publicKey`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`chatRoomId`) REFERENCES `ChatRoom`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "participantPublicKey", + "columnName": "participantPublicKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "chatRoomId", + "columnName": "chatRoomId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "relayHint", + "columnName": "relayHint", + "affinity": "TEXT" + }, + { + "fieldPath": "adminAt", + "columnName": "adminAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updatedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "savedAt", + "columnName": "savedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "deletedAt", + "columnName": "deletedAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "broadcastedAt", + "columnName": "broadcastedAt", + "affinity": "INTEGER" + } + ], + "primaryKey": { + "autoGenerate": true, + "columnNames": [ + "id" + ] + }, + "foreignKeys": [ + { + "table": "Profile", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "participantPublicKey" + ], + "referencedColumns": [ + "publicKey" + ] + }, + { + "table": "ChatRoom", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "chatRoomId" + ], + "referencedColumns": [ + "id" + ] + } + ] + }, + { + "tableName": "Post", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `repostId` TEXT, `quote` TEXT, `content` TEXT NOT NULL, `nostrEventId` TEXT NOT NULL, `replyToId` TEXT, `profilePublicKey` TEXT NOT NULL, `createdAt` INTEGER NOT NULL, `updatedAt` INTEGER NOT NULL, `savedAt` INTEGER NOT NULL, `viewedAt` INTEGER, `deletedAt` INTEGER, `broadcastedAt` INTEGER, PRIMARY KEY(`id`), FOREIGN KEY(`profilePublicKey`) REFERENCES `Profile`(`publicKey`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`nostrEventId`) REFERENCES `NostrEvent`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`replyToId`) REFERENCES `Post`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`repostId`) REFERENCES `Post`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "repostId", + "columnName": "repostId", + "affinity": "TEXT" + }, + { + "fieldPath": "quote", + "columnName": "quote", + "affinity": "TEXT" + }, + { + "fieldPath": "content", + "columnName": "content", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "nostrEventId", + "columnName": "nostrEventId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "replyToId", + "columnName": "replyToId", + "affinity": "TEXT" + }, + { + "fieldPath": "profilePublicKey", + "columnName": "profilePublicKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updatedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "savedAt", + "columnName": "savedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "viewedAt", + "columnName": "viewedAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "deletedAt", + "columnName": "deletedAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "broadcastedAt", + "columnName": "broadcastedAt", + "affinity": "INTEGER" + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "id" + ] + }, + "indices": [ + { + "name": "index_Post_profilePublicKey", + "unique": false, + "columnNames": [ + "profilePublicKey" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_Post_profilePublicKey` ON `${TABLE_NAME}` (`profilePublicKey`)" + }, + { + "name": "index_Post_nostrEventId", + "unique": false, + "columnNames": [ + "nostrEventId" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_Post_nostrEventId` ON `${TABLE_NAME}` (`nostrEventId`)" + }, + { + "name": "index_Post_replyToId", + "unique": false, + "columnNames": [ + "replyToId" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_Post_replyToId` ON `${TABLE_NAME}` (`replyToId`)" + }, + { + "name": "index_Post_repostId", + "unique": false, + "columnNames": [ + "repostId" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_Post_repostId` ON `${TABLE_NAME}` (`repostId`)" + } + ], + "foreignKeys": [ + { + "table": "Profile", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "profilePublicKey" + ], + "referencedColumns": [ + "publicKey" + ] + }, + { + "table": "NostrEvent", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "nostrEventId" + ], + "referencedColumns": [ + "id" + ] + }, + { + "table": "Post", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "replyToId" + ], + "referencedColumns": [ + "id" + ] + }, + { + "table": "Post", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "repostId" + ], + "referencedColumns": [ + "id" + ] + } + ] + }, + { + "tableName": "Profile", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`publicKey` TEXT NOT NULL, `userName` TEXT, `displayName` TEXT, `picture` TEXT, `banner` TEXT, `website` TEXT, `about` TEXT, `bot` INTEGER, `pronouns` TEXT, `nip05` TEXT, `domain` TEXT, `lud06` TEXT, `lud16` TEXT, `twitter` TEXT, `nostrEventId` TEXT NOT NULL, `createdAt` INTEGER NOT NULL, `updatedAt` INTEGER NOT NULL, `savedAt` INTEGER NOT NULL, `viewedAt` INTEGER, `deletedAt` INTEGER, `broadcastedAt` INTEGER, PRIMARY KEY(`publicKey`), FOREIGN KEY(`nostrEventId`) REFERENCES `NostrEvent`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "publicKey", + "columnName": "publicKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "userName", + "columnName": "userName", + "affinity": "TEXT" + }, + { + "fieldPath": "displayName", + "columnName": "displayName", + "affinity": "TEXT" + }, + { + "fieldPath": "picture", + "columnName": "picture", + "affinity": "TEXT" + }, + { + "fieldPath": "banner", + "columnName": "banner", + "affinity": "TEXT" + }, + { + "fieldPath": "website", + "columnName": "website", + "affinity": "TEXT" + }, + { + "fieldPath": "about", + "columnName": "about", + "affinity": "TEXT" + }, + { + "fieldPath": "bot", + "columnName": "bot", + "affinity": "INTEGER" + }, + { + "fieldPath": "pronouns", + "columnName": "pronouns", + "affinity": "TEXT" + }, + { + "fieldPath": "nip05", + "columnName": "nip05", + "affinity": "TEXT" + }, + { + "fieldPath": "domain", + "columnName": "domain", + "affinity": "TEXT" + }, + { + "fieldPath": "lud06", + "columnName": "lud06", + "affinity": "TEXT" + }, + { + "fieldPath": "lud16", + "columnName": "lud16", + "affinity": "TEXT" + }, + { + "fieldPath": "twitter", + "columnName": "twitter", + "affinity": "TEXT" + }, + { + "fieldPath": "nostrEventId", + "columnName": "nostrEventId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updatedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "savedAt", + "columnName": "savedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "viewedAt", + "columnName": "viewedAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "deletedAt", + "columnName": "deletedAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "broadcastedAt", + "columnName": "broadcastedAt", + "affinity": "INTEGER" + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "publicKey" + ] + }, + "indices": [ + { + "name": "index_Profile_nostrEventId", + "unique": false, + "columnNames": [ + "nostrEventId" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_Profile_nostrEventId` ON `${TABLE_NAME}` (`nostrEventId`)" + } + ], + "foreignKeys": [ + { + "table": "NostrEvent", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "nostrEventId" + ], + "referencedColumns": [ + "id" + ] + } + ] + }, + { + "tableName": "QuotedRelation", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`quotingNostrEventId` TEXT NOT NULL, `quotedNostrEventId` TEXT NOT NULL, `quotedProfilePublicKey` TEXT, `createdAt` INTEGER NOT NULL, `updatedAt` INTEGER NOT NULL, `savedAt` INTEGER NOT NULL, `viewedAt` INTEGER, `deletedAt` INTEGER, `broadcastedAt` INTEGER, PRIMARY KEY(`quotingNostrEventId`, `quotedNostrEventId`), FOREIGN KEY(`quotedProfilePublicKey`) REFERENCES `Profile`(`publicKey`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`quotingNostrEventId`) REFERENCES `NostrEvent`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`quotedNostrEventId`) REFERENCES `NostrEvent`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "quotingNostrEventId", + "columnName": "quotingNostrEventId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "quotedNostrEventId", + "columnName": "quotedNostrEventId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "quotedProfilePublicKey", + "columnName": "quotedProfilePublicKey", + "affinity": "TEXT" + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updatedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "savedAt", + "columnName": "savedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "viewedAt", + "columnName": "viewedAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "deletedAt", + "columnName": "deletedAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "broadcastedAt", + "columnName": "broadcastedAt", + "affinity": "INTEGER" + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "quotingNostrEventId", + "quotedNostrEventId" + ] + }, + "foreignKeys": [ + { + "table": "Profile", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "quotedProfilePublicKey" + ], + "referencedColumns": [ + "publicKey" + ] + }, + { + "table": "NostrEvent", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "quotingNostrEventId" + ], + "referencedColumns": [ + "id" + ] + }, + { + "table": "NostrEvent", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "quotedNostrEventId" + ], + "referencedColumns": [ + "id" + ] + } + ] + }, + { + "tableName": "Reaction", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `content` TEXT NOT NULL, `nostrEventId` TEXT NOT NULL, `replyToId` TEXT NOT NULL, `profilePublicKey` TEXT NOT NULL, `createdAt` INTEGER NOT NULL, `updatedAt` INTEGER NOT NULL, `savedAt` INTEGER NOT NULL, `viewedAt` INTEGER, `deletedAt` INTEGER, `broadcastedAt` INTEGER, PRIMARY KEY(`id`), FOREIGN KEY(`profilePublicKey`) REFERENCES `Profile`(`publicKey`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`nostrEventId`) REFERENCES `NostrEvent`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`replyToId`) REFERENCES `Post`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "content", + "columnName": "content", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "nostrEventId", + "columnName": "nostrEventId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "replyToId", + "columnName": "replyToId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "profilePublicKey", + "columnName": "profilePublicKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updatedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "savedAt", + "columnName": "savedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "viewedAt", + "columnName": "viewedAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "deletedAt", + "columnName": "deletedAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "broadcastedAt", + "columnName": "broadcastedAt", + "affinity": "INTEGER" + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "id" + ] + }, + "indices": [ + { + "name": "index_Reaction_profilePublicKey", + "unique": false, + "columnNames": [ + "profilePublicKey" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_Reaction_profilePublicKey` ON `${TABLE_NAME}` (`profilePublicKey`)" + }, + { + "name": "index_Reaction_nostrEventId", + "unique": false, + "columnNames": [ + "nostrEventId" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_Reaction_nostrEventId` ON `${TABLE_NAME}` (`nostrEventId`)" + }, + { + "name": "index_Reaction_replyToId", + "unique": false, + "columnNames": [ + "replyToId" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_Reaction_replyToId` ON `${TABLE_NAME}` (`replyToId`)" + } + ], + "foreignKeys": [ + { + "table": "Profile", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "profilePublicKey" + ], + "referencedColumns": [ + "publicKey" + ] + }, + { + "table": "NostrEvent", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "nostrEventId" + ], + "referencedColumns": [ + "id" + ] + }, + { + "table": "Post", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "replyToId" + ], + "referencedColumns": [ + "id" + ] + } + ] + }, + { + "tableName": "RecentSearch", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`query` TEXT NOT NULL, `synchronizationFilters` TEXT, `createdAt` INTEGER NOT NULL, `updatedAt` INTEGER NOT NULL, PRIMARY KEY(`query`))", + "fields": [ + { + "fieldPath": "query", + "columnName": "query", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "synchronizationFilters", + "columnName": "synchronizationFilters", + "affinity": "TEXT" + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updatedAt", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "query" + ] + } + }, + { + "tableName": "Relay", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`publicKey` TEXT NOT NULL, `type` TEXT NOT NULL, `url` TEXT NOT NULL, `read` INTEGER NOT NULL, `write` INTEGER NOT NULL, PRIMARY KEY(`publicKey`, `type`, `url`))", + "fields": [ + { + "fieldPath": "publicKey", + "columnName": "publicKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "type", + "columnName": "type", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "url", + "columnName": "url", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "read", + "columnName": "read", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "write", + "columnName": "write", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "publicKey", + "type", + "url" + ] + } + }, + { + "tableName": "RepostedRelation", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`repostingNostrEventId` TEXT NOT NULL, `repostedNostrEventId` TEXT NOT NULL, `repostedProfilePublicKey` TEXT, `createdAt` INTEGER NOT NULL, `updatedAt` INTEGER NOT NULL, `savedAt` INTEGER NOT NULL, `viewedAt` INTEGER, `deletedAt` INTEGER, `broadcastedAt` INTEGER, PRIMARY KEY(`repostingNostrEventId`, `repostedNostrEventId`), FOREIGN KEY(`repostedProfilePublicKey`) REFERENCES `Profile`(`publicKey`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`repostedNostrEventId`) REFERENCES `NostrEvent`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`repostingNostrEventId`) REFERENCES `NostrEvent`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "repostingNostrEventId", + "columnName": "repostingNostrEventId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "repostedNostrEventId", + "columnName": "repostedNostrEventId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "repostedProfilePublicKey", + "columnName": "repostedProfilePublicKey", + "affinity": "TEXT" + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updatedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "savedAt", + "columnName": "savedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "viewedAt", + "columnName": "viewedAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "deletedAt", + "columnName": "deletedAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "broadcastedAt", + "columnName": "broadcastedAt", + "affinity": "INTEGER" + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "repostingNostrEventId", + "repostedNostrEventId" + ] + }, + "foreignKeys": [ + { + "table": "Profile", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "repostedProfilePublicKey" + ], + "referencedColumns": [ + "publicKey" + ] + }, + { + "table": "NostrEvent", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "repostedNostrEventId" + ], + "referencedColumns": [ + "id" + ] + }, + { + "table": "NostrEvent", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "repostingNostrEventId" + ], + "referencedColumns": [ + "id" + ] + } + ] + }, + { + "tableName": "SynchronizeNostrEventRequest", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `purpose` TEXT NOT NULL, `status` TEXT NOT NULL, `relayURL` TEXT NOT NULL, `isRecommendedRelay` INTEGER NOT NULL, `level` INTEGER NOT NULL, `synchronizationFilters` TEXT NOT NULL, `ownerPublicKey` TEXT, `nostrEventId` TEXT, `unsignedNostrEventId` INTEGER, `createdAt` INTEGER NOT NULL, `updatedAt` INTEGER NOT NULL, PRIMARY KEY(`id`), FOREIGN KEY(`nostrEventId`) REFERENCES `NostrEvent`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`unsignedNostrEventId`) REFERENCES `UnsignedNostrEvent`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "purpose", + "columnName": "purpose", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "status", + "columnName": "status", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "relayURL", + "columnName": "relayURL", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "isRecommendedRelay", + "columnName": "isRecommendedRelay", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "level", + "columnName": "level", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "synchronizationFilters", + "columnName": "synchronizationFilters", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "ownerPublicKey", + "columnName": "ownerPublicKey", + "affinity": "TEXT" + }, + { + "fieldPath": "nostrEventId", + "columnName": "nostrEventId", + "affinity": "TEXT" + }, + { + "fieldPath": "unsignedNostrEventId", + "columnName": "unsignedNostrEventId", + "affinity": "INTEGER" + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updatedAt", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "id" + ] + }, + "indices": [ + { + "name": "index_SynchronizeNostrEventRequest_nostrEventId", + "unique": false, + "columnNames": [ + "nostrEventId" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_SynchronizeNostrEventRequest_nostrEventId` ON `${TABLE_NAME}` (`nostrEventId`)" + }, + { + "name": "index_SynchronizeNostrEventRequest_status", + "unique": false, + "columnNames": [ + "status" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_SynchronizeNostrEventRequest_status` ON `${TABLE_NAME}` (`status`)" + } + ], + "foreignKeys": [ + { + "table": "NostrEvent", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "nostrEventId" + ], + "referencedColumns": [ + "id" + ] + }, + { + "table": "UnsignedNostrEvent", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "unsignedNostrEventId" + ], + "referencedColumns": [ + "id" + ] + } + ] + }, + { + "tableName": "SynchronizeNostrEventResult", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `relayURL` TEXT NOT NULL, `nostrEventId` TEXT, `createdAt` INTEGER NOT NULL, `updatedAt` INTEGER NOT NULL, PRIMARY KEY(`id`), FOREIGN KEY(`nostrEventId`) REFERENCES `NostrEvent`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "relayURL", + "columnName": "relayURL", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "nostrEventId", + "columnName": "nostrEventId", + "affinity": "TEXT" + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updatedAt", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "id" + ] + }, + "indices": [ + { + "name": "index_SynchronizeNostrEventResult_nostrEventId", + "unique": false, + "columnNames": [ + "nostrEventId" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_SynchronizeNostrEventResult_nostrEventId` ON `${TABLE_NAME}` (`nostrEventId`)" + } + ], + "foreignKeys": [ + { + "table": "NostrEvent", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "nostrEventId" + ], + "referencedColumns": [ + "id" + ] + } + ] + }, + { + "tableName": "UnsignedNostrEvent", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `pubKey` TEXT NOT NULL, `kind` INTEGER NOT NULL, `tags` TEXT NOT NULL, `privateTags` TEXT, `content` TEXT NOT NULL, `signedAt` INTEGER, `createdAt` INTEGER NOT NULL, `updatedAt` INTEGER NOT NULL, `savedAt` INTEGER NOT NULL, `deletedAt` INTEGER, `broadcastedAt` INTEGER)", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "pubKey", + "columnName": "pubKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "kind", + "columnName": "kind", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "tags", + "columnName": "tags", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "privateTags", + "columnName": "privateTags", + "affinity": "TEXT" + }, + { + "fieldPath": "content", + "columnName": "content", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "signedAt", + "columnName": "signedAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updatedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "savedAt", + "columnName": "savedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "deletedAt", + "columnName": "deletedAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "broadcastedAt", + "columnName": "broadcastedAt", + "affinity": "INTEGER" + } + ], + "primaryKey": { + "autoGenerate": true, + "columnNames": [ + "id" + ] + }, + "indices": [ + { + "name": "index_UnsignedNostrEvent_pubKey", + "unique": false, + "columnNames": [ + "pubKey" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_UnsignedNostrEvent_pubKey` ON `${TABLE_NAME}` (`pubKey`)" + }, + { + "name": "index_UnsignedNostrEvent_kind", + "unique": false, + "columnNames": [ + "kind" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_UnsignedNostrEvent_kind` ON `${TABLE_NAME}` (`kind`)" + } + ] + }, + { + "tableName": "Zap", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `postId` TEXT NOT NULL, `senderPublicKey` TEXT NOT NULL, `receiverPublicKey` TEXT NOT NULL, `message` TEXT, `invoice` TEXT, `amountInMillisatoshis` INTEGER, `nostrEventId` TEXT NOT NULL, `createdAt` INTEGER NOT NULL, `updatedAt` INTEGER NOT NULL, `savedAt` INTEGER NOT NULL, `viewedAt` INTEGER, `deletedAt` INTEGER, `broadcastedAt` INTEGER, PRIMARY KEY(`id`), FOREIGN KEY(`senderPublicKey`) REFERENCES `Profile`(`publicKey`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`receiverPublicKey`) REFERENCES `Profile`(`publicKey`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`nostrEventId`) REFERENCES `NostrEvent`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`postId`) REFERENCES `Post`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "postId", + "columnName": "postId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "senderPublicKey", + "columnName": "senderPublicKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "receiverPublicKey", + "columnName": "receiverPublicKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "message", + "columnName": "message", + "affinity": "TEXT" + }, + { + "fieldPath": "invoice", + "columnName": "invoice", + "affinity": "TEXT" + }, + { + "fieldPath": "amountInMillisatoshis", + "columnName": "amountInMillisatoshis", + "affinity": "INTEGER" + }, + { + "fieldPath": "nostrEventId", + "columnName": "nostrEventId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "createdAt", + "columnName": "createdAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updatedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "savedAt", + "columnName": "savedAt", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "viewedAt", + "columnName": "viewedAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "deletedAt", + "columnName": "deletedAt", + "affinity": "INTEGER" + }, + { + "fieldPath": "broadcastedAt", + "columnName": "broadcastedAt", + "affinity": "INTEGER" + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "id" + ] + }, + "indices": [ + { + "name": "index_Zap_senderPublicKey", + "unique": false, + "columnNames": [ + "senderPublicKey" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_Zap_senderPublicKey` ON `${TABLE_NAME}` (`senderPublicKey`)" + }, + { + "name": "index_Zap_nostrEventId", + "unique": false, + "columnNames": [ + "nostrEventId" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_Zap_nostrEventId` ON `${TABLE_NAME}` (`nostrEventId`)" + }, + { + "name": "index_Zap_postId", + "unique": false, + "columnNames": [ + "postId" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_Zap_postId` ON `${TABLE_NAME}` (`postId`)" + } + ], + "foreignKeys": [ + { + "table": "Profile", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "senderPublicKey" + ], + "referencedColumns": [ + "publicKey" + ] + }, + { + "table": "Profile", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "receiverPublicKey" + ], + "referencedColumns": [ + "publicKey" + ] + }, + { + "table": "NostrEvent", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "nostrEventId" + ], + "referencedColumns": [ + "id" + ] + }, + { + "table": "Post", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "postId" + ], + "referencedColumns": [ + "id" + ] + } + ] + } + ], + "setupQueries": [ + "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)", + "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '47aa631ec4032d9b2c00bf0b38689864')" + ] + } +} \ No newline at end of file diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/BennuDatabase.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/BennuDatabase.kt index 2f9bce5f..e6eb68be 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/BennuDatabase.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/BennuDatabase.kt @@ -2,6 +2,7 @@ package com.machankura.bennu.compose.database import com.machankura.bennu.compose.database.model.GroupTransaction import com.machankura.bennu.compose.database.dao.GroupTransactionDao +import com.machankura.bennu.compose.database.dao.MemberWalletDao import androidx.room3.ColumnTypeConverters import androidx.room3.AutoMigration import androidx.room3.ConstructedBy @@ -78,6 +79,8 @@ import com.machankura.bennu.compose.database.model.MarmotPublishObligation import com.machankura.bennu.compose.database.model.MarmotOutboundGate import com.machankura.bennu.compose.managers.MarmotEngine import com.machankura.bennu.compose.database.model.MarmotRetainedEpochSecret +import com.machankura.bennu.compose.database.model.MemberWallet +import com.machankura.bennu.compose.database.model.MemberWalletSpend import com.machankura.bennu.compose.database.model.Mention import com.machankura.bennu.compose.database.model.NegentropySynchronizeRequest import com.machankura.bennu.compose.database.model.NegentropySynchronizeResult @@ -135,6 +138,8 @@ val GENESIS_AT = Instant.fromEpochMilliseconds(1231006505000L) MarmotPublishObligation::class, MarmotOutboundGate::class, MarmotRetainedEpochSecret::class, + MemberWallet::class, + MemberWalletSpend::class, Mention::class, NegentropySynchronizeRequest::class, NegentropySynchronizeResult::class, @@ -153,7 +158,7 @@ val GENESIS_AT = Instant.fromEpochMilliseconds(1231006505000L) UnsignedNostrEvent::class, Zap::class ], - version = 29, + version = 30, autoMigrations = [ // v2 only adds the DkgSession/DkgParticipantMessage tables, so Room can // generate the migration itself — nothing existing changes shape. @@ -355,6 +360,12 @@ val GENESIS_AT = Instant.fromEpochMilliseconds(1231006505000L) // subgroup's ceremony was proposed under (docs/subgroup-wallet-policy.md, // Phase 2). Every ceremony before it chose none, which is what null means. AutoMigration(from = 28, to = 29), + // v30 adds MemberWallet and MemberWalletSpend: the random key of a + // guarded wallet one member holds and a group guards, and the spends the + // member signed alone from it (docs/member-guarded-wallets.md, Phase 5). + // New tables, and no foreign keys -- deleting a group's room must never + // delete a key coins may sit behind. + AutoMigration(from = 29, to = 30), ] ) @ConstructedBy(BennuDatabaseConstructor::class) @@ -391,6 +402,8 @@ abstract class BennuDatabase: RoomDatabase() { abstract fun groupTransactionDao(): GroupTransactionDao + abstract fun memberWalletDao(): MemberWalletDao + abstract fun connectionDao(): ConnectionDao abstract fun giftWrapMessageDao(): GiftWrapMessageDao diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/dao/MemberWalletDao.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/dao/MemberWalletDao.kt new file mode 100644 index 00000000..fc279727 --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/dao/MemberWalletDao.kt @@ -0,0 +1,46 @@ +package com.machankura.bennu.compose.database.dao + +import androidx.room3.Dao +import androidx.room3.Query +import androidx.room3.Upsert +import com.machankura.bennu.compose.database.model.MemberWallet +import com.machankura.bennu.compose.database.model.MemberWalletSpend +import kotlinx.coroutines.flow.Flow + +@Dao +abstract class MemberWalletDao { + @Query("SELECT * FROM MemberWallet WHERE ownerPublicKey = :ownerPublicKey ORDER BY createdAt DESC") + abstract suspend fun getByOwner(ownerPublicKey: String): List + + @Query("SELECT * FROM MemberWallet WHERE ownerPublicKey = :ownerPublicKey ORDER BY createdAt DESC") + abstract fun observeByOwner(ownerPublicKey: String): Flow> + + @Query("SELECT * FROM MemberWallet WHERE walletId = :walletId") + abstract suspend fun getById(walletId: String): MemberWallet? + + @Query("SELECT * FROM MemberWallet WHERE guardingChatRoomId = :chatRoomId ORDER BY createdAt DESC") + abstract suspend fun getByGuardingChatRoomId(chatRoomId: String): List + + @Upsert + abstract suspend fun upsert(wallet: MemberWallet) + + /** + * Deletes a wallet's key. `MemberWalletManager.discard` is the only caller, + * and only for a wallet no group has certified: before then no address was + * ever offered, so no coin can be behind the key. + */ + @Query("DELETE FROM MemberWallet WHERE walletId = :walletId") + abstract suspend fun delete(walletId: String) + + @Query("SELECT * FROM MemberWalletSpend WHERE walletId = :walletId ORDER BY createdAt DESC") + abstract suspend fun getSpends(walletId: String): List + + @Query("SELECT * FROM MemberWalletSpend WHERE walletId = :walletId ORDER BY createdAt DESC") + abstract fun observeSpends(walletId: String): Flow> + + @Query("SELECT * FROM MemberWalletSpend WHERE txid = :txid") + abstract suspend fun getSpend(txid: String): MemberWalletSpend? + + @Upsert + abstract suspend fun upsertSpend(spend: MemberWalletSpend) +} diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/model/MemberWallet.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/model/MemberWallet.kt new file mode 100644 index 00000000..68850128 --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/model/MemberWallet.kt @@ -0,0 +1,68 @@ +package com.machankura.bennu.compose.database.model + +import androidx.room3.Entity +import androidx.room3.Index +import androidx.room3.PrimaryKey +import com.vitorpamplona.quartz.nip01Core.core.HexKey +import kotlin.time.Clock +import kotlin.time.Instant + +/** + * A guarded wallet this device holds the key of: one member's random key, and + * the request that asked a group to guard it. `docs/member-guarded-wallets.md`. + * + * The key is why there is a table at all. Everything else about a member's + * wallet is read off signed events -- whether it is certified is whether the + * group's room holds a 30334 for [walletId] that verifies, read again each time + * the way `GroupWallet` reads statements -- so there is no *certified* column to + * disagree with the signature. + * + * ### `guardingChatRoomId` is a plain column, never a foreign key + * + * The argument `docs/subgroups.md` makes against cascading `parentChatRoomId`, + * with money at the end of it. Deleting the group's room on this device must + * never delete a private key that coins may sit behind; and a member who leaves + * the group keeps a wallet the group still guards. + * + * ### One database holds every profile + * + * So every read is scoped by [ownerPublicKey], the profile the key belongs to. + */ +@Entity( + indices = [ + Index("ownerPublicKey"), + Index("guardingChatRoomId"), + ], +) +data class MemberWallet( + /** `W`: `MemberWalletDerivation.walletId` of the wallet key. */ + @PrimaryKey + val walletId: String, + + /** The profile the wallet belongs to: the npub that signed the request. */ + val ownerPublicKey: HexKey, + + /** The group asked to guard it. */ + val guardingChatRoomId: String, + + /** The network, as `GroupWalletStatementEvent.chainName` writes it. */ + val chain: String, + + /** + * `k`, hex. Stored as `DkgSession.secretShare` is, in the profile's database; + * never logged, never sent. Lost with the device unless exported -- and then + * the guardians can still move the coins after 12 blocks. + */ + val walletPrivateKey: HexKey, + + /** The member's name for it, as the request carries it. */ + val label: String? = null, + + /** The signed 30335, whole: kept so a request the group did not sign can be asked again, unchanged. */ + val requestJson: String, + + val createdAt: Instant = Clock.System.now(), +) { + override fun toString(): String = + "MemberWallet(walletId=$walletId, owner=$ownerPublicKey, guardedBy=$guardingChatRoomId, chain=$chain, key=)" +} diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/model/MemberWalletSpend.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/model/MemberWalletSpend.kt new file mode 100644 index 00000000..18307bb9 --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/model/MemberWalletSpend.kt @@ -0,0 +1,53 @@ +package com.machankura.bennu.compose.database.model + +import androidx.room3.Entity +import androidx.room3.Index +import androidx.room3.PrimaryKey +import kotlin.time.Clock +import kotlin.time.Instant + +/** + * One transaction a member signed alone from their guarded wallet. + * + * The subset of [GroupTransaction] a spend with no signing session needs. + * `GroupTransaction` cannot hold it: its foreign keys are to a session and a + * room, and a member's own spend has neither. Written whole when it is signed, + * then filled in as the chain answers. + * + * No foreign key to [MemberWallet] either. A spend is a fact about the chain, + * and a row that cascaded away with its wallet would take the record of where + * the coins went with it. + */ +@Entity( + indices = [ + Index("walletId"), + ], +) +data class MemberWalletSpend( + /** The transaction's id, which a segwit spend fixes before it is signed. */ + @PrimaryKey + val txid: String, + + /** `W`, the wallet the inputs are under. */ + val walletId: String, + + /** The PSBT as built, base64: what every input's sighash was computed from. */ + val psbt: String, + + /** The finished transaction, hex, once it has passed `correctlySpends`. */ + val signedTransaction: String, + + /** When this device last handed it to Electrum -- which reports success whatever the server said. */ + val broadcastAt: Instant? = null, + + /** When this device's wallet first saw the transaction, in the mempool or in a block. */ + val seenAt: Instant? = null, + + /** When its first confirmation was seen. */ + val confirmedAt: Instant? = null, + + /** The txid of a later spend of the same coins that confirmed instead, if one did. */ + val replacedByTxid: String? = null, + + val createdAt: Instant = Clock.System.now(), +) diff --git a/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/database/dao/MemberWalletDaoJvmTest.kt b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/database/dao/MemberWalletDaoJvmTest.kt new file mode 100644 index 00000000..8b35f792 --- /dev/null +++ b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/database/dao/MemberWalletDaoJvmTest.kt @@ -0,0 +1,76 @@ +package com.machankura.bennu.compose.database.dao + +import androidx.room3.Room +import com.machankura.bennu.compose.database.BennuDatabase +import com.machankura.bennu.compose.database.builder.getRoomDatabase +import com.machankura.bennu.compose.database.model.MemberWallet +import com.machankura.bennu.compose.database.model.MemberWalletSpend +import com.machankura.bennu.compose.managers.GroupFixtures +import kotlinx.coroutines.runBlocking +import kotlin.test.AfterTest +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFalse +import kotlin.test.assertNotNull +import kotlin.test.assertNull +import kotlin.time.Instant + +/** + * Schema 30's two tables round-trip, are scoped by profile, and -- the property + * that matters most -- outlive the room of the group that guards them. + */ +class MemberWalletDaoJvmTest { + private val db: BennuDatabase = getRoomDatabase(Room.inMemoryDatabaseBuilder()) + + @AfterTest + fun closeDb() = db.close() + + private val group = "6a".repeat(32) + private val alice = "a1".repeat(32) + private val bob = "b0".repeat(32) + + private fun wallet(id: String, owner: String = alice) = MemberWallet( + walletId = id, + ownerPublicKey = owner, + guardingChatRoomId = group, + chain = "regtest", + walletPrivateKey = "11".repeat(32), + label = "Savings", + requestJson = "{}", + createdAt = Instant.fromEpochSeconds(1_700_000_000), + ) + + @Test + fun `a wallet round-trips and is listed for its owner only`(): Unit = runBlocking { + val dao = db.memberWalletDao() + dao.upsert(wallet("01".repeat(32))) + dao.upsert(wallet("02".repeat(32), owner = bob)) + + assertEquals(wallet("01".repeat(32)), dao.getById("01".repeat(32))) + assertEquals(listOf("01".repeat(32)), dao.getByOwner(alice).map { it.walletId }) + assertEquals(2, dao.getByGuardingChatRoomId(group).size) + assertFalse(wallet("01".repeat(32)).toString().contains("11".repeat(32)), "the key is never in a log line") + } + + @Test + fun `deleting the group's room leaves the key`(): Unit = runBlocking { + GroupFixtures.seedRoom(db, group) + db.memberWalletDao().upsert(wallet("01".repeat(32))) + + db.chatRoomDao().delete(assertNotNull(db.chatRoomDao().findChatRoomById(group)).chatRoom) + + assertNull(db.chatRoomDao().findChatRoomById(group)) + assertNotNull(db.memberWalletDao().getById("01".repeat(32))) + } + + @Test + fun `a spend round-trips and is filled in`(): Unit = runBlocking { + val dao = db.memberWalletDao() + val spend = MemberWalletSpend(txid = "aa".repeat(32), walletId = "01".repeat(32), psbt = "cHNidP8=", signedTransaction = "00") + dao.upsertSpend(spend) + dao.upsertSpend(spend.copy(seenAt = Instant.fromEpochSeconds(1_700_000_100))) + + assertEquals(Instant.fromEpochSeconds(1_700_000_100), dao.getSpend("aa".repeat(32))?.seenAt) + assertEquals(1, dao.getSpends("01".repeat(32)).size) + } +} From 2b0cd72d8bec35819fdecc5952c4faa5848f0f7e Mon Sep 17 00:00:00 2001 From: Kgothatso Ngako Date: Sat, 24 Oct 2026 07:30:14 +0200 Subject: [PATCH 10/21] feat(wallet): every signer derives a funding's address again before naming it (Phase 3) GroupSpend.fundingsOf reads each payment's derivation against the guarded wallets the room holds: a claim that derives is a funding, one that does not refuses the spend, and one under an account this device does not hold is left as the bare address. Every proposal and acceptance path and checkedSpend read it, ProposedSpend says "Fund X's guarded wallet", open fundings hold their addresses, and a bump keeps the claim. Co-Authored-By: Claude Opus 5.5 --- .../DatabaseFrostSigningRepository.kt | 7 + .../compose/managers/FrostSigningManager.kt | 42 +++++- .../repository/FrostSigningRepository.kt | 4 + .../bennu/compose/text/ProposedSpend.kt | 20 ++- .../bennu/compose/wallet/GroupSpend.kt | 60 +++++++++ .../bennu/compose/wallet/GroupSpendBuilder.kt | 3 + .../managers/GuardianSigningJvmTest.kt | 127 ++++++++++++++++++ 7 files changed, 256 insertions(+), 7 deletions(-) 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 1308606a..d31bd046 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 @@ -186,6 +186,13 @@ class DatabaseFrostSigningRepository( emptySet() } + override suspend fun reservedFundingIndices(chatRoomId: String, account: GroupWalletDerivation.Account): Set = try { + FrostSigningManager.reservedFundingIndices(database, chatRoomId, account) + } catch (e: Throwable) { + logger.e("Error reading the funding 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 ed490ee8..75c9da59 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 @@ -674,7 +674,7 @@ object FrostSigningManager { val wallet = GroupWalletManager.walletFor(database, chatRoomId, thresholdPublicKey, chain, account) ?: throw IllegalStateException("This group has not opened a wallet on ${GroupWalletStatementEvent.chainName(chain)}") - val checked = when (val result = GroupSpend.check(psbt, wallet.account)) { + val checked = when (val result = GroupSpend.check(psbt, wallet.account).withFundings(database, chatRoomId)) { is GroupSpend.Result.Ok -> result.checked is GroupSpend.Result.Refused -> throw IllegalArgumentException("This spend ${result.reason}") } @@ -752,7 +752,7 @@ object FrostSigningManager { val guarded = GuardianManager.guardedWalletFor(database, chatRoomId, descendantChatRoomId, chain, account) ?: throw IllegalStateException("This group guards no wallet of $descendantChatRoomId on ${GroupWalletStatementEvent.chainName(chain)}") - val checked = when (val result = GroupSpend.check(psbt, guarded.account, guarded.spender(thresholdPublicKey))) { + val checked = when (val result = GroupSpend.check(psbt, guarded.account, guarded.spender(thresholdPublicKey)).withFundings(database, chatRoomId)) { is GroupSpend.Result.Ok -> result.checked is GroupSpend.Result.Refused -> throw IllegalArgumentException("This spend ${result.reason}") } @@ -882,7 +882,7 @@ object FrostSigningManager { guarded.account to guarded.spender(thresholdPublicKey) } - val checked = when (val result = GroupSpend.check(psbt, walletAccount, spender)) { + val checked = when (val result = GroupSpend.check(psbt, walletAccount, spender).withFundings(database, localChatRoom.chatRoom.id)) { is GroupSpend.Result.Ok -> result.checked is GroupSpend.Result.Refused -> { logger.w("Spend proposal $sessionId ${result.reason}; dropping") @@ -1054,7 +1054,26 @@ object FrostSigningManager { ?: return null val context = spendContext(database, session, thresholdPublicKey) ?: return null val psbt = GroupSpend.decode(context.transaction.psbt) ?: return null - return (GroupSpend.check(psbt, context.account, context.spender) as? GroupSpend.Result.Ok)?.checked + return (GroupSpend.check(psbt, context.account, context.spender).withFundings(database, context.transaction.chatRoomId) as? GroupSpend.Result.Ok)?.checked + } + + /** + * A checked spend with its payments into descendants' guarded wallets read + * against the ones [chatRoomId] holds -- `GroupSpend.fundingsOf` -- or + * refused for a claim that does not derive. Every place a spend is checked + * for a member to read or sign reads its fundings here, so the label a + * signer sees is the one every other signer's device derived too. + * + * A spend none of whose payments claims anything -- every spend to a typed + * address -- reads no guarded wallets at all. + */ + private suspend fun GroupSpend.Result.withFundings(database: BennuDatabase, chatRoomId: String): GroupSpend.Result { + val checked = (this as? GroupSpend.Result.Ok)?.checked ?: return this + if (checked.payments.all { checked.psbt.outputs[it.index].taprootDerivationPaths.isEmpty() }) return this + return when (val reading = GroupSpend.fundingsOf(checked, GuardianManager.guardedWalletsOf(database, chatRoomId))) { + is GroupSpend.FundingReading.Ok -> GroupSpend.Result.Ok(checked.copy(fundings = reading.fundings)) + is GroupSpend.FundingReading.Refused -> GroupSpend.Result.Refused(reading.reason) + } } /** @@ -1083,6 +1102,21 @@ object FrostSigningManager { .flatMap { GroupSpend.claimedChangeIndices(it, account) } .toSet() + /** + * The receive addresses of [account] -- a descendant's guarded wallet -- that + * a room's open spends fund, which a new funding should not pay as well. + * Held by the same sessions as [reservedOutPoints], for the reason + * [reservedChangeIndices] gives. + */ + suspend fun reservedFundingIndices( + database: BennuDatabase, + chatRoomId: String, + account: GroupWalletDerivation.Account, + ): Set = + openSpends(database, chatRoomId) + .flatMap { GroupSpend.claimedFundingIndices(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) 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 6c7bcdd9..846c48b3 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 @@ -263,6 +263,9 @@ interface FrostSigningRepository { /** The change indices under [account] the room's open spends already pay back to. */ suspend fun reservedChangeIndices(chatRoomId: String, account: GroupWalletDerivation.Account): Set + /** The receive indices of [account], a descendant's guarded wallet, the room's open spends already fund. */ + suspend fun reservedFundingIndices(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> @@ -352,6 +355,7 @@ interface FrostSigningRepository { override suspend fun reservedOutPoints(chatRoomId: String): Set = emptySet() override suspend fun reservedChangeIndices(chatRoomId: String, account: GroupWalletDerivation.Account): Set = emptySet() + override suspend fun reservedFundingIndices(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/text/ProposedSpend.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/text/ProposedSpend.kt index a95f079b..bb81b740 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/text/ProposedSpend.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/text/ProposedSpend.kt @@ -4,6 +4,7 @@ import com.machankura.bennu.compose.wallet.GroupSpend import fr.acinq.bitcoin.Bitcoin import fr.acinq.bitcoin.ByteVector import fr.acinq.bitcoin.Chain +import fr.acinq.bitcoin.Satoshi /** * A spend the group is being asked to sign, said in words -- [ProposedEvent]'s @@ -15,16 +16,29 @@ object ProposedSpend { ProposedEvent.Summary( // A guardian's spend takes a descendant's coins, so whose they are // is the first thing a signer reads. + // A funding comes next: where the money goes, as every signer's + // device derived it -- never the proposer's word for it. label = when (val guardian = spend.spender as? GroupSpend.Spender.Guardian) { - null -> "Spend from the group's wallet" + null -> spend.fundings.singleOrNull()?.takeIf { spend.payments.size == 1 } + ?.let { "Fund ${nameOf(it)}'s guarded wallet" } + ?: "Spend from the group's wallet" else -> "Spend from ${guardian.name ?: "a subgroup"}'s guarded wallet" }, detail = when (val payment = spend.payments.singleOrNull()) { - null -> "Send ${spend.amountSent.grouped()} sats to ${spend.payments.size} addresses" - else -> "Send ${payment.txOut.amount.grouped()} sats to ${addressOf(payment.txOut.publicKeyScript, chain)}" + null -> "Send ${spend.amountSent.grouped()} sats to ${spend.payments.size} addresses" + when (val funding = spend.fundings.singleOrNull()) { + null -> if (spend.fundings.isEmpty()) "" else + ", ${Satoshi(spend.fundings.sumOf { spend.tx.txOut[it.outputIndex].amount.sat }).grouped()} of them to ${spend.fundings.size} guarded wallets" + else -> ", ${spend.tx.txOut[funding.outputIndex].amount.grouped()} of them to ${nameOf(funding)}'s guarded wallet" + } + else -> when (val funding = spend.fundings.singleOrNull()) { + null -> "Send ${payment.txOut.amount.grouped()} sats to ${addressOf(payment.txOut.publicKeyScript, chain)}" + else -> "Send ${payment.txOut.amount.grouped()} sats to ${nameOf(funding)}'s guarded wallet, address ${funding.derived.index}" + } } ) + private fun nameOf(funding: GroupSpend.Funding): String = funding.wallet.name ?: "a subgroup" + /** The address [script] pays, or the script itself where it has no address. */ fun addressOf(script: ByteVector, chain: Chain): String = Bitcoin.addressFromPublicKeyScript(chain.chainHash, script.toByteArray()).right ?: script.toHex() 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 08f705b7..e1171c72 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 @@ -2,6 +2,7 @@ package com.machankura.bennu.compose.wallet import com.machankura.bennu.compose.managers.FrostSigningManager import com.machankura.bennu.compose.managers.GroupWalletDerivation +import com.machankura.bennu.compose.managers.GuardianManager import com.machankura.bennu.compose.managers.GuardianDerivation import com.vitorpamplona.quartz.nip01Core.core.HexKey import fr.acinq.bitcoin.ByteVector @@ -149,6 +150,12 @@ object GroupSpend { */ val weight: Int, val spender: Spender = Spender.Owner, + /** + * The payments that fund a descendant's guarded wallet, each claim derived + * again -- [fundingsOf]. Empty until a caller holding the room's guarded + * wallets has read them, which [check] alone cannot. + */ + val fundings: List = emptyList(), ) { val tx: Transaction get() = psbt.global.tx @@ -173,6 +180,59 @@ object GroupSpend { data class Refused(val reason: String) : Result } + /** A payment into a descendant's guarded wallet, at [derived] under its account -- the claim, derived again. */ + data class Funding( + val outputIndex: Int, + val wallet: GuardianManager.GuardedWallet, + val derived: GroupWalletDerivation.Derived, + ) + + sealed interface FundingReading { + data class Ok(val fundings: List) : FundingReading + data class Refused(val reason: String) : FundingReading + } + + /** + * Which of [checked]'s payments fund one of [guarded] -- the descendants' + * guarded wallets the room holds -- read off each payment's derivation and + * derived again, the way change is. `docs/guarded-wallet-funding.md`, D4: + * + * - a claim under a wallet in [guarded] that derives to the payment's script + * is a funding; + * - a claim under a wallet in [guarded] that does not -- another index, + * another branch, another key -- refuses the spend, so no proposer can put + * a descendant's name on a payment to an address it does not own; + * - a claim under any other account is not this device's to check, and the + * payment is read as the bare address it is. + * + * Fingerprints are four bytes, so every held wallet sharing one is tried + * before a claim is refused. + */ + fun fundingsOf(checked: Checked, guarded: List): FundingReading { + val fundings = checked.payments.mapNotNull { payment -> + val paths = checked.psbt.outputs[payment.index].taprootDerivationPaths + val (internalKey, path, candidates) = paths.entries.firstNotNullOfOrNull { (internalKey, path) -> + guarded.filter { it.chain == checked.account.chain && isOurs(path, it.account) } + .takeIf { it.isNotEmpty() } + ?.let { Triple(internalKey, path, it) } + } ?: return@mapNotNull null + + val (branch, index) = path.keyPath.path.takeIf { it.size == 2 && path.leaves.isEmpty() } + ?: return FundingReading.Refused("output ${payment.index} claims a place in a guarded wallet that is not one") + if (branch != GroupWalletDerivation.RECEIVE || index !in 0L..MAX_ADDRESS_INDEX) { + return FundingReading.Refused("output ${payment.index} claims $branch/$index, which is not a receive address") + } + candidates.firstNotNullOfOrNull { wallet -> + GroupWalletDerivation.derive(wallet.account, branch, index) + .takeIf { it.pubkeyScript == payment.txOut.publicKeyScript && it.internalKey == internalKey } + ?.let { Funding(payment.index, wallet, it) } + } ?: return FundingReading.Refused( + "output ${payment.index} claims $branch/$index of ${candidates.first().name ?: "a subgroup"}'s guarded wallet, which is not where it pays" + ) + } + return FundingReading.Ok(fundings) + } + /** * The checks a member makes before signing, in the order `docs/group-chain-wallet.md` * numbers them, against [account] -- which comes from the room's verified 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 cf84d8c9..35627cec 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 @@ -190,17 +190,20 @@ object GroupSpendBuilder { if (reduced < DUST) return Result.NotEnough val tx = spend.tx.copy(txOut = spend.tx.txOut.mapIndexed { index, out -> if (index == target.index) out.copy(amount = reduced) else out }) + // A funding keeps its claim, or the bump would read as a payment to a bare address. val psbt = GroupSpend.psbtOf( tx, spend.inputs.map { it.txOut to it.derivation }, spend.outputs.mapNotNull { output -> output.change?.let { output.index to it } }.toMap(), spend.account, + funding = spend.fundings.associate { it.outputIndex to (it.wallet.account to it.derived) }, ) return Result.Built( psbt = psbt, amount = if (target.isChange) spend.amountSent else reduced, fee = fee, change = if (target.isChange) reduced else null, + funded = spend.fundings.singleOrNull()?.let { Destination.Funding(it.wallet.account, it.derived) }, ) } 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 45e22bf8..6eece51e 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 @@ -625,4 +625,131 @@ class GuardianSigningJvmTest { val psbt = GroupSpend.psbtOf(unlocked, listOf(funding.txOut[0] to GroupWalletDerivation.derive(guarded.account, 0, 0)), emptyMap(), guarded.account) assertIs(GroupSpend.check(psbt, guarded.account, guarded.spender(thresholdPublicKey))) } + + // ---- Funding a descendant's guarded wallet ------------------------------- + + /** The room opens its own plain wallet, signed by a quorum, so it has coins to fund with. */ + private suspend fun openOwnWallet(proposer: Device, other: Device): GroupWalletDerivation.Account { + val own = GroupWalletDerivation.account(thresholdPublicKey, chain) + val template = GroupWalletStatementEvent.template(own) + val session = FrostSigningManager.proposeSigning(proposer.db, proposer.room, proposer.publicKey, template.kind, template.tags, template.content) + pump(proposer, other) + FrostSigningManager.approve(other.db, other.room, session.id) + pump(proposer, other) + listOf(proposer, other).forEach { assertNotNull(GroupWalletManager.walletFor(it.db, roomId, chain), "the room's own wallet is open") } + return own + } + + /** The room's own wallet holding one confirmed coin at its first receive address. */ + private fun ownState(own: GroupWalletDerivation.Account): GroupWalletState { + val coin = GroupWalletDerivation.derive(own, GroupWalletDerivation.RECEIVE, 0) + val paid = Transaction( + 2, listOf(TxIn(OutPoint(TxId(ByteVector32(ByteArray(32) { 0x71 })), 0), ByteVector.empty, 0xffffffffL)), + listOf(TxOut(Satoshi(80_000), coin.pubkeyScript)), 0, + ) + val meta = WalletState.AddressMeta.Derived(0) + val receive = WalletState(mapOf(coin.address(chain) to WalletState.AddressState(meta, alreadyUsed = true, utxos = listOf(WalletState.Utxo(paid.txid, 0, 100, paid, meta))))) + val change = WalletState((0 until 3).associate { index -> + GroupWalletDerivation.derive(own, GroupWalletDerivation.CHANGE, index.toLong()).address(chain) to + WalletState.AddressState(WalletState.AddressMeta.Derived(index), alreadyUsed = false, utxos = emptyList()) + }) + return GroupWalletState(own, receive, change, tipHeight = 110) + } + + private fun fundingTo(guarded: GuardianManager.GuardedWallet, index: Long) = + GroupSpendBuilder.Destination.Funding(guarded.account, GroupWalletDerivation.derive(guarded.account, GroupWalletDerivation.RECEIVE, index)) + + @Test + fun `a funding is read as one by every device holding the wallet, and its address is held`(): 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 own = openOwnWallet(proposer, other) + + val guarded = assertNotNull(GuardianManager.guardedWalletFor(proposer.db, roomId, guardedChildRoomId, chain, 0)) + val built = assertIs( + GroupSpendBuilder.send(ownState(own), fundingTo(guarded, 2), Satoshi(30_000), 2, emptySet()) + ) + val session = FrostSigningManager.proposeSpend(proposer.db, proposer.room, proposer.publicKey, built.psbt, chain) + pump(proposer, other) + + val seen = assertNotNull(FrostSigningManager.checkedSpend(other.db, session.id)) + val funding = seen.fundings.single() + assertEquals(guardedChildRoomId, funding.wallet.descendantChatRoomId) + assertEquals(2L, funding.derived.index) + assertEquals( + com.machankura.bennu.compose.text.ProposedEvent.Summary( + "Fund Translation team's guarded wallet", + "Send 30,000 sats to Translation team's guarded wallet, address 2", + ), + com.machankura.bennu.compose.text.ProposedSpend.summarize(seen, chain), + ) + assertEquals(setOf(2L), FrostSigningManager.reservedFundingIndices(other.db, roomId, guarded.account)) + + // A bump keeps the claim, or it would read as a payment to a bare address. + val bumped = assertIs(GroupSpendBuilder.bump(seen, 5)) + assertEquals(setOf(2L), GroupSpend.claimedFundingIndices(bumped.psbt, guarded.account)) + assertEquals(2L, bumped.funded?.derived?.index) + + // Abandoned, it lets the address go. + other.db.frostSigningSessionDao().upsert(other.session(session.id)!!.copy(stage = FrostSigningStage.FAILED)) + assertEquals(emptySet(), FrostSigningManager.reservedFundingIndices(other.db, roomId, guarded.account)) + } + + @Test + fun `a funding claiming an address it does not pay is refused by every device that can tell`(): Unit = runBlocking { + val proposer = device(members[0], signerIndex = 0) + val other = device(members[1], signerIndex = 1) + // Only the other device holds the wallet, so only it can check the claim. + tell(other, guardedStatement()) + val own = openOwnWallet(proposer, other) + + val guarded = assertNotNull(GuardianManager.guardedWalletFor(other.db, roomId, guardedChildRoomId, chain, 0)) + val honest = assertIs( + GroupSpendBuilder.send(ownState(own), fundingTo(guarded, 2), Satoshi(30_000), 2, emptySet()) + ) + // Pays address 2, says address 3. + val claimed = GroupWalletDerivation.derive(guarded.account, GroupWalletDerivation.RECEIVE, 3) + val coin = GroupWalletDerivation.derive(own, GroupWalletDerivation.RECEIVE, 0) + val lying = GroupSpend.psbtOf( + honest.psbt.global.tx, + listOf(TxOut(Satoshi(80_000), coin.pubkeyScript) to coin), + mapOf(1 to GroupWalletDerivation.derive(own, GroupWalletDerivation.CHANGE, 0)), + own, + funding = mapOf(0 to (guarded.account to claimed)), + ) + assertIs( + GroupSpend.fundingsOf(assertIs(GroupSpend.check(lying, own)).checked, listOf(guarded)) + ) + + val session = FrostSigningManager.proposeSpend(proposer.db, proposer.room, proposer.publicKey, lying, chain) + pump(proposer, other) + assertNull(other.session(session.id), "the device that holds the wallet never puts it to the member") + } + + @Test + fun `a device never told about the wallet reads a funding as the bare address it pays`(): Unit = runBlocking { + val proposer = device(members[0], signerIndex = 0) + val other = device(members[1], signerIndex = 1) + tell(proposer, guardedStatement()) + val own = openOwnWallet(proposer, other) + + val guarded = assertNotNull(GuardianManager.guardedWalletFor(proposer.db, roomId, guardedChildRoomId, chain, 0)) + val destination = fundingTo(guarded, 2) + val built = assertIs( + GroupSpendBuilder.send(ownState(own), destination, Satoshi(30_000), 2, emptySet()) + ) + val session = FrostSigningManager.proposeSpend(proposer.db, proposer.room, proposer.publicKey, built.psbt, chain) + pump(proposer, other) + + val seen = assertNotNull(FrostSigningManager.checkedSpend(other.db, session.id), "accepted: the address is the truth") + assertEquals(emptyList(), seen.fundings) + assertEquals( + "Send 30,000 sats to ${destination.derived.address(chain)}", + com.machankura.bennu.compose.text.ProposedSpend.summarize(seen, chain).detail, + ) + assertEquals(1, assertNotNull(FrostSigningManager.checkedSpend(proposer.db, session.id)).fundings.size, "and the proposer's own device still names it") + } } From e181690f81741dca35d57febb44d084f3eb8a4d4 Mon Sep 17 00:00:00 2001 From: Kgothatso Ngako Date: Sat, 24 Oct 2026 07:31:57 +0200 Subject: [PATCH 11/21] feat(wallet): every signer checks a member wallet before the group guards it (Phase 7) acceptProposal refuses a 30334 before it is shown unless it is exactly the certificate the request it carries asks for, the person asking is a member of the room, and its guardians are the ones this group grants -- SubgroupManager.grantFor with the wallet id in a child room's place. MemberWalletManager.putToGroup is how a signer sponsors a request: one session over the certificate the request determines, or the session another sponsor already opened over the same event id. The signers read the proposal as whose wallet and what the group can take from it, and the transcript gets a line for the request and for the certificate rather than raw JSON. Co-Authored-By: Claude Opus 5.5 --- .../compose/database/model/ChatMessage.kt | 63 ++++++ .../compose/managers/FrostSigningManager.kt | 18 ++ .../compose/managers/MemberWalletManager.kt | 143 +++++++++++++ .../wallet/MemberWalletCertificateEvent.kt | 9 +- .../bennu/compose/text/ProposedEvent.kt | 37 +++- .../composable/widgets/chat/ChatTranscript.kt | 2 + .../bennu/compose/managers/GroupFixtures.kt | 59 ++++++ .../managers/MemberWalletSigningJvmTest.kt | 197 ++++++++++++++++++ 8 files changed, 525 insertions(+), 3 deletions(-) create mode 100644 composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/MemberWalletSigningJvmTest.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 bbbdf40b..f1394197 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 @@ -14,6 +14,8 @@ import com.machankura.bennu.compose.exceptions.MarmotUnprocessableInnerEventExce import com.machankura.bennu.compose.managers.ChronicleManager import com.machankura.bennu.compose.managers.MemberWalletManager import com.machankura.bennu.compose.nostr.wallet.GroupKeyNoticeEvent +import com.machankura.bennu.compose.nostr.wallet.MemberWalletCertificateEvent +import com.machankura.bennu.compose.nostr.wallet.MemberWalletRequestEvent import com.machankura.bennu.compose.managers.GroupKeyStateManager import com.machankura.bennu.compose.managers.GroupWalletManager import com.machankura.bennu.compose.managers.GuardianManager @@ -467,6 +469,17 @@ data class ChatMessage( */ const val TYPE_GUARDIAN_SPEND = "guardianSpend" + /** + * A member asked this group to guard a wallet only they can spend from -- + * a `MemberWalletRequestEvent` this device checked. A request, not a + * decision: the group decides when a signer puts it to the quorum. See + * `docs/member-guarded-wallets.md`. + */ + const val TYPE_MEMBER_WALLET_REQUESTED = "memberWalletRequested" + + /** The group signed a member wallet certificate: it now guards that member's wallet. */ + const val TYPE_MEMBER_WALLET_GUARDED = "memberWalletGuarded" + /** * Every line the group signed, for the one check the transcript * dispatches on. A type missing from here renders as a chat bubble, @@ -482,6 +495,8 @@ data class ChatMessage( TYPE_GROUP_TRANSACTION_CONFIRMED, TYPE_GUARDED_WALLET_SHARED, TYPE_GUARDIAN_SPEND, + TYPE_MEMBER_WALLET_REQUESTED, + TYPE_MEMBER_WALLET_GUARDED, ) /** @@ -1118,6 +1133,10 @@ data class ChatMessage( * which is why they need an id of their own, and why every row this * writes carries it. */ + /** A member as a transcript line names them: their profile's name, or the start of their key. */ + private suspend fun memberName(database: BennuDatabase, publicKey: HexKey): String = + database.profileDao().getProfileByPublicKey(publicKey)?.humanReadableNameOrPubkey() ?: publicKey.take(8) + internal suspend fun applyInnerEvent( database: BennuDatabase, groupId: String, @@ -1252,6 +1271,50 @@ data class ChatMessage( ) } + // A member asking the group to guard a wallet of theirs. The + // inner event carries the signed request whole; only a request + // that checks out and asks this room gets a line, and it is a + // line and nothing more -- the group decides when a signer puts + // it to the quorum. docs/member-guarded-wallets.md. + MemberWalletRequestEvent.KIND -> { + val request = MemberWalletRequestEvent.carried(event) ?: return null + val reading = MemberWalletRequestEvent.verified(request)?.reading ?: return null + if (!reading.groupChatRoomId.equals(groupId, ignoreCase = true)) return null + + ChatMessage( + giftWrapPayloadId = null, + messageType = TYPE_MEMBER_WALLET_REQUESTED, + marmotGroupEventId = marmotGroupEventId, + marmotInnerEventId = marmotInnerEventId, + senderPublicKey = senderPublicKey, + isUserMessage = isUserMessage, + chatRoomId = groupId, + createdAt = createdAt, + content = "@${memberName(database, reading.memberPublicKey)} asked this group to guard a wallet", + ) + } + + // The group agreeing to guard a member's wallet. Checked whole -- + // the room's signature and the request inside -- because the line + // says the group made a promise about somebody's money. It is + // filed as a `GroupSignedEvent` either way, and every reader + // checks it there again. + MemberWalletCertificateEvent.KIND -> { + val verified = MemberWalletCertificateEvent.verify(event, groupId) ?: return null + + ChatMessage( + giftWrapPayloadId = null, + messageType = TYPE_MEMBER_WALLET_GUARDED, + marmotGroupEventId = marmotGroupEventId, + marmotInnerEventId = marmotInnerEventId, + senderPublicKey = senderPublicKey, + isUserMessage = isUserMessage, + chatRoomId = groupId, + createdAt = createdAt, + content = "This group now guards a wallet for @${memberName(database, verified.memberPublicKey)}", + ) + } + // The group opening a wallet. Checked the whole way -- the room's // signature, and the statement rederiving from the room's own key -- // because a line saying "the group opened a wallet" is a line people 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 ed490ee8..6b9b8be7 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 @@ -6,6 +6,7 @@ import fr.acinq.bitcoin.OutPoint import com.machankura.bennu.compose.database.model.GroupTransaction import com.machankura.bennu.compose.database.model.types.FrostSigningSubject import com.machankura.bennu.compose.nostr.wallet.GroupWalletStatementEvent +import com.machankura.bennu.compose.nostr.wallet.MemberWalletCertificateEvent import com.machankura.bennu.compose.wallet.GroupSpend import fr.acinq.bitcoin.ByteVector64 import fr.acinq.bitcoin.Chain @@ -573,6 +574,23 @@ object FrostSigningManager { } } + // A member wallet's certificate is this group agreeing to guard one + // member's key, so it has to be exactly what that member asked for, asked + // by a member, with exactly the guardian keys this group grants -- the + // list a guarded subgroup of it would get. Recomputed from this device's + // own key state, never taken from the sponsor who proposed it. + // docs/member-guarded-wallets.md, Phase 7. + unsignedEvents.forEach { rebuilt -> + if (rebuilt.kind != MemberWalletCertificateEvent.KIND) return@forEach + val reason = thresholdPublicKey + ?.let { MemberWalletManager.refuseCertificate(database, rebuilt.pubKey, it, rebuilt) } + ?: if (thresholdPublicKey == null) "cannot be checked without the group's key" else null + reason?.let { + logger.w("Signing proposal $sessionId carries a member wallet certificate that $it; dropping") + return null + } + } + // A subgroup's key state carries its birth certificate, and the // certificate's wallet policy has to be the one this group was made // under: every admin was shown it at the join gate, so joining was diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/MemberWalletManager.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/MemberWalletManager.kt index 12b1c90f..e4e637c4 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/MemberWalletManager.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/MemberWalletManager.kt @@ -2,8 +2,13 @@ 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.FrostSigningSession import com.machankura.bennu.compose.database.model.MarmotInnerEvent +import com.machankura.bennu.compose.database.model.intermdiate.LocalChatRoom +import com.machankura.bennu.compose.database.model.types.FrostSigningStage import com.machankura.bennu.compose.nostr.wallet.GroupKeyNoticeEvent +import com.machankura.bennu.compose.nostr.wallet.MemberWalletCertificateEvent +import com.machankura.bennu.compose.nostr.wallet.MemberWalletRequestEvent import com.vitorpamplona.quartz.nip01Core.core.Event import com.vitorpamplona.quartz.nip01Core.core.HexKey import com.vitorpamplona.quartz.nip01Core.crypto.EventHasher @@ -91,6 +96,144 @@ object MemberWalletManager { return true } + // ---- The group's side ------------------------------------------------ + + /** + * Every certificate [chatRoomId] holds that verifies as its own: the member + * wallets this group guards, newest first. One per wallet -- the `d` tag makes + * two certificates for one wallet replacements, and they say the same thing. + */ + suspend fun certificatesOf(database: BennuDatabase, chatRoomId: String): List = + database.groupSignedEventDao() + .getByChatRoomIdAndKind(chatRoomId, MemberWalletCertificateEvent.KIND) + .mapNotNull { MemberWalletCertificateEvent.verify(it.toEvent(), chatRoomId) } + .sortedByDescending { it.certificate.createdAt } + .distinctBy { it.walletId } + + /** + * Every request a member has put into [chatRoomId] that checks out and asks + * this room, newest first, one per wallet. + */ + suspend fun requestsIn(database: BennuDatabase, chatRoomId: String): List = + database.marmotInnerEventDao() + .getByChatRoomAndKinds(chatRoomId, listOf(MemberWalletRequestEvent.KIND)) + .mapNotNull { MemberWalletRequestEvent.carried(it.asEvent()) } + .mapNotNull { MemberWalletRequestEvent.verified(it) } + .filter { it.reading.groupChatRoomId.equals(chatRoomId, ignoreCase = true) } + .sortedByDescending { it.request.createdAt } + .distinctBy { it.reading.walletId } + + /** + * The event id a certificate for [request] signed in [chatRoomId] will have. + * The room's id is the author, and the request fixes everything else -- which + * is what lets two sponsors find each other's session. + */ + fun certificateIdFor(chatRoomId: String, request: Event): HexKey { + val template = MemberWalletCertificateEvent.template(request) + return EventHasher.hashId(chatRoomId.lowercase(), template.createdAt, template.kind, template.tags, template.content) + } + + /** The session open in [chatRoomId] over [request]'s certificate, if one is still running. */ + suspend fun openSessionFor(database: BennuDatabase, chatRoomId: String, request: Event): FrostSigningSession? { + val certificateId = certificateIdFor(chatRoomId, request) + return database.frostSigningSessionDao().getSessionsForChatRoom(chatRoomId) + .filter { it.stage != FrostSigningStage.FAILED && it.stage != FrostSigningStage.COMPLETE } + .firstOrNull { session -> database.frostSigningSessionDao().getItems(session.id).any { it.eventId == certificateId } } + } + + /** Whether the latest session over [request]'s certificate in [chatRoomId] failed -- declined, or abandoned. */ + suspend fun wasNotSigned(database: BennuDatabase, chatRoomId: String, request: Event): Boolean { + val certificateId = certificateIdFor(chatRoomId, request) + val sessions = database.frostSigningSessionDao().getSessionsForChatRoom(chatRoomId) + .filter { session -> database.frostSigningSessionDao().getItems(session.id).any { it.eventId == certificateId } } + return sessions.isNotEmpty() && sessions.all { it.stage == FrostSigningStage.FAILED } + } + + /** + * The requests in [chatRoomId] still waiting for somebody to put them to the + * group: no certificate for the wallet, and no session running over one. + */ + suspend fun awaitingSponsor(database: BennuDatabase, chatRoomId: String): List { + val certified = certificatesOf(database, chatRoomId).map { it.walletId }.toSet() + return requestsIn(database, chatRoomId) + .filter { it.reading.walletId !in certified } + .filter { openSessionFor(database, chatRoomId, it.request) == null } + } + + /** + * Why [chatRoomId], signing as [thresholdPublicKey], should not sign a + * proposed member wallet [certificate] -- or null when it may. + * + * The check every signer makes before agreeing to guard a member's wallet, + * refused before anything is shown, for the reason a mismatched id is: + * + * - it is not exactly the certificate the request it carries asks for, or + * the request does not check out, or it asked another group; + * - the person asking is not a member of this room; + * - its guardians are not the ones this group grants: `SubgroupManager.grantFor` + * with the wallet's id in a child room's place -- the same list a guarded + * subgroup of this group would get. A coordinator who slipped a key in, + * dropped an ancestor or reordered the leaves is refused here. + * + * The group's own wallet policy decides only which keys the grant carries. + * It never refuses a member's wallet: an unguarded group guards its members + * with its own key alone. `docs/member-guarded-wallets.md`, Phase 7. + */ + suspend fun refuseCertificate( + database: BennuDatabase, + chatRoomId: String, + thresholdPublicKey: HexKey, + certificate: Event, + ): String? { + val verified = MemberWalletCertificateEvent.verify(certificate, chatRoomId, signed = false) + ?: return "is not a certificate this group could have been asked for" + + val member = database.participantDao().findParticipantsByChatRoomId(chatRoomId) + .any { it.participantPublicKey.equals(verified.memberPublicKey, ignoreCase = true) } + if (!member) return "was asked by somebody who is not a member" + + val expected = runCatching { SubgroupManager.grantFor(database, chatRoomId, thresholdPublicKey, verified.walletId) }.getOrNull() + ?: return "grants keys this device cannot check" + return if (verified.account.guardians == expected) null else "grants guardian keys this group does not" + } + + /** + * Puts [request] to [groupRoom]'s quorum, as [userPublicKey]: a signing + * session over the certificate the request determines, which this device's + * proposing counts as approving. Returns the session already running over it + * instead, when another signer got there first. + * + * @throws IllegalStateException when the wallet is already certified, or this + * device would refuse the certificate itself -- a quorum should never be asked + * for what the proposer's own device knows is wrong. + */ + suspend fun putToGroup(database: BennuDatabase, groupRoom: LocalChatRoom, userPublicKey: HexKey, request: Event): FrostSigningSession { + val chatRoomId = groupRoom.chatRoom.id + val reading = MemberWalletRequestEvent.verified(request)?.reading + ?: throw IllegalStateException("This request does not check out") + check(certificatesOf(database, chatRoomId).none { it.walletId == reading.walletId }) { "This group already guards that wallet" } + openSessionFor(database, chatRoomId, request)?.let { return it } + + val thresholdPublicKey = GroupWalletManager.thresholdKeyFor(database, chatRoomId) + ?: throw IllegalStateException("This group has no shared key to sign with") + val template = MemberWalletCertificateEvent.template(request) + val unsigned = Event(certificateIdFor(chatRoomId, request), chatRoomId.lowercase(), template.createdAt, template.kind, template.tags, template.content, "") + refuseCertificate(database, chatRoomId, thresholdPublicKey, unsigned)?.let { reason -> + throw IllegalStateException("This group would refuse it: it $reason") + } + + logger.i("Putting ${reading.memberPublicKey.take(8)}'s wallet ${reading.walletId.take(8)} to $chatRoomId") + return FrostSigningManager.proposeSigning( + database = database, + localChatRoom = groupRoom, + userPublicKey = userPublicKey, + kind = template.kind, + tags = template.tags, + content = template.content, + createdAt = template.createdAt, + ) + } + private suspend fun noticesIn(database: BennuDatabase, chatRoomId: String): List = database.marmotInnerEventDao() .getByChatRoomAndKinds(chatRoomId, listOf(GroupKeyNoticeEvent.KIND)) diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/nostr/wallet/MemberWalletCertificateEvent.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/nostr/wallet/MemberWalletCertificateEvent.kt index ddfc1e94..20c64a0a 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/nostr/wallet/MemberWalletCertificateEvent.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/nostr/wallet/MemberWalletCertificateEvent.kt @@ -126,10 +126,15 @@ object MemberWalletCertificateEvent { * Whether the guardians are the ones the group grants is what the group's * signers checked before signing. A reader trusts the group's quorum for * that, and it is no new trust: that quorum can already take every coin. + * + * [signed] false is for a certificate still being proposed, which has no + * signature yet: everything else is checked, and its author has to be the + * room the session will sign as. */ - fun verify(certificate: Event, groupChatRoomId: String): Verified? = runCatching { + fun verify(certificate: Event, groupChatRoomId: String, signed: Boolean = true): Verified? = runCatching { if (certificate.kind != KIND) return null - if (!GroupKeyStateEvent.isSignedByRoom(certificate, groupChatRoomId)) return null + if (signed && !GroupKeyStateEvent.isSignedByRoom(certificate, groupChatRoomId)) return null + if (!signed && !certificate.pubKey.equals(groupChatRoomId, ignoreCase = true)) return null val request = requestOf(certificate) ?: return null val verified = MemberWalletRequestEvent.verified(request) ?: return null diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/text/ProposedEvent.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/text/ProposedEvent.kt index 3dafdf6a..d5ca25ab 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/text/ProposedEvent.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/text/ProposedEvent.kt @@ -3,6 +3,10 @@ package com.machankura.bennu.compose.text import com.machankura.bennu.compose.nostr.subgroup.WalletPolicyReading import com.machankura.bennu.compose.nostr.subgroup.SubgroupWalletPolicy import com.vitorpamplona.quartz.nip01Core.core.Event +import com.vitorpamplona.quartz.nip01Core.core.HexKey +import com.machankura.bennu.compose.managers.GuardianDerivation +import com.machankura.bennu.compose.nostr.wallet.MemberWalletCertificateEvent +import com.machankura.bennu.compose.nostr.wallet.MemberWalletRequestEvent import com.machankura.bennu.compose.managers.SharedKeyDerivation import com.machankura.bennu.compose.nostr.frost.GroupKeyStateEvent import com.machankura.bennu.compose.nostr.subgroup.SubgroupBirthCertificateEvent @@ -27,7 +31,12 @@ object ProposedEvent { */ data class Summary(val label: String, val detail: String) - fun summarize(event: Event): Summary = when (event.kind) { + /** + * [nameOf] names a member by public key, for the one summary that is about a + * person: a caller with profiles to hand passes them, and one without gets + * the summary without a name rather than a wrong one. + */ + fun summarize(event: Event, nameOf: (HexKey) -> String? = { null }): Summary = when (event.kind) { // The one thing a group signs that is about the group rather than about // its work, and the only one a member sees before the room has done // anything. Shown as the path and the ceremony rather than as the key: @@ -92,6 +101,32 @@ object ProposedEvent { } ?: "A wallet statement this device cannot read" ) + // The group agreeing to guard one member's wallet. What a signer weighs + // is whose wallet, and what the group can do with it: take any coin that + // has sat for 12 blocks, alongside every group above it, while only the + // member can spend before then. The keys are their device's to check. + MemberWalletCertificateEvent.KIND -> Summary( + label = "Guard a member's wallet", + detail = MemberWalletCertificateEvent.requestOf(event) + ?.let { MemberWalletRequestEvent.read(it) } + ?.let { reading -> + val delay = GuardianDerivation.ANCESTOR_DELAY + val reach = when (val count = reading.guardians.size) { + 1 -> "this group can take its coins once they are $delay blocks old" + 2 -> "this group and the one above it can take its coins once they are $delay blocks old" + else -> "this group and the ${count - 1} above it can take its coins once they are $delay blocks old" + } + listOfNotNull( + nameOf(reading.memberPublicKey)?.let { "For @$it" }, + reading.label, + "on ${GroupWalletStatementEvent.chainName(reading.chain)}", + reach, + "only the member can spend from it before then", + ).joinToString(" · ") + } + ?: "A member wallet this device cannot read" + ) + else -> Summary(label = "Event of kind ${event.kind}", detail = event.content) } } diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/widgets/chat/ChatTranscript.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/widgets/chat/ChatTranscript.kt index 7fa3d7ec..7b61abca 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/widgets/chat/ChatTranscript.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/widgets/chat/ChatTranscript.kt @@ -16,6 +16,7 @@ import androidx.compose.foundation.lazy.LazyColumn import androidx.compose.foundation.lazy.items import androidx.compose.foundation.text.selection.SelectionContainer import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.AccountBalanceWallet import androidx.compose.material.icons.filled.AccountTree import bennu.composeapp.generated.resources.open import bennu.composeapp.generated.resources.the_group_has_its_key_finish_setting_it_up @@ -841,6 +842,7 @@ private fun RitualNotice( // path, so they get separate icons -- the whole reason both lines exist is // to be able to see that the first happened and the second did not. ChatMessage.TYPE_SUBGROUP_CERTIFIED -> Icons.Default.AccountTree + ChatMessage.TYPE_MEMBER_WALLET_REQUESTED, ChatMessage.TYPE_MEMBER_WALLET_GUARDED -> Icons.Default.AccountBalanceWallet ChatMessage.TYPE_MEMBER_INVITED -> Icons.Default.PersonAdd ChatMessage.TYPE_MEMBER_INVITE_SENT -> Icons.Default.Upload ChatMessage.TYPE_MEMBER_INVITE_FAILED -> Icons.Default.ErrorOutline diff --git a/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/GroupFixtures.kt b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/GroupFixtures.kt index 766c88fb..bd23cc63 100644 --- a/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/GroupFixtures.kt +++ b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/GroupFixtures.kt @@ -2,6 +2,17 @@ package com.machankura.bennu.compose.managers import com.machankura.bennu.compose.database.BennuDatabase import com.machankura.bennu.compose.database.model.ChatRoom +import com.machankura.bennu.compose.database.model.DkgParticipantMessage +import com.machankura.bennu.compose.database.model.DkgSession +import com.machankura.bennu.compose.database.model.Participant +import com.machankura.bennu.compose.database.model.intermdiate.LocalChatRoom +import com.machankura.bennu.compose.database.model.types.DkgRitualStage +import com.machankura.bennu.compose.nostr.Relays +import com.machankura.bennu.compose.nostr.dkg.DkgRitualEvents +import com.vitorpamplona.quartz.marmot.mip01Groups.MarmotGroupData +import com.vitorpamplona.quartz.marmot.mls.crypto.Ed25519 +import com.vitorpamplona.quartz.marmot.mls.group.MlsGroup +import com.vitorpamplona.quartz.nip01Core.crypto.KeyPair import com.machankura.bennu.compose.database.model.GroupKeyState import com.machankura.bennu.compose.database.model.NostrEvent import com.machankura.bennu.compose.database.model.Profile @@ -118,6 +129,54 @@ internal object GroupFixtures { db.chatRoomDao().upsert(ChatRoom(id = chatRoomId, userPublicKey = owner, subject = subject, description = null, mlsGroupState = null)) } + /** + * [material]'s Marmot room on this device, with [owner] holding a share of its + * key and every one of [members] a participant: a room this device can open + * a signing session in. Built as a real room is -- the id derived from the + * group's own key -- for the reason `SubgroupManagerJvmTest.parentWith` gives. + */ + suspend fun signingRoom(db: BennuDatabase, material: KeyMaterial, members: List, subject: String = "#Ekklesia"): LocalChatRoom { + val roomId = roomOf(material) + (members + owner).forEach { seedProfile(db, it) } + + val metadata = MarmotGroupData( + nostrGroupId = roomId, + name = subject, + description = SharedKeyDerivation.describe("Admins of $subject."), + adminPubkeys = members + owner, + relays = Relays.DefaultDMRelayList.map { it.url }, + ) + val mlsGroup = MlsGroup.create(KeyPair().pubKey, Ed25519.generateKeyPair().privateKey, listOf(metadata.toExtension())) + db.chatRoomDao().upsert( + ChatRoom(id = roomId, userPublicKey = owner, subject = subject, description = metadata.description, mlsGroupState = mlsGroup.saveState().encodeTls().toHex()) + ) + db.participantDao().upsert((members + owner).map { Participant(participantPublicKey = it, chatRoomId = roomId, relayHint = null) }) + + val ceremonyId = "signing-" + roomId.take(8) + db.dkgSessionDao().upsert( + DkgSession( + id = ceremonyId, + chatRoomId = roomId, + coordinatorPublicKey = owner, + userPublicKey = owner, + threshold = THRESHOLD, + participantCount = members.size + 1, + stage = DkgRitualStage.COMPLETE, + hostPublicKey = owner, + round1Random = "aa".repeat(32), + round2AuxRandom = "bb".repeat(32), + thresholdPublicKey = thresholdKeyOf(material), + secretShare = "cc".repeat(32), + ) + ) + (members + owner).forEachIndexed { index, member -> + db.dkgSessionDao().upsert( + DkgParticipantMessage(sessionId = ceremonyId, participantPublicKey = member, kind = DkgRitualEvents.HOST_KEY, payload = "0${index + 1}".repeat(33)) + ) + } + return requireNotNull(db.chatRoomDao().findChatRoomById(roomId)) + } + private fun signature(material: KeyMaterial, eventId: String): String { val cache = SharedKeyDerivation.derive(thresholdKeyOf(material), path).cache val message = ByteVector(eventId.hexToByteArray()) diff --git a/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/MemberWalletSigningJvmTest.kt b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/MemberWalletSigningJvmTest.kt new file mode 100644 index 00000000..a851825b --- /dev/null +++ b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/MemberWalletSigningJvmTest.kt @@ -0,0 +1,197 @@ +package com.machankura.bennu.compose.managers + +import androidx.room3.Room +import com.machankura.bennu.compose.database.BennuDatabase +import com.machankura.bennu.compose.database.builder.getRoomDatabase +import com.machankura.bennu.compose.database.model.GroupSignedEvent +import com.machankura.bennu.compose.database.model.MarmotInnerEvent +import com.machankura.bennu.compose.managers.GroupFixtures.fileKeyState +import com.machankura.bennu.compose.managers.GroupFixtures.guardedCertificate +import com.machankura.bennu.compose.managers.GroupFixtures.keyMaterial +import com.machankura.bennu.compose.managers.GroupFixtures.roomOf +import com.machankura.bennu.compose.managers.GroupFixtures.signedAsRoom +import com.machankura.bennu.compose.managers.GroupFixtures.signingRoom +import com.machankura.bennu.compose.managers.GroupFixtures.thresholdKeyOf +import com.machankura.bennu.compose.nostr.wallet.MemberWalletCertificateEvent +import com.machankura.bennu.compose.nostr.wallet.MemberWalletRequestEvent +import com.machankura.bennu.compose.text.ProposedEvent +import com.vitorpamplona.quartz.nip01Core.core.Event +import fr.acinq.bitcoin.ByteVector32 +import fr.acinq.bitcoin.Chain +import fr.acinq.bitcoin.PrivateKey +import fr.acinq.secp256k1.Hex +import kotlinx.coroutines.runBlocking +import kotlin.test.AfterTest +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFailsWith +import kotlin.test.assertNotNull +import kotlin.test.assertNull +import kotlin.test.assertTrue +import kotlin.time.Instant + +/** + * A group's signers checking a member wallet certificate before they are asked + * to approve it, and a signer putting a member's request to the group. + * + * The group is itself a guarded subgroup, so a member's wallet under it carries + * two leaves -- the group's and its parent's, one step further -- and every + * refusal below is one way of getting that list wrong. + */ +class MemberWalletSigningJvmTest { + private val db: BennuDatabase = getRoomDatabase(Room.inMemoryDatabaseBuilder()) + + @AfterTest + fun closeDb() = db.close() + + private val chain = Chain.Regtest + + private fun privateKey(seed: Long): PrivateKey = PrivateKey(ByteVector32(Hex.decode(seed.toString(16).padStart(64, '0')))) + + private val parent = keyMaterial("9a9e") + private val group = keyMaterial("6a0b") + private val stranger = keyMaterial("57a9") + private val groupRoom = roomOf(group) + + private val member = privateKey(0x3e3be7) + private val memberPublicKey = member.xOnlyPublicKey().value.toHex() + private val outsider = privateKey(0x07575) + private val walletPrivateKey = privateKey(0xa11ce) + private val walletId = MemberWalletDerivation.walletId(walletPrivateKey.publicKey()) + + /** What the group grants the member's wallet: its own key, then its parent's, one step further. */ + private val grant: List = GuardianDerivation.grant( + thresholdKeyOf(group), groupRoom, + GuardianDerivation.grant(thresholdKeyOf(parent), roomOf(parent), emptyList(), groupRoom), + walletId, + ) + + private suspend fun groupRoomHere() = signingRoom(db, group, members = listOf(memberPublicKey)).also { + fileKeyState(db, group, guardedCertificate(parent, group)) + } + + private fun request(guardians: List = grant, by: PrivateKey = member, asking: String = groupRoom) = + MemberWalletRequestEvent.build( + memberPrivateKey = by, + groupChatRoomId = asking, + walletPrivateKey = walletPrivateKey, + account = MemberWalletDerivation.account(walletPrivateKey.publicKey(), chain, guardians), + label = "Savings", + createdAt = 1_700_000_000, + ) + + /** The certificate [request] asks for, as a session would carry it -- unsigned, authored by the room. */ + private fun proposed(request: Event, room: String = groupRoom): Event { + val template = MemberWalletCertificateEvent.template(request) + return Event(MemberWalletManager.certificateIdFor(room, request), room, template.createdAt, template.kind, template.tags, template.content, "") + } + + private suspend fun refusal(request: Event): String? = + MemberWalletManager.refuseCertificate(db, groupRoom, thresholdKeyOf(group), proposed(request)) + + @Test + fun `the honest certificate is signable`(): Unit = runBlocking { + groupRoomHere() + assertNull(refusal(request())) + } + + @Test + fun `a certificate that drops the group above is refused`(): Unit = runBlocking { + groupRoomHere() + assertEquals("grants guardian keys this group does not", refusal(request(guardians = grant.take(1)))) + } + + @Test + fun `a certificate whose leaves are reordered is refused`(): Unit = runBlocking { + groupRoomHere() + // Reordered, the group is no longer the nearest guardian, so the request itself is refused. + assertNotNull(refusal(request(guardians = grant.reversed()))) + } + + @Test + fun `a certificate naming another group's key is refused`(): Unit = runBlocking { + groupRoomHere() + val swapped = listOf(grant[0], GuardianDerivation.grant(thresholdKeyOf(stranger), roomOf(stranger), emptyList(), walletId).single()) + assertEquals("grants guardian keys this group does not", refusal(request(guardians = swapped))) + } + + @Test + fun `a certificate asked by somebody who is not a member is refused`(): Unit = runBlocking { + groupRoomHere() + assertEquals("was asked by somebody who is not a member", refusal(request(by = outsider))) + } + + @Test + fun `a request made of another group is refused here`(): Unit = runBlocking { + groupRoomHere() + val elsewhere = request(asking = roomOf(stranger), guardians = GuardianDerivation.grant(thresholdKeyOf(stranger), roomOf(stranger), emptyList(), walletId)) + assertNotNull(MemberWalletManager.refuseCertificate(db, groupRoom, thresholdKeyOf(group), proposed(elsewhere))) + } + + @Test + fun `an unguarded group guards its members with its own key alone`(): Unit = runBlocking { + // A root group: no certificate, so nothing to pass down. + signingRoom(db, group, members = listOf(memberPublicKey)) + fileKeyState(db, group, certificate = null) + assertNull(refusal(request(guardians = grant.take(1)))) + assertEquals("grants guardian keys this group does not", refusal(request())) + } + + private suspend fun deliverRequest(request: Event) { + db.marmotInnerEventDao().upsert( + MarmotInnerEvent( + id = "1".repeat(63) + "0", + publicKey = request.pubKey, + kind = MemberWalletRequestEvent.KIND, + createdAt = Instant.fromEpochSeconds(request.createdAt), + tags = arrayOf(arrayOf("h", groupRoom)), + content = request.toJson(), + chatRoomId = groupRoom, + ) + ) + } + + @Test + fun `a signer puts a request to the group, and a second sponsor finds the same session`(): Unit = runBlocking { + val room = groupRoomHere() + val request = request() + deliverRequest(request) + assertEquals(listOf(walletId), MemberWalletManager.awaitingSponsor(db, groupRoom).map { it.reading.walletId }) + + val session = MemberWalletManager.putToGroup(db, room, GroupFixtures.owner, request) + val items = db.frostSigningSessionDao().getItems(session.id) + assertEquals(listOf(MemberWalletManager.certificateIdFor(groupRoom, request)), items.map { it.eventId }) + assertTrue(MemberWalletManager.awaitingSponsor(db, groupRoom).isEmpty(), "no longer waiting for a sponsor") + + assertEquals(session.id, MemberWalletManager.putToGroup(db, room, GroupFixtures.owner, request).id) + } + + @Test + fun `a sponsor refuses to put what the group would refuse`(): Unit = runBlocking { + val room = groupRoomHere() + assertFailsWith { + MemberWalletManager.putToGroup(db, room, GroupFixtures.owner, request(guardians = grant.take(1))) + } + assertTrue(db.frostSigningSessionDao().getSessionsForChatRoom(groupRoom).isEmpty()) + } + + @Test + fun `a wallet the group already guards is not put to it again`(): Unit = runBlocking { + val room = groupRoomHere() + val request = request() + val template = MemberWalletCertificateEvent.template(request) + val signed = signedAsRoom(group, template.kind, template.tags, template.content, template.createdAt) + db.groupSignedEventDao().upsert(GroupSignedEvent.fromEvent(signed, chatRoomId = groupRoom, derivationPath = SharedKeyDerivation.formatPath(GroupFixtures.path), frostSigningSessionId = null)) + + assertEquals(listOf(walletId), MemberWalletManager.certificatesOf(db, groupRoom).map { it.walletId }) + assertFailsWith { MemberWalletManager.putToGroup(db, room, GroupFixtures.owner, request) } + } + + @Test + fun `the signers read who it is for and what the group can do`() { + val summary = ProposedEvent.summarize(proposed(request())) { if (it == memberPublicKey) "alice" else null } + assertEquals("Guard a member's wallet", summary.label) + assertTrue(summary.detail.startsWith("For @alice · Savings · on regtest"), summary.detail) + assertTrue(summary.detail.contains("this group and the one above it can take its coins once they are 12 blocks old"), summary.detail) + } +} From 784855954786b8d91b46480e6695c97a585fa286 Mon Sep 17 00:00:00 2001 From: Kgothatso Ngako Date: Sat, 24 Oct 2026 07:34:33 +0200 Subject: [PATCH 12/21] feat(wallet): the send form funds a descendant's guarded wallet (Phase 4) GroupSendRoute.fundChatRoomId opens the form in fund mode: the address field gives way to a fixed destination card naming the wallet, the address fundingAddress chose and its index, and that the group can spend the coins again after the leaf's lock. The form follows the descendant's chain state and the room's open fundings, so a paid or held address moves on while it is open. A route naming both a source and a destination is not opened. Co-Authored-By: Claude Opus 5.5 --- .../composeResources/values/strings.xml | 6 + .../compose/ui/composable/GroupSendScreen.kt | 109 +++++++++++++--- .../ui/composable/navigation/BennuNavHost.kt | 1 + .../navigation/routes/GroupSendRoute.kt | 5 + .../ui/view/model/GroupSendViewModel.kt | 67 +++++++--- .../compose/ui/view/state/GroupSendUIState.kt | 22 ++++ .../view/model/GroupSendViewModelJvmTest.kt | 116 ++++++++++++++++++ 7 files changed, 296 insertions(+), 30 deletions(-) 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) + } } From 0bc076a894ba713d8a4a5c817e015ff18f0882c3 Mon Sep 17 00:00:00 2001 From: Kgothatso Ngako Date: Sat, 24 Oct 2026 07:38:30 +0200 Subject: [PATCH 13/21] feat(wallet): a member asks a group to guard a wallet only they can spend from (Phase 6) MemberWalletManager.request makes a random key, works out the group's leaf and every inherited one, builds both descriptors, stores the key, and only then puts the signed request into the group's room. It checks the request the way every signer will before it goes, and a member who holds a share of the group's key puts it to the group in the same step. NewMemberWalletScreen is a consent screen first: who can take the member's coins and after how long, who will see them, and that the group is the recovery path -- then an optional label and one button. Every refusal is named, and a member who does not know the group's key can ask for it from there. Its entrances arrive with the profile's guarded wallets (Phase 8) and the group's page (Phase 11). GroupWalletRollout.MEMBER_WALLETS_ON_MAINNET is shut: the entrances are offered on test networks only, since the member's own spend is the first single-signer path the app has. Co-Authored-By: Claude Opus 5.5 --- .../composeResources/values/strings.xml | 23 ++ .../DatabaseMemberWalletRepository.kt | 52 ++++ .../compose/managers/MemberWalletManager.kt | 152 +++++++++++ .../repository/MemberWalletRepository.kt | 41 +++ .../ui/composable/NewMemberWalletScreen.kt | 239 ++++++++++++++++++ .../ui/composable/navigation/BennuNavHost.kt | 24 ++ .../navigation/routes/NewMemberWalletRoute.kt | 14 + .../ui/view/model/NewMemberWalletViewModel.kt | 124 +++++++++ .../ui/view/state/NewMemberWalletUIState.kt | 31 +++ .../compose/wallet/GroupWalletRollout.kt | 14 + .../bennu/compose/managers/GroupFixtures.kt | 10 +- .../managers/MemberWalletRequestJvmTest.kt | 162 ++++++++++++ 12 files changed, 885 insertions(+), 1 deletion(-) create mode 100644 composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/repository/DatabaseMemberWalletRepository.kt create mode 100644 composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/repository/MemberWalletRepository.kt create mode 100644 composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/NewMemberWalletScreen.kt create mode 100644 composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/navigation/routes/NewMemberWalletRoute.kt create mode 100644 composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/NewMemberWalletViewModel.kt create mode 100644 composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/NewMemberWalletUIState.kt create mode 100644 composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/MemberWalletRequestJvmTest.kt diff --git a/composeApp/src/commonMain/composeResources/values/strings.xml b/composeApp/src/commonMain/composeResources/values/strings.xml index 52c5e968..b5816a43 100644 --- a/composeApp/src/commonMain/composeResources/values/strings.xml +++ b/composeApp/src/commonMain/composeResources/values/strings.xml @@ -563,4 +563,27 @@ The subgroup's wallet will not be guarded: only the subgroup can spend from it. The group above this one decided this group's wallet is guarded. Each group above it can spend any coin in it once it has %1$d confirmations, without this group agreeing. The group above this one decided this group's wallet is not guarded. Only this group can spend from it. + + New guarded wallet + A group + Choose a group to guard it + You're in no groups that could guard a wallet for you. + A wallet only you can spend from, guarded by %1$s + %1$s can take any coin in it that has been confirmed for %2$d blocks, without asking you. + %1$s and the group above it can take any coin in it that has been confirmed for %2$d blocks, without asking you. + %1$s and the %2$d groups above it can take any coin in it that has been confirmed for %3$d blocks, without asking you. + Members of the groups that guard it will see its balance, and that it's yours. + If you lose this device, those groups can still move your coins for you. + Label (optional) + Ask %1$s + Asked %1$s to guard a wallet. + Couldn't ask the group to guard a wallet. + This profile can only look, so it can't sign a request. + Only a group with a shared key can guard a wallet. + This device doesn't know what this group signs with yet, so it can't work out the group's leaves. + Ask the group for its key + Asked. A member who holds the group's key will answer when their device next reads the room. + This group's guardian keys can't be read by this version of the app. + Guarded wallets for members aren't offered on this network yet. + This profile has no wallet of its own to watch the chain with, so it couldn't see its own coins. diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/repository/DatabaseMemberWalletRepository.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/repository/DatabaseMemberWalletRepository.kt new file mode 100644 index 00000000..4e86cf57 --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/repository/DatabaseMemberWalletRepository.kt @@ -0,0 +1,52 @@ +package com.machankura.bennu.compose.database.repository + +import co.touchlab.kermit.Logger +import com.machankura.bennu.compose.database.BennuDatabase +import com.machankura.bennu.compose.database.model.MemberWallet +import com.machankura.bennu.compose.database.model.intermdiate.LocalChatRoom +import com.machankura.bennu.compose.identity.Identity +import com.machankura.bennu.compose.managers.MemberWalletManager +import com.machankura.bennu.compose.repository.MemberWalletRepository +import com.vitorpamplona.quartz.nip01Core.core.HexKey +import fr.acinq.bitcoin.Chain +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow + +class DatabaseMemberWalletRepository( + private val database: BennuDatabase, + private val activeIdentity: StateFlow = MutableStateFlow(null), +) : MemberWalletRepository { + private val logger = Logger.withTag(TAG) + + override suspend fun groupsOf(ownerPublicKey: HexKey): List = + database.chatRoomDao().getChatRoomListByUserPublicKey(ownerPublicKey) + .filter { it.chatRoom.mlsGroupState != null } + + override suspend fun refusal(chatRoomId: String, chain: Chain): MemberWalletManager.Refusal? = try { + MemberWalletManager.refusal(database, chatRoomId, canSign = activeIdentity.value?.canSign == true, chain = chain) + } catch (e: Throwable) { + logger.e("Error reading whether $chatRoomId can guard a wallet", e) + MemberWalletManager.Refusal.KEY_UNKNOWN + } + + override suspend fun reachOf(chatRoomId: String): Int? = try { + MemberWalletManager.reachOf(database, chatRoomId) + } catch (e: Throwable) { + logger.e("Error reading how far $chatRoomId's guard reaches", e) + null + } + + override suspend fun askForGroupKey(chatRoomId: String): Boolean { + val identity = activeIdentity.value ?: return false + return MemberWalletManager.askForGroupKey(database, chatRoomId, identity.nostrPublicKey) + } + + override suspend fun request(chatRoomId: String, chain: Chain, label: String?): MemberWallet { + val key = activeIdentity.value?.nostrPrivateKey ?: throw IllegalStateException("This profile cannot sign") + return MemberWalletManager.request(database, chatRoomId, key, chain, label) + } + + companion object { + private const val TAG = "DatabaseMemberWalletRepository" + } +} diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/MemberWalletManager.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/MemberWalletManager.kt index e4e637c4..1d27ef02 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/MemberWalletManager.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/MemberWalletManager.kt @@ -3,15 +3,21 @@ 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.FrostSigningSession +import com.machankura.bennu.compose.database.model.MemberWallet import com.machankura.bennu.compose.database.model.MarmotInnerEvent import com.machankura.bennu.compose.database.model.intermdiate.LocalChatRoom import com.machankura.bennu.compose.database.model.types.FrostSigningStage +import com.machankura.bennu.compose.nostr.subgroup.SubgroupBirthCertificateEvent import com.machankura.bennu.compose.nostr.wallet.GroupKeyNoticeEvent +import com.machankura.bennu.compose.nostr.wallet.GroupWalletStatementEvent import com.machankura.bennu.compose.nostr.wallet.MemberWalletCertificateEvent import com.machankura.bennu.compose.nostr.wallet.MemberWalletRequestEvent import com.vitorpamplona.quartz.nip01Core.core.Event import com.vitorpamplona.quartz.nip01Core.core.HexKey import com.vitorpamplona.quartz.nip01Core.crypto.EventHasher +import com.machankura.bennu.compose.wallet.GroupWalletRollout +import fr.acinq.bitcoin.Chain +import fr.acinq.bitcoin.PrivateKey import kotlin.time.Clock import kotlin.time.Instant @@ -96,6 +102,152 @@ object MemberWalletManager { return true } + // ---- The member's side ----------------------------------------------- + + /** Why a member cannot ask a group to guard a wallet for them here, said as a reason the screen can name. */ + enum class Refusal { + /** A read-only profile: it cannot sign the request. */ + CANNOT_SIGN, + + /** The room is not a Marmot group, so there is no quorum to sign and no room to carry it. */ + NOT_A_GROUP, + + /** This device does not know what the group signs with -- [askForGroupKey] is the way on. */ + KEY_UNKNOWN, + + /** The group's certificate carries guardian keys this build cannot read. */ + GUARDIANS_UNREADABLE, + + /** Member wallets are not offered on this network yet: `GroupWalletRollout.offersMemberWalletsOn`. */ + NOT_ON_THIS_NETWORK, + + /** The profile has no Electrum client, so it could not see its own coins. Read by the screen, not here. */ + CANNOT_WATCH, + } + + /** Why [chatRoomId] cannot guard a wallet for this profile on [chain], or null when it can. */ + suspend fun refusal(database: BennuDatabase, chatRoomId: String, canSign: Boolean, chain: Chain): Refusal? { + if (!canSign) return Refusal.CANNOT_SIGN + if (!GroupWalletRollout.offersMemberWalletsOn(chain)) return Refusal.NOT_ON_THIS_NETWORK + val room = database.chatRoomDao().findChatRoomById(chatRoomId) + if (room?.chatRoom?.mlsGroupState == null) return Refusal.NOT_A_GROUP + val groupKey = groupKeyFor(database, chatRoomId) ?: return Refusal.KEY_UNKNOWN + if (groupKey.certificate != null && SubgroupBirthCertificateEvent.parseGuardians(groupKey.certificate.tags) == null) { + return Refusal.GUARDIANS_UNREADABLE + } + return null + } + + /** + * How many groups a wallet guarded by [chatRoomId] would be guarded by: the + * group, and every group above it whose key it passes down. Null when this + * device does not know the group's key. + */ + suspend fun reachOf(database: BennuDatabase, chatRoomId: String): Int? = + groupKeyFor(database, chatRoomId)?.let { it.guardians.size + 1 } + + /** + * Steps 1 and 2: makes a random key, works out every ancestor's leaf and + * both descriptors, stores the key, and only then asks [chatRoomId] to + * guard the wallet, as the member [memberPrivateKey] holds. + * + * The row is written before the request is queued, so a crash between the + * two leaves a key and no request rather than a request and no key. The + * request is checked the way every signer will check it before it goes, so + * a quorum is never shown one this device would refuse. A member who holds a + * share of the group's key puts it to the group in the same breath; anybody + * else waits for a signer to. + * + * @throws IllegalStateException with the [Refusal] when it cannot be asked + */ + suspend fun request( + database: BennuDatabase, + chatRoomId: String, + memberPrivateKey: PrivateKey, + chain: Chain, + label: String?, + createdAt: Instant = Clock.System.now(), + ): MemberWallet { + refusal(database, chatRoomId, canSign = true, chain)?.let { throw IllegalStateException("Cannot ask: $it") } + val groupKey = groupKeyFor(database, chatRoomId) ?: throw IllegalStateException("Cannot ask: ${Refusal.KEY_UNKNOWN}") + val memberPublicKey = memberPrivateKey.xOnlyPublicKey().value.toHex() + + val walletPrivateKey = MemberWalletDerivation.generate() + val walletId = MemberWalletDerivation.walletId(walletPrivateKey.publicKey()) + val grant = GuardianDerivation.grant(groupKey.thresholdPublicKey, chatRoomId.lowercase(), groupKey.guardians, walletId) + val account = MemberWalletDerivation.account(walletPrivateKey.publicKey(), chain, grant) + + val request = MemberWalletRequestEvent.build( + memberPrivateKey = memberPrivateKey, + groupChatRoomId = chatRoomId, + walletPrivateKey = walletPrivateKey, + account = account, + label = label, + createdAt = createdAt.epochSeconds, + ) + checkNotNull(MemberWalletRequestEvent.verified(request)) { "The request this device built does not check out" } + + val wallet = MemberWallet( + walletId = walletId, + ownerPublicKey = memberPublicKey, + guardingChatRoomId = chatRoomId, + chain = GroupWalletStatementEvent.chainName(chain), + walletPrivateKey = walletPrivateKey.value.toHex(), + label = MemberWalletRequestEvent.read(request)?.label, + requestJson = request.toJson(), + // The request's own second: the row and the event it carries agree on when. + createdAt = Instant.fromEpochSeconds(request.createdAt), + ) + database.memberWalletDao().upsert(wallet) + send(database, chatRoomId, request) + logger.i("Asked $chatRoomId to guard wallet ${walletId.take(8)}") + + sponsorIfSigner(database, chatRoomId, memberPublicKey, request) + return wallet + } + + /** + * Asks again with the request [wallet] was asked with, unchanged -- for a + * request no signer put to the group, or one the group did not sign. + */ + suspend fun askAgain(database: BennuDatabase, wallet: MemberWallet) { + val request = Event.fromJsonOrNull(wallet.requestJson) ?: throw IllegalStateException("The stored request does not read") + send(database, wallet.guardingChatRoomId, request) + sponsorIfSigner(database, wallet.guardingChatRoomId, wallet.ownerPublicKey, request) + } + + /** + * Forgets [walletId]'s key. Refused once a group has certified the wallet: + * from then on its addresses may have been paid. Before, none was ever + * offered, so no coin can be behind the key. + */ + suspend fun discard(database: BennuDatabase, walletId: String) { + val wallet = database.memberWalletDao().getById(walletId) ?: return + check(certificatesOf(database, wallet.guardingChatRoomId).none { it.walletId == walletId }) { + "A group guards this wallet: its key is not discarded" + } + database.memberWalletDao().delete(walletId) + } + + /** The request into [chatRoomId], whole, as an inner event's content: see `MemberWalletRequestEvent`. */ + private suspend fun send(database: BennuDatabase, chatRoomId: String, request: Event) { + queue( + database = database, + chatRoomId = chatRoomId, + userPublicKey = request.pubKey, + tags = arrayOf(arrayOf("h", chatRoomId.lowercase())), + content = request.toJson(), + kind = MemberWalletRequestEvent.KIND, + ) + } + + private suspend fun sponsorIfSigner(database: BennuDatabase, chatRoomId: String, memberPublicKey: HexKey, request: Event) { + if (!FrostSigningManager.canSign(database, chatRoomId)) return + val room = database.chatRoomDao().findChatRoomById(chatRoomId) ?: return + runCatching { putToGroup(database, room, memberPublicKey, request) } + .onFailure { logger.w("Asked $chatRoomId, and could not put it to the group: ${it.message}") } + } + // ---- The group's side ------------------------------------------------ /** diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/repository/MemberWalletRepository.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/repository/MemberWalletRepository.kt new file mode 100644 index 00000000..e0e7dec6 --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/repository/MemberWalletRepository.kt @@ -0,0 +1,41 @@ +package com.machankura.bennu.compose.repository + +import com.machankura.bennu.compose.database.model.MemberWallet +import com.machankura.bennu.compose.database.model.intermdiate.LocalChatRoom +import com.machankura.bennu.compose.managers.MemberWalletManager +import com.vitorpamplona.quartz.nip01Core.core.HexKey +import fr.acinq.bitcoin.Chain + +/** + * A member's guarded wallets, for the screens: asking a group to guard one, and + * -- from the group's side -- the requests and certificates in a room. + * `docs/member-guarded-wallets.md`. The key-holding identity is the + * repository's, never the screen's: nothing above this layer touches a key. + */ +interface MemberWalletRepository { + /** The groups [ownerPublicKey] is in that could guard a wallet: Marmot rooms, whether or not their key is known yet. */ + suspend fun groupsOf(ownerPublicKey: HexKey): List + + /** Why [chatRoomId] cannot guard a wallet for the active profile on [chain], or null when it can. */ + suspend fun refusal(chatRoomId: String, chain: Chain): MemberWalletManager.Refusal? + + /** How many groups a wallet guarded by [chatRoomId] would be guarded by, or null while its key is unknown. */ + suspend fun reachOf(chatRoomId: String): Int? + + /** Asks [chatRoomId] what it signs with, for a member who holds no key state. Whether it asked. */ + suspend fun askForGroupKey(chatRoomId: String): Boolean + + /** Makes the key, works out the leaves, stores the key, and asks [chatRoomId] to guard it. */ + suspend fun request(chatRoomId: String, chain: Chain, label: String?): MemberWallet + + companion object { + val NO_OP = object : MemberWalletRepository { + override suspend fun groupsOf(ownerPublicKey: HexKey): List = emptyList() + override suspend fun refusal(chatRoomId: String, chain: Chain): MemberWalletManager.Refusal? = MemberWalletManager.Refusal.CANNOT_SIGN + override suspend fun reachOf(chatRoomId: String): Int? = null + override suspend fun askForGroupKey(chatRoomId: String): Boolean = false + override suspend fun request(chatRoomId: String, chain: Chain, label: String?): MemberWallet = + throw UnsupportedOperationException("no repository") + } + } +} diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/NewMemberWalletScreen.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/NewMemberWalletScreen.kt new file mode 100644 index 00000000..7a8b7ecb --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/NewMemberWalletScreen.kt @@ -0,0 +1,239 @@ +package com.machankura.bennu.compose.ui.composable + +import androidx.compose.foundation.clickable +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.items +import androidx.compose.foundation.rememberScrollState +import androidx.compose.foundation.verticalScroll +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.AccountBalanceWallet +import androidx.compose.material.icons.filled.Groups +import androidx.compose.material3.Button +import androidx.compose.material3.ExperimentalMaterial3Api +import androidx.compose.material3.Icon +import androidx.compose.material3.ListItem +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.OutlinedTextField +import androidx.compose.material3.Scaffold +import androidx.compose.material3.SnackbarHost +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.material3.TopAppBar +import androidx.compose.material3.minimumInteractiveComponentSize +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.rememberCoroutineScope +import androidx.compose.ui.Modifier +import androidx.compose.ui.text.style.TextOverflow +import androidx.lifecycle.viewmodel.compose.viewModel +import bennu.composeapp.generated.resources.Res +import bennu.composeapp.generated.resources.a_group +import bennu.composeapp.generated.resources.a_wallet_only_you_can_spend_from_guarded_by_s +import bennu.composeapp.generated.resources.ask_s +import bennu.composeapp.generated.resources.ask_the_group_for_its_key +import bennu.composeapp.generated.resources.asked_for_the_group_s_key +import bennu.composeapp.generated.resources.asked_s_to_guard_a_wallet +import bennu.composeapp.generated.resources.choose_a_group_to_guard_it +import bennu.composeapp.generated.resources.couldn_t_ask_the_group_to_guard_a_wallet +import bennu.composeapp.generated.resources.if_you_lose_this_device_those_groups_can_still_move_your_coins +import bennu.composeapp.generated.resources.label_optional +import bennu.composeapp.generated.resources.member_wallets_are_not_offered_on_this_network +import bennu.composeapp.generated.resources.members_of_those_groups_will_see_this_wallet +import bennu.composeapp.generated.resources.new_guarded_wallet +import bennu.composeapp.generated.resources.only_a_group_can_guard_a_wallet +import bennu.composeapp.generated.resources.s_and_the_d_groups_above_it_can_take_any_coin_without_asking_you +import bennu.composeapp.generated.resources.s_and_the_group_above_it_can_take_any_coin_without_asking_you +import bennu.composeapp.generated.resources.s_can_take_any_coin_without_asking_you +import bennu.composeapp.generated.resources.this_device_does_not_know_what_this_group_signs_with +import bennu.composeapp.generated.resources.this_group_s_guardian_keys_can_t_be_read_to_guard_a_wallet +import bennu.composeapp.generated.resources.this_profile_cannot_sign_a_request +import bennu.composeapp.generated.resources.this_profile_cannot_watch_its_own_coins +import bennu.composeapp.generated.resources.you_are_in_no_groups_that_can_guard_a_wallet +import com.machankura.bennu.compose.managers.GuardianDerivation +import com.machankura.bennu.compose.managers.MemberWalletManager +import com.machankura.bennu.compose.repository.MemberWalletRepository +import com.machankura.bennu.compose.ui.composable.widgets.Decorative +import com.machankura.bennu.compose.ui.composable.widgets.EmptyState +import com.machankura.bennu.compose.ui.composable.widgets.ErrorState +import com.machankura.bennu.compose.ui.composable.widgets.LoadingDataIndicator +import com.machankura.bennu.compose.ui.composable.widgets.LocalSnackbarHostState +import com.machankura.bennu.compose.ui.composable.widgets.NavigateBackButton +import com.machankura.bennu.compose.ui.composable.widgets.ScreenStateTransition +import com.machankura.bennu.compose.ui.composable.widgets.rememberNotifier +import com.machankura.bennu.compose.ui.theme.readableContent +import com.machankura.bennu.compose.ui.theme.spacing +import com.machankura.bennu.compose.ui.view.model.NewMemberWalletViewModel +import com.machankura.bennu.compose.ui.view.state.NewMemberWalletUIState +import com.vitorpamplona.quartz.nip01Core.core.HexKey +import fr.acinq.bitcoin.Chain +import org.jetbrains.compose.resources.stringResource + +/** + * Asking a group to guard a wallet only this member can spend from. + * + * A consent screen first and a form second: what the member gives up -- the + * groups that can take their coins, and see them -- is said before the one + * button, in the words `docs/member-guarded-wallets.md` uses. Nothing leaves the + * device until that button: the key is made, the leaves worked out and the key + * stored, and only then is the group asked. + */ +@OptIn(ExperimentalMaterial3Api::class) +@Composable +fun NewMemberWalletScreen( + activeUserPublicKey: HexKey, + chatRoomId: String?, + chain: Chain, + canWatch: Boolean, + initialUIState: NewMemberWalletUIState = NewMemberWalletUIState.Loading, + memberWalletRepository: MemberWalletRepository, + onNavigateBack: () -> Unit, +) { + val viewModel: NewMemberWalletViewModel = viewModel( + factory = NewMemberWalletViewModel.factory( + activeUserPublicKey = activeUserPublicKey, + chatRoomId = chatRoomId, + chain = chain, + canWatch = canWatch, + initialUIState = initialUIState, + memberWalletRepository = memberWalletRepository, + ) + ) + + LaunchedEffect(true) { + if (initialUIState == NewMemberWalletUIState.Loading) viewModel.initiate() + } + + // Read above the handlers: the notifier and the strings are composable and + // an onClick is not. The caller's scope, so "asked" outlives the screen + // navigating away. + val notify = rememberNotifier(rememberCoroutineScope()) + val couldNotAsk = stringResource(Res.string.couldn_t_ask_the_group_to_guard_a_wallet) + val fallbackName = stringResource(Res.string.a_group) + val chosenName = (viewModel.uiState as? NewMemberWalletUIState.Chosen)?.room?.chatRoom?.subject?.takeIf { it.isNotBlank() } ?: fallbackName + val asked = stringResource(Res.string.asked_s_to_guard_a_wallet, chosenName) + + Scaffold( + snackbarHost = { SnackbarHost(LocalSnackbarHostState.current) }, + topBar = { + TopAppBar( + title = { Text(stringResource(Res.string.new_guarded_wallet)) }, + navigationIcon = { NavigateBackButton(onNavigateBack) }, + ) + } + ) { padding -> + ScreenStateTransition(viewModel.uiState) { uiState -> + when (val state = uiState) { + NewMemberWalletUIState.Loading -> LoadingDataIndicator(modifier = Modifier.fillMaxWidth().padding(padding)) + + // Nothing to retry: the group came from a navigation argument. + is NewMemberWalletUIState.Error -> ErrorState(modifier = Modifier.padding(padding), message = state.message, onRetry = null) + + is NewMemberWalletUIState.Picking -> if (state.groups.isEmpty()) { + EmptyState( + modifier = Modifier.padding(padding).readableContent(), + message = stringResource(Res.string.you_are_in_no_groups_that_can_guard_a_wallet), + icon = Icons.Default.Groups, + ) + } else { + LazyColumn( + modifier = Modifier.padding(padding).readableContent().fillMaxSize() + .padding(MaterialTheme.spacing.screenMargin), + verticalArrangement = Arrangement.spacedBy(MaterialTheme.spacing.relatedGap), + ) { + item { + Text(stringResource(Res.string.choose_a_group_to_guard_it), style = MaterialTheme.typography.titleMedium) + } + items(state.groups, key = { it.room.chatRoom.id }) { choice -> + ListItem( + modifier = Modifier.clickable { viewModel.pick(choice.room.chatRoom.id) }.minimumInteractiveComponentSize(), + leadingContent = { Icon(Icons.Default.Groups, contentDescription = Decorative) }, + headlineContent = { + Text(choice.room.chatRoom.subject?.takeIf { it.isNotBlank() } ?: fallbackName, maxLines = 1, overflow = TextOverflow.Ellipsis) + }, + supportingContent = choice.refusal?.let { refusal -> { Text(refusalText(refusal)) } }, + ) + } + } + } + + is NewMemberWalletUIState.Chosen -> Column( + modifier = Modifier.padding(padding).readableContent().fillMaxSize() + .verticalScroll(rememberScrollState()) + .padding(MaterialTheme.spacing.screenMargin), + verticalArrangement = Arrangement.spacedBy(MaterialTheme.spacing.itemGap), + ) { + Icon(Icons.Default.AccountBalanceWallet, contentDescription = Decorative) + Text( + text = stringResource(Res.string.a_wallet_only_you_can_spend_from_guarded_by_s, chosenName), + style = MaterialTheme.typography.titleLarge, + ) + + state.reach?.let { reach -> Text(reachText(chosenName, reach), style = MaterialTheme.typography.bodyLarge) } + Text(stringResource(Res.string.members_of_those_groups_will_see_this_wallet), style = MaterialTheme.typography.bodyLarge) + Text( + stringResource(Res.string.if_you_lose_this_device_those_groups_can_still_move_your_coins), + style = MaterialTheme.typography.bodyMedium, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + + when (val refusal = state.refusal) { + null -> { + OutlinedTextField( + modifier = Modifier.fillMaxWidth(), + value = viewModel.label.value, + onValueChange = viewModel::setLabel, + label = { Text(stringResource(Res.string.label_optional)) }, + singleLine = true, + ) + Button( + onClick = { viewModel.ask(onAsked = { notify(asked); onNavigateBack() }, onFailure = { notify(couldNotAsk) }) }, + enabled = !viewModel.isActionPending.value, + ) { + Text(stringResource(Res.string.ask_s, chosenName)) + } + } + + MemberWalletManager.Refusal.KEY_UNKNOWN -> { + Text(refusalText(refusal), color = MaterialTheme.colorScheme.onSurfaceVariant) + if (state.askedForKey) { + Text(stringResource(Res.string.asked_for_the_group_s_key), color = MaterialTheme.colorScheme.onSurfaceVariant) + } else { + TextButton(onClick = viewModel::askForGroupKey) { Text(stringResource(Res.string.ask_the_group_for_its_key)) } + } + } + + else -> Text(refusalText(refusal), color = MaterialTheme.colorScheme.onSurfaceVariant) + } + } + } + } + } +} + +/** Who can take the member's coins: the group alone, the group and its parent, or the group and N above it. */ +@Composable +private fun reachText(groupName: String, reach: Int): String { + val delay = GuardianDerivation.ANCESTOR_DELAY.toInt() + return when (reach) { + 1 -> stringResource(Res.string.s_can_take_any_coin_without_asking_you, groupName, delay) + 2 -> stringResource(Res.string.s_and_the_group_above_it_can_take_any_coin_without_asking_you, groupName, delay) + else -> stringResource(Res.string.s_and_the_d_groups_above_it_can_take_any_coin_without_asking_you, groupName, reach - 1, delay) + } +} + +@Composable +private fun refusalText(refusal: MemberWalletManager.Refusal): String = stringResource( + when (refusal) { + MemberWalletManager.Refusal.CANNOT_SIGN -> Res.string.this_profile_cannot_sign_a_request + MemberWalletManager.Refusal.NOT_A_GROUP -> Res.string.only_a_group_can_guard_a_wallet + MemberWalletManager.Refusal.KEY_UNKNOWN -> Res.string.this_device_does_not_know_what_this_group_signs_with + MemberWalletManager.Refusal.GUARDIANS_UNREADABLE -> Res.string.this_group_s_guardian_keys_can_t_be_read_to_guard_a_wallet + MemberWalletManager.Refusal.NOT_ON_THIS_NETWORK -> Res.string.member_wallets_are_not_offered_on_this_network + MemberWalletManager.Refusal.CANNOT_WATCH -> Res.string.this_profile_cannot_watch_its_own_coins + } +) 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..a049a904 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 @@ -139,6 +139,9 @@ import kotlinx.coroutines.SupervisorJob import kotlinx.coroutines.launch import com.machankura.bennu.compose.ui.composable.navigation.routes.GroupWalletRoute import com.machankura.bennu.compose.ui.composable.navigation.routes.GroupWalletAddressesRoute +import com.machankura.bennu.compose.ui.composable.navigation.routes.NewMemberWalletRoute +import com.machankura.bennu.compose.ui.composable.NewMemberWalletScreen +import com.machankura.bennu.compose.database.repository.DatabaseMemberWalletRepository import com.machankura.bennu.compose.wallet.GroupOnchainWallets import com.machankura.bennu.compose.wallet.GroupTransactionWatcher import fr.acinq.phoenix.managers.NodeParamsManager @@ -208,6 +211,13 @@ fun BennuNavHost( ) } + val databaseMemberWalletRepository = remember { + DatabaseMemberWalletRepository( + database = auxDatabaseManager.auxDatabase, + activeIdentity = sovereignWalletViewModel.activeIdentity, + ) + } + val databaseMarmotRepository = remember { DatabaseMarmotRepository( database = auxDatabaseManager.auxDatabase, @@ -1146,6 +1156,20 @@ fun BennuNavHost( } ) } + composable { backStackEntry -> + val route = backStackEntry.toRoute() + + NewMemberWalletScreen( + activeUserPublicKey = route.activeUserPublicKey, + chatRoomId = route.chatRoomId, + chain = NodeParamsManager.chain, + canWatch = groupOnchainWallets != null, + memberWalletRepository = databaseMemberWalletRepository, + onNavigateBack = { + navController.popBackStack() + } + ) + } composable { backStackEntry -> val route = backStackEntry.toRoute() diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/navigation/routes/NewMemberWalletRoute.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/navigation/routes/NewMemberWalletRoute.kt new file mode 100644 index 00000000..8e1d9446 --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/navigation/routes/NewMemberWalletRoute.kt @@ -0,0 +1,14 @@ +package com.machankura.bennu.compose.ui.composable.navigation.routes + +import kotlinx.serialization.Serializable + +/** + * Asking a group to guard a wallet only the active member can spend from -- + * `docs/member-guarded-wallets.md`, Phase 6. With [chatRoomId] the group is + * already chosen; without it the screen offers the groups this profile is in. + */ +@Serializable +data class NewMemberWalletRoute( + val activeUserPublicKey: String, + val chatRoomId: String? = null, +): Route() diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/NewMemberWalletViewModel.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/NewMemberWalletViewModel.kt new file mode 100644 index 00000000..4996341b --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/NewMemberWalletViewModel.kt @@ -0,0 +1,124 @@ +package com.machankura.bennu.compose.ui.view.model + +import androidx.compose.runtime.MutableState +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.setValue +import androidx.lifecycle.ViewModel +import androidx.lifecycle.ViewModelProvider +import androidx.lifecycle.viewModelScope +import androidx.lifecycle.viewmodel.initializer +import androidx.lifecycle.viewmodel.viewModelFactory +import co.touchlab.kermit.Logger +import com.machankura.bennu.compose.managers.MemberWalletManager +import com.machankura.bennu.compose.repository.MemberWalletRepository +import com.machankura.bennu.compose.ui.view.state.GroupChoice +import com.machankura.bennu.compose.ui.view.state.NewMemberWalletUIState +import com.vitorpamplona.quartz.nip01Core.core.HexKey +import fr.acinq.bitcoin.Chain +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext + +/** + * Asking a group to guard a wallet only this member can spend from. + * + * The screen offers nothing that would be refused. Every refusal is read before + * the button is drawn and again inside `MemberWalletManager.request`, the way + * the subgroup picker refuses: the screen keeps a member out of a dead end, the + * manager keeps a bug out of the room. + * + * [canWatch] is whether this profile has an Electrum client: one without could + * not see its own coins, so it is not offered a wallet it cannot see (D3). + */ +class NewMemberWalletViewModel( + val activeUserPublicKey: HexKey, + private val chatRoomId: String?, + private val chain: Chain, + private val canWatch: Boolean, + initialUIState: NewMemberWalletUIState, + private val memberWalletRepository: MemberWalletRepository, +) : ViewModel() { + private val logger = Logger.withTag(TAG) + + var uiState: NewMemberWalletUIState by mutableStateOf(initialUIState) + private set + + val label: MutableState = mutableStateOf("") + + val isActionPending: MutableState = mutableStateOf(false) + + fun initiate() { + viewModelScope.launch(Dispatchers.IO) { + uiState = when (val chosen = chatRoomId) { + null -> NewMemberWalletUIState.Picking( + memberWalletRepository.groupsOf(activeUserPublicKey).map { GroupChoice(it, refusal(it.chatRoom.id)) } + ) + else -> choose(chosen) ?: NewMemberWalletUIState.Error("Couldn't find the group") + } + } + } + + fun pick(chatRoomId: String) { + viewModelScope.launch(Dispatchers.IO) { + uiState = choose(chatRoomId) ?: NewMemberWalletUIState.Error("Couldn't find the group") + } + } + + private suspend fun choose(chatRoomId: String): NewMemberWalletUIState.Chosen? { + val room = memberWalletRepository.groupsOf(activeUserPublicKey).firstOrNull { it.chatRoom.id == chatRoomId } ?: return null + return NewMemberWalletUIState.Chosen(room = room, refusal = refusal(chatRoomId), reach = memberWalletRepository.reachOf(chatRoomId)) + } + + private suspend fun refusal(chatRoomId: String): MemberWalletManager.Refusal? = + memberWalletRepository.refusal(chatRoomId, chain) + ?: if (!canWatch) MemberWalletManager.Refusal.CANNOT_WATCH else null + + fun askForGroupKey() { + val chosen = uiState as? NewMemberWalletUIState.Chosen ?: return + viewModelScope.launch(Dispatchers.IO) { + memberWalletRepository.askForGroupKey(chosen.room.chatRoom.id) + uiState = chosen.copy(askedForKey = true) + } + } + + fun setLabel(value: String) { + label.value = value.take(LABEL_LENGTH) + } + + /** Asks the chosen group; [onAsked] gets the group's name, [onFailure] runs when it could not. */ + fun ask(onAsked: () -> Unit, onFailure: () -> Unit) { + val chosen = uiState as? NewMemberWalletUIState.Chosen ?: return + if (chosen.refusal != null || isActionPending.value) return + isActionPending.value = true + viewModelScope.launch(Dispatchers.IO) { + val asked = runCatching { + memberWalletRepository.request(chosen.room.chatRoom.id, chain, label.value.takeIf { it.isNotBlank() }) + }.onFailure { logger.e("Couldn't ask ${chosen.room.chatRoom.id} to guard a wallet", it) }.isSuccess + withContext(Dispatchers.Main) { + isActionPending.value = false + if (asked) onAsked() else onFailure() + } + } + } + + companion object { + private const val TAG = "NewMemberWalletViewModel" + + /** The longest label a request carries -- `MemberWalletRequestEvent.MAX_LABEL_LENGTH`. */ + const val LABEL_LENGTH = 64 + + fun factory( + activeUserPublicKey: HexKey, + chatRoomId: String?, + chain: Chain, + canWatch: Boolean, + initialUIState: NewMemberWalletUIState = NewMemberWalletUIState.Loading, + memberWalletRepository: MemberWalletRepository, + ): ViewModelProvider.Factory = viewModelFactory { + initializer { + NewMemberWalletViewModel(activeUserPublicKey, chatRoomId, chain, canWatch, initialUIState, memberWalletRepository) + } + } + } +} diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/NewMemberWalletUIState.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/NewMemberWalletUIState.kt new file mode 100644 index 00000000..8f3d6eee --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/NewMemberWalletUIState.kt @@ -0,0 +1,31 @@ +package com.machankura.bennu.compose.ui.view.state + +import com.machankura.bennu.compose.database.model.intermdiate.LocalChatRoom +import com.machankura.bennu.compose.managers.MemberWalletManager + +sealed interface NewMemberWalletUIState { + data object Loading : NewMemberWalletUIState + + data class Error(val message: String) : NewMemberWalletUIState + + /** No group chosen yet: every group this profile is in, each with why it cannot guard a wallet, if it cannot. */ + data class Picking(val groups: List) : NewMemberWalletUIState + + /** + * A group chosen. [refusal] null means it can be asked, and [reach] is how + * many groups the wallet would be guarded by -- the group and every group + * above it whose key it passes down. + */ + data class Chosen( + val room: LocalChatRoom, + val refusal: MemberWalletManager.Refusal?, + val reach: Int?, + /** The member already asked the group for its key, and is waiting on an answer. */ + val askedForKey: Boolean = false, + ) : NewMemberWalletUIState +} + +data class GroupChoice( + val room: LocalChatRoom, + val refusal: MemberWalletManager.Refusal?, +) diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/wallet/GroupWalletRollout.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/wallet/GroupWalletRollout.kt index 3970edca..c3c519bd 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/wallet/GroupWalletRollout.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/wallet/GroupWalletRollout.kt @@ -43,4 +43,18 @@ object GroupWalletRollout { const val GUARDIANS_ON_MAINNET: Boolean = true fun offersGuardiansOn(chain: Chain): Boolean = GUARDIANS_ON_MAINNET || !chain.isMainnet() + + /** + * Whether a member is offered a guarded wallet of their own on mainnet -- + * `docs/member-guarded-wallets.md`, D8. Test networks are offered one from + * the start. Shut until a three-level hierarchy has watched one member's + * wallet on signet and its root has made a guardian spend from it: the + * member's own spend is the first single-signer path this app has. + * + * The entrances only. A device with it shut still accepts, shows and signs + * a certificate somebody else asked for. + */ + const val MEMBER_WALLETS_ON_MAINNET: Boolean = false + + fun offersMemberWalletsOn(chain: Chain): Boolean = MEMBER_WALLETS_ON_MAINNET || !chain.isMainnet() } diff --git a/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/GroupFixtures.kt b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/GroupFixtures.kt index bd23cc63..18e6b1db 100644 --- a/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/GroupFixtures.kt +++ b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/GroupFixtures.kt @@ -135,7 +135,13 @@ internal object GroupFixtures { * a signing session in. Built as a real room is -- the id derived from the * group's own key -- for the reason `SubgroupManagerJvmTest.parentWith` gives. */ - suspend fun signingRoom(db: BennuDatabase, material: KeyMaterial, members: List, subject: String = "#Ekklesia"): LocalChatRoom { + suspend fun signingRoom( + db: BennuDatabase, + material: KeyMaterial, + members: List, + subject: String = "#Ekklesia", + holdsShare: Boolean = true, + ): LocalChatRoom { val roomId = roomOf(material) (members + owner).forEach { seedProfile(db, it) } @@ -152,6 +158,8 @@ internal object GroupFixtures { ) db.participantDao().upsert((members + owner).map { Participant(participantPublicKey = it, chatRoomId = roomId, relayHint = null) }) + if (!holdsShare) return requireNotNull(db.chatRoomDao().findChatRoomById(roomId)) + val ceremonyId = "signing-" + roomId.take(8) db.dkgSessionDao().upsert( DkgSession( diff --git a/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/MemberWalletRequestJvmTest.kt b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/MemberWalletRequestJvmTest.kt new file mode 100644 index 00000000..881626e9 --- /dev/null +++ b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/MemberWalletRequestJvmTest.kt @@ -0,0 +1,162 @@ +package com.machankura.bennu.compose.managers + +import androidx.room3.Room +import com.machankura.bennu.compose.database.BennuDatabase +import com.machankura.bennu.compose.database.builder.getRoomDatabase +import com.machankura.bennu.compose.database.model.GroupSignedEvent +import com.machankura.bennu.compose.database.model.MarmotInnerEvent +import com.machankura.bennu.compose.managers.GroupFixtures.fileKeyState +import com.machankura.bennu.compose.managers.GroupFixtures.guardedCertificate +import com.machankura.bennu.compose.managers.GroupFixtures.keyMaterial +import com.machankura.bennu.compose.managers.GroupFixtures.roomOf +import com.machankura.bennu.compose.managers.GroupFixtures.signedAsRoom +import com.machankura.bennu.compose.managers.GroupFixtures.signingRoom +import com.machankura.bennu.compose.managers.GroupFixtures.thresholdKeyOf +import com.machankura.bennu.compose.managers.MemberWalletManager.Refusal +import com.machankura.bennu.compose.managers.MemberWalletManager.asEvent +import com.machankura.bennu.compose.nostr.wallet.GroupKeyNoticeEvent +import com.machankura.bennu.compose.nostr.wallet.MemberWalletCertificateEvent +import com.machankura.bennu.compose.nostr.wallet.MemberWalletRequestEvent +import com.vitorpamplona.quartz.nip01Core.core.Event +import fr.acinq.bitcoin.ByteVector32 +import fr.acinq.bitcoin.Chain +import fr.acinq.bitcoin.PrivateKey +import fr.acinq.secp256k1.Hex +import kotlinx.coroutines.runBlocking +import kotlin.test.AfterTest +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFailsWith +import kotlin.test.assertNotNull +import kotlin.test.assertNull +import kotlin.test.assertTrue +import kotlin.time.Instant + +/** + * A member asking a group to guard a wallet: the key stored before anything + * leaves the device, the request one every signer will accept, and each reason + * the screen gives for not asking. + */ +class MemberWalletRequestJvmTest { + private val db: BennuDatabase = getRoomDatabase(Room.inMemoryDatabaseBuilder()) + + @AfterTest + fun closeDb() = db.close() + + private val chain = Chain.Regtest + + private fun privateKey(seed: Long): PrivateKey = PrivateKey(ByteVector32(Hex.decode(seed.toString(16).padStart(64, '0')))) + + private val parent = keyMaterial("9a9e") + private val group = keyMaterial("6a0b") + private val groupRoom = roomOf(group) + + private val member = privateKey(0x3e3be7) + private val memberPublicKey = member.xOnlyPublicKey().value.toHex() + + /** The group as a member who holds no share sees it: a Marmot room, and nothing to sign with. */ + private suspend fun asMember(knowsKey: Boolean = true) { + signingRoom(db, group, members = listOf(memberPublicKey), holdsShare = false) + if (knowsKey) fileKeyState(db, group, guardedCertificate(parent, group)) + } + + private suspend fun requestsSent(): List = + db.marmotInnerEventDao().getByChatRoomAndKinds(groupRoom, listOf(MemberWalletRequestEvent.KIND)) + .mapNotNull { MemberWalletRequestEvent.carried(it.asEvent()) } + + @Test + fun `the key is stored and the request one every signer will accept`(): Unit = runBlocking { + asMember() + val wallet = MemberWalletManager.request(db, groupRoom, member, chain, label = "Savings") + + assertEquals(wallet, db.memberWalletDao().getById(wallet.walletId)) + assertEquals(memberPublicKey, wallet.ownerPublicKey) + assertEquals(groupRoom, wallet.guardingChatRoomId) + assertEquals("Savings", wallet.label) + assertEquals(wallet.walletId, MemberWalletDerivation.walletId(PrivateKey.fromHex(wallet.walletPrivateKey).publicKey())) + + val sent = requestsSent().single() + val verified = assertNotNull(MemberWalletRequestEvent.verified(sent)) + assertEquals(wallet.walletId, verified.reading.walletId) + assertEquals(SubgroupManager.grantFor(db, groupRoom, thresholdKeyOf(group), wallet.walletId), verified.reading.guardians) + assertEquals(2, verified.reading.guardians.size, "the group, and its parent one step further") + + // Exactly what a signer's device will be shown, and it is signable. + val template = MemberWalletCertificateEvent.template(sent) + val proposed = Event(MemberWalletManager.certificateIdFor(groupRoom, sent), groupRoom, template.createdAt, template.kind, template.tags, template.content, "") + assertNull(MemberWalletManager.refuseCertificate(db, groupRoom, thresholdKeyOf(group), proposed)) + + assertTrue(db.frostSigningSessionDao().getSessionsForChatRoom(groupRoom).isEmpty(), "a member without a share waits for a signer") + assertEquals(listOf(wallet.walletId), MemberWalletManager.awaitingSponsor(db, groupRoom).map { it.reading.walletId }) + } + + @Test + fun `two requests are two keys`(): Unit = runBlocking { + asMember() + val first = MemberWalletManager.request(db, groupRoom, member, chain, label = null) + val second = MemberWalletManager.request(db, groupRoom, member, chain, label = null) + assertTrue(first.walletId != second.walletId) + assertTrue(first.walletPrivateKey != second.walletPrivateKey) + } + + @Test + fun `a member who holds a share puts it to the group at once`(): Unit = runBlocking { + // A share-holding member: one of the ceremony's participants on this device. + signingRoom(db, group, members = listOf(memberPublicKey)) + fileKeyState(db, group, guardedCertificate(parent, group)) + + val wallet = MemberWalletManager.request(db, groupRoom, member, chain, label = null) + + val session = assertNotNull(MemberWalletManager.openSessionFor(db, groupRoom, Event.fromJson(wallet.requestJson))) + assertNotNull(session.signApprovedAt, "proposing is approving") + assertTrue(MemberWalletManager.awaitingSponsor(db, groupRoom).isEmpty()) + } + + @Test + fun `each refusal holds`(): Unit = runBlocking { + assertEquals(Refusal.CANNOT_SIGN, MemberWalletManager.refusal(db, groupRoom, canSign = false, chain)) + assertEquals(Refusal.NOT_A_GROUP, MemberWalletManager.refusal(db, groupRoom, canSign = true, chain)) + + GroupFixtures.seedRoom(db, groupRoom) + assertEquals(Refusal.NOT_A_GROUP, MemberWalletManager.refusal(db, groupRoom, canSign = true, chain), "a room with no MLS state") + + db.chatRoomDao().delete(db.chatRoomDao().findChatRoomById(groupRoom)!!.chatRoom) + asMember(knowsKey = false) + assertEquals(Refusal.KEY_UNKNOWN, MemberWalletManager.refusal(db, groupRoom, canSign = true, chain)) + assertFailsWith { MemberWalletManager.request(db, groupRoom, member, chain, label = null) } + assertTrue(db.memberWalletDao().getByOwner(memberPublicKey).isEmpty(), "a refused request makes no key") + + assertEquals(Refusal.NOT_ON_THIS_NETWORK, MemberWalletManager.refusal(db, groupRoom, canSign = true, Chain.Mainnet)) + } + + @Test + fun `a member with no key state can ask once an answer is in the room`(): Unit = runBlocking { + asMember(knowsKey = false) + val answer = GroupKeyNoticeEvent.GroupKey(groupRoom, thresholdKeyOf(group), guardedCertificate(parent, group)) + val tags = GroupKeyNoticeEvent.answeringTags("e".repeat(64), answer, GroupFixtures.path) + db.marmotInnerEventDao().upsert( + MarmotInnerEvent(id = "f".repeat(64), publicKey = "5".repeat(64), kind = GroupKeyNoticeEvent.KIND, createdAt = Instant.fromEpochSeconds(1_700_000_000), tags = tags, content = answer.thresholdPublicKey, chatRoomId = groupRoom) + ) + + assertNull(MemberWalletManager.refusal(db, groupRoom, canSign = true, chain)) + assertEquals(2, MemberWalletManager.reachOf(db, groupRoom)) + val wallet = MemberWalletManager.request(db, groupRoom, member, chain, label = null) + assertNotNull(MemberWalletRequestEvent.verified(Event.fromJson(wallet.requestJson))) + } + + @Test + fun `a key is discarded only before a group guards its wallet`(): Unit = runBlocking { + asMember() + val unasked = MemberWalletManager.request(db, groupRoom, member, chain, label = null) + MemberWalletManager.discard(db, unasked.walletId) + assertNull(db.memberWalletDao().getById(unasked.walletId)) + + val guarded = MemberWalletManager.request(db, groupRoom, member, chain, label = null) + val template = MemberWalletCertificateEvent.template(Event.fromJson(guarded.requestJson)) + val signed = signedAsRoom(group, template.kind, template.tags, template.content, template.createdAt) + db.groupSignedEventDao().upsert(GroupSignedEvent.fromEvent(signed, chatRoomId = groupRoom, derivationPath = SharedKeyDerivation.formatPath(GroupFixtures.path), frostSigningSessionId = null)) + + assertFailsWith { MemberWalletManager.discard(db, guarded.walletId) } + assertNotNull(db.memberWalletDao().getById(guarded.walletId)) + } +} From 467965b81a93dccd8ddbe2230184cbf950e62e37 Mon Sep 17 00:00:00 2001 From: Kgothatso Ngako Date: Sat, 24 Oct 2026 07:42:21 +0200 Subject: [PATCH 14/21] feat(wallet): Fund beside Spend on every guarded wallet, in a card that keeps the name (Phase 5) Each guarded wallet on an ancestor's wallet screen becomes an outlined card: the name (now up to two lines) and what is within reach, then Fund and Spend in a flow row under them rather than in the list item's trailing slot, each naming its wallet to a screen reader. Fund is offered only where the room has a wallet of its own and can sign and watch. The supporting line adds what is arriving -- coins not yet past the leaf's lock -- so a funding does not look lost for two hours. The send form's destination card names the wallet once, under "To", instead of repeating the title. Co-Authored-By: Claude Opus 5.5 --- .../composeResources/values/strings.xml | 3 + .../compose/ui/composable/GroupSendScreen.kt | 3 +- .../ui/composable/GroupWalletScreen.kt | 104 +++++++++-- .../ui/view/state/GroupWalletUIState.kt | 12 ++ .../ui/view/state/GuardedWalletRowTest.kt | 80 +++++++++ .../ui/composable/GroupSendScreenJvmTest.kt | 41 ++++- .../ui/composable/GuardedWalletCardJvmTest.kt | 167 ++++++++++++++++++ 7 files changed, 390 insertions(+), 20 deletions(-) create mode 100644 composeApp/src/commonTest/kotlin/com/machankura/bennu/compose/ui/view/state/GuardedWalletRowTest.kt create mode 100644 composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/ui/composable/GuardedWalletCardJvmTest.kt diff --git a/composeApp/src/commonMain/composeResources/values/strings.xml b/composeApp/src/commonMain/composeResources/values/strings.xml index 449eecf8..15583caf 100644 --- a/composeApp/src/commonMain/composeResources/values/strings.xml +++ b/composeApp/src/commonMain/composeResources/values/strings.xml @@ -473,8 +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 Fund %1$s's guarded wallet + %1$s sats arriving To + %1$s's guarded wallet 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. 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 d089fed7..fdea3ee7 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 @@ -9,6 +9,7 @@ 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.s_s_guarded_wallet 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 @@ -320,7 +321,7 @@ private fun FundingDestination(funding: FundingTarget) { 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) + Text(text = stringResource(Res.string.s_s_guarded_wallet, name), style = MaterialTheme.typography.titleMedium) val address = funding.address when { address != null -> { diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/GroupWalletScreen.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/GroupWalletScreen.kt index 65b06227..aae6c5be 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/GroupWalletScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/GroupWalletScreen.kt @@ -4,6 +4,14 @@ import bennu.composeapp.generated.resources.the_group_above_decided_this_wallet_ import bennu.composeapp.generated.resources.the_group_above_decided_this_wallet_is_guarded import com.machankura.bennu.compose.nostr.subgroup.WalletPolicyReading import com.machankura.bennu.compose.nostr.subgroup.SubgroupWalletPolicy +import androidx.compose.foundation.layout.FlowRow +import androidx.compose.material3.OutlinedCard +import androidx.compose.ui.semantics.contentDescription +import androidx.compose.ui.semantics.semantics +import bennu.composeapp.generated.resources.fund +import bennu.composeapp.generated.resources.fund_s_s_guarded_wallet +import bennu.composeapp.generated.resources.s_sats_arriving +import bennu.composeapp.generated.resources.spend_from_s_s_guarded_wallet import androidx.compose.foundation.layout.Row import com.machankura.bennu.compose.text.ProposedSpend import com.machankura.bennu.compose.ui.view.state.SpendRow @@ -197,6 +205,18 @@ fun GroupWalletScreen( ) ) } + // Behind the room's own send's gates, since a funding is one: a share to + // propose with, and a node to see this group's coins with. + val toGuardianFund = { row: GuardedWalletRow -> + onNavigateToRoute( + GroupSendRoute( + activeUserPublicKey = activeUserPublicKey, + chatRoomId = chatRoomId, + relayHint = null, + fundChatRoomId = row.wallet.descendantChatRoomId, + ) + ) + } val onShare = { shareable: GuardianManager.Shareable -> groupWalletViewModel.share(shareable, onShared = { notify(shared) }, onFailure = { notify(couldNotShare) }) } @@ -297,6 +317,8 @@ fun GroupWalletScreen( isPending = groupWalletViewModel.isActionPending.value, onShare = onShare, onSpend = if (state.canSign && wallets != null) toGuardianSpend else null, + // A group with no wallet of its own has nothing to fund with. + onFund = null, ) } } @@ -340,6 +362,7 @@ fun GroupWalletScreen( isPending = groupWalletViewModel.isActionPending.value, onShare = onShare, onSpend = if (state.canSign && state.canWatch) toGuardianSpend else null, + onFund = if (state.canSign && state.canWatch) toGuardianFund else null, ) } } @@ -440,6 +463,7 @@ private fun OpenWallet( isPending: Boolean, onShare: (GuardianManager.Shareable) -> Unit, onSpend: ((GuardedWalletRow) -> Unit)?, + onFund: ((GuardedWalletRow) -> Unit)?, ) { val clipboardManager = LocalClipboardManager.current val addressCopied = stringResource(Res.string.address_copied) @@ -605,6 +629,7 @@ private fun OpenWallet( isPending = isPending, onShare = onShare, onSpend = onSpend, + onFund = onFund, ) } } @@ -662,6 +687,7 @@ private fun LazyListScope.guardianItems( isPending: Boolean, onShare: (GuardianManager.Shareable) -> Unit, onSpend: ((GuardedWalletRow) -> Unit)?, + onFund: ((GuardedWalletRow) -> Unit)?, ) { if (guardedWallets.isNotEmpty()) { item { @@ -675,23 +701,7 @@ private fun LazyListScope.guardianItems( ) } items(guardedWallets, key = { "guarded-" + it.wallet.statement.id }) { row -> - ListItem( - leadingContent = { Icon(Icons.Default.AccountBalanceWallet, contentDescription = Decorative) }, - headlineContent = { Text(row.wallet.name ?: stringResource(Res.string.a_subgroup), maxLines = 1, overflow = TextOverflow.Ellipsis) }, - supportingContent = { - Text( - row.withinReach?.let { stringResource(Res.string.s_sats_within_this_group_s_reach, it.grouped()) } - ?: stringResource(Res.string.balance_not_known_yet) - ) - }, - trailingContent = onSpend?.let { spend -> - { - TextButton(onClick = { spend(row) }) { - Text(stringResource(Res.string.spend)) - } - } - }, - ) + GuardedWalletCard(row = row, onSpend = onSpend, onFund = onFund) } } @@ -713,6 +723,66 @@ private fun LazyListScope.guardianItems( } } +/** + * One descendant's guarded wallet: its name and what is within reach, and under + * them the actions, in the card's own row rather than the list item's trailing + * slot. Two buttons there would leave the name -- the one thing that says which + * wallet this is -- a few characters at large text sizes, and a flow row wraps + * them instead. Each button names its wallet, since a screen reader hears every + * row's *Fund* and *Spend* alike. See `docs/guarded-wallet-funding.md`, Phase 5. + */ +@Composable +private fun GuardedWalletCard( + row: GuardedWalletRow, + onSpend: ((GuardedWalletRow) -> Unit)?, + onFund: ((GuardedWalletRow) -> Unit)?, +) { + val name = row.wallet.name ?: stringResource(Res.string.a_subgroup) + OutlinedCard(modifier = Modifier.fillMaxWidth()) { + ListItem( + leadingContent = { Icon(Icons.Default.AccountBalanceWallet, contentDescription = Decorative) }, + // Two lines, since the name is what says which wallet the buttons act on. + headlineContent = { Text(name, maxLines = 2, overflow = TextOverflow.Ellipsis) }, + supportingContent = { + val reach = row.withinReach?.let { stringResource(Res.string.s_sats_within_this_group_s_reach, it.grouped()) } + val arriving = row.arriving?.takeIf { it.sat > 0 }?.let { stringResource(Res.string.s_sats_arriving, it.grouped()) } + Text( + when { + reach == null -> stringResource(Res.string.balance_not_known_yet) + arriving == null -> reach + else -> stringResource(Res.string.s_dot_s, reach, arriving) + } + ) + }, + ) + if (onFund != null || onSpend != null) { + val fundLabel = stringResource(Res.string.fund_s_s_guarded_wallet, name) + val spendLabel = stringResource(Res.string.spend_from_s_s_guarded_wallet, name) + FlowRow( + modifier = Modifier.fillMaxWidth().padding( + start = MaterialTheme.spacing.containerPadding, + end = MaterialTheme.spacing.containerPadding, + bottom = MaterialTheme.spacing.compactPadding, + ), + horizontalArrangement = Arrangement.spacedBy(MaterialTheme.spacing.targetGap, Alignment.End), + ) { + // Money in before money out, at equal weight: neither is the one + // every member wants, and a filled button would say it was. + onFund?.let { fund -> + TextButton(onClick = { fund(row) }, modifier = Modifier.semantics { contentDescription = fundLabel }) { + Text(stringResource(Res.string.fund)) + } + } + onSpend?.let { spend -> + TextButton(onClick = { spend(row) }, modifier = Modifier.semantics { contentDescription = spendLabel }) { + Text(stringResource(Res.string.spend)) + } + } + } + } + } +} + @Composable private fun BalanceCard(walletState: GroupWalletState?) { Card(modifier = Modifier.fillMaxWidth()) { diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/GroupWalletUIState.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/GroupWalletUIState.kt index baf38de0..1ed598cf 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/GroupWalletUIState.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/GroupWalletUIState.kt @@ -88,6 +88,18 @@ data class GuardedWalletRow( get() = walletState?.let { state -> state.utxos.filter { state.confirmations(it) >= GuardianDerivation.ANCESTOR_DELAY }.map { it.amount }.sum() } + + /** + * Coins in the wallet not yet within reach: in the mempool, or confirmed + * less deeply than the leaf's lock. What a funding looks like for the two + * hours after it lands -- without it, [withinReach] would make the money + * look gone. Every such coin, whoever paid it, which is all this group can + * know. Null while the chain is not known. + */ + val arriving: Satoshi? + get() = walletState?.let { state -> + state.utxos.filter { state.confirmations(it) < GuardianDerivation.ANCESTOR_DELAY }.map { it.amount }.sum() + } } /** Where one of the room's spends has got to, as one fact a member reads. */ diff --git a/composeApp/src/commonTest/kotlin/com/machankura/bennu/compose/ui/view/state/GuardedWalletRowTest.kt b/composeApp/src/commonTest/kotlin/com/machankura/bennu/compose/ui/view/state/GuardedWalletRowTest.kt new file mode 100644 index 00000000..0136d3eb --- /dev/null +++ b/composeApp/src/commonTest/kotlin/com/machankura/bennu/compose/ui/view/state/GuardedWalletRowTest.kt @@ -0,0 +1,80 @@ +package com.machankura.bennu.compose.ui.view.state + +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.nostr.wallet.GroupWalletStatementEvent +import com.machankura.bennu.compose.wallet.GroupWalletState +import com.vitorpamplona.quartz.nip01Core.core.Event +import fr.acinq.bitcoin.ByteVector +import fr.acinq.bitcoin.ByteVector32 +import fr.acinq.bitcoin.Chain +import fr.acinq.bitcoin.OutPoint +import fr.acinq.bitcoin.PrivateKey +import fr.acinq.bitcoin.Satoshi +import fr.acinq.bitcoin.Transaction +import fr.acinq.bitcoin.TxId +import fr.acinq.bitcoin.TxIn +import fr.acinq.bitcoin.TxOut +import fr.acinq.lightning.blockchain.electrum.WalletState +import fr.acinq.secp256k1.Hex +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertNull + +/** + * What an ancestor's wallet screen says about a descendant's guarded wallet: a + * funding is *arriving* until the leaf's lock lets it go, and then *within + * reach* -- never neither, which would make the money look gone. + */ +class GuardedWalletRowTest { + private val descendantRoomId = "c".repeat(64) + private val account = GroupWalletDerivation.account( + PrivateKey(ByteVector32(Hex.decode("decaf".padStart(64, '0')))).publicKey().toString(), Chain.Regtest, + ) + private val wallet = GuardianManager.GuardedWallet( + ancestorChatRoomId = "d".repeat(64), + descendantChatRoomId = descendantRoomId, + statement = Event("1".repeat(64), descendantRoomId, 1_700_000_000, GroupWalletStatementEvent.KIND, emptyArray(), "", ""), + account = account, + certificate = Event("2".repeat(64), "d".repeat(64), 1_700_000_000, 0, emptyArray(), "", ""), + lineage = listOf(descendantRoomId), + ) + + /** One coin of 50,000 sats at the first receive address, confirmed at [height] (0 in the mempool), with the tip at [tip]. */ + private fun holding(height: Long, tip: Int): GroupWalletState { + val derived = GroupWalletDerivation.derive(account, GroupWalletDerivation.RECEIVE, 0) + val tx = Transaction(2, listOf(TxIn(OutPoint(TxId(ByteVector32(ByteArray(32) { 7 })), 0), ByteVector.empty, 0xffffffffL)), listOf(TxOut(Satoshi(50_000), derived.pubkeyScript)), 0) + val meta = WalletState.AddressMeta.Derived(0) + return GroupWalletState( + account, + WalletState(mapOf(derived.address(Chain.Regtest) to WalletState.AddressState(meta, true, listOf(WalletState.Utxo(tx.txid, 0, height, tx, meta))))), + WalletState.empty, + tipHeight = tip, + ) + } + + @Test + fun `a coin is arriving until the lock lets it go, then within reach`() { + val lock = GuardianDerivation.ANCESTOR_DELAY.toInt() + + val mempool = GuardedWalletRow(wallet, holding(height = 0, tip = 100)) + assertEquals(Satoshi(50_000), mempool.arriving) + assertEquals(Satoshi(0), mempool.withinReach) + + val young = GuardedWalletRow(wallet, holding(height = 100, tip = 100 + lock - 2)) + assertEquals(Satoshi(50_000), young.arriving, "${lock - 1} confirmations") + assertEquals(Satoshi(0), young.withinReach) + + val old = GuardedWalletRow(wallet, holding(height = 100, tip = 100 + lock - 1)) + assertEquals(Satoshi(0), old.arriving, "$lock confirmations") + assertEquals(Satoshi(50_000), old.withinReach) + } + + @Test + fun `nothing is said before the chain is known`() { + val row = GuardedWalletRow(wallet, walletState = null) + assertNull(row.arriving) + assertNull(row.withinReach) + } +} diff --git a/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/ui/composable/GroupSendScreenJvmTest.kt b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/ui/composable/GroupSendScreenJvmTest.kt index 197071e3..4d54fd35 100644 --- a/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/ui/composable/GroupSendScreenJvmTest.kt +++ b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/ui/composable/GroupSendScreenJvmTest.kt @@ -19,6 +19,9 @@ import com.machankura.bennu.compose.database.model.ChatRoom import com.machankura.bennu.compose.database.model.GroupSignedEvent 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 @@ -106,6 +109,40 @@ class GroupSendScreenJvmTest { onNodeWithText("Ask the group to send").assertIsNotEnabled() } + @Test + fun `funding a guarded wallet names it, shows where it pays, and takes no address`() = render(Chain.Regtest, funded = true) { + onNodeWithText("Fund Savings's guarded wallet").assertIsDisplayed() + onNodeWithText("Savings's guarded wallet").assertIsDisplayed() + onNodeWithText("Address").assertDoesNotExist() + onNodeWithText("Address 2").assertIsDisplayed() + onNodeWithText("This group can spend these coins again once they have 12 confirmations.").assertIsDisplayed() + + onNodeWithText("Fee rate in sats per byte").performTextInput("4") + onNodeWithText("Amount in sats").performTextInput("40000") + onNodeWithText("Sends 40,000 sats to Savings's guarded wallet", substring = true).assertIsDisplayed() + onNodeWithText("Ask the group to send").assertIsEnabled() + } + + private fun funding(chain: Chain): FundingTarget { + val descendantRoomId = "c".repeat(64) + val descendant = GroupWalletDerivation.account( + PrivateKey(ByteVector32(Hex.decode("decaf".padStart(64, '0')))).publicKey().toString(), chain, + ) + 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), + ) + val receive = (0 until 10).associate { index -> + GroupWalletDerivation.derive(descendant, GroupWalletDerivation.RECEIVE, index.toLong()).address(chain) to + WalletState.AddressState(WalletState.AddressMeta.Derived(index), alreadyUsed = false, utxos = emptyList()) + } + return FundingTarget(guarded, GroupWalletState(descendant, WalletState(receive), WalletState.empty, tipHeight = 110)) + } + private fun ComposeUiTest.fill(address: String, amount: String) { onNodeWithText("Address").performTextInput(address) onNodeWithText("Fee rate in sats per byte").performTextInput("4") @@ -146,7 +183,7 @@ class GroupSendScreenJvmTest { return GroupSendUIState.Ready(room, wallet, walletState, reserved = emptySet()) } - private fun render(chain: Chain, assertions: ComposeUiTest.() -> Unit) = + private fun render(chain: Chain, funded: Boolean = false, assertions: ComposeUiTest.() -> Unit) = runDesktopComposeUiTest(width = 400, height = 1200) { setContent { BennuTheme { @@ -156,7 +193,7 @@ class GroupSendScreenJvmTest { activeUserPublicKey = "a".repeat(64), chatRoomId = chatRoomId, chain = chain, - initialGroupSendUIState = ready(chain), + initialGroupSendUIState = ready(chain).let { if (funded) it.copy(funding = funding(chain)) else it }, chatRepository = ChatRepository.NO_OP_CHAT_REPOSITORY, frostSigningRepository = FrostSigningRepository.NO_OP_FROST_SIGNING_REPOSITORY, wallets = null, diff --git a/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/ui/composable/GuardedWalletCardJvmTest.kt b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/ui/composable/GuardedWalletCardJvmTest.kt new file mode 100644 index 00000000..58831b5b --- /dev/null +++ b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/ui/composable/GuardedWalletCardJvmTest.kt @@ -0,0 +1,167 @@ +package com.machankura.bennu.compose.ui.composable + +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.runtime.CompositionLocalProvider +import androidx.compose.ui.Modifier +import androidx.compose.ui.platform.LocalDensity +import androidx.compose.ui.test.ComposeUiTest +import androidx.compose.ui.test.ExperimentalTestApi +import androidx.compose.ui.test.assertIsDisplayed +import androidx.compose.ui.test.onNodeWithContentDescription +import androidx.compose.ui.test.onNodeWithText +import androidx.compose.ui.test.performClick +import androidx.compose.ui.test.runDesktopComposeUiTest +import androidx.compose.ui.unit.Density +import com.machankura.bennu.compose.database.model.ChatRoom +import com.machankura.bennu.compose.database.model.GroupSignedEvent +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.nostr.wallet.GroupWallet +import com.machankura.bennu.compose.nostr.wallet.GroupWalletStatementEvent +import com.machankura.bennu.compose.repository.ChatRepository +import com.machankura.bennu.compose.repository.FrostSigningRepository +import com.machankura.bennu.compose.ui.composable.navigation.routes.GroupSendRoute +import com.machankura.bennu.compose.ui.composable.navigation.routes.Route +import com.machankura.bennu.compose.ui.composable.widgets.ProvideSnackbarHost +import com.machankura.bennu.compose.ui.theme.BennuTheme +import com.machankura.bennu.compose.ui.view.state.GroupWalletUIState +import com.machankura.bennu.compose.ui.view.state.GuardedWalletRow +import com.machankura.bennu.compose.wallet.GroupWalletState +import com.vitorpamplona.quartz.nip01Core.core.Event +import fr.acinq.bitcoin.ByteVector +import fr.acinq.bitcoin.ByteVector32 +import fr.acinq.bitcoin.Chain +import fr.acinq.bitcoin.OutPoint +import fr.acinq.bitcoin.PrivateKey +import fr.acinq.bitcoin.Satoshi +import fr.acinq.bitcoin.Transaction +import fr.acinq.bitcoin.TxId +import fr.acinq.bitcoin.TxIn +import fr.acinq.bitcoin.TxOut +import fr.acinq.lightning.blockchain.electrum.WalletState +import fr.acinq.secp256k1.Hex +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.time.Instant + +/** + * A descendant's guarded wallet on an ancestor's wallet screen: a card whose + * actions sit under the name rather than squeezing it, each one telling a + * screen reader which wallet it acts on. `docs/guarded-wallet-funding.md`, Phase 5. + */ +@OptIn(ExperimentalTestApi::class) +class GuardedWalletCardJvmTest { + private val chatRoomId = "d4c3b2a1".repeat(8) + private val descendantRoomId = "c".repeat(64) + + private fun account(seed: String) = GroupWalletDerivation.account( + PrivateKey(ByteVector32(Hex.decode(seed.padStart(64, '0')))).publicKey().toString(), Chain.Regtest, + ) + + private fun holding(account: GroupWalletDerivation.Account, sats: Long, height: Long, tip: Int): GroupWalletState { + val derived = GroupWalletDerivation.derive(account, GroupWalletDerivation.RECEIVE, 0) + val next = GroupWalletDerivation.derive(account, GroupWalletDerivation.RECEIVE, 1) + val tx = Transaction(2, listOf(TxIn(OutPoint(TxId(ByteVector32(ByteArray(32) { 3 })), 0), ByteVector.empty, 0xffffffffL)), listOf(TxOut(Satoshi(sats), derived.pubkeyScript)), 0) + val meta = WalletState.AddressMeta.Derived(0) + return GroupWalletState( + account, + WalletState(mapOf( + derived.address(Chain.Regtest) to WalletState.AddressState(meta, true, listOf(WalletState.Utxo(tx.txid, 0, height, tx, meta))), + next.address(Chain.Regtest) to WalletState.AddressState(WalletState.AddressMeta.Derived(1), false, emptyList()), + )), + WalletState.empty, + tipHeight = tip, + ) + } + + private fun loaded(name: String): GroupWalletUIState.Loaded { + val own = account("1c0ffee") + val descendant = account("decaf") + 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", name)), "", ""), + lineage = listOf(descendantRoomId), + ) + val wallet = GroupWallet( + GroupSignedEvent( + id = "e".repeat(64), chatRoomId = chatRoomId, publicKey = chatRoomId, kind = GroupWalletStatementEvent.KIND, + tags = GroupWalletStatementEvent.template(own).tags, content = own.xpub, signature = "f".repeat(128), + createdAt = Instant.fromEpochSeconds(1_700_000_000), + ), + own, + ) + val room = LocalChatRoom(ChatRoom(id = chatRoomId, userPublicKey = "a".repeat(64), subject = "Treasury", description = null, initialGiftWrapPayloadId = "p", mlsGroupState = "state")) + return GroupWalletUIState.Loaded( + localChatRoom = room, + wallet = wallet, + walletState = holding(own, 100_000, height = 100, tip = 200), + canWatch = true, + canSign = true, + guardedWallets = listOf(GuardedWalletRow(guarded, holding(descendant, 50_000, height = 0, tip = 200))), + ) + } + + private fun render(state: GroupWalletUIState, fontScale: Float = 1f, width: Int = 400, onRoute: (Route) -> Unit = {}, assertions: ComposeUiTest.() -> Unit) = + runDesktopComposeUiTest(width = width, height = 2400) { + setContent { + BennuTheme { + ProvideSnackbarHost { + CompositionLocalProvider(LocalDensity provides Density(LocalDensity.current.density, fontScale)) { + Box(modifier = Modifier.fillMaxSize()) { + GroupWalletScreen( + activeUserPublicKey = "a".repeat(64), + chatRoomId = chatRoomId, + chain = Chain.Regtest, + initialGroupWalletUIState = state, + chatRepository = ChatRepository.NO_OP_CHAT_REPOSITORY, + frostSigningRepository = FrostSigningRepository.NO_OP_FROST_SIGNING_REPOSITORY, + wallets = null, + onNavigateToRoute = onRoute, + onNavigateBack = {}, + ) + } + } + } + } + } + assertions() + } + + @Test + fun `each guarded wallet offers fund beside spend, each naming its wallet`() = render(loaded("Savings")) { + onNodeWithText("Savings").assertIsDisplayed() + onNodeWithText("0 sats within this group's reach · 50,000 sats arriving").assertIsDisplayed() + onNodeWithContentDescription("Fund Savings's guarded wallet").assertIsDisplayed() + onNodeWithContentDescription("Spend from Savings's guarded wallet").assertIsDisplayed() + } + + @Test + fun `fund opens the send form paying the descendant, from the room's own wallet`() { + var opened: Route? = null + render(loaded("Savings"), onRoute = { opened = it }) { + onNodeWithContentDescription("Fund Savings's guarded wallet").performClick() + } + assertEquals( + GroupSendRoute(activeUserPublicKey = "a".repeat(64), chatRoomId = chatRoomId, relayHint = null, fundChatRoomId = descendantRoomId), + opened, + ) + } + + @Test + fun `a device that cannot sign is offered neither`() = render(loaded("Savings").copy(canSign = false)) { + onNodeWithText("Savings").assertIsDisplayed() + onNodeWithText("Fund").assertDoesNotExist() + onNodeWithText("Spend").assertDoesNotExist() + } + + @Test + fun `at twice the text size the buttons stay whole`() = render(loaded("Savings"), fontScale = 2f) { + onNodeWithContentDescription("Fund Savings's guarded wallet").assertIsDisplayed() + onNodeWithContentDescription("Spend from Savings's guarded wallet").assertIsDisplayed() + } +} From b5f0709c3f79c6b5ce3e80ab363b9cede87865ce Mon Sep 17 00:00:00 2001 From: Kgothatso Ngako Date: Sat, 24 Oct 2026 07:42:59 +0200 Subject: [PATCH 15/21] docs: funding a guarded wallet is built, and the notes it touched say so (Phase 6) Co-Authored-By: Claude Opus 5.5 --- docs/README.md | 5 +++-- docs/group-wallet-addresses.md | 4 +++- docs/group-wallet-guardians.md | 3 ++- docs/guarded-wallet-funding.md | 23 +++++++++++++++++++++-- 4 files changed, 29 insertions(+), 6 deletions(-) diff --git a/docs/README.md b/docs/README.md index 192e7ccf..c7fcf62c 100644 --- a/docs/README.md +++ b/docs/README.md @@ -58,10 +58,11 @@ The subgroup-wallet-policy note is a phased plan that has been built. It reads as the guardians note's *whose choice it is* reversed: read that section, then this note's Phase 0, whose five decisions shape every phase after it, and its table of where the build chose differently before the code. -The guarded-wallet-funding note is a phased plan that has not been built. It +The guarded-wallet-funding note is a phased plan that has been built. It reads as the guardians note run the other way, coins in rather than out: read that note and the address note's *Why `+ 2`* first, then its seven decisions -before its phases. +before its phases, and its table of where the build chose differently before +the code. The Material Design note is a phased plan that has not been built, and is the only one about what the app looks like rather than what it does; read the jvm-target note first if you want to know why its adaptive-layout phase exists. diff --git a/docs/group-wallet-addresses.md b/docs/group-wallet-addresses.md index 44f4e207..2ff4b332 100644 --- a/docs/group-wallet-addresses.md +++ b/docs/group-wallet-addresses.md @@ -90,7 +90,9 @@ wallet to two payers in the same hour hand out the same address, and the group reuses it. Offering `current + 1` and `current + 2` beside it gives a second and third member something else to hand out. Both are already watched, because the look-ahead keeps the wallet subscribed to `current … current + 9`, so a payment -to either is seen the moment it reaches the mempool. +to either is seen the moment it reaches the mempool. An ancestor funding a +guarded wallet starts at the top of that window, `current + 2`, and goes up, so +it stays out of the members' way -- [guarded-wallet-funding.md](./guarded-wallet-funding.md), D2. **Why `highest used`.** `firstUnusedDerivedAddress` takes the *lowest* unused index, so a payment above `current` does not move `current`. If `/0/3` is diff --git a/docs/group-wallet-guardians.md b/docs/group-wallet-guardians.md index 074c1126..651b104b 100644 --- a/docs/group-wallet-guardians.md +++ b/docs/group-wallet-guardians.md @@ -442,7 +442,8 @@ the group does not un-know a key*, inherited one level down. **It does not tell the child before it happens**, and it does not constrain where the coins go. "Only back into the child, at a new address" is a covenant, and there is none on mainnet to write it with (`OP_CHECKTEMPLATEVERIFY`, -`OP_VAULT`). +`OP_VAULT`). The other direction is supported: an ancestor paying coins *into* +a guarded wallet is [guarded-wallet-funding.md](./guarded-wallet-funding.md). ## Appendix — what was considered and rejected diff --git a/docs/guarded-wallet-funding.md b/docs/guarded-wallet-funding.md index 46a0ee3c..4269b4bb 100644 --- a/docs/guarded-wallet-funding.md +++ b/docs/guarded-wallet-funding.md @@ -17,8 +17,27 @@ the forwarded statement from the first, the send form and its reservations from the second, and the "current plus two" rule from the third. It changes no format, no derivation and no schema. -**Not built.** Written against the code as it stood at `8cb6f04e`, schema v29, -with the `lightning-kmp-app` submodule at `e0d2b82`. +**Built**, phases 1-6, one commit each, written against the code as it stood +at `8cb6f04e`, schema v29, with the `lightning-kmp-app` submodule at `e0d2b82`; +the build changes no schema. `GroupWalletState.fundingAddress`, +`GroupSpendBuilder.Destination.Funding`, `GroupSpend.fundingsOf` and +`GroupSendRoute.fundChatRoomId` are the entry points. The phases below are kept +as written; where the build chose differently the table says so. + +| what the plan said | what it turned out to be | +|---|---| +| Phase 1 tests `claimedFundingIndices` | Phase 2 does: until the builder writes a claim there is no PSBT to read one from. Phase 1's watched-window test also counts the slots, eight, so the bound and the look-ahead cannot drift apart unnoticed | +| Phase 2: `send` and `sendAll` take a destination rather than an address string | both, as overloads: the string versions build a `Destination.Address` and call through, so the thirty-odd existing call sites, most of them tests, did not change. The claim always goes on output 0, where both builders put the payment | +| Phase 3: the check runs in `acceptSpendProposal` and `checkedSpend` | and in `proposeSpend` and `proposeGuardianSpend`, so a proposal every other device would refuse is refused before it is sent. It is one extension, `GroupSpend.Result.withFundings`, and a spend none of whose payments claims anything reads no guarded wallets at all | +| nothing about bumping | `GroupSpendBuilder.bump` rebuilt the PSBT without the claim, so a bumped funding would have read as a payment to a bare address and released its index. It carries `Checked.fundings` across | +| Phase 3's test is in the shape of `GuardianSpendRoundTest` | it is three tests in `GuardianSigningJvmTest`, which already holds an ancestor, a guarded child and the forwarding. The refusal test has the lie proposed by a device never told about the wallet -- the realistic way one arrives, since a device that holds the wallet refuses to propose it | +| Phase 4: the card says *To* and then the wallet's name | *To* and then *Savings's guarded wallet*. The title already says *Fund …*, and the card repeating it read twice. The index uses the address list's own *Address %1$s* | +| Phase 4: `MiddleEllipsis` on the address | as written, and on the desktop target it ellipsises at the end, as the address list does there | +| Phase 5: the name stays on one line | two: at 200% text a one-line name was cut to a word, and the name is what says which wallet the buttons act on | +| Phase 5: a `GroupWalletViewModelJvmTest` case for `arriving` | `GuardedWalletRowTest` in commonTest, since `arriving` is a property of the row and needs no view model; and `GuardedWalletCardJvmTest` renders the card, including at twice the text size | + +Still to do by hand: the signet funding between two real devices that the end +of Phase 6 asks for. The headline: **the group already watches every guarded wallet below it, so its devices already know which of that wallet's receive addresses are unused. A From eb4d6278400debf2aacb36cb1aa937dea07be089 Mon Sep 17 00:00:00 2001 From: Kgothatso Ngako Date: Sat, 24 Oct 2026 07:44:30 +0200 Subject: [PATCH 16/21] feat(wallet): a member's guarded wallets on their profile, and each one's screen (Phase 8) The profile lists every guarded wallet of its own this device knows about, named for the group that guards it: the ones whose key is here, and the ones a group this device is in has certified for this npub, which includes wallets made on another device and shown watch-only. Each row says where the asking has got to -- asked, signing, not signed, open -- or the balance. MemberWalletScreen offers addresses only once a group has certified the wallet. Before then the member can ask again or discard the key, which is safe exactly then; after, it shows the balance, the address, the coins and every coin a guardian took, read off the chain. Export key, behind a confirmation, shows both descriptors with the private key in them. wipeData has no callers and deletes nothing yet, so there is no wipe to guard; a note on it says what a caller must do once it does. Co-Authored-By: Claude Opus 5.5 --- .../composeResources/values/strings.xml | 24 ++ .../bennu/compose/database/BennuDatabase.kt | 5 + .../DatabaseMemberWalletRepository.kt | 36 ++ .../managers/MemberWalletDerivation.kt | 19 + .../compose/managers/MemberWalletManager.kt | 99 +++++ .../repository/MemberWalletRepository.kt | 24 ++ .../ui/composable/ActiveProfileScreen.kt | 31 ++ .../ui/composable/GroupWalletScreen.kt | 4 +- .../ui/composable/MemberWalletItems.kt | 112 ++++++ .../ui/composable/MemberWalletScreen.kt | 378 ++++++++++++++++++ .../ui/composable/NewMemberWalletScreen.kt | 2 +- .../ui/composable/navigation/BennuNavHost.kt | 17 + .../navigation/routes/MemberWalletRoute.kt | 14 + .../ui/view/model/MemberWalletViewModel.kt | 123 ++++++ .../ui/view/model/MemberWalletsViewModel.kt | 70 ++++ .../ui/view/state/MemberWalletUIState.kt | 31 ++ .../managers/MemberWalletDerivationTest.kt | 13 + .../compose/managers/MemberWalletsJvmTest.kt | 127 ++++++ 18 files changed, 1126 insertions(+), 3 deletions(-) create mode 100644 composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/MemberWalletItems.kt create mode 100644 composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/MemberWalletScreen.kt create mode 100644 composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/navigation/routes/MemberWalletRoute.kt create mode 100644 composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/MemberWalletViewModel.kt create mode 100644 composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/MemberWalletsViewModel.kt create mode 100644 composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/MemberWalletUIState.kt create mode 100644 composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/MemberWalletsJvmTest.kt diff --git a/composeApp/src/commonMain/composeResources/values/strings.xml b/composeApp/src/commonMain/composeResources/values/strings.xml index b5816a43..8789c2de 100644 --- a/composeApp/src/commonMain/composeResources/values/strings.xml +++ b/composeApp/src/commonMain/composeResources/values/strings.xml @@ -586,4 +586,28 @@ This group's guardian keys can't be read by this version of the app. Guarded wallets for members aren't offered on this network yet. This profile has no wallet of its own to watch the chain with, so it couldn't see its own coins. + You have no guarded wallets. + Waiting for someone in %1$s to put it to the group + %1$s is signing + %1$s didn't sign. Ask again, or discard it. + Key on another device + You're no longer in %1$s. It still guards this wallet. + Guarded by %1$s + Discard + Discard this wallet? + Its key is forgotten. No address of it was ever offered, so nothing can have been paid to it. + Export key + Export this wallet's key? + Whoever holds these descriptors can spend every coin in this wallet. Keep them where only you can reach them. + Show key + Receive descriptor + Change descriptor + Copied. + Copy + Finding your coins… + %1$s took %2$s sats through its guardian leaf, in %3$s. + Taken by guardians + This wallet's key is on another of your devices, so it can be watched here but not spent from. + Couldn't ask again. + Couldn't discard the wallet. diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/BennuDatabase.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/BennuDatabase.kt index e6eb68be..7da2744a 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/BennuDatabase.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/BennuDatabase.kt @@ -471,6 +471,11 @@ abstract class BennuDatabase: RoomDatabase() { useWriterConnection { transactor -> transactor.immediateTransaction { // TODO: Actually delete the data... + // + // When this does: MemberWallet holds the only copy of keys that + // coins may sit behind (docs/member-guarded-wallets.md, D6). A + // caller wiping a profile that holds an open member wallet has to + // say so first and offer the key's export, before anything goes. } } } diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/repository/DatabaseMemberWalletRepository.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/repository/DatabaseMemberWalletRepository.kt index 4e86cf57..31aebf02 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/repository/DatabaseMemberWalletRepository.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/repository/DatabaseMemberWalletRepository.kt @@ -46,6 +46,42 @@ class DatabaseMemberWalletRepository( return MemberWalletManager.request(database, chatRoomId, key, chain, label) } + override suspend fun walletsOf(ownerPublicKey: HexKey): List = try { + MemberWalletManager.walletsOf(database, ownerPublicKey) + } catch (e: Throwable) { + // A profile that lists no wallets is wrong and survivable; one that will + // not open because reading them threw is neither. + logger.e("Error reading $ownerPublicKey's guarded wallets", e) + emptyList() + } + + override suspend fun walletOf(ownerPublicKey: HexKey, walletId: String): MemberWalletManager.MemberWalletRow? = try { + MemberWalletManager.walletOf(database, ownerPublicKey, walletId) + } catch (e: Throwable) { + logger.e("Error reading guarded wallet $walletId", e) + null + } + + override suspend fun askAgain(walletId: String) { + val wallet = database.memberWalletDao().getById(walletId) ?: throw IllegalStateException("No key for $walletId here") + check(wallet.ownerPublicKey == activeIdentity.value?.nostrPublicKey) { "Not this profile's wallet" } + MemberWalletManager.askAgain(database, wallet) + } + + override suspend fun discard(walletId: String) { + val wallet = database.memberWalletDao().getById(walletId) ?: return + check(wallet.ownerPublicKey == activeIdentity.value?.nostrPublicKey) { "Not this profile's wallet" } + MemberWalletManager.discard(database, walletId) + } + + override suspend fun exportKey(walletId: String): Pair? { + val owner = activeIdentity.value?.nostrPublicKey ?: return null + return MemberWalletManager.exportKey(database, owner, walletId) + } + + override suspend fun roomName(chatRoomId: String): String? = + database.chatRoomDao().findChatRoomById(chatRoomId)?.chatRoom?.subject?.takeIf { it.isNotBlank() } + companion object { private const val TAG = "DatabaseMemberWalletRepository" } diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/MemberWalletDerivation.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/MemberWalletDerivation.kt index fe45cab5..6fa8ec41 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/MemberWalletDerivation.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/MemberWalletDerivation.kt @@ -9,6 +9,7 @@ import fr.acinq.bitcoin.ByteVector32 import fr.acinq.bitcoin.ByteVector64 import fr.acinq.bitcoin.Chain import fr.acinq.bitcoin.Crypto +import fr.acinq.bitcoin.Descriptor import fr.acinq.bitcoin.DeterministicWallet import fr.acinq.bitcoin.KeyPath import fr.acinq.bitcoin.PrivateKey @@ -104,6 +105,24 @@ object MemberWalletDerivation { return accountPrivateKey(walletPrivateKey, chain).derivePrivateKey(listOf(change, index)).privateKey } + /** + * The receive and change descriptors of [account] with the account's private + * key in place of its xpub -- what any wallet that imports taproot + * descriptors can sweep the coins with. The member's backup of last resort, + * shown only behind a confirmation: whoever holds these holds the coins. + */ + fun privateDescriptors(walletPrivateKey: PrivateKey, account: GroupWalletDerivation.Account): Pair { + val extended = accountPrivateKey(walletPrivateKey, account.chain) + require(extended.extendedPublicKey == account.extendedPublicKey) { "this key does not open this account" } + val xprv = extended.encode(if (account.chain.isMainnet()) DeterministicWallet.xprv else DeterministicWallet.tprv) + + fun swap(descriptor: String): String { + val body = descriptor.substringBefore('#').replaceFirst(account.xpub, xprv) + return "$body#${Descriptor.checksum(body)}" + } + return swap(account.receiveDescriptor) to swap(account.changeDescriptor) + } + /** * The signature [input] of a checked spend needs from the wallet's own key: * the address's private key under the address's taproot tweak, over the diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/MemberWalletManager.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/MemberWalletManager.kt index 1d27ef02..5622ce47 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/MemberWalletManager.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/MemberWalletManager.kt @@ -248,6 +248,105 @@ object MemberWalletManager { .onFailure { logger.w("Asked $chatRoomId, and could not put it to the group: ${it.message}") } } + /** Where a member's wallet has got to, as one fact the profile shows. */ + enum class WalletState { + /** A key and a request here; nobody has put it to the group yet. */ + ASKED, + + /** A session is running over its certificate. */ + SIGNING, + + /** The session failed or was declined, and the group has not certified it. */ + NOT_SIGNED, + + /** Certified, and the key is on this device. */ + OPEN, + + /** Certified, and the key is on another device of this profile's. */ + WATCH_ONLY, + } + + /** One of a member's guarded wallets, as their profile lists it. */ + data class MemberWalletRow( + val walletId: String, + val groupChatRoomId: String, + /** The guarding group's room on this device, or null when this device is not in it. */ + val groupRoom: LocalChatRoom?, + val label: String?, + val chain: Chain, + /** The account the wallet opens: rederived from the request, guardians and all. */ + val account: GroupWalletDerivation.Account, + val state: WalletState, + /** Whether the member is still a member of the guarding group, as far as this device can see. */ + val isMember: Boolean, + /** The stored key's row, for a wallet whose key is here. Never handed to a screen. */ + internal val stored: MemberWallet?, + ) { + val isCertified: Boolean get() = state == WalletState.OPEN || state == WalletState.WATCH_ONLY + } + + /** + * Every guarded wallet of [ownerPublicKey]'s this device knows about, newest + * first: the ones whose key is here, and the ones a group this device is in + * has certified for this profile -- which includes wallets made on another + * of its devices. + */ + suspend fun walletsOf(database: BennuDatabase, ownerPublicKey: HexKey): List { + val stored = database.memberWalletDao().getByOwner(ownerPublicKey) + val certified = database.groupSignedEventDao().getByKind(MemberWalletCertificateEvent.KIND) + .filter { MemberWalletCertificateEvent.memberOf(it.toEvent()).equals(ownerPublicKey, ignoreCase = true) } + .mapNotNull { MemberWalletCertificateEvent.verify(it.toEvent(), it.chatRoomId) } + .distinctBy { it.walletId } + .associateBy { it.walletId } + + val fromKeys = stored.mapNotNull { wallet -> + val request = Event.fromJsonOrNull(wallet.requestJson) ?: return@mapNotNull null + val verified = MemberWalletRequestEvent.verified(request) ?: return@mapNotNull null + val state = when { + certified.containsKey(wallet.walletId) -> WalletState.OPEN + openSessionFor(database, wallet.guardingChatRoomId, request) != null -> WalletState.SIGNING + wasNotSigned(database, wallet.guardingChatRoomId, request) -> WalletState.NOT_SIGNED + else -> WalletState.ASKED + } + row(database, wallet.walletId, wallet.guardingChatRoomId, wallet.label, verified.account, state, ownerPublicKey, wallet) + } + val elsewhere = certified.values + .filter { cert -> stored.none { it.walletId == cert.walletId } } + .map { row(database, it.walletId, it.groupChatRoomId, it.label, it.account, WalletState.WATCH_ONLY, ownerPublicKey, null) } + + return (fromKeys + elsewhere).sortedByDescending { it.stored?.createdAt?.epochSeconds ?: 0L } + } + + private suspend fun row( + database: BennuDatabase, + walletId: String, + groupChatRoomId: String, + label: String?, + account: GroupWalletDerivation.Account, + state: WalletState, + ownerPublicKey: HexKey, + stored: MemberWallet?, + ): MemberWalletRow { + val room = database.chatRoomDao().findChatRoomById(groupChatRoomId) + val isMember = room == null || database.participantDao().findParticipantsByChatRoomId(groupChatRoomId) + .any { it.participantPublicKey.equals(ownerPublicKey, ignoreCase = true) } + return MemberWalletRow(walletId, groupChatRoomId, room, label, account.chain, account, state, isMember, stored) + } + + /** [ownerPublicKey]'s wallet [walletId], or null when this device knows of none. */ + suspend fun walletOf(database: BennuDatabase, ownerPublicKey: HexKey, walletId: String): MemberWalletRow? = + walletsOf(database, ownerPublicKey).firstOrNull { it.walletId == walletId } + + /** + * [walletId]'s descriptors with its private key in them, or null when the key + * is not on this device. See `MemberWalletDerivation.privateDescriptors`. + */ + suspend fun exportKey(database: BennuDatabase, ownerPublicKey: HexKey, walletId: String): Pair? { + val row = walletOf(database, ownerPublicKey, walletId) ?: return null + val key = row.stored?.walletPrivateKey?.let { PrivateKey.fromHex(it) } ?: return null + return MemberWalletDerivation.privateDescriptors(key, row.account) + } + // ---- The group's side ------------------------------------------------ /** diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/repository/MemberWalletRepository.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/repository/MemberWalletRepository.kt index e0e7dec6..b93214de 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/repository/MemberWalletRepository.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/repository/MemberWalletRepository.kt @@ -28,6 +28,24 @@ interface MemberWalletRepository { /** Makes the key, works out the leaves, stores the key, and asks [chatRoomId] to guard it. */ suspend fun request(chatRoomId: String, chain: Chain, label: String?): MemberWallet + /** Every guarded wallet of [ownerPublicKey]'s this device knows about, newest first. */ + suspend fun walletsOf(ownerPublicKey: HexKey): List + + /** One of them, or null. */ + suspend fun walletOf(ownerPublicKey: HexKey, walletId: String): MemberWalletManager.MemberWalletRow? + + /** Asks the group again, with the request the wallet was first asked with. */ + suspend fun askAgain(walletId: String) + + /** Forgets a wallet's key -- refused once a group guards it. */ + suspend fun discard(walletId: String) + + /** The wallet's receive and change descriptors with its private key in them, or null when the key is not here. */ + suspend fun exportKey(walletId: String): Pair? + + /** What [chatRoomId] is called on this device, or null when it has no room for it. */ + suspend fun roomName(chatRoomId: String): String? + companion object { val NO_OP = object : MemberWalletRepository { override suspend fun groupsOf(ownerPublicKey: HexKey): List = emptyList() @@ -36,6 +54,12 @@ interface MemberWalletRepository { override suspend fun askForGroupKey(chatRoomId: String): Boolean = false override suspend fun request(chatRoomId: String, chain: Chain, label: String?): MemberWallet = throw UnsupportedOperationException("no repository") + override suspend fun walletsOf(ownerPublicKey: HexKey): List = emptyList() + override suspend fun walletOf(ownerPublicKey: HexKey, walletId: String): MemberWalletManager.MemberWalletRow? = null + override suspend fun askAgain(walletId: String) = Unit + override suspend fun discard(walletId: String) = Unit + override suspend fun exportKey(walletId: String): Pair? = null + override suspend fun roomName(chatRoomId: String): String? = null } } } diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/ActiveProfileScreen.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/ActiveProfileScreen.kt index 4017c0ef..6c153fa9 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/ActiveProfileScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/ActiveProfileScreen.kt @@ -1,5 +1,10 @@ package com.machankura.bennu.compose.ui.composable +import com.machankura.bennu.compose.repository.MemberWalletRepository +import com.machankura.bennu.compose.wallet.GroupOnchainWallets +import com.machankura.bennu.compose.ui.view.model.MemberWalletsViewModel +import com.machankura.bennu.compose.ui.composable.navigation.routes.MemberWalletRoute +import com.machankura.bennu.compose.ui.composable.navigation.routes.NewMemberWalletRoute import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Column import androidx.compose.foundation.layout.Row @@ -99,6 +104,11 @@ fun ActiveProfileScreen( // an identity to sign out of (previews, tests), in which case the button keeps its // pending route for every kind. signOut: SignOutDependencies? = null, + // The member's guarded wallets (docs/member-guarded-wallets.md). The no-op + // repository lists none, for previews and tests; null wallets is a profile + // that cannot watch the chain, whose rows show no balance. + memberWalletRepository: MemberWalletRepository = MemberWalletRepository.NO_OP, + wallets: GroupOnchainWallets? = null, ) { // Whether this identity can sign, which decides which rows below exist. @@ -130,6 +140,16 @@ fun ActiveProfileScreen( if (signOutState is SignOutViewModel.State.Failed) notify(couldNotSignOut) } + val memberWalletsViewModel: MemberWalletsViewModel = viewModel( + factory = MemberWalletsViewModel.factory( + ownerPublicKey = activeUserPublicKey, + memberWalletRepository = memberWalletRepository, + wallets = wallets, + ), + ) + // Each time the profile is shown: a certificate can arrive while it is not. + LaunchedEffect(true) { memberWalletsViewModel.refresh() } + val activeProfileViewModel: ActiveProfileViewModel = viewModel( factory = ActiveProfileViewModel.factory( nostrEventId = nostrEventId, @@ -272,6 +292,17 @@ fun ActiveProfileScreen( } } + memberWalletItems( + rows = memberWalletsViewModel.rows, + onOpen = { walletId -> + onNavigateToRoute.invoke(MemberWalletRoute(activeUserPublicKey = activeUserPublicKey, walletId = walletId)) + }, + // A read-only identity cannot sign a request, so it is not offered one. + onNew = if (canSign) { + { onNavigateToRoute.invoke(NewMemberWalletRoute(activeUserPublicKey = activeUserPublicKey)) } + } else null, + ) + // Key packages are signed, and there is nothing to recover for // an identity the device holds no secret for: neither row for a // read-only identity. diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/GroupWalletScreen.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/GroupWalletScreen.kt index 65b06227..6043aeb0 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/GroupWalletScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/GroupWalletScreen.kt @@ -714,7 +714,7 @@ private fun LazyListScope.guardianItems( } @Composable -private fun BalanceCard(walletState: GroupWalletState?) { +internal fun BalanceCard(walletState: GroupWalletState?) { Card(modifier = Modifier.fillMaxWidth()) { Column( modifier = Modifier.padding(MaterialTheme.spacing.containerPadding), @@ -741,7 +741,7 @@ private fun BalanceCard(walletState: GroupWalletState?) { } @Composable -private fun CoinRow(utxo: GroupUtxo, confirmations: Int) { +internal fun CoinRow(utxo: GroupUtxo, confirmations: Int) { ListItem( leadingContent = { Icon(Icons.Default.AccountBalanceWallet, contentDescription = Decorative) }, headlineContent = { Text(stringResource(Res.string.s_sats, utxo.amount.grouped())) }, diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/MemberWalletItems.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/MemberWalletItems.kt new file mode 100644 index 00000000..9b6bfeee --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/MemberWalletItems.kt @@ -0,0 +1,112 @@ +package com.machankura.bennu.compose.ui.composable + +import androidx.compose.foundation.clickable +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.lazy.LazyListScope +import androidx.compose.foundation.lazy.items +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.AccountBalanceWallet +import androidx.compose.material.icons.filled.Add +import androidx.compose.material3.Icon +import androidx.compose.material3.ListItem +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.material3.minimumInteractiveComponentSize +import androidx.compose.runtime.Composable +import androidx.compose.ui.Modifier +import androidx.compose.ui.text.style.TextOverflow +import bennu.composeapp.generated.resources.Res +import bennu.composeapp.generated.resources.a_group +import bennu.composeapp.generated.resources.balance_not_known_yet +import bennu.composeapp.generated.resources.guarded_wallets +import bennu.composeapp.generated.resources.key_on_another_device +import bennu.composeapp.generated.resources.new_guarded_wallet +import bennu.composeapp.generated.resources.s_did_not_sign +import bennu.composeapp.generated.resources.s_dot_s +import bennu.composeapp.generated.resources.s_is_signing +import bennu.composeapp.generated.resources.s_sats +import bennu.composeapp.generated.resources.waiting_for_someone_in_s_to_put_it_to_the_group +import bennu.composeapp.generated.resources.you_have_no_guarded_wallets +import bennu.composeapp.generated.resources.you_re_no_longer_in_s +import com.machankura.bennu.compose.managers.MemberWalletManager +import com.machankura.bennu.compose.text.grouped +import com.machankura.bennu.compose.ui.composable.widgets.Decorative +import com.machankura.bennu.compose.ui.composable.widgets.EmptyState +import com.machankura.bennu.compose.ui.theme.spacing +import com.machankura.bennu.compose.ui.view.model.MemberWalletsViewModel +import org.jetbrains.compose.resources.stringResource + +/** + * A member's guarded wallets, on their own profile: one row per wallet, named + * for the group that guards it, and the way to ask for another. + * `docs/member-guarded-wallets.md`, Phase 8. + * + * Never published. A profile's kind 0 is public, and a member wallet's xpub + * never leaves an encryption. + */ +fun LazyListScope.memberWalletItems( + rows: List?, + onOpen: (walletId: String) -> Unit, + onNew: (() -> Unit)?, +) { + item { + Text( + modifier = Modifier.fillMaxWidth(), + text = stringResource(Res.string.guarded_wallets), + style = MaterialTheme.typography.titleMedium, + ) + } + + when { + rows == null -> Unit + rows.isEmpty() -> item { EmptyState(message = stringResource(Res.string.you_have_no_guarded_wallets), icon = Icons.Default.AccountBalanceWallet) } + else -> items(rows, key = { "member-wallet-" + it.wallet.walletId }) { row -> + ListItem( + modifier = Modifier.clickable { onOpen(row.wallet.walletId) }.minimumInteractiveComponentSize(), + leadingContent = { Icon(Icons.Default.AccountBalanceWallet, contentDescription = Decorative) }, + headlineContent = { + val group = groupNameOf(row.wallet) + Text( + text = row.wallet.label?.let { stringResource(Res.string.s_dot_s, group, it) } ?: group, + maxLines = 1, + overflow = TextOverflow.Ellipsis, + ) + }, + supportingContent = { Text(supportingLine(row)) }, + ) + } + } + + onNew?.let { new -> + item { + TextButton(onClick = new) { + Icon(Icons.Default.Add, contentDescription = Decorative) + Spacer(modifier = Modifier.width(MaterialTheme.spacing.relatedGap)) + Text(stringResource(Res.string.new_guarded_wallet)) + } + } + } +} + +/** The guarding group as the member's rows name it: the room's name here, or a generic one. */ +@Composable +internal fun groupNameOf(wallet: MemberWalletManager.MemberWalletRow): String = + wallet.groupRoom?.chatRoom?.subject?.takeIf { it.isNotBlank() } ?: stringResource(Res.string.a_group) + +@Composable +private fun supportingLine(row: MemberWalletsViewModel.Row): String { + val group = groupNameOf(row.wallet) + if (!row.wallet.isMember) return stringResource(Res.string.you_re_no_longer_in_s, group) + val balance = row.walletState?.let { stringResource(Res.string.s_sats, it.confirmedBalance.grouped()) } + ?: stringResource(Res.string.balance_not_known_yet) + return when (row.wallet.state) { + MemberWalletManager.WalletState.ASKED -> stringResource(Res.string.waiting_for_someone_in_s_to_put_it_to_the_group, group) + MemberWalletManager.WalletState.SIGNING -> stringResource(Res.string.s_is_signing, group) + MemberWalletManager.WalletState.NOT_SIGNED -> stringResource(Res.string.s_did_not_sign, group) + MemberWalletManager.WalletState.OPEN -> balance + MemberWalletManager.WalletState.WATCH_ONLY -> stringResource(Res.string.s_dot_s, balance, stringResource(Res.string.key_on_another_device)) + } +} diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/MemberWalletScreen.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/MemberWalletScreen.kt new file mode 100644 index 00000000..afbd1f17 --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/MemberWalletScreen.kt @@ -0,0 +1,378 @@ +package com.machankura.bennu.compose.ui.composable + +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.items +import androidx.compose.foundation.rememberScrollState +import androidx.compose.foundation.text.selection.SelectionContainer +import androidx.compose.foundation.verticalScroll +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.ContentCopy +import androidx.compose.material.icons.filled.Key +import androidx.compose.material.icons.filled.Send +import androidx.compose.material3.Button +import androidx.compose.material3.AlertDialog +import androidx.compose.material3.Card +import androidx.compose.material3.ExperimentalMaterial3Api +import androidx.compose.material3.Icon +import androidx.compose.material3.ListItem +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.OutlinedButton +import androidx.compose.material3.Scaffold +import androidx.compose.material3.SnackbarHost +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.material3.TopAppBar +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.rememberCoroutineScope +import androidx.compose.runtime.setValue +import androidx.compose.ui.Modifier +import androidx.compose.ui.platform.LocalClipboardManager +import androidx.compose.ui.text.buildAnnotatedString +import androidx.compose.ui.text.style.TextOverflow +import androidx.lifecycle.viewmodel.compose.viewModel +import bennu.composeapp.generated.resources.Res +import bennu.composeapp.generated.resources.a_group +import bennu.composeapp.generated.resources.address_copied +import bennu.composeapp.generated.resources.ask_again +import bennu.composeapp.generated.resources.cancel +import bennu.composeapp.generated.resources.change_descriptor +import bennu.composeapp.generated.resources.close +import bennu.composeapp.generated.resources.coins +import bennu.composeapp.generated.resources.copied +import bennu.composeapp.generated.resources.copy_address +import bennu.composeapp.generated.resources.couldn_t_ask_again +import bennu.composeapp.generated.resources.couldn_t_discard_the_wallet +import bennu.composeapp.generated.resources.discard +import bennu.composeapp.generated.resources.discard_this_wallet_question +import bennu.composeapp.generated.resources.discarding_forgets_its_key +import bennu.composeapp.generated.resources.export_key +import bennu.composeapp.generated.resources.export_this_wallet_s_key_question +import bennu.composeapp.generated.resources.finding_your_coins +import bennu.composeapp.generated.resources.copy +import bennu.composeapp.generated.resources.send +import bennu.composeapp.generated.resources.guarded_by_s +import bennu.composeapp.generated.resources.guarded_wallet +import bennu.composeapp.generated.resources.if_you_lose_this_device_those_groups_can_still_move_your_coins +import bennu.composeapp.generated.resources.nothing_has_been_sent_to_this_wallet_yet +import bennu.composeapp.generated.resources.receive_address +import bennu.composeapp.generated.resources.receive_descriptor +import bennu.composeapp.generated.resources.s_did_not_sign +import bennu.composeapp.generated.resources.s_is_signing +import bennu.composeapp.generated.resources.s_took_s_sats_in_s +import bennu.composeapp.generated.resources.show_key +import bennu.composeapp.generated.resources.taken_by_guardians +import bennu.composeapp.generated.resources.the_key_of_this_wallet_is_on_another_device +import bennu.composeapp.generated.resources.this_profile_cannot_watch_its_own_coins +import bennu.composeapp.generated.resources.waiting_for_someone_in_s_to_put_it_to_the_group +import bennu.composeapp.generated.resources.whoever_holds_these_descriptors_holds_the_coins +import bennu.composeapp.generated.resources.you_re_no_longer_in_s +import com.machankura.bennu.compose.managers.MemberWalletManager.WalletState +import com.machankura.bennu.compose.repository.MemberWalletRepository +import com.machankura.bennu.compose.text.grouped +import com.machankura.bennu.compose.ui.composable.widgets.Decorative +import com.machankura.bennu.compose.ui.composable.widgets.EmptyState +import com.machankura.bennu.compose.ui.composable.widgets.ErrorState +import com.machankura.bennu.compose.ui.composable.widgets.LoadingDataIndicator +import com.machankura.bennu.compose.ui.composable.widgets.LocalSnackbarHostState +import com.machankura.bennu.compose.ui.composable.widgets.NavigateBackButton +import com.machankura.bennu.compose.ui.composable.widgets.QRCodeView +import com.machankura.bennu.compose.ui.composable.widgets.ScreenStateTransition +import com.machankura.bennu.compose.ui.composable.widgets.rememberNotifier +import com.machankura.bennu.compose.ui.theme.readableContent +import com.machankura.bennu.compose.ui.theme.spacing +import com.machankura.bennu.compose.ui.view.model.MemberWalletViewModel +import com.machankura.bennu.compose.ui.view.state.MemberWalletUIState +import com.machankura.bennu.compose.wallet.GroupOnchainWallets +import com.machankura.bennu.compose.wallet.bip21Uri +import com.vitorpamplona.quartz.nip01Core.core.HexKey +import org.jetbrains.compose.resources.stringResource + +/** + * One of the member's guarded wallets. + * + * Before a group has certified it, where the asking has got to and the two + * things the member can do about it: ask again, or discard the key -- which is + * safe exactly then, because no address was ever offered. Once certified, the + * wallet itself: balance, the address to be paid at, the coins, and every coin + * a guardian took, read off the chain. + */ +@OptIn(ExperimentalMaterial3Api::class) +@Composable +fun MemberWalletScreen( + activeUserPublicKey: HexKey, + walletId: String, + initialUIState: MemberWalletUIState = MemberWalletUIState.Loading, + memberWalletRepository: MemberWalletRepository, + wallets: GroupOnchainWallets?, + /** The send form for this wallet, or null where there is none to offer. */ + onSend: ((walletId: String) -> Unit)? = null, + onNavigateBack: () -> Unit, +) { + val viewModel: MemberWalletViewModel = viewModel( + factory = MemberWalletViewModel.factory( + ownerPublicKey = activeUserPublicKey, + walletId = walletId, + initialUIState = initialUIState, + memberWalletRepository = memberWalletRepository, + wallets = wallets, + ) + ) + + LaunchedEffect(true) { + if (initialUIState == MemberWalletUIState.Loading) viewModel.initiate() + } + + val notify = rememberNotifier(rememberCoroutineScope()) + val couldNotAskAgain = stringResource(Res.string.couldn_t_ask_again) + val couldNotDiscard = stringResource(Res.string.couldn_t_discard_the_wallet) + val addressCopied = stringResource(Res.string.address_copied) + val copied = stringResource(Res.string.copied) + val clipboardManager = LocalClipboardManager.current + + var confirmingDiscard by remember { mutableStateOf(false) } + var confirmingExport by remember { mutableStateOf(false) } + + val title = (viewModel.uiState as? MemberWalletUIState.Loaded)?.wallet?.label ?: stringResource(Res.string.guarded_wallet) + + Scaffold( + snackbarHost = { SnackbarHost(LocalSnackbarHostState.current) }, + topBar = { + TopAppBar( + title = { Text(title, maxLines = 1, overflow = TextOverflow.Ellipsis) }, + navigationIcon = { NavigateBackButton(onNavigateBack) }, + ) + } + ) { padding -> + ScreenStateTransition(viewModel.uiState) { uiState -> + when (val state = uiState) { + MemberWalletUIState.Loading -> LoadingDataIndicator(modifier = Modifier.fillMaxWidth().padding(padding)) + + // Nothing to retry: the wallet came from a navigation argument. + is MemberWalletUIState.Error -> ErrorState(modifier = Modifier.padding(padding), message = state.message, onRetry = null) + + is MemberWalletUIState.Loaded -> { + val wallet = state.wallet + val group = wallet.groupRoom?.chatRoom?.subject?.takeIf { it.isNotBlank() } ?: stringResource(Res.string.a_group) + val walletState = state.walletState + + LazyColumn( + modifier = Modifier.padding(padding).readableContent().fillMaxSize() + .padding(MaterialTheme.spacing.screenMargin), + verticalArrangement = Arrangement.spacedBy(MaterialTheme.spacing.itemGap), + ) { + item { Text(stringResource(Res.string.guarded_by_s, group), style = MaterialTheme.typography.titleMedium) } + item { + Text( + reachText(group, state.reach), + style = MaterialTheme.typography.bodyMedium, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + if (!wallet.isMember) item { Text(stringResource(Res.string.you_re_no_longer_in_s, group)) } + + when (wallet.state) { + WalletState.ASKED, WalletState.SIGNING, WalletState.NOT_SIGNED -> { + item { + Text( + stringResource( + when (wallet.state) { + WalletState.SIGNING -> Res.string.s_is_signing + WalletState.NOT_SIGNED -> Res.string.s_did_not_sign + else -> Res.string.waiting_for_someone_in_s_to_put_it_to_the_group + }, + group, + ) + ) + } + if (wallet.state != WalletState.SIGNING) { + item { + OutlinedButton( + onClick = { viewModel.askAgain(onAsked = {}, onFailure = { notify(couldNotAskAgain) }) }, + enabled = !viewModel.isActionPending.value, + ) { Text(stringResource(Res.string.ask_again)) } + } + item { + TextButton(onClick = { confirmingDiscard = true }, enabled = !viewModel.isActionPending.value) { + Text(stringResource(Res.string.discard)) + } + } + } + } + + WalletState.OPEN, WalletState.WATCH_ONLY -> { + item { BalanceCard(walletState) } + + if (wallet.state == WalletState.WATCH_ONLY) { + item { + Text( + stringResource(Res.string.the_key_of_this_wallet_is_on_another_device), + style = MaterialTheme.typography.bodyMedium, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + } + + onSend?.takeIf { wallet.state == WalletState.OPEN && state.canWatch }?.let { send -> + item { SendButton(onClick = { send(wallet.walletId) }) } + } + + when { + !state.canWatch -> item { + Text( + stringResource(Res.string.this_profile_cannot_watch_its_own_coins), + style = MaterialTheme.typography.bodyMedium, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + + walletState?.receiveAddress == null -> item { + LoadingDataIndicator(fillScreen = false, text = stringResource(Res.string.finding_your_coins)) + } + + else -> { + val address = walletState.receiveAddress!! + item { + Card(modifier = Modifier.fillMaxWidth()) { + Column( + modifier = Modifier.padding(MaterialTheme.spacing.containerPadding), + verticalArrangement = Arrangement.spacedBy(MaterialTheme.spacing.itemGap), + ) { + Text(stringResource(Res.string.receive_address), style = MaterialTheme.typography.titleMedium) + QRCodeView(bip21Uri(address)) + SelectionContainer { Text(text = address, style = MaterialTheme.typography.bodyMedium) } + TextButton(onClick = { + clipboardManager.setText(buildAnnotatedString { append(address) }) + notify(addressCopied) + }) { + Icon(Icons.Default.ContentCopy, contentDescription = Decorative) + Spacer(modifier = Modifier.width(MaterialTheme.spacing.relatedGap)) + Text(stringResource(Res.string.copy_address)) + } + } + } + } + + item { Text(stringResource(Res.string.coins), style = MaterialTheme.typography.titleMedium) } + if (walletState.utxos.isEmpty()) { + item { EmptyState(message = stringResource(Res.string.nothing_has_been_sent_to_this_wallet_yet)) } + } else { + items(walletState.utxos, key = { it.utxo.outPoint.toString() }) { utxo -> + CoinRow(utxo = utxo, confirmations = walletState.confirmations(utxo)) + } + } + } + } + + if (state.taken.isNotEmpty()) { + item { Text(stringResource(Res.string.taken_by_guardians), style = MaterialTheme.typography.titleMedium) } + items(state.taken, key = { "taken-" + it.txid + it.guardianName }) { line -> + ListItem( + headlineContent = { + Text(stringResource(Res.string.s_took_s_sats_in_s, line.guardianName ?: stringResource(Res.string.a_group), line.amount.grouped(), line.txid)) + } + ) + } + } + + if (wallet.state == WalletState.OPEN) { + item { + TextButton(onClick = { confirmingExport = true }) { + Icon(Icons.Default.Key, contentDescription = Decorative) + Spacer(modifier = Modifier.width(MaterialTheme.spacing.relatedGap)) + Text(stringResource(Res.string.export_key)) + } + } + } + } + } + + item { + Text( + stringResource(Res.string.if_you_lose_this_device_those_groups_can_still_move_your_coins), + style = MaterialTheme.typography.bodyMedium, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + } + } + } + } + } + + if (confirmingDiscard) { + AlertDialog( + onDismissRequest = { confirmingDiscard = false }, + title = { Text(stringResource(Res.string.discard_this_wallet_question)) }, + text = { Text(stringResource(Res.string.discarding_forgets_its_key)) }, + confirmButton = { + TextButton(onClick = { + confirmingDiscard = false + viewModel.discard(onDiscarded = onNavigateBack, onFailure = { notify(couldNotDiscard) }) + }) { Text(stringResource(Res.string.discard)) } + }, + dismissButton = { TextButton(onClick = { confirmingDiscard = false }) { Text(stringResource(Res.string.cancel)) } }, + ) + } + + if (confirmingExport) { + AlertDialog( + onDismissRequest = { confirmingExport = false }, + title = { Text(stringResource(Res.string.export_this_wallet_s_key_question)) }, + text = { Text(stringResource(Res.string.whoever_holds_these_descriptors_holds_the_coins)) }, + confirmButton = { + TextButton(onClick = { + confirmingExport = false + viewModel.exportKey() + }) { Text(stringResource(Res.string.show_key)) } + }, + dismissButton = { TextButton(onClick = { confirmingExport = false }) { Text(stringResource(Res.string.cancel)) } }, + ) + } + + viewModel.exported?.let { (receive, change) -> + AlertDialog( + onDismissRequest = viewModel::hideKey, + title = { Text(stringResource(Res.string.export_key)) }, + text = { + Column( + modifier = Modifier.verticalScroll(rememberScrollState()), + verticalArrangement = Arrangement.spacedBy(MaterialTheme.spacing.itemGap), + ) { + listOf(Res.string.receive_descriptor to receive, Res.string.change_descriptor to change).forEach { (name, descriptor) -> + Text(stringResource(name), style = MaterialTheme.typography.titleSmall) + SelectionContainer { Text(descriptor, style = MaterialTheme.typography.bodySmall) } + TextButton(onClick = { + clipboardManager.setText(buildAnnotatedString { append(descriptor) }) + notify(copied) + }) { + Icon(Icons.Default.ContentCopy, contentDescription = Decorative) + Spacer(modifier = Modifier.width(MaterialTheme.spacing.relatedGap)) + Text(stringResource(Res.string.copy)) + } + } + } + }, + confirmButton = { TextButton(onClick = viewModel::hideKey) { Text(stringResource(Res.string.close)) } }, + ) + } +} + +@Composable +private fun SendButton(onClick: () -> Unit) { + Button(onClick = onClick) { + Icon(Icons.Default.Send, contentDescription = Decorative) + Spacer(modifier = Modifier.width(MaterialTheme.spacing.relatedGap)) + Text(stringResource(Res.string.send)) + } +} diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/NewMemberWalletScreen.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/NewMemberWalletScreen.kt index 7a8b7ecb..02e393b6 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/NewMemberWalletScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/NewMemberWalletScreen.kt @@ -217,7 +217,7 @@ fun NewMemberWalletScreen( /** Who can take the member's coins: the group alone, the group and its parent, or the group and N above it. */ @Composable -private fun reachText(groupName: String, reach: Int): String { +internal fun reachText(groupName: String, reach: Int): String { val delay = GuardianDerivation.ANCESTOR_DELAY.toInt() return when (reach) { 1 -> stringResource(Res.string.s_can_take_any_coin_without_asking_you, groupName, delay) 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 a049a904..a28dff3b 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 @@ -140,6 +140,8 @@ import kotlinx.coroutines.launch import com.machankura.bennu.compose.ui.composable.navigation.routes.GroupWalletRoute import com.machankura.bennu.compose.ui.composable.navigation.routes.GroupWalletAddressesRoute import com.machankura.bennu.compose.ui.composable.navigation.routes.NewMemberWalletRoute +import com.machankura.bennu.compose.ui.composable.navigation.routes.MemberWalletRoute +import com.machankura.bennu.compose.ui.composable.MemberWalletScreen import com.machankura.bennu.compose.ui.composable.NewMemberWalletScreen import com.machankura.bennu.compose.database.repository.DatabaseMemberWalletRepository import com.machankura.bennu.compose.wallet.GroupOnchainWallets @@ -919,6 +921,8 @@ fun BennuNavHost( ) }, signOut = signOutOfReadOnlyIdentity, + memberWalletRepository = databaseMemberWalletRepository, + wallets = groupOnchainWallets, ) } composable { backStackEntry -> @@ -1156,6 +1160,19 @@ fun BennuNavHost( } ) } + composable { backStackEntry -> + val route = backStackEntry.toRoute() + + MemberWalletScreen( + activeUserPublicKey = route.activeUserPublicKey, + walletId = route.walletId, + memberWalletRepository = databaseMemberWalletRepository, + wallets = groupOnchainWallets, + onNavigateBack = { + navController.popBackStack() + } + ) + } composable { backStackEntry -> val route = backStackEntry.toRoute() diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/navigation/routes/MemberWalletRoute.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/navigation/routes/MemberWalletRoute.kt new file mode 100644 index 00000000..df587573 --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/navigation/routes/MemberWalletRoute.kt @@ -0,0 +1,14 @@ +package com.machankura.bennu.compose.ui.composable.navigation.routes + +import kotlinx.serialization.Serializable + +/** + * One of the active member's guarded wallets: its balance, where to be paid, + * its coins, what its guardians took, and -- while no group has certified it -- + * where the asking has got to. `docs/member-guarded-wallets.md`, Phase 8. + */ +@Serializable +data class MemberWalletRoute( + val activeUserPublicKey: String, + val walletId: String, +): Route() diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/MemberWalletViewModel.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/MemberWalletViewModel.kt new file mode 100644 index 00000000..bb1cf196 --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/MemberWalletViewModel.kt @@ -0,0 +1,123 @@ +package com.machankura.bennu.compose.ui.view.model + +import androidx.compose.runtime.MutableState +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.setValue +import androidx.lifecycle.ViewModel +import androidx.lifecycle.ViewModelProvider +import androidx.lifecycle.viewModelScope +import androidx.lifecycle.viewmodel.initializer +import androidx.lifecycle.viewmodel.viewModelFactory +import co.touchlab.kermit.Logger +import com.machankura.bennu.compose.repository.MemberWalletRepository +import com.machankura.bennu.compose.ui.view.state.MemberWalletUIState +import com.machankura.bennu.compose.ui.view.state.TakenLine +import com.machankura.bennu.compose.wallet.GroupOnchainWallets +import com.vitorpamplona.quartz.nip01Core.core.HexKey +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.Job +import kotlinx.coroutines.flow.distinctUntilChangedBy +import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext + +/** + * One of the member's guarded wallets: read once for where the asking has got + * to, then -- for a certified wallet on a profile that can watch the chain -- + * watched for its coins, and searched for what its guardians took. + * + * Addresses are offered only once a group has certified the wallet: a wallet + * nobody has agreed to guard should not be handed out to be paid. + */ +class MemberWalletViewModel( + private val ownerPublicKey: HexKey, + val walletId: String, + initialUIState: MemberWalletUIState, + private val memberWalletRepository: MemberWalletRepository, + private val wallets: GroupOnchainWallets?, +) : ViewModel() { + private val logger = Logger.withTag(TAG) + + var uiState: MemberWalletUIState by mutableStateOf(initialUIState) + private set + + val isActionPending: MutableState = mutableStateOf(false) + + /** The exported descriptors while they are being shown, and only then. */ + var exported: Pair? by mutableStateOf(null) + private set + + private var watching: Job? = null + + fun initiate() { + viewModelScope.launch(Dispatchers.IO) { + val wallet = memberWalletRepository.walletOf(ownerPublicKey, walletId) + if (wallet == null) { + uiState = MemberWalletUIState.Error("Couldn't find this wallet") + return@launch + } + val loaded = MemberWalletUIState.Loaded(wallet = wallet, canWatch = wallets != null) + uiState = loaded + + watching?.cancel() + if (!wallet.isCertified || wallets == null) return@launch + watching = viewModelScope.launch(Dispatchers.IO) { + var taken = emptyList() + wallets.walletFor(wallet.account).state + .distinctUntilChangedBy { state -> state.utxos.map { it.utxo.outPoint } to state.tipHeight } + .collect { state -> + uiState = loaded.copy(walletState = state, taken = taken) + // History, not a watch: a device asleep when a guardian took a + // coin still finds it, since the chain keeps the record. + taken = wallets.guardianSpends(state).map { spend -> + TakenLine(spend.txid.toString(), memberWalletRepository.roomName(spend.guardian.chatRoomId), spend.amount) + } + uiState = loaded.copy(walletState = state, taken = taken) + } + } + } + } + + fun askAgain(onAsked: () -> Unit, onFailure: () -> Unit) = act(onAsked, onFailure) { + memberWalletRepository.askAgain(walletId) + initiate() + } + + fun discard(onDiscarded: () -> Unit, onFailure: () -> Unit) = act(onDiscarded, onFailure) { + memberWalletRepository.discard(walletId) + } + + fun exportKey() { + viewModelScope.launch(Dispatchers.IO) { exported = memberWalletRepository.exportKey(walletId) } + } + + fun hideKey() { + exported = null + } + + private fun act(onDone: () -> Unit, onFailure: () -> Unit, action: suspend () -> Unit) { + if (isActionPending.value) return + isActionPending.value = true + viewModelScope.launch(Dispatchers.IO) { + val done = runCatching { action() }.onFailure { logger.e("Couldn't act on wallet $walletId", it) }.isSuccess + withContext(Dispatchers.Main) { + isActionPending.value = false + if (done) onDone() else onFailure() + } + } + } + + companion object { + private const val TAG = "MemberWalletViewModel" + + fun factory( + ownerPublicKey: HexKey, + walletId: String, + initialUIState: MemberWalletUIState = MemberWalletUIState.Loading, + memberWalletRepository: MemberWalletRepository, + wallets: GroupOnchainWallets?, + ): ViewModelProvider.Factory = viewModelFactory { + initializer { MemberWalletViewModel(ownerPublicKey, walletId, initialUIState, memberWalletRepository, wallets) } + } + } +} diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/MemberWalletsViewModel.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/MemberWalletsViewModel.kt new file mode 100644 index 00000000..a6d97d86 --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/MemberWalletsViewModel.kt @@ -0,0 +1,70 @@ +package com.machankura.bennu.compose.ui.view.model + +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.setValue +import androidx.lifecycle.ViewModel +import androidx.lifecycle.ViewModelProvider +import androidx.lifecycle.viewModelScope +import androidx.lifecycle.viewmodel.initializer +import androidx.lifecycle.viewmodel.viewModelFactory +import com.machankura.bennu.compose.managers.MemberWalletManager +import com.machankura.bennu.compose.repository.MemberWalletRepository +import com.machankura.bennu.compose.wallet.GroupOnchainWallets +import com.machankura.bennu.compose.wallet.GroupWalletState +import com.vitorpamplona.quartz.nip01Core.core.HexKey +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.Job +import kotlinx.coroutines.flow.combine +import kotlinx.coroutines.flow.flowOf +import kotlinx.coroutines.launch + +/** + * A member's guarded wallets, as their profile lists them: each one's state, + * and -- for the ones a group has certified, on a profile that can watch the + * chain -- its balance. + */ +class MemberWalletsViewModel( + private val ownerPublicKey: HexKey, + private val memberWalletRepository: MemberWalletRepository, + private val wallets: GroupOnchainWallets?, +) : ViewModel() { + /** One wallet and, once the chain has answered, its coins. */ + data class Row(val wallet: MemberWalletManager.MemberWalletRow, val walletState: GroupWalletState?) + + /** Null until the first read. */ + var rows: List? by mutableStateOf(null) + private set + + private var watching: Job? = null + + /** Reads the list again: called each time the profile is shown, since a certificate can arrive while it is not. */ + fun refresh() { + viewModelScope.launch(Dispatchers.IO) { + val found = memberWalletRepository.walletsOf(ownerPublicKey) + rows = found.map { Row(it, walletState = null) } + + watching?.cancel() + val watched = found.filter { it.isCertified } + if (wallets == null || watched.isEmpty()) return@launch + watching = viewModelScope.launch(Dispatchers.IO) { + val states = found.map { wallet -> + if (wallet.isCertified) wallets.walletFor(wallet.account).state else flowOf(null) + } + combine(states) { it.toList() }.collect { current -> + rows = found.zip(current) { wallet, state -> Row(wallet, state) } + } + } + } + } + + companion object { + fun factory( + ownerPublicKey: HexKey, + memberWalletRepository: MemberWalletRepository, + wallets: GroupOnchainWallets?, + ): ViewModelProvider.Factory = viewModelFactory { + initializer { MemberWalletsViewModel(ownerPublicKey, memberWalletRepository, wallets) } + } + } +} diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/MemberWalletUIState.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/MemberWalletUIState.kt new file mode 100644 index 00000000..c1381b27 --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/MemberWalletUIState.kt @@ -0,0 +1,31 @@ +package com.machankura.bennu.compose.ui.view.state + +import com.machankura.bennu.compose.managers.MemberWalletManager +import com.machankura.bennu.compose.wallet.GroupWalletState +import fr.acinq.bitcoin.Satoshi + +sealed interface MemberWalletUIState { + data object Loading : MemberWalletUIState + + data class Error(val message: String) : MemberWalletUIState + + data class Loaded( + val wallet: MemberWalletManager.MemberWalletRow, + /** Null before Electrum's first answer, for a wallet no group has certified, and for a profile that cannot watch the chain. */ + val walletState: GroupWalletState? = null, + /** Whether this profile has an Electrum client to watch the chain with. */ + val canWatch: Boolean, + /** What the wallet's guardians took from it, read off the chain: never stored, found again on each look. */ + val taken: List = emptyList(), + /** How many groups guard it, for the line under the title. */ + val reach: Int = wallet.account.guardians.size, + ) : MemberWalletUIState +} + +/** One guardian spend from a member's wallet, named for the group that made it. */ +data class TakenLine( + val txid: String, + /** The guardian's room name on this device, or null when this device is not in it. */ + val guardianName: String?, + val amount: Satoshi, +) diff --git a/composeApp/src/commonTest/kotlin/com/machankura/bennu/compose/managers/MemberWalletDerivationTest.kt b/composeApp/src/commonTest/kotlin/com/machankura/bennu/compose/managers/MemberWalletDerivationTest.kt index ed73802f..cef93ce4 100644 --- a/composeApp/src/commonTest/kotlin/com/machankura/bennu/compose/managers/MemberWalletDerivationTest.kt +++ b/composeApp/src/commonTest/kotlin/com/machankura/bennu/compose/managers/MemberWalletDerivationTest.kt @@ -152,4 +152,17 @@ class MemberWalletDerivationTest { assertEquals(GuardianDerivation.leafKey(grant[position], chain, MemberWalletDerivation.ACCOUNT, 0, 4), signing.leafKey) } } + + @Test + fun `the exported descriptors carry the private key and nothing else changes`() { + val (receive, change) = MemberWalletDerivation.privateDescriptors(walletPrivateKey, account) + for ((exported, public) in listOf(receive to account.receiveDescriptor, change to account.changeDescriptor)) { + val (body, checksum) = exported.split('#') + assertEquals(Descriptor.checksum(body), checksum) + assertTrue(body.contains("tprv"), "a test network's private key") + assertTrue(!body.contains(account.xpub), "the account xpub is gone") + assertEquals(public.substringBefore('#').replace(account.xpub, ""), body.replace(Regex("tprv[1-9A-HJ-NP-Za-km-z]+"), "")) + } + assertFails { MemberWalletDerivation.privateDescriptors(privateKey(0xb0b), account) } + } } diff --git a/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/MemberWalletsJvmTest.kt b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/MemberWalletsJvmTest.kt new file mode 100644 index 00000000..d9e9e823 --- /dev/null +++ b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/MemberWalletsJvmTest.kt @@ -0,0 +1,127 @@ +package com.machankura.bennu.compose.managers + +import androidx.room3.Room +import com.machankura.bennu.compose.database.BennuDatabase +import com.machankura.bennu.compose.database.builder.getRoomDatabase +import com.machankura.bennu.compose.database.model.GroupSignedEvent +import com.machankura.bennu.compose.database.model.types.FrostSigningStage +import com.machankura.bennu.compose.managers.GroupFixtures.fileKeyState +import com.machankura.bennu.compose.managers.GroupFixtures.guardedCertificate +import com.machankura.bennu.compose.managers.GroupFixtures.keyMaterial +import com.machankura.bennu.compose.managers.GroupFixtures.roomOf +import com.machankura.bennu.compose.managers.GroupFixtures.signedAsRoom +import com.machankura.bennu.compose.managers.GroupFixtures.signingRoom +import com.machankura.bennu.compose.managers.MemberWalletManager.WalletState +import com.machankura.bennu.compose.nostr.wallet.MemberWalletCertificateEvent +import com.vitorpamplona.quartz.nip01Core.core.Event +import fr.acinq.bitcoin.ByteVector32 +import fr.acinq.bitcoin.Chain +import fr.acinq.bitcoin.PrivateKey +import fr.acinq.secp256k1.Hex +import kotlinx.coroutines.runBlocking +import kotlin.test.AfterTest +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFalse +import kotlin.test.assertNotNull +import kotlin.test.assertNull +import kotlin.test.assertTrue + +/** + * A member's guarded wallets as their profile lists them: one state per wallet, + * read off the key here, the sessions in the group's room and the group's + * certificates -- and a wallet made on another device, which this one can + * only watch. + */ +class MemberWalletsJvmTest { + private val db: BennuDatabase = getRoomDatabase(Room.inMemoryDatabaseBuilder()) + + @AfterTest + fun closeDb() = db.close() + + private val chain = Chain.Regtest + + private fun privateKey(seed: Long): PrivateKey = PrivateKey(ByteVector32(Hex.decode(seed.toString(16).padStart(64, '0')))) + + private val parent = keyMaterial("9a9e") + private val group = keyMaterial("6a0b") + private val groupRoom = roomOf(group) + + private val member = privateKey(0x3e3be7) + private val memberPublicKey = member.xOnlyPublicKey().value.toHex() + + private suspend fun setUp(signer: Boolean = false) { + signingRoom(db, group, members = listOf(memberPublicKey), holdsShare = signer) + fileKeyState(db, group, guardedCertificate(parent, group)) + } + + private suspend fun certify(request: Event) { + val template = MemberWalletCertificateEvent.template(request) + val signed = signedAsRoom(group, template.kind, template.tags, template.content, template.createdAt) + db.groupSignedEventDao().upsert(GroupSignedEvent.fromEvent(signed, chatRoomId = groupRoom, derivationPath = SharedKeyDerivation.formatPath(GroupFixtures.path), frostSigningSessionId = null)) + } + + private suspend fun stateOf(walletId: String): WalletState? = + MemberWalletManager.walletsOf(db, memberPublicKey).firstOrNull { it.walletId == walletId }?.state + + @Test + fun `asked, then certified`(): Unit = runBlocking { + setUp() + val wallet = MemberWalletManager.request(db, groupRoom, member, chain, label = "Savings") + assertEquals(WalletState.ASKED, stateOf(wallet.walletId)) + + certify(Event.fromJson(wallet.requestJson)) + val row = assertNotNull(MemberWalletManager.walletOf(db, memberPublicKey, wallet.walletId)) + assertEquals(WalletState.OPEN, row.state) + assertTrue(row.isCertified) + assertTrue(row.isMember) + assertEquals("Savings", row.label) + assertEquals(groupRoom, row.groupRoom?.chatRoom?.id) + assertEquals(2, row.account.guardians.size) + assertNotNull(MemberWalletManager.exportKey(db, memberPublicKey, wallet.walletId)) + } + + @Test + fun `signing, then not signed`(): Unit = runBlocking { + setUp(signer = true) + val wallet = MemberWalletManager.request(db, groupRoom, member, chain, label = null) + assertEquals(WalletState.SIGNING, stateOf(wallet.walletId), "a signer puts it to the group at once") + + val session = assertNotNull(MemberWalletManager.openSessionFor(db, groupRoom, Event.fromJson(wallet.requestJson))) + db.frostSigningSessionDao().upsert(session.copy(stage = FrostSigningStage.FAILED)) + assertEquals(WalletState.NOT_SIGNED, stateOf(wallet.walletId)) + } + + @Test + fun `a wallet made on another device is listed to watch`(): Unit = runBlocking { + setUp() + val wallet = MemberWalletManager.request(db, groupRoom, member, chain, label = null) + certify(Event.fromJson(wallet.requestJson)) + // As the other device sees it: the certificate, and no key. + db.memberWalletDao().delete(wallet.walletId) + + val row = assertNotNull(MemberWalletManager.walletOf(db, memberPublicKey, wallet.walletId)) + assertEquals(WalletState.WATCH_ONLY, row.state) + assertNull(MemberWalletManager.exportKey(db, memberPublicKey, wallet.walletId), "no key to export here") + } + + @Test + fun `somebody else's wallets are not listed`(): Unit = runBlocking { + setUp() + val wallet = MemberWalletManager.request(db, groupRoom, member, chain, label = null) + certify(Event.fromJson(wallet.requestJson)) + assertTrue(MemberWalletManager.walletsOf(db, privateKey(0xb0b).xOnlyPublicKey().value.toHex()).isEmpty()) + } + + @Test + fun `a member who left keeps the wallet, and is told`(): Unit = runBlocking { + setUp() + val wallet = MemberWalletManager.request(db, groupRoom, member, chain, label = null) + certify(Event.fromJson(wallet.requestJson)) + db.participantDao().delete(db.participantDao().findParticipantsByChatRoomId(groupRoom).filter { it.participantPublicKey == memberPublicKey }) + + val row = assertNotNull(MemberWalletManager.walletOf(db, memberPublicKey, wallet.walletId)) + assertFalse(row.isMember) + assertEquals(WalletState.OPEN, row.state) + } +} From 70d896a38dd939dd3c1b7fd2eb966668620fde21 Mon Sep 17 00:00:00 2001 From: Kgothatso Ngako Date: Sat, 24 Oct 2026 07:46:14 +0200 Subject: [PATCH 17/21] refactor(wallet): the send form is one composable a member's spend can share (Phase 9, part 1) GroupSendScreen's fields and preview move, unchanged, into SpendForm, which emits into the caller's column so the group's form lays out as it did. The button stays the caller's: a group asks its quorum, a member will sign alone. An ownWallet flag changes the words -- "your coins", "this wallet" -- and nothing else, so the two forms cannot drift. Co-Authored-By: Claude Opus 5.5 --- .../composeResources/values/strings.xml | 3 + .../compose/ui/composable/GroupSendScreen.kt | 192 +++++++++++------- 2 files changed, 125 insertions(+), 70 deletions(-) diff --git a/composeApp/src/commonMain/composeResources/values/strings.xml b/composeApp/src/commonMain/composeResources/values/strings.xml index 8789c2de..97502312 100644 --- a/composeApp/src/commonMain/composeResources/values/strings.xml +++ b/composeApp/src/commonMain/composeResources/values/strings.xml @@ -610,4 +610,7 @@ This wallet's key is on another of your devices, so it can be watched here but not spent from. Couldn't ask again. Couldn't discard the wallet. + %1$s sats come back to this wallet as change. + This wallet has nothing confirmed to spend. + This wallet doesn't have that much confirmed. 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..3fb5489c 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,5 +1,12 @@ package com.machankura.bennu.compose.ui.composable +import androidx.compose.foundation.text.input.TextFieldState +import androidx.compose.runtime.MutableState +import fr.acinq.bitcoin.Satoshi +import bennu.composeapp.generated.resources.finding_your_coins +import bennu.composeapp.generated.resources.s_sats_come_back_to_this_wallet_as_change +import bennu.composeapp.generated.resources.this_wallet_has_nothing_confirmed_to_spend +import bennu.composeapp.generated.resources.this_wallet_doesn_t_have_that_much_confirmed import bennu.composeapp.generated.resources.while_the_wallet_is_new_at_most_s_sats import androidx.compose.foundation.selection.toggleable import androidx.compose.material3.minimumInteractiveComponentSize @@ -177,73 +184,20 @@ fun GroupSendScreen( verticalArrangement = Arrangement.spacedBy(MaterialTheme.spacing.itemGap) ) { val preview = groupSendViewModel.preview() - // 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)) }, + SpendForm( + addressField = groupSendViewModel.addressField, + amountField = groupSendViewModel.amountField, + feerateField = groupSendViewModel.feerateField, + sendEverything = groupSendViewModel.sendEverything, + spendable = groupSendViewModel.spendable(), + cap = GroupWalletRollout.capFor(chain), + preview = preview, + amountProblem = preview?.takeIf { groupSendViewModel.isAboutTheAmount(it) }, + coinsKnown = state.walletState != null, + chain = chain, ) - // The row is the target, so the label toggles too: one 48dp control with one name. - Row( - modifier = Modifier.fillMaxWidth() - .toggleable( - value = groupSendViewModel.sendEverything.value, - role = Role.Switch, - onValueChange = { groupSendViewModel.sendEverything.value = it }, - ) - .minimumInteractiveComponentSize(), - verticalAlignment = Alignment.CenterVertically, - horizontalArrangement = Arrangement.SpaceBetween, - ) { - Text(stringResource(Res.string.send_everything)) - Switch(checked = groupSendViewModel.sendEverything.value, onCheckedChange = null) - } - - // Hidden rather than cleared, so turning send-everything off again finds the amount typed. - if (!groupSendViewModel.sendEverything.value) { - val spendable = groupSendViewModel.spendable() - val cap = GroupWalletRollout.capFor(chain) - OutlinedTextField( - modifier = Modifier.fillMaxWidth(), - state = groupSendViewModel.amountField, - outputTransformation = GroupedSats, - lineLimits = TextFieldLineLimits.SingleLine, - keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number, imeAction = ImeAction.Next), - label = { Text(stringResource(Res.string.amount_in_sats)) }, - suffix = { Text(stringResource(Res.string.sats)) }, - isError = amountProblem != null, - supportingText = if (amountProblem == null && spendable == null && cap == null) null else { - { - if (amountProblem != null) { - Text(problemWith(amountProblem, chain)) - } else Column { - spendable?.let { Text(stringResource(Res.string.s_sats_confirmed_and_free_to_spend, it.grouped())) } - cap?.let { Text(stringResource(Res.string.while_the_wallet_is_new_at_most_s_sats, it.grouped())) } - } - } - }, - ) - } - - OutlinedTextField( - modifier = Modifier.fillMaxWidth(), - state = groupSendViewModel.feerateField, - lineLimits = TextFieldLineLimits.SingleLine, - keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number), - label = { Text(stringResource(Res.string.feerate_in_sats_per_byte)) }, - ) - - // Still finding change is still finding coins: neither is anything to correct. - 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) } - } - Text( text = stringResource(Res.string.nothing_leaves_until_a_quorum_signs), style = MaterialTheme.typography.bodySmall, @@ -279,9 +233,100 @@ fun GroupSendScreen( } } +/** + * The fields of a send and what they would build: the address, send + * everything, the amount, the feerate, and the preview -- one form for every + * wallet that spends, so the group's and a member's cannot drift. The button + * under it is the caller's, because what it does is not the same: a group asks + * its quorum, a member signs alone. + * + * [ownWallet] is a member spending their own guarded wallet, which changes the + * words -- "your coins", "this wallet" -- and nothing else. + */ +@Composable +internal fun SpendForm( + addressField: TextFieldState, + amountField: TextFieldState, + feerateField: TextFieldState, + sendEverything: MutableState, + /** The confirmed coins free to spend, or null before Electrum has answered. */ + spendable: Satoshi?, + cap: Satoshi?, + preview: GroupSpendBuilder.Result?, + /** A problem with the amount, said on the amount field, beside what caused it. */ + amountProblem: GroupSpendBuilder.Result?, + coinsKnown: Boolean, + chain: Chain, + ownWallet: Boolean = false, +) { + // No column of its own: the fields go into the caller's, under its spacing, + // exactly as they did before the form was shared. + OutlinedTextField( + modifier = Modifier.fillMaxWidth(), + state = addressField, + lineLimits = TextFieldLineLimits.SingleLine, + label = { Text(stringResource(Res.string.address)) }, + ) + + // The row is the target, so the label toggles too: one 48dp control with one name. + Row( + modifier = Modifier.fillMaxWidth() + .toggleable( + value = sendEverything.value, + role = Role.Switch, + onValueChange = { sendEverything.value = it }, + ) + .minimumInteractiveComponentSize(), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.SpaceBetween, + ) { + Text(stringResource(Res.string.send_everything)) + Switch(checked = sendEverything.value, onCheckedChange = null) + } + + // Hidden rather than cleared, so turning send-everything off again finds the amount typed. + if (!sendEverything.value) { + OutlinedTextField( + modifier = Modifier.fillMaxWidth(), + state = amountField, + outputTransformation = GroupedSats, + lineLimits = TextFieldLineLimits.SingleLine, + keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number, imeAction = ImeAction.Next), + label = { Text(stringResource(Res.string.amount_in_sats)) }, + suffix = { Text(stringResource(Res.string.sats)) }, + isError = amountProblem != null, + supportingText = if (amountProblem == null && spendable == null && cap == null) null else { + { + if (amountProblem != null) { + Text(problemWith(amountProblem, chain, ownWallet)) + } else Column { + spendable?.let { Text(stringResource(Res.string.s_sats_confirmed_and_free_to_spend, it.grouped())) } + cap?.let { Text(stringResource(Res.string.while_the_wallet_is_new_at_most_s_sats, it.grouped())) } + } + } + }, + ) + } + + OutlinedTextField( + modifier = Modifier.fillMaxWidth(), + state = feerateField, + lineLimits = TextFieldLineLimits.SingleLine, + keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number), + label = { Text(stringResource(Res.string.feerate_in_sats_per_byte)) }, + ) + + // Still finding change is still finding coins: neither is anything to correct. + if (!coinsKnown || preview == GroupSpendBuilder.Result.FindingChange) { + LoadingDataIndicator(fillScreen = false, text = stringResource(if (ownWallet) Res.string.finding_your_coins else Res.string.finding_the_group_s_coins)) + } else if (amountProblem == null) { + preview?.let { SendPreview(it, chain, ownWallet) } + } +} + /** What the form would build, or why it cannot. */ @Composable -private fun SendPreview(result: GroupSpendBuilder.Result, chain: Chain) { +private fun SendPreview(result: GroupSpendBuilder.Result, chain: Chain, ownWallet: Boolean) { when (result) { is GroupSpendBuilder.Result.Built -> Column(verticalArrangement = Arrangement.spacedBy(MaterialTheme.spacing.relatedGap)) { Text( @@ -290,7 +335,10 @@ private fun SendPreview(result: GroupSpendBuilder.Result, chain: Chain) { ) result.change?.let { change -> Text( - text = stringResource(Res.string.s_sats_come_back_to_the_group_as_change, change.grouped()), + text = stringResource( + if (ownWallet) Res.string.s_sats_come_back_to_this_wallet_as_change else Res.string.s_sats_come_back_to_the_group_as_change, + change.grouped(), + ), style = MaterialTheme.typography.bodyMedium, color = MaterialTheme.colorScheme.onSurfaceVariant, ) @@ -305,7 +353,7 @@ private fun SendPreview(result: GroupSpendBuilder.Result, chain: Chain) { } else -> Text( - text = problemWith(result, chain), + text = problemWith(result, chain, ownWallet), style = MaterialTheme.typography.bodyMedium, color = MaterialTheme.colorScheme.error, ) @@ -314,11 +362,15 @@ private fun SendPreview(result: GroupSpendBuilder.Result, chain: Chain) { /** Why [result] cannot be proposed, in words. */ @Composable -private fun problemWith(result: GroupSpendBuilder.Result, chain: Chain): String = when (result) { +private fun problemWith(result: GroupSpendBuilder.Result, chain: Chain, ownWallet: Boolean): String = when (result) { GroupSpendBuilder.Result.NotAnAddress -> 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.NothingToSpend -> stringResource( + if (ownWallet) Res.string.this_wallet_has_nothing_confirmed_to_spend else Res.string.the_group_has_nothing_confirmed_to_spend + ) + GroupSpendBuilder.Result.NotEnough -> stringResource( + if (ownWallet) Res.string.this_wallet_doesn_t_have_that_much_confirmed else 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) { From 8a3e98e4d6cb8a82837aa3cb38c7d38091471930 Mon Sep 17 00:00:00 2001 From: Kgothatso Ngako Date: Sat, 24 Oct 2026 07:49:59 +0200 Subject: [PATCH 18/21] feat(wallet): a member spends their guarded wallet alone (Phase 9, part 2) MemberWalletManager.signSpend checks a spend the way a group member checks a group's -- GroupSpend.check against the account the wallet rederives to -- signs every input on the key path with the member's key, asserts correctlySpends, and files it as a MemberWalletSpend. While member wallets are shut on mainnet a member's own spend there is held to the same cap as every group spend. MemberSendScreen is the group's SpendForm with a button that signs and sends; the line above it says there is no quorum after this. There is no session for GroupTransactionWatcher to follow, so the wallet screen follows the member's spends while it is open, sending again any Electrum has not heard of, and lists them. Co-Authored-By: Claude Opus 5.5 --- .../composeResources/values/strings.xml | 9 + .../DatabaseMemberWalletRepository.kt | 15 ++ .../compose/managers/MemberWalletManager.kt | 62 ++++++ .../repository/MemberWalletRepository.kt | 18 ++ .../compose/ui/composable/MemberSendScreen.kt | 154 +++++++++++++++ .../ui/composable/MemberWalletScreen.kt | 24 +++ .../ui/composable/navigation/BennuNavHost.kt | 19 ++ .../navigation/routes/MemberSendRoute.kt | 10 + .../ui/view/model/MemberSendViewModel.kt | 186 ++++++++++++++++++ .../ui/view/model/MemberWalletViewModel.kt | 38 +++- .../ui/view/state/MemberSendUIState.kt | 24 +++ .../ui/view/state/MemberWalletUIState.kt | 3 + .../compose/wallet/GroupOnchainWallets.kt | 13 ++ .../compose/wallet/GroupWalletRollout.kt | 7 + .../managers/MemberWalletSpendJvmTest.kt | 138 +++++++++++++ 15 files changed, 715 insertions(+), 5 deletions(-) create mode 100644 composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/MemberSendScreen.kt create mode 100644 composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/navigation/routes/MemberSendRoute.kt create mode 100644 composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/MemberSendViewModel.kt create mode 100644 composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/MemberSendUIState.kt create mode 100644 composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/MemberWalletSpendJvmTest.kt diff --git a/composeApp/src/commonMain/composeResources/values/strings.xml b/composeApp/src/commonMain/composeResources/values/strings.xml index 97502312..f73a2325 100644 --- a/composeApp/src/commonMain/composeResources/values/strings.xml +++ b/composeApp/src/commonMain/composeResources/values/strings.xml @@ -613,4 +613,13 @@ %1$s sats come back to this wallet as change. This wallet has nothing confirmed to spend. This wallet doesn't have that much confirmed. + Send from your guarded wallet + You sign this alone, and it is sent as soon as you press the button. + Sending needs this wallet's key on this device, a group's certificate for it, and a wallet of this profile's own to watch the chain with. + Sign and send + Sent. + Couldn't send. + Your spends + Sent, waiting for the network to report it + In the mempool diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/repository/DatabaseMemberWalletRepository.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/repository/DatabaseMemberWalletRepository.kt index 31aebf02..d43661e9 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/repository/DatabaseMemberWalletRepository.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/repository/DatabaseMemberWalletRepository.kt @@ -3,6 +3,11 @@ package com.machankura.bennu.compose.database.repository import co.touchlab.kermit.Logger import com.machankura.bennu.compose.database.BennuDatabase import com.machankura.bennu.compose.database.model.MemberWallet +import com.machankura.bennu.compose.database.model.MemberWalletSpend +import fr.acinq.bitcoin.Transaction +import fr.acinq.bitcoin.psbt.Psbt +import kotlinx.coroutines.flow.Flow +import kotlin.time.Instant import com.machankura.bennu.compose.database.model.intermdiate.LocalChatRoom import com.machankura.bennu.compose.identity.Identity import com.machankura.bennu.compose.managers.MemberWalletManager @@ -82,6 +87,16 @@ class DatabaseMemberWalletRepository( override suspend fun roomName(chatRoomId: String): String? = database.chatRoomDao().findChatRoomById(chatRoomId)?.chatRoom?.subject?.takeIf { it.isNotBlank() } + override suspend fun signSpend(walletId: String, psbt: Psbt): Transaction { + val owner = activeIdentity.value?.nostrPublicKey ?: throw IllegalStateException("No profile is active") + return MemberWalletManager.signSpend(database, owner, walletId, psbt) + } + + override suspend fun recordChain(txid: String, confirmations: Int?, broadcastAt: Instant?) = + MemberWalletManager.recordChain(database, txid, confirmations, broadcastAt) + + override fun observeSpends(walletId: String): Flow> = database.memberWalletDao().observeSpends(walletId) + companion object { private const val TAG = "DatabaseMemberWalletRepository" } diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/MemberWalletManager.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/MemberWalletManager.kt index 5622ce47..eff3f0db 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/MemberWalletManager.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/MemberWalletManager.kt @@ -4,6 +4,12 @@ import co.touchlab.kermit.Logger import com.machankura.bennu.compose.database.BennuDatabase import com.machankura.bennu.compose.database.model.FrostSigningSession import com.machankura.bennu.compose.database.model.MemberWallet +import com.machankura.bennu.compose.database.model.MemberWalletSpend +import com.machankura.bennu.compose.wallet.GroupSpend +import fr.acinq.bitcoin.ScriptFlags +import fr.acinq.bitcoin.Transaction +import fr.acinq.bitcoin.psbt.Psbt +import fr.acinq.secp256k1.Hex import com.machankura.bennu.compose.database.model.MarmotInnerEvent import com.machankura.bennu.compose.database.model.intermdiate.LocalChatRoom import com.machankura.bennu.compose.database.model.types.FrostSigningStage @@ -347,6 +353,62 @@ object MemberWalletManager { return MemberWalletDerivation.privateDescriptors(key, row.account) } + /** + * Signs [psbt] as [walletId]'s own key and files the spend, returning the + * finished transaction for the caller to broadcast. + * + * Checked the way a group member checks a group spend -- `GroupSpend.check` + * against the account the wallet rederives to, never against the PSBT's own + * claims -- because the builder is shared and so are its mistakes; and then + * `correctlySpends`, the last word on whether the network will take it. + * + * @throws IllegalStateException when the key is not here, the wallet is not + * certified, the spend fails a check or is over the cap + */ + suspend fun signSpend(database: BennuDatabase, ownerPublicKey: HexKey, walletId: String, psbt: Psbt, at: Instant = Clock.System.now()): Transaction { + val row = walletOf(database, ownerPublicKey, walletId) ?: throw IllegalStateException("No such wallet") + check(row.state == WalletState.OPEN) { "Only a certified wallet whose key is here can spend" } + val key = PrivateKey.fromHex(checkNotNull(row.stored).walletPrivateKey) + + val checked = when (val result = GroupSpend.check(psbt, row.account, GroupSpend.Spender.Owner)) { + is GroupSpend.Result.Ok -> result.checked + is GroupSpend.Result.Refused -> throw IllegalStateException("This spend ${result.reason}") + } + GroupWalletRollout.memberCapFor(row.chain)?.let { cap -> + check(checked.amountSent <= cap) { "This spend sends more than ${cap.sat} sats while member wallets are new" } + } + + val signed = checked.witnessed(checked.inputs.map { MemberWalletDerivation.sign(key, row.chain, it) }) + signed.correctlySpends(checked.inputs.associate { it.outPoint to it.txOut }, ScriptFlags.STANDARD_SCRIPT_VERIFY_FLAGS) + + database.memberWalletDao().upsertSpend( + MemberWalletSpend( + txid = signed.txid.toString(), + walletId = walletId, + psbt = GroupSpend.encode(psbt), + signedTransaction = Hex.encode(Transaction.write(signed)), + createdAt = at, + ) + ) + logger.i("Signed ${signed.txid} from wallet ${walletId.take(8)}") + return signed + } + + /** + * Files what the chain said of [txid]: handed to Electrum at [broadcastAt], + * and -- with [confirmations] non-null -- seen, and confirmed once it is at + * least one deep. + */ + suspend fun recordChain(database: BennuDatabase, txid: String, confirmations: Int?, broadcastAt: Instant? = null, at: Instant = Clock.System.now()) { + val spend = database.memberWalletDao().getSpend(txid) ?: return + val updated = spend.copy( + broadcastAt = broadcastAt ?: spend.broadcastAt, + seenAt = spend.seenAt ?: at.takeIf { confirmations != null }, + confirmedAt = spend.confirmedAt ?: at.takeIf { (confirmations ?: 0) >= 1 }, + ) + if (updated != spend) database.memberWalletDao().upsertSpend(updated) + } + // ---- The group's side ------------------------------------------------ /** diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/repository/MemberWalletRepository.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/repository/MemberWalletRepository.kt index b93214de..8238c2e8 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/repository/MemberWalletRepository.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/repository/MemberWalletRepository.kt @@ -1,6 +1,12 @@ package com.machankura.bennu.compose.repository import com.machankura.bennu.compose.database.model.MemberWallet +import com.machankura.bennu.compose.database.model.MemberWalletSpend +import fr.acinq.bitcoin.Transaction +import fr.acinq.bitcoin.psbt.Psbt +import kotlinx.coroutines.flow.Flow +import kotlinx.coroutines.flow.flowOf +import kotlin.time.Instant import com.machankura.bennu.compose.database.model.intermdiate.LocalChatRoom import com.machankura.bennu.compose.managers.MemberWalletManager import com.vitorpamplona.quartz.nip01Core.core.HexKey @@ -46,6 +52,15 @@ interface MemberWalletRepository { /** What [chatRoomId] is called on this device, or null when it has no room for it. */ suspend fun roomName(chatRoomId: String): String? + /** Signs [psbt] as [walletId]'s own key, files the spend, and returns the transaction to broadcast. */ + suspend fun signSpend(walletId: String, psbt: Psbt): Transaction + + /** Files what the chain said of a member's spend. */ + suspend fun recordChain(txid: String, confirmations: Int?, broadcastAt: Instant? = null) + + /** The spends the member signed from [walletId], newest first. */ + fun observeSpends(walletId: String): Flow> + companion object { val NO_OP = object : MemberWalletRepository { override suspend fun groupsOf(ownerPublicKey: HexKey): List = emptyList() @@ -60,6 +75,9 @@ interface MemberWalletRepository { override suspend fun discard(walletId: String) = Unit override suspend fun exportKey(walletId: String): Pair? = null override suspend fun roomName(chatRoomId: String): String? = null + override suspend fun signSpend(walletId: String, psbt: Psbt): Transaction = throw UnsupportedOperationException("no repository") + override suspend fun recordChain(txid: String, confirmations: Int?, broadcastAt: Instant?) = Unit + override fun observeSpends(walletId: String): Flow> = flowOf(emptyList()) } } } diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/MemberSendScreen.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/MemberSendScreen.kt new file mode 100644 index 00000000..d45bdd7c --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/MemberSendScreen.kt @@ -0,0 +1,154 @@ +package com.machankura.bennu.compose.ui.composable + +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.rememberScrollState +import androidx.compose.foundation.verticalScroll +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.AccountBalanceWallet +import androidx.compose.material.icons.filled.Send +import androidx.compose.material3.Button +import androidx.compose.material3.ExperimentalMaterial3Api +import androidx.compose.material3.Icon +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Scaffold +import androidx.compose.material3.SnackbarHost +import androidx.compose.material3.Text +import androidx.compose.material3.TopAppBar +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.rememberCoroutineScope +import androidx.compose.ui.Modifier +import androidx.compose.ui.text.style.TextOverflow +import androidx.lifecycle.viewmodel.compose.viewModel +import bennu.composeapp.generated.resources.Res +import bennu.composeapp.generated.resources.couldn_t_send +import bennu.composeapp.generated.resources.send_from_your_guarded_wallet +import bennu.composeapp.generated.resources.sending_from_this_wallet_needs_its_key_and_a_node +import bennu.composeapp.generated.resources.sent +import bennu.composeapp.generated.resources.sign_and_send +import bennu.composeapp.generated.resources.signed_by_you_alone_and_sent_at_once +import com.machankura.bennu.compose.repository.MemberWalletRepository +import com.machankura.bennu.compose.ui.composable.widgets.Decorative +import com.machankura.bennu.compose.ui.composable.widgets.EmptyState +import com.machankura.bennu.compose.ui.composable.widgets.ErrorState +import com.machankura.bennu.compose.ui.composable.widgets.LoadingDataIndicator +import com.machankura.bennu.compose.ui.composable.widgets.LocalSnackbarHostState +import com.machankura.bennu.compose.ui.composable.widgets.NavigateBackButton +import com.machankura.bennu.compose.ui.composable.widgets.ScreenStateTransition +import com.machankura.bennu.compose.ui.composable.widgets.rememberNotifier +import com.machankura.bennu.compose.ui.theme.readableContent +import com.machankura.bennu.compose.ui.theme.spacing +import com.machankura.bennu.compose.ui.view.model.MemberSendViewModel +import com.machankura.bennu.compose.ui.view.state.MemberSendUIState +import com.machankura.bennu.compose.wallet.GroupOnchainWallets +import com.machankura.bennu.compose.wallet.GroupSpendBuilder +import com.machankura.bennu.compose.wallet.GroupWalletRollout +import com.vitorpamplona.quartz.nip01Core.core.HexKey +import fr.acinq.bitcoin.Chain +import org.jetbrains.compose.resources.stringResource + +/** + * A spend from the member's own guarded wallet: the group's send form, and a + * button that signs with the member's key alone and sends. There is no quorum + * to stop a mistake after this, which the line above the button says. + */ +@OptIn(ExperimentalMaterial3Api::class) +@Composable +fun MemberSendScreen( + activeUserPublicKey: HexKey, + walletId: String, + chain: Chain, + initialUIState: MemberSendUIState = MemberSendUIState.Loading, + memberWalletRepository: MemberWalletRepository, + wallets: GroupOnchainWallets?, + onNavigateBack: () -> Unit, +) { + val viewModel: MemberSendViewModel = viewModel( + factory = MemberSendViewModel.factory( + ownerPublicKey = activeUserPublicKey, + walletId = walletId, + chain = chain, + initialUIState = initialUIState, + memberWalletRepository = memberWalletRepository, + wallets = wallets, + ) + ) + + LaunchedEffect(true) { + if (initialUIState == MemberSendUIState.Loading) viewModel.initiate() + } + + // The caller's scope, so "sent" outlives the screen going back. + val notify = rememberNotifier(rememberCoroutineScope()) + val sent = stringResource(Res.string.sent) + val couldNotSend = stringResource(Res.string.couldn_t_send) + + Scaffold( + snackbarHost = { SnackbarHost(LocalSnackbarHostState.current) }, + topBar = { + TopAppBar( + title = { Text(stringResource(Res.string.send_from_your_guarded_wallet), maxLines = 1, overflow = TextOverflow.Ellipsis) }, + navigationIcon = { NavigateBackButton(onNavigateBack) }, + ) + } + ) { padding -> + ScreenStateTransition(viewModel.uiState) { uiState -> + when (val state = uiState) { + // Nothing to retry: the wallet came from a navigation argument. + is MemberSendUIState.Error -> ErrorState(modifier = Modifier.padding(padding), message = state.message, onRetry = null) + + MemberSendUIState.Loading -> LoadingDataIndicator(modifier = Modifier.fillMaxWidth().padding(padding)) + + MemberSendUIState.Unavailable -> EmptyState( + modifier = Modifier.padding(padding).readableContent(), + message = stringResource(Res.string.sending_from_this_wallet_needs_its_key_and_a_node), + icon = Icons.Default.AccountBalanceWallet, + ) + + is MemberSendUIState.Ready -> Column( + modifier = Modifier.padding(padding).readableContent().fillMaxSize() + .verticalScroll(rememberScrollState()) + .padding(MaterialTheme.spacing.screenMargin), + verticalArrangement = Arrangement.spacedBy(MaterialTheme.spacing.itemGap), + ) { + val preview = viewModel.preview() + + SpendForm( + addressField = viewModel.addressField, + amountField = viewModel.amountField, + feerateField = viewModel.feerateField, + sendEverything = viewModel.sendEverything, + spendable = viewModel.spendable(), + cap = GroupWalletRollout.memberCapFor(chain), + preview = preview, + amountProblem = preview?.takeIf { viewModel.isAboutTheAmount(it) }, + coinsKnown = state.walletState != null, + chain = chain, + ownWallet = true, + ) + + Text( + text = stringResource(Res.string.signed_by_you_alone_and_sent_at_once), + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + + Button( + enabled = preview is GroupSpendBuilder.Result.Built && !viewModel.isActionPending.value, + onClick = { viewModel.send(onSent = { notify(sent); onNavigateBack() }, onFailure = { notify(couldNotSend) }) }, + ) { + Icon(Icons.Default.Send, contentDescription = Decorative) + Spacer(modifier = Modifier.width(MaterialTheme.spacing.relatedGap)) + Text(stringResource(Res.string.sign_and_send)) + } + } + } + } + } +} diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/MemberWalletScreen.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/MemberWalletScreen.kt index afbd1f17..bedda67b 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/MemberWalletScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/MemberWalletScreen.kt @@ -77,6 +77,10 @@ import bennu.composeapp.generated.resources.this_profile_cannot_watch_its_own_co import bennu.composeapp.generated.resources.waiting_for_someone_in_s_to_put_it_to_the_group import bennu.composeapp.generated.resources.whoever_holds_these_descriptors_holds_the_coins import bennu.composeapp.generated.resources.you_re_no_longer_in_s +import bennu.composeapp.generated.resources.your_spends +import bennu.composeapp.generated.resources.confirmed +import bennu.composeapp.generated.resources.in_the_mempool +import bennu.composeapp.generated.resources.sent_waiting_for_the_network import com.machankura.bennu.compose.managers.MemberWalletManager.WalletState import com.machankura.bennu.compose.repository.MemberWalletRepository import com.machankura.bennu.compose.text.grouped @@ -274,6 +278,26 @@ fun MemberWalletScreen( } } + if (state.spends.isNotEmpty()) { + item { Text(stringResource(Res.string.your_spends), style = MaterialTheme.typography.titleMedium) } + items(state.spends, key = { "spend-" + it.txid }) { spend -> + ListItem( + headlineContent = { Text(spend.txid, maxLines = 1, overflow = TextOverflow.Ellipsis) }, + supportingContent = { + Text( + stringResource( + when { + spend.confirmedAt != null -> Res.string.confirmed + spend.seenAt != null -> Res.string.in_the_mempool + else -> Res.string.sent_waiting_for_the_network + } + ) + ) + }, + ) + } + } + if (state.taken.isNotEmpty()) { item { Text(stringResource(Res.string.taken_by_guardians), style = MaterialTheme.typography.titleMedium) } items(state.taken, key = { "taken-" + it.txid + it.guardianName }) { line -> diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/navigation/BennuNavHost.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/navigation/BennuNavHost.kt index a28dff3b..8873e5c1 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/navigation/BennuNavHost.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/navigation/BennuNavHost.kt @@ -141,6 +141,8 @@ import com.machankura.bennu.compose.ui.composable.navigation.routes.GroupWalletR import com.machankura.bennu.compose.ui.composable.navigation.routes.GroupWalletAddressesRoute import com.machankura.bennu.compose.ui.composable.navigation.routes.NewMemberWalletRoute import com.machankura.bennu.compose.ui.composable.navigation.routes.MemberWalletRoute +import com.machankura.bennu.compose.ui.composable.navigation.routes.MemberSendRoute +import com.machankura.bennu.compose.ui.composable.MemberSendScreen import com.machankura.bennu.compose.ui.composable.MemberWalletScreen import com.machankura.bennu.compose.ui.composable.NewMemberWalletScreen import com.machankura.bennu.compose.database.repository.DatabaseMemberWalletRepository @@ -1168,6 +1170,23 @@ fun BennuNavHost( walletId = route.walletId, memberWalletRepository = databaseMemberWalletRepository, wallets = groupOnchainWallets, + onSend = { walletId -> + navController.navigate(route = MemberSendRoute(activeUserPublicKey = route.activeUserPublicKey, walletId = walletId)) + }, + onNavigateBack = { + navController.popBackStack() + } + ) + } + composable { backStackEntry -> + val route = backStackEntry.toRoute() + + MemberSendScreen( + activeUserPublicKey = route.activeUserPublicKey, + walletId = route.walletId, + chain = NodeParamsManager.chain, + memberWalletRepository = databaseMemberWalletRepository, + wallets = groupOnchainWallets, onNavigateBack = { navController.popBackStack() } diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/navigation/routes/MemberSendRoute.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/navigation/routes/MemberSendRoute.kt new file mode 100644 index 00000000..116b0ad3 --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/navigation/routes/MemberSendRoute.kt @@ -0,0 +1,10 @@ +package com.machankura.bennu.compose.ui.composable.navigation.routes + +import kotlinx.serialization.Serializable + +/** The form a member sends from their own guarded wallet with, signing alone. */ +@Serializable +data class MemberSendRoute( + val activeUserPublicKey: String, + val walletId: String, +): Route() diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/MemberSendViewModel.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/MemberSendViewModel.kt new file mode 100644 index 00000000..751e64b9 --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/MemberSendViewModel.kt @@ -0,0 +1,186 @@ +package com.machankura.bennu.compose.ui.view.model + +import androidx.compose.foundation.text.input.TextFieldState +import androidx.compose.foundation.text.input.setTextAndPlaceCursorAtEnd +import androidx.compose.runtime.MutableState +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.setValue +import androidx.lifecycle.ViewModel +import androidx.lifecycle.ViewModelProvider +import androidx.lifecycle.viewModelScope +import androidx.lifecycle.viewmodel.initializer +import androidx.lifecycle.viewmodel.viewModelFactory +import co.touchlab.kermit.Logger +import com.machankura.bennu.compose.database.model.MemberWalletSpend +import com.machankura.bennu.compose.managers.MemberWalletManager +import com.machankura.bennu.compose.repository.MemberWalletRepository +import com.machankura.bennu.compose.text.SatsInput +import com.machankura.bennu.compose.text.parseSats +import com.machankura.bennu.compose.ui.view.state.MemberSendUIState +import com.machankura.bennu.compose.wallet.GroupOnchainWallets +import com.machankura.bennu.compose.wallet.GroupSpend +import com.machankura.bennu.compose.wallet.GroupSpendBuilder +import com.machankura.bennu.compose.wallet.GroupWalletRollout +import com.vitorpamplona.quartz.nip01Core.core.HexKey +import fr.acinq.bitcoin.Chain +import fr.acinq.bitcoin.OutPoint +import fr.acinq.bitcoin.Satoshi +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.Job +import kotlinx.coroutines.flow.combine +import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext +import kotlin.time.Clock + +/** + * A spend from the member's own guarded wallet, built as they type and signed + * alone when they ask. + * + * The group's send form, read the same way -- the preview is the spend, so the + * fee shown is the fee paid -- with one difference that matters: there is no + * quorum after this. Pressing the button signs and broadcasts. + */ +class MemberSendViewModel( + private val ownerPublicKey: HexKey, + val walletId: String, + val chain: Chain, + initialUIState: MemberSendUIState, + private val memberWalletRepository: MemberWalletRepository, + private val wallets: GroupOnchainWallets?, +) : ViewModel() { + private val logger = Logger.withTag(TAG) + + var uiState: MemberSendUIState by mutableStateOf(initialUIState) + private set + + val addressField = TextFieldState() + val amountField = TextFieldState() + val feerateField = TextFieldState() + val sendEverything: MutableState = mutableStateOf(false) + + val isActionPending: MutableState = mutableStateOf(false) + + private var watching: Job? = null + + fun initiate() { + viewModelScope.launch(Dispatchers.IO) { + val wallet = memberWalletRepository.walletOf(ownerPublicKey, walletId) + if (wallet == null) { + uiState = MemberSendUIState.Error("Couldn't find this wallet") + return@launch + } + if (wallet.state != MemberWalletManager.WalletState.OPEN || wallets == null) { + uiState = MemberSendUIState.Unavailable + return@launch + } + + val ready = MemberSendUIState.Ready(wallet = wallet, walletState = null) + uiState = ready + + wallets.suggestedFeeratePerVbyte()?.let { suggested -> + withContext(Dispatchers.Main) { + if (feerateField.text.isEmpty()) feerateField.setTextAndPlaceCursorAtEnd(suggested.toString()) + } + } + + watching?.cancel() + watching = viewModelScope.launch(Dispatchers.IO) { + combine(wallets.walletFor(wallet.account).state, memberWalletRepository.observeSpends(walletId)) { state, spends -> + val (reserved, reservedChange) = reservationsOf(spends, ready) + ready.copy(walletState = state, reserved = reserved, reservedChange = reservedChange) + }.collect { uiState = it } + } + } + } + + /** + * What the member's own spends still on their way hold: their coins, and the + * change they pay back to. Electrum stops listing a coin once a spend of it + * is in the mempool, so this matters for the moment between signing and the + * server hearing of it -- a second send then would spend the same coin. + */ + private fun reservationsOf(spends: List, ready: MemberSendUIState.Ready): Pair, Set> { + val open = spends.filter { it.seenAt == null && it.replacedByTxid == null } + .mapNotNull { GroupSpend.decode(it.psbt) } + .mapNotNull { (GroupSpend.check(it, ready.wallet.account) as? GroupSpend.Result.Ok)?.checked } + return open.flatMap { spend -> spend.inputs.map { it.outPoint } }.toSet() to + open.flatMap { spend -> spend.outputs.mapNotNull { it.change?.index } }.toSet() + } + + fun amount(): SatsInput = parseSats(amountField.text) + + fun spendable(): Satoshi? { + val state = uiState as? MemberSendUIState.Ready ?: return null + return state.walletState?.let { GroupSpendBuilder.spendableBalance(it, state.reserved, GroupSpend.Spender.Owner) } + } + + fun isAboutTheAmount(result: GroupSpendBuilder.Result?): Boolean = + !sendEverything.value && ( + result is GroupSpendBuilder.Result.InvalidAmount || + result is GroupSpendBuilder.Result.OverCap || + result == GroupSpendBuilder.Result.NotEnough || + result == GroupSpendBuilder.Result.BelowDust + ) + + /** The spend the form describes, or null while it is incomplete -- the same build the group's form makes. */ + fun preview(): GroupSpendBuilder.Result? { + val state = uiState as? MemberSendUIState.Ready ?: return null + val walletState = state.walletState ?: return null + + val amount = if (sendEverything.value) { + null + } else { + when (val input = amount()) { + SatsInput.Empty -> return null + is SatsInput.Sats -> input.amount + else -> return GroupSpendBuilder.Result.InvalidAmount(input) + } + } + val feerate = feerateField.text.toString().trim().toLongOrNull()?.takeIf { it > 0 } ?: return null + val address = addressField.text.toString().trim().takeIf { it.isNotEmpty() } ?: return null + + val built = if (amount == null) { + GroupSpendBuilder.sendAll(walletState, address, feerate, state.reserved) + } else { + GroupSpendBuilder.send(walletState, address, amount, feerate, state.reserved, state.reservedChange) + } + return GroupSpendBuilder.capped(built, GroupWalletRollout.memberCapFor(chain)) + } + + /** Signs what the form describes and hands it to Electrum. [onSent] when it went, [onFailure] when it did not. */ + fun send(onSent: () -> Unit, onFailure: () -> Unit) { + val built = preview() as? GroupSpendBuilder.Result.Built ?: return + val wallets = wallets ?: return + if (isActionPending.value) return + isActionPending.value = true + + viewModelScope.launch(Dispatchers.IO) { + val sent = runCatching { + val signed = memberWalletRepository.signSpend(walletId, built.psbt) + wallets.broadcast(signed) + memberWalletRepository.recordChain(signed.txid.toString(), confirmations = null, broadcastAt = Clock.System.now()) + }.onFailure { logger.e("Couldn't send from wallet $walletId", it) }.isSuccess + + withContext(Dispatchers.Main) { + isActionPending.value = false + if (sent) onSent() else onFailure() + } + } + } + + companion object { + private const val TAG = "MemberSendViewModel" + + fun factory( + ownerPublicKey: HexKey, + walletId: String, + chain: Chain, + initialUIState: MemberSendUIState = MemberSendUIState.Loading, + memberWalletRepository: MemberWalletRepository, + wallets: GroupOnchainWallets?, + ): ViewModelProvider.Factory = viewModelFactory { + initializer { MemberSendViewModel(ownerPublicKey, walletId, chain, initialUIState, memberWalletRepository, wallets) } + } + } +} diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/MemberWalletViewModel.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/MemberWalletViewModel.kt index bb1cf196..0241d2ca 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/MemberWalletViewModel.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/MemberWalletViewModel.kt @@ -17,7 +17,11 @@ import com.machankura.bennu.compose.wallet.GroupOnchainWallets import com.vitorpamplona.quartz.nip01Core.core.HexKey import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.Job +import kotlinx.coroutines.flow.combine import kotlinx.coroutines.flow.distinctUntilChangedBy +import com.machankura.bennu.compose.database.model.MemberWalletSpend +import fr.acinq.bitcoin.Transaction +import kotlin.time.Clock import kotlinx.coroutines.launch import kotlinx.coroutines.withContext @@ -63,21 +67,45 @@ class MemberWalletViewModel( if (!wallet.isCertified || wallets == null) return@launch watching = viewModelScope.launch(Dispatchers.IO) { var taken = emptyList() - wallets.walletFor(wallet.account).state - .distinctUntilChangedBy { state -> state.utxos.map { it.utxo.outPoint } to state.tipHeight } - .collect { state -> - uiState = loaded.copy(walletState = state, taken = taken) + combine( + wallets.walletFor(wallet.account).state + .distinctUntilChangedBy { state -> state.utxos.map { it.utxo.outPoint } to state.tipHeight }, + memberWalletRepository.observeSpends(walletId), + ) { state, spends -> state to spends } + .collect { (state, spends) -> + uiState = loaded.copy(walletState = state, taken = taken, spends = spends) + follow(spends) // History, not a watch: a device asleep when a guardian took a // coin still finds it, since the chain keeps the record. taken = wallets.guardianSpends(state).map { spend -> TakenLine(spend.txid.toString(), memberWalletRepository.roomName(spend.guardian.chatRoomId), spend.amount) } - uiState = loaded.copy(walletState = state, taken = taken) + uiState = loaded.copy(walletState = state, taken = taken, spends = spends) } } } } + /** + * Asks the chain where each of the member's unsettled spends has got to, + * and sends again any Electrum has not heard of. There is no session for + * `GroupTransactionWatcher` to follow, so the wallet screen follows its own + * spends while it is open -- the economy the guardian-spend notice makes: a + * device that never opens the screen writes nothing, and the chain keeps the + * record for the next one that does. + */ + private suspend fun follow(spends: List) { + val wallets = wallets ?: return + spends.filter { it.confirmedAt == null && it.replacedByTxid == null }.forEach { spend -> + val tx = runCatching { Transaction.read(spend.signedTransaction) }.getOrNull() ?: return@forEach + val confirmations = wallets.confirmationsOf(tx) + val resent = if (confirmations == null) { + runCatching { wallets.broadcast(tx) }.getOrNull()?.let { Clock.System.now() } + } else null + memberWalletRepository.recordChain(spend.txid, confirmations, broadcastAt = resent) + } + } + fun askAgain(onAsked: () -> Unit, onFailure: () -> Unit) = act(onAsked, onFailure) { memberWalletRepository.askAgain(walletId) initiate() diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/MemberSendUIState.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/MemberSendUIState.kt new file mode 100644 index 00000000..8bf3fd34 --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/MemberSendUIState.kt @@ -0,0 +1,24 @@ +package com.machankura.bennu.compose.ui.view.state + +import com.machankura.bennu.compose.managers.MemberWalletManager +import com.machankura.bennu.compose.wallet.GroupWalletState +import fr.acinq.bitcoin.OutPoint + +sealed interface MemberSendUIState { + data object Loading : MemberSendUIState + + data class Error(val message: String) : MemberSendUIState + + /** A wallet this device can spend from: certified, its key here, and a node to see the coins with. */ + data object Unavailable : MemberSendUIState + + data class Ready( + val wallet: MemberWalletManager.MemberWalletRow, + /** Null until Electrum answers. */ + val walletState: GroupWalletState?, + /** The coins the member's own unsettled spends hold, which a new one leaves alone. */ + val reserved: Set = emptySet(), + /** The change indices those spends pay back to, which a new one pays past. */ + val reservedChange: Set = emptySet(), + ) : MemberSendUIState +} diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/MemberWalletUIState.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/MemberWalletUIState.kt index c1381b27..59986b66 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/MemberWalletUIState.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/MemberWalletUIState.kt @@ -1,5 +1,6 @@ package com.machankura.bennu.compose.ui.view.state +import com.machankura.bennu.compose.database.model.MemberWalletSpend import com.machankura.bennu.compose.managers.MemberWalletManager import com.machankura.bennu.compose.wallet.GroupWalletState import fr.acinq.bitcoin.Satoshi @@ -17,6 +18,8 @@ sealed interface MemberWalletUIState { val canWatch: Boolean, /** What the wallet's guardians took from it, read off the chain: never stored, found again on each look. */ val taken: List = emptyList(), + /** The spends the member signed from it, newest first. */ + val spends: List = emptyList(), /** How many groups guard it, for the line under the title. */ val reach: Int = wallet.account.guardians.size, ) : MemberWalletUIState diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/wallet/GroupOnchainWallets.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/wallet/GroupOnchainWallets.kt index 0e34b15e..51889918 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/wallet/GroupOnchainWallets.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/wallet/GroupOnchainWallets.kt @@ -90,6 +90,19 @@ class GroupOnchainWallets( mutex.withLock { transactions[txid] } ?: runCatching { electrum.getTx(txid) }.getOrNull()?.also { tx -> mutex.withLock { transactions[txid] = tx } } + /** + * Hands [tx] to Electrum -- for a spend a member signed alone, which has no + * session for `GroupTransactionWatcher` to follow. Electrum reports success + * whatever the server said, so this is not evidence it reached the network: + * [confirmationsOf] is. + */ + suspend fun broadcast(tx: Transaction) { + electrum.broadcastTransaction(tx) + } + + /** How deep [tx] is: 0 in the mempool, null while Electrum has not heard of it or cannot be asked. */ + suspend fun confirmationsOf(tx: Transaction): Int? = runCatching { electrum.getConfirmations(tx) }.getOrNull() + suspend fun stop() = mutex.withLock { wallets.values.forEach { it.stop() } wallets.clear() diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/wallet/GroupWalletRollout.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/wallet/GroupWalletRollout.kt index c3c519bd..bb192e65 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/wallet/GroupWalletRollout.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/wallet/GroupWalletRollout.kt @@ -57,4 +57,11 @@ object GroupWalletRollout { const val MEMBER_WALLETS_ON_MAINNET: Boolean = false fun offersMemberWalletsOn(chain: Chain): Boolean = MEMBER_WALLETS_ON_MAINNET || !chain.isMainnet() + + /** + * The most a member's own spend from their guarded wallet may send on + * [chain]: [MAINNET_CAP] on mainnet until [MEMBER_WALLETS_ON_MAINNET] lifts, + * since the member's spend is signed by a path no group spend goes through. + */ + fun memberCapFor(chain: Chain): Satoshi? = capFor(chain).takeIf { !MEMBER_WALLETS_ON_MAINNET } } diff --git a/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/MemberWalletSpendJvmTest.kt b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/MemberWalletSpendJvmTest.kt new file mode 100644 index 00000000..f7a61e7d --- /dev/null +++ b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/MemberWalletSpendJvmTest.kt @@ -0,0 +1,138 @@ +package com.machankura.bennu.compose.managers + +import androidx.room3.Room +import com.machankura.bennu.compose.database.BennuDatabase +import com.machankura.bennu.compose.database.builder.getRoomDatabase +import com.machankura.bennu.compose.database.model.GroupSignedEvent +import com.machankura.bennu.compose.database.model.MemberWallet +import com.machankura.bennu.compose.managers.GroupFixtures.fileKeyState +import com.machankura.bennu.compose.managers.GroupFixtures.guardedCertificate +import com.machankura.bennu.compose.managers.GroupFixtures.keyMaterial +import com.machankura.bennu.compose.managers.GroupFixtures.roomOf +import com.machankura.bennu.compose.managers.GroupFixtures.signedAsRoom +import com.machankura.bennu.compose.managers.GroupFixtures.signingRoom +import com.machankura.bennu.compose.nostr.wallet.MemberWalletCertificateEvent +import com.machankura.bennu.compose.wallet.GroupSpend +import com.machankura.bennu.compose.wallet.GroupSpendBuilder +import com.machankura.bennu.compose.wallet.GroupWalletState +import com.vitorpamplona.quartz.nip01Core.core.Event +import fr.acinq.bitcoin.ByteVector +import fr.acinq.bitcoin.ByteVector32 +import fr.acinq.bitcoin.Chain +import fr.acinq.bitcoin.OutPoint +import fr.acinq.bitcoin.PrivateKey +import fr.acinq.bitcoin.Satoshi +import fr.acinq.bitcoin.ScriptFlags +import fr.acinq.bitcoin.Transaction +import fr.acinq.bitcoin.TxId +import fr.acinq.bitcoin.TxIn +import fr.acinq.bitcoin.TxOut +import fr.acinq.lightning.blockchain.electrum.WalletState +import fr.acinq.secp256k1.Hex +import kotlinx.coroutines.runBlocking +import kotlin.test.AfterTest +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFailsWith +import kotlin.test.assertIs +import kotlin.test.assertNotNull +import kotlin.test.assertNull +import kotlin.time.Instant + +/** + * A member spending their own guarded wallet alone: the spend checked against + * the account the wallet rederives to, signed with the member's key, accepted + * by the script interpreter, and filed -- and refused for every wallet this + * device cannot sign for. + */ +class MemberWalletSpendJvmTest { + private val db: BennuDatabase = getRoomDatabase(Room.inMemoryDatabaseBuilder()) + + @AfterTest + fun closeDb() = db.close() + + private val chain = Chain.Regtest + + private fun privateKey(seed: Long): PrivateKey = PrivateKey(ByteVector32(Hex.decode(seed.toString(16).padStart(64, '0')))) + + private val parent = keyMaterial("9a9e") + private val group = keyMaterial("6a0b") + private val groupRoom = roomOf(group) + + private val member = privateKey(0x3e3be7) + private val memberPublicKey = member.xOnlyPublicKey().value.toHex() + + private val destination = "bcrt1qw508d6qejxtdg4y5r3zarvary0c5xw7kygt080" + + private suspend fun certifiedWallet(): MemberWallet { + signingRoom(db, group, members = listOf(memberPublicKey), holdsShare = false) + fileKeyState(db, group, guardedCertificate(parent, group)) + val wallet = MemberWalletManager.request(db, groupRoom, member, chain, label = null) + val template = MemberWalletCertificateEvent.template(Event.fromJson(wallet.requestJson)) + val signed = signedAsRoom(group, template.kind, template.tags, template.content, template.createdAt) + db.groupSignedEventDao().upsert(GroupSignedEvent.fromEvent(signed, chatRoomId = groupRoom, derivationPath = SharedKeyDerivation.formatPath(GroupFixtures.path), frostSigningSessionId = null)) + return wallet + } + + /** [account]'s wallet with one coin of [sats] at receive address [index], and an unused change address. */ + private fun stateWith(account: GroupWalletDerivation.Account, index: Int = 0, sats: Long = 80_000): GroupWalletState { + val derived = GroupWalletDerivation.derive(account, GroupWalletDerivation.RECEIVE, index.toLong()) + val funding = Transaction(2, listOf(TxIn(OutPoint(TxId(ByteVector32(ByteArray(32) { 7 })), 0), ByteVector.empty, 0xffffffffL)), listOf(TxOut(Satoshi(sats), derived.pubkeyScript)), 0) + val meta = WalletState.AddressMeta.Derived(index) + val receive = WalletState(mapOf(derived.address(chain) to WalletState.AddressState(meta, true, listOf(WalletState.Utxo(funding.txid, 0, 100, funding, meta))))) + val change = WalletState( + mapOf(GroupWalletDerivation.derive(account, GroupWalletDerivation.CHANGE, 0).address(chain) to WalletState.AddressState(WalletState.AddressMeta.Derived(0), false, emptyList())) + ) + return GroupWalletState(account, receive, change, tipHeight = 110) + } + + @Test + fun `a member signs alone, and the network would take it`(): Unit = runBlocking { + val wallet = certifiedWallet() + val account = assertNotNull(MemberWalletManager.walletOf(db, memberPublicKey, wallet.walletId)).account + val built = assertIs(GroupSpendBuilder.send(stateWith(account), destination, Satoshi(30_000), 3L, emptySet())) + + val signed = MemberWalletManager.signSpend(db, memberPublicKey, wallet.walletId, built.psbt, at = Instant.fromEpochSeconds(1_700_000_000)) + + val checked = assertIs(GroupSpend.check(built.psbt, account)).checked + signed.correctlySpends(checked.inputs.associate { it.outPoint to it.txOut }, ScriptFlags.STANDARD_SCRIPT_VERIFY_FLAGS) + signed.txIn.forEach { assertEquals(1, it.witness.stack.size, "the key path: the tree stays hidden") } + + val spend = assertNotNull(db.memberWalletDao().getSpend(signed.txid.toString())) + assertEquals(wallet.walletId, spend.walletId) + assertNull(spend.seenAt) + + MemberWalletManager.recordChain(db, spend.txid, confirmations = 0, at = Instant.fromEpochSeconds(1_700_000_100)) + assertEquals(Instant.fromEpochSeconds(1_700_000_100), db.memberWalletDao().getSpend(spend.txid)?.seenAt) + assertNull(db.memberWalletDao().getSpend(spend.txid)?.confirmedAt) + MemberWalletManager.recordChain(db, spend.txid, confirmations = 2, at = Instant.fromEpochSeconds(1_700_000_700)) + assertEquals(Instant.fromEpochSeconds(1_700_000_700), db.memberWalletDao().getSpend(spend.txid)?.confirmedAt) + assertEquals(Instant.fromEpochSeconds(1_700_000_100), db.memberWalletDao().getSpend(spend.txid)?.seenAt, "first seen stays first seen") + } + + @Test + fun `a spend of another wallet's coins is refused`(): Unit = runBlocking { + val wallet = certifiedWallet() + val other = MemberWalletDerivation.account(privateKey(0xb0b).publicKey(), chain, emptyList()) + val built = assertIs(GroupSpendBuilder.sendAll(stateWith(other), destination, 3L, emptySet())) + assertFailsWith { MemberWalletManager.signSpend(db, memberPublicKey, wallet.walletId, built.psbt) } + assertEquals(emptyList(), db.memberWalletDao().getSpends(wallet.walletId)) + } + + @Test + fun `nothing is signed before a group certifies the wallet, or without its key`(): Unit = runBlocking { + signingRoom(db, group, members = listOf(memberPublicKey), holdsShare = false) + fileKeyState(db, group, guardedCertificate(parent, group)) + val asked = MemberWalletManager.request(db, groupRoom, member, chain, label = null) + val account = assertNotNull(MemberWalletManager.walletOf(db, memberPublicKey, asked.walletId)).account + val built = assertIs(GroupSpendBuilder.sendAll(stateWith(account), destination, 3L, emptySet())) + assertFailsWith { MemberWalletManager.signSpend(db, memberPublicKey, asked.walletId, built.psbt) } + + // Certified, and the key on another device. + val template = MemberWalletCertificateEvent.template(Event.fromJson(asked.requestJson)) + val signed = signedAsRoom(group, template.kind, template.tags, template.content, template.createdAt) + db.groupSignedEventDao().upsert(GroupSignedEvent.fromEvent(signed, chatRoomId = groupRoom, derivationPath = SharedKeyDerivation.formatPath(GroupFixtures.path), frostSigningSessionId = null)) + db.memberWalletDao().delete(asked.walletId) + assertFailsWith { MemberWalletManager.signSpend(db, memberPublicKey, asked.walletId, built.psbt) } + } +} From 4ea38043ada5a53bec59c3f45cc05542d75c3d24 Mon Sep 17 00:00:00 2001 From: Kgothatso Ngako Date: Sat, 24 Oct 2026 07:53:23 +0200 Subject: [PATCH 19/21] feat(wallet): the groups guarding a member's wallet list it as @name (Phase 10) A guarded wallet's subject is now a subgroup or a member. GuardianManager.verify takes a member wallet certificate beside a subgroup's statement, checks it on its own and walks the ancestor's guardian root down a line of descent that ends in the wallet's id. The group that signed a certificate lists it from its own signed events; the groups above learn of it from a 30333 notice, and a member in both rooms can carry it upward from the wallet screen as before. The guardian spend is unchanged: the guarded tag carries W, the builder, the check and the signing cache take any id. The wallet screen names a subgroup's wallet #name and a member's @name -- the live profile name, since the certificate fixes who the member is, not what they are called. Co-Authored-By: Claude Opus 5.5 --- .../composeResources/values/strings.xml | 1 + .../database/model/GroupTransaction.kt | 5 + .../bennu/compose/managers/GuardianManager.kt | 131 +++++++++-- .../ui/composable/GroupWalletScreen.kt | 34 ++- .../bennu/compose/managers/GroupFixtures.kt | 12 +- .../managers/MemberWalletGuardianJvmTest.kt | 205 ++++++++++++++++++ 6 files changed, 362 insertions(+), 26 deletions(-) create mode 100644 composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/MemberWalletGuardianJvmTest.kt diff --git a/composeApp/src/commonMain/composeResources/values/strings.xml b/composeApp/src/commonMain/composeResources/values/strings.xml index f73a2325..1a5ddf81 100644 --- a/composeApp/src/commonMain/composeResources/values/strings.xml +++ b/composeApp/src/commonMain/composeResources/values/strings.xml @@ -622,4 +622,5 @@ Your spends Sent, waiting for the network to report it In the mempool + @%1$s diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/model/GroupTransaction.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/model/GroupTransaction.kt index f0ed7081..0e3c7ba3 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/model/GroupTransaction.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/model/GroupTransaction.kt @@ -52,6 +52,11 @@ data class GroupTransaction( * The descendant whose guarded wallet this spend draws from, through this * room's guardian leaf -- or null for a spend from the room's own wallet. * [account] is then the descendant's, from the statement this room was told. + * + * A descendant is a subgroup's room id or, since + * `docs/member-guarded-wallets.md`, a member wallet's `W`: either is what the + * line of descent ends in. The column keeps its name, because a rename is a + * migration for a word. */ val guardedChatRoomId: String? = null, 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 d1009ca9..908d2ad6 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 @@ -10,6 +10,8 @@ import com.machankura.bennu.compose.nostr.frost.GroupKeyStateEvent import com.machankura.bennu.compose.nostr.subgroup.SubgroupBirthCertificateEvent import com.machankura.bennu.compose.nostr.wallet.GroupWalletStatementEvent import com.machankura.bennu.compose.nostr.wallet.GuardedWalletNoticeEvent +import com.machankura.bennu.compose.nostr.wallet.MemberWalletCertificateEvent +import com.machankura.bennu.compose.nostr.subgroup.tags.GuardianTag import com.machankura.bennu.compose.wallet.GroupSpend import com.vitorpamplona.quartz.nip01Core.core.Event import com.vitorpamplona.quartz.nip01Core.core.HexKey @@ -43,22 +45,48 @@ object GuardianManager { private val logger = Logger.withTag(TAG) + /** + * Whose guarded wallet it is: a subgroup's, under its quorum's key, or one + * member's, under a key only they hold -- `docs/member-guarded-wallets.md`. + * Either way [id] is what the line of descent ends in, so every guardian + * signs for its leaf the same way. + */ + sealed interface GuardedSubject { + /** A room id, or a member wallet's `W`. */ + val id: String + + data class Subgroup(override val id: String, val name: String?) : GuardedSubject + + data class Member( + override val id: String, + val ownerPublicKey: HexKey, + val label: String?, + /** The member's profile name on this device, where one is known; filled where a database is to hand. */ + val ownerName: String? = null, + ) : GuardedSubject + } + /** A descendant's guarded wallet, as one of its ancestors holds it. */ data class GuardedWallet( /** The ancestor holding it: the room it was told to. */ val ancestorChatRoomId: String, + /** [subject]'s id: the descendant's room, or a member wallet's `W`. */ val descendantChatRoomId: String, - /** The descendant's signed statement, whole. */ + /** + * What the ancestor believes it on, whole: a subgroup's signed statement, + * or the member wallet certificate the guarding group signed. + */ val statement: Event, /** The account the statement opens, rederived from the descendant's key. */ val account: GroupWalletDerivation.Account, - /** The descendant's birth certificate, carried in the statement. */ + /** A subgroup's birth certificate, carried in the statement -- or, for a member, the certificate itself. */ val certificate: Event, /** The rooms the ancestor walks from its own child down to the descendant -- `GuardianDerivation.lineage`. */ val lineage: List, + val subject: GuardedSubject = GuardedSubject.Subgroup(descendantChatRoomId, SubgroupBirthCertificateEvent.parseName(certificate.tags)), ) { - /** What the descendant's parent certified it as. The founding name: a rename does not reach it. */ - val name: String? get() = SubgroupBirthCertificateEvent.parseName(certificate.tags) + /** What the descendant's parent certified it as, for a subgroup. The founding name: a rename does not reach it. */ + val name: String? get() = (subject as? GuardedSubject.Subgroup)?.name val chain: Chain get() = account.chain @@ -69,7 +97,14 @@ object GuardianManager { /** The ancestor as the spender of a spend from this wallet, signing as [thresholdPublicKey] -- null to only build one. */ fun spender(thresholdPublicKey: HexKey? = null): GroupSpend.Spender.Guardian = - GroupSpend.Spender.Guardian(position = position, lineage = lineage, thresholdPublicKey = thresholdPublicKey, name = name) + GroupSpend.Spender.Guardian(position = position, lineage = lineage, thresholdPublicKey = thresholdPublicKey, name = displayName) + + /** How a spend from it names it: a subgroup's founding name, or `@` and a member's. */ + val displayName: String? + get() = when (val subject = subject) { + is GuardedSubject.Subgroup -> subject.name + is GuardedSubject.Member -> "@" + (subject.ownerName ?: subject.ownerPublicKey.take(8)) + } } /** @@ -89,6 +124,7 @@ object GuardianManager { * a leaf this group cannot sign, whatever the statement calls it. */ fun verify(statement: Event, ancestorChatRoomId: String, ancestorThresholdPublicKey: HexKey): GuardedWallet? = runCatching { + if (statement.kind == MemberWalletCertificateEvent.KIND) return verifyMember(statement, ancestorChatRoomId, ancestorThresholdPublicKey) if (statement.kind != GroupWalletStatementEvent.KIND) return null val descendantChatRoomId = statement.pubKey if (!GroupKeyStateEvent.isSignedByRoom(statement, descendantChatRoomId)) return null @@ -121,6 +157,42 @@ object GuardianManager { ) }.getOrNull() + /** + * [certificate] as a member's guarded wallet [ancestorChatRoomId] guards, or + * null when it is not one: the guarding group signed it over the member's + * own request (`MemberWalletCertificateEvent.verify`), and -- rule 4 of + * [verify] -- the key it names for the ancestor is the key the ancestor's + * guardian root reaches down the line of descent, which ends in the + * wallet's id where a subgroup's ends in its room. + */ + private fun verifyMember(certificate: Event, ancestorChatRoomId: String, ancestorThresholdPublicKey: HexKey): GuardedWallet? = runCatching { + val verified = MemberWalletCertificateEvent.verify(certificate, certificate.pubKey) ?: return null + val account = verified.account + + val lineage = GuardianDerivation.lineage(account.guardians, verified.walletId, ancestorChatRoomId) ?: return null + val named = account.guardians.first { it.chatRoomId.equals(ancestorChatRoomId, ignoreCase = true) } + val walked = GuardianDerivation.root(ancestorThresholdPublicKey).extendedPublicKey + .derivePublicKey(lineage.map(GuardianDerivation::childIndex)) + if (walked.publicKey != named.publicKey || walked.chaincode != named.chainCode) return null + + GuardedWallet( + ancestorChatRoomId = ancestorChatRoomId, + descendantChatRoomId = verified.walletId, + statement = certificate, + account = account, + certificate = certificate, + lineage = lineage, + subject = GuardedSubject.Member(verified.walletId, verified.memberPublicKey, verified.label), + ) + }.getOrNull() + + /** [wallet] with its member's profile name, where this device knows one. */ + private suspend fun named(database: BennuDatabase, wallet: GuardedWallet): GuardedWallet { + val member = wallet.subject as? GuardedSubject.Member ?: return wallet + val name = database.profileDao().getProfileByPublicKey(member.ownerPublicKey)?.humanReadableNameOrPubkey() + return wallet.copy(subject = member.copy(ownerName = name)) + } + /** * Every guarded wallet [ancestorChatRoomId] has been told about and can sign * for, one per descendant account on each network. @@ -135,10 +207,19 @@ object GuardianManager { val thresholdPublicKey = GroupWalletManager.thresholdKeyFor(database, ancestorChatRoomId) ?: return emptyList() val order = compareBy({ it.openedAt }, { it.statement.id }) - return database.marmotInnerEventDao() + // What it was told, and -- for its own members' wallets -- what it signed: + // the group holds a member wallet certificate it signed, and needs no + // notice to learn of it. + val told = database.marmotInnerEventDao() .getByChatRoomAndKinds(ancestorChatRoomId, listOf(GuardedWalletNoticeEvent.KIND)) .mapNotNull { row -> Event.fromJsonOrNull(row.content) } + val signed = database.groupSignedEventDao() + .getByChatRoomIdAndKind(ancestorChatRoomId, MemberWalletCertificateEvent.KIND) + .map { it.toEvent() } + + return (told + signed) .mapNotNull { verify(it, ancestorChatRoomId, thresholdPublicKey) } + .map { named(database, it) } .groupBy { Triple(it.descendantChatRoomId, it.chain, it.account.account) } .mapNotNull { (_, statements) -> val first = statements.minWithOrNull(order) ?: return@mapNotNull null @@ -161,9 +242,12 @@ object GuardianManager { /** A guarded statement this device can carry upward, and the rooms it can carry it into. */ data class Shareable( val statement: Event, - /** What the statement's room was certified as, for the screen. */ + /** What the statement's room was certified as, for the screen. Null for a member's wallet. */ val name: String?, val rooms: List, + /** For a member's wallet: the member, and their profile name where this device knows one. */ + val ownerPublicKey: HexKey? = null, + val ownerName: String? = null, ) /** @@ -180,25 +264,37 @@ object GuardianManager { val certificate = GroupWalletStatementEvent.read(statement.tags, statement.content)?.certificate statement to (certificate?.let { SubgroupBirthCertificateEvent.parseName(it.tags) }) } + // Everything it guards or was told of -- its own members' wallets among + // them, since it holds those certificates itself -- passed on a + // generation further. val passedOn = guardedWalletsOf(database, chatRoomId) .filter { it.chain == chain } - .map { it.statement to it.name } - return (listOfNotNull(own) + passedOn).mapNotNull { (statement, name) -> - val rooms = targetsFor(database, statement, excluding = chatRoomId) - rooms.takeIf { it.isNotEmpty() }?.let { Shareable(statement, name, it) } + val candidates = listOfNotNull(own?.let { (statement, name) -> Shareable(statement, name, emptyList()) }) + + passedOn.map { wallet -> + val member = wallet.subject as? GuardedSubject.Member + Shareable(wallet.statement, wallet.name, emptyList(), member?.ownerPublicKey, member?.ownerName) + } + + return candidates.mapNotNull { candidate -> + val rooms = targetsFor(database, candidate.statement, excluding = chatRoomId) + rooms.takeIf { it.isNotEmpty() }?.let { candidate.copy(rooms = it) } } } + /** The guardians [statement] names, nearest first: a subgroup's statement's, or a member wallet certificate's. */ + private fun guardiansNamedIn(statement: Event): List = when (statement.kind) { + MemberWalletCertificateEvent.KIND -> GuardianTag.parseAll(statement.tags).orEmpty() + else -> GroupWalletStatementEvent.read(statement.tags, statement.content)?.guardians.orEmpty() + } + /** * The guardian rooms of [statement] this device can post into and has not * told it yet. Only Marmot rooms: a guardian is a group with a key, and a * group with a key has an MLS room. */ private suspend fun targetsFor(database: BennuDatabase, statement: Event, excluding: String): List { - val guardians = GroupWalletStatementEvent.read(statement.tags, statement.content)?.guardians.orEmpty() - - return guardians + return guardiansNamedIn(statement) .map { it.chatRoomId } .filterNot { it.equals(excluding, ignoreCase = true) } .mapNotNull { database.chatRoomDao().findChatRoomById(it) } @@ -333,7 +429,10 @@ object GuardianManager { val thresholdPublicKey = GroupWalletManager.thresholdKeyFor(database, chatRoomId) ?: return null val wallet = verify(statement, chatRoomId, thresholdPublicKey) ?: return null - return wallet.name?.let { "Shared the guarded wallet of $it with this group." } - ?: "Shared a subgroup's guarded wallet with this group." + return when (val subject = named(database, wallet).subject) { + is GuardedSubject.Member -> "Shared @${subject.ownerName ?: subject.ownerPublicKey.take(8)}'s guarded wallet with this group." + is GuardedSubject.Subgroup -> subject.name?.let { "Shared the guarded wallet of $it with this group." } + ?: "Shared a subgroup's guarded wallet with this group." + } } } diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/GroupWalletScreen.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/GroupWalletScreen.kt index 6043aeb0..cfc52221 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/GroupWalletScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/GroupWalletScreen.kt @@ -80,6 +80,7 @@ import bennu.composeapp.generated.resources.nothing_has_been_sent_to_this_wallet import bennu.composeapp.generated.resources.open_a_group_wallet import bennu.composeapp.generated.resources.open_a_guarded_wallet import bennu.composeapp.generated.resources.a_subgroup +import bennu.composeapp.generated.resources.at_s import bennu.composeapp.generated.resources.couldn_t_share_the_wallet import bennu.composeapp.generated.resources.guarded_wallets import bennu.composeapp.generated.resources.not_yet_shared_with_the_groups_above @@ -677,12 +678,13 @@ private fun LazyListScope.guardianItems( items(guardedWallets, key = { "guarded-" + it.wallet.statement.id }) { row -> ListItem( leadingContent = { Icon(Icons.Default.AccountBalanceWallet, contentDescription = Decorative) }, - headlineContent = { Text(row.wallet.name ?: stringResource(Res.string.a_subgroup), maxLines = 1, overflow = TextOverflow.Ellipsis) }, + headlineContent = { Text(guardedName(row.wallet.subject), maxLines = 1, overflow = TextOverflow.Ellipsis) }, supportingContent = { - Text( - row.withinReach?.let { stringResource(Res.string.s_sats_within_this_group_s_reach, it.grouped()) } - ?: stringResource(Res.string.balance_not_known_yet) - ) + val reach = row.withinReach?.let { stringResource(Res.string.s_sats_within_this_group_s_reach, it.grouped()) } + ?: stringResource(Res.string.balance_not_known_yet) + // A member's label says which of their wallets it is. + val label = (row.wallet.subject as? GuardianManager.GuardedSubject.Member)?.label + Text(label?.let { stringResource(Res.string.s_dot_s, it, reach) } ?: reach) }, trailingContent = onSpend?.let { spend -> { @@ -701,7 +703,15 @@ private fun LazyListScope.guardianItems( } items(shareable, key = { "shareable-" + it.statement.id }) { candidate -> ListItem( - headlineContent = { Text(candidate.name ?: stringResource(Res.string.a_subgroup), maxLines = 1, overflow = TextOverflow.Ellipsis) }, + headlineContent = { + Text( + text = candidate.ownerPublicKey?.let { stringResource(Res.string.at_s, candidate.ownerName ?: it.take(8)) } + ?: candidate.name + ?: stringResource(Res.string.a_subgroup), + maxLines = 1, + overflow = TextOverflow.Ellipsis, + ) + }, supportingContent = { Text(stringResource(Res.string.not_yet_shared_with_the_groups_above)) }, trailingContent = { TextButton(onClick = { onShare(candidate) }, enabled = !isPending) { @@ -713,6 +723,18 @@ private fun LazyListScope.guardianItems( } } +/** + * A guarded wallet as an ancestor's list names it: a subgroup by the name its + * parent certified -- `#Translation` -- and a member by their profile's name -- + * `@alice` -- falling back to the start of their key. A person's name is theirs + * and live; the certificate fixes who they are, not what they are called. + */ +@Composable +internal fun guardedName(subject: GuardianManager.GuardedSubject): String = when (subject) { + is GuardianManager.GuardedSubject.Subgroup -> subject.name ?: stringResource(Res.string.a_subgroup) + is GuardianManager.GuardedSubject.Member -> stringResource(Res.string.at_s, subject.ownerName ?: subject.ownerPublicKey.take(8)) +} + @Composable internal fun BalanceCard(walletState: GroupWalletState?) { Card(modifier = Modifier.fillMaxWidth()) { diff --git a/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/GroupFixtures.kt b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/GroupFixtures.kt index 18e6b1db..05ca1340 100644 --- a/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/GroupFixtures.kt +++ b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/GroupFixtures.kt @@ -31,6 +31,8 @@ import fr.acinq.bitcoin.crypto.frost.IndividualNonce import fr.acinq.bitcoin.crypto.frost.KeyMaterial import fr.acinq.bitcoin.crypto.frost.SecretNonce import fr.acinq.bitcoin.crypto.frost.Session +import fr.acinq.bitcoin.crypto.frost.TweakCache +import fr.acinq.bitcoin.ByteVector64 import kotlin.time.Instant /** @@ -185,9 +187,11 @@ internal object GroupFixtures { return requireNotNull(db.chatRoomDao().findChatRoomById(roomId)) } - private fun signature(material: KeyMaterial, eventId: String): String { - val cache = SharedKeyDerivation.derive(thresholdKeyOf(material), path).cache - val message = ByteVector(eventId.hexToByteArray()) + private fun signature(material: KeyMaterial, eventId: String): String = + signWith(material, SharedKeyDerivation.derive(thresholdKeyOf(material), path).cache, ByteVector(eventId.hexToByteArray())).toHex() + + /** A 2-of-3 FROST signature by [material]'s quorum over [message] under [cache] -- a leaf's, an address's, the room's. */ + fun signWith(material: KeyMaterial, cache: TweakCache, message: ByteVector): ByteVector64 { val signerIds = listOf(0, 1) val nonces = signerIds.map { signerId -> @@ -212,6 +216,6 @@ internal object GroupFixtures { val partials = signerIds.mapIndexed { position, signerId -> session.sign(nonces[position].first, material.secretShares[signerId], signerId.toUInt()).right!! } - return session.aggregateSigs(partials).right!!.toByteArray().toHex() + return session.aggregateSigs(partials).right!! } } diff --git a/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/MemberWalletGuardianJvmTest.kt b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/MemberWalletGuardianJvmTest.kt new file mode 100644 index 00000000..c6cad631 --- /dev/null +++ b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/MemberWalletGuardianJvmTest.kt @@ -0,0 +1,205 @@ +package com.machankura.bennu.compose.managers + +import androidx.room3.Room +import com.machankura.bennu.compose.database.BennuDatabase +import com.machankura.bennu.compose.database.builder.getRoomDatabase +import com.machankura.bennu.compose.database.model.GroupSignedEvent +import com.machankura.bennu.compose.database.model.MarmotInnerEvent +import com.machankura.bennu.compose.managers.GroupFixtures.fileKeyState +import com.machankura.bennu.compose.managers.GroupFixtures.guardedCertificate +import com.machankura.bennu.compose.managers.GroupFixtures.keyMaterial +import com.machankura.bennu.compose.managers.GroupFixtures.roomOf +import com.machankura.bennu.compose.managers.GroupFixtures.signWith +import com.machankura.bennu.compose.managers.GroupFixtures.signedAsRoom +import com.machankura.bennu.compose.managers.GroupFixtures.signingRoom +import com.machankura.bennu.compose.managers.GroupFixtures.thresholdKeyOf +import com.machankura.bennu.compose.managers.GuardianManager.GuardedSubject +import com.machankura.bennu.compose.nostr.wallet.GuardedWalletNoticeEvent +import com.machankura.bennu.compose.nostr.wallet.MemberWalletCertificateEvent +import com.machankura.bennu.compose.nostr.wallet.MemberWalletRequestEvent +import com.machankura.bennu.compose.wallet.GroupSpend +import com.machankura.bennu.compose.wallet.GroupSpendBuilder +import com.machankura.bennu.compose.wallet.GroupWalletState +import com.vitorpamplona.quartz.nip01Core.core.Event +import fr.acinq.bitcoin.ByteVector +import fr.acinq.bitcoin.ByteVector32 +import fr.acinq.bitcoin.Chain +import fr.acinq.bitcoin.OutPoint +import fr.acinq.bitcoin.PrivateKey +import fr.acinq.bitcoin.Satoshi +import fr.acinq.bitcoin.ScriptFlags +import fr.acinq.bitcoin.Transaction +import fr.acinq.bitcoin.TxId +import fr.acinq.bitcoin.TxIn +import fr.acinq.bitcoin.TxOut +import fr.acinq.lightning.blockchain.electrum.WalletState +import fr.acinq.secp256k1.Hex +import kotlinx.coroutines.runBlocking +import kotlin.test.AfterTest +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFails +import kotlin.test.assertIs +import kotlin.test.assertNotNull +import kotlin.test.assertNull +import kotlin.test.assertTrue +import kotlin.time.Instant + +/** + * The guardians' side of a member's wallet: the group that signed its + * certificate lists it, a group above learns of it from a notice and lists it + * too, each finds its own leaf in the wallet's addresses, and a spend through + * that leaf is one the script interpreter takes once the coin is 12 blocks old. + */ +class MemberWalletGuardianJvmTest { + private val db: BennuDatabase = getRoomDatabase(Room.inMemoryDatabaseBuilder()) + + @AfterTest + fun closeDb() = db.close() + + private val chain = Chain.Regtest + + private fun privateKey(seed: Long): PrivateKey = PrivateKey(ByteVector32(Hex.decode(seed.toString(16).padStart(64, '0')))) + + private val parent = keyMaterial("9a9e") + private val group = keyMaterial("6a0b") + private val stranger = keyMaterial("57a9") + private val groupRoom = roomOf(group) + private val parentRoom = roomOf(parent) + + private val member = privateKey(0x3e3be7) + private val memberPublicKey = member.xOnlyPublicKey().value.toHex() + private val walletPrivateKey = privateKey(0xa11ce) + private val walletId = MemberWalletDerivation.walletId(walletPrivateKey.publicKey()) + + private val grant = GuardianDerivation.grant( + thresholdKeyOf(group), groupRoom, + GuardianDerivation.grant(thresholdKeyOf(parent), parentRoom, emptyList(), groupRoom), + walletId, + ) + + private fun certificate(guardians: List = grant): Event { + val request = MemberWalletRequestEvent.build( + memberPrivateKey = member, + groupChatRoomId = groupRoom, + walletPrivateKey = walletPrivateKey, + account = MemberWalletDerivation.account(walletPrivateKey.publicKey(), chain, guardians), + label = "Savings", + createdAt = 1_700_000_000, + ) + val template = MemberWalletCertificateEvent.template(request) + return signedAsRoom(group, template.kind, template.tags, template.content, template.createdAt) + } + + /** This device in [material]'s room, holding its verified key state. */ + private suspend fun inRoom(material: fr.acinq.bitcoin.crypto.frost.KeyMaterial, certificate: Event? = null) { + signingRoom(db, material, members = listOf(memberPublicKey), subject = "#" + roomOf(material).take(4)) + fileKeyState(db, material, certificate) + } + + private suspend fun fileSigned(certificate: Event) = + db.groupSignedEventDao().upsert(GroupSignedEvent.fromEvent(certificate, chatRoomId = groupRoom, derivationPath = SharedKeyDerivation.formatPath(GroupFixtures.path), frostSigningSessionId = null)) + + private suspend fun noticeIn(room: String, statement: Event) = + db.marmotInnerEventDao().upsert( + MarmotInnerEvent( + id = statement.id.take(60) + "0000", + publicKey = memberPublicKey, + kind = GuardedWalletNoticeEvent.KIND, + createdAt = Instant.fromEpochSeconds(1_700_000_100), + tags = arrayOf(arrayOf("h", room)), + content = statement.toJson(), + chatRoomId = room, + ) + ) + + @Test + fun `the group that signed it lists its member's wallet as theirs`(): Unit = runBlocking { + GroupFixtures.seedProfile(db, memberPublicKey, name = "alice") + inRoom(group, guardedCertificate(parent, group)) + fileSigned(certificate()) + + val listed = GuardianManager.guardedWalletsOf(db, groupRoom).single() + val subject = assertIs(listed.subject) + assertEquals(walletId, subject.id) + assertEquals(memberPublicKey, subject.ownerPublicKey) + assertEquals("alice", subject.ownerName) + assertEquals("Savings", subject.label) + assertEquals(walletId, listed.descendantChatRoomId) + assertEquals(listOf(walletId), listed.lineage) + assertEquals(0, listed.position) + assertNull(listed.name, "a member's wallet has no founding name") + assertEquals("@alice", listed.spender().name) + } + + @Test + fun `a group above learns of it from a notice, and walks down to its own leaf`(): Unit = runBlocking { + inRoom(parent) + noticeIn(parentRoom, certificate()) + + val listed = GuardianManager.guardedWalletsOf(db, parentRoom).single() + assertEquals(listOf(groupRoom, walletId), listed.lineage) + assertEquals(1, listed.position) + assertTrue(GuardianManager.describeNotice(db, parentRoom, Event("1".repeat(64), memberPublicKey, 1, GuardedWalletNoticeEvent.KIND, emptyArray(), certificate().toJson(), ""))!!.startsWith("Shared @")) + } + + @Test + fun `a notice whose entry for this group is not the key it reaches is ignored`(): Unit = runBlocking { + inRoom(parent) + // The group signed a certificate naming the stranger's key under the parent's room. + val forged = listOf(grant[0], GuardianDerivation.grant(thresholdKeyOf(stranger), parentRoom, emptyList(), groupRoom).single().grantedTo(walletId)) + noticeIn(parentRoom, certificate(forged)) + assertTrue(GuardianManager.guardedWalletsOf(db, parentRoom).isEmpty()) + } + + @Test + fun `a member of both groups can carry it upward`(): Unit = runBlocking { + inRoom(group, guardedCertificate(parent, group)) + inRoom(parent) + fileSigned(certificate()) + + val shareable = GuardianManager.shareableFrom(db, groupRoom, chain).single() + assertEquals(memberPublicKey, shareable.ownerPublicKey) + assertEquals(listOf(parentRoom), shareable.rooms.map { it.chatRoom.id }) + + GuardianManager.share(db, shareable.statement, shareable.rooms, memberPublicKey) + assertEquals(walletId, GuardianManager.guardedWalletsOf(db, parentRoom).single().descendantChatRoomId) + assertTrue(GuardianManager.shareableFrom(db, groupRoom, chain).isEmpty(), "told once") + } + + @Test + fun `a guardian's spend through its leaf of a member's wallet`(): Unit = runBlocking { + inRoom(parent) + noticeIn(parentRoom, certificate()) + val wallet = GuardianManager.guardedWalletsOf(db, parentRoom).single() + + // One coin at receive address 2, confirmed long enough ago. + val derived = GroupWalletDerivation.derive(wallet.account, GroupWalletDerivation.RECEIVE, 2) + val funding = Transaction(2, listOf(TxIn(OutPoint(TxId(ByteVector32(ByteArray(32) { 3 })), 0), ByteVector.empty, 0xffffffffL)), listOf(TxOut(Satoshi(60_000), derived.pubkeyScript)), 0) + val meta = WalletState.AddressMeta.Derived(2) + val receive = WalletState(mapOf(derived.address(chain) to WalletState.AddressState(meta, true, listOf(WalletState.Utxo(funding.txid, 0, 100, funding, meta))))) + val change = WalletState(mapOf(GroupWalletDerivation.derive(wallet.account, GroupWalletDerivation.CHANGE, 0).address(chain) to WalletState.AddressState(WalletState.AddressMeta.Derived(0), false, emptyList()))) + val state = GroupWalletState(wallet.account, receive, change, tipHeight = 200) + + val spender = wallet.spender(thresholdKeyOf(parent)) + val built = assertIs(GroupSpendBuilder.sendAll(state, "bcrt1qw508d6qejxtdg4y5r3zarvary0c5xw7kygt080", 3L, emptySet(), spender)) + val checked = assertIs(GroupSpend.check(built.psbt, wallet.account, spender)).checked + + val signatures = checked.inputs.map { signWith(parent, it.cache, it.sighash) } + val signed = checked.witnessed(signatures) + signed.correctlySpends(checked.inputs.associate { it.outPoint to it.txOut }, ScriptFlags.STANDARD_SCRIPT_VERIFY_FLAGS) + assertEquals(3, signed.txIn.single().witness.stack.size, "signature, leaf, control block") + + // The member's own device names who took it. + val taken = GuardianManager.takenIn(signed, wallet.account, mapOf(funding.let { OutPoint(it, 0) } to (funding.txOut[0] to derived))) + assertEquals(parentRoom, taken.single().guardian.chatRoomId) + + // Eleven blocks is too soon: the same spend at sequence 11, signed properly + // for that sequence, so the only thing wrong with it is the lock. + val input = checked.inputs.single() + val unsigned = checked.tx.let { tx -> Transaction(tx.version, tx.txIn.map { it.copy(sequence = 11, witness = fr.acinq.bitcoin.ScriptWitness.empty) }, tx.txOut, tx.lockTime) } + val sighash = unsigned.hashForSigningTaprootScriptPath(0, checked.spentOutputs, fr.acinq.bitcoin.SigHash.SIGHASH_DEFAULT, input.leaf!!.hash()) + val early = unsigned.updateWitness(0, input.witness(signWith(parent, input.cache, sighash))) + assertFails { early.correctlySpends(checked.inputs.associate { it.outPoint to it.txOut }, ScriptFlags.STANDARD_SCRIPT_VERIFY_FLAGS) } + } +} From ece52a12fd9d8333e7412a9447b91145c6464010 Mon Sep 17 00:00:00 2001 From: Kgothatso Ngako Date: Sat, 24 Oct 2026 07:58:05 +0200 Subject: [PATCH 20/21] feat(groups): a group's page lists its members' wallets, and a person's page the groups guarding them (Phase 11) ChatRoomDetailScreen gets a Members' guarded wallets section of its own under Subgroups: a row is a person, @name and the wallet's label, and it opens their profile rather than a room. A request no signer has put to the group yet says so, and a share-holder can put it to the group from the row; a member who could ask has the way in beneath. ProfilePreviewScreen lists the person's wallets the groups this profile is in guard, one row per guarding group, with Spend where this device holds a share -- the guardian spend the wallet screen already makes. Co-Authored-By: Claude Opus 5.5 --- .../composeResources/values/strings.xml | 6 + .../DatabaseMemberWalletRepository.kt | 24 ++++ .../compose/managers/MemberWalletManager.kt | 57 +++++++++ .../repository/MemberWalletRepository.kt | 15 +++ .../ui/composable/ChatRoomDetailScreen.kt | 110 +++++++++++++++++- .../ui/composable/ProfilePreviewScreen.kt | 70 ++++++++++- .../ui/composable/navigation/BennuNavHost.kt | 3 + .../ui/view/model/ChatRoomDetailViewModel.kt | 34 ++++++ .../model/PersonGuardedWalletsViewModel.kt | 39 +++++++ .../ui/view/state/ChatRoomDetailUIState.kt | 11 ++ .../managers/MemberWalletPagesJvmTest.kt | 103 ++++++++++++++++ 11 files changed, 466 insertions(+), 6 deletions(-) create mode 100644 composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/PersonGuardedWalletsViewModel.kt create mode 100644 composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/MemberWalletPagesJvmTest.kt diff --git a/composeApp/src/commonMain/composeResources/values/strings.xml b/composeApp/src/commonMain/composeResources/values/strings.xml index 1a5ddf81..94d160e6 100644 --- a/composeApp/src/commonMain/composeResources/values/strings.xml +++ b/composeApp/src/commonMain/composeResources/values/strings.xml @@ -623,4 +623,10 @@ Sent, waiting for the network to report it In the mempool @%1$s + Members' guarded wallets + Ask this group to guard a wallet for you + Asked by %1$s, not yet signed + Put to the group + Couldn't put it to the group. + Wallets your groups guard diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/repository/DatabaseMemberWalletRepository.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/repository/DatabaseMemberWalletRepository.kt index d43661e9..05308e02 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/repository/DatabaseMemberWalletRepository.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/database/repository/DatabaseMemberWalletRepository.kt @@ -2,7 +2,10 @@ package com.machankura.bennu.compose.database.repository import co.touchlab.kermit.Logger import com.machankura.bennu.compose.database.BennuDatabase +import com.machankura.bennu.compose.database.model.FrostSigningSession import com.machankura.bennu.compose.database.model.MemberWallet +import com.machankura.bennu.compose.managers.GuardianManager +import com.vitorpamplona.quartz.nip01Core.core.Event import com.machankura.bennu.compose.database.model.MemberWalletSpend import fr.acinq.bitcoin.Transaction import fr.acinq.bitcoin.psbt.Psbt @@ -97,6 +100,27 @@ class DatabaseMemberWalletRepository( override fun observeSpends(walletId: String): Flow> = database.memberWalletDao().observeSpends(walletId) + override suspend fun memberWalletsOf(chatRoomId: String): List = try { + MemberWalletManager.memberWalletsOf(database, chatRoomId) + } catch (e: Throwable) { + logger.e("Error reading the member wallets $chatRoomId guards", e) + emptyList() + } + + override suspend fun putToGroup(chatRoomId: String, request: Event): FrostSigningSession { + val identity = activeIdentity.value ?: throw IllegalStateException("No profile is active") + val room = database.chatRoomDao().findChatRoomById(chatRoomId) ?: throw IllegalStateException("No such group here") + return MemberWalletManager.putToGroup(database, room, identity.nostrPublicKey, request) + } + + override suspend fun guardedByGroupsHere(ownerPublicKey: HexKey): List = try { + val viewer = activeIdentity.value?.nostrPublicKey ?: return emptyList() + MemberWalletManager.guardedByGroupsHere(database, viewer, ownerPublicKey) + } catch (e: Throwable) { + logger.e("Error reading the wallets of $ownerPublicKey this profile's groups guard", e) + emptyList() + } + companion object { private const val TAG = "DatabaseMemberWalletRepository" } diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/MemberWalletManager.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/MemberWalletManager.kt index eff3f0db..769d457f 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/MemberWalletManager.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/managers/MemberWalletManager.kt @@ -547,6 +547,63 @@ object MemberWalletManager { ) } + // ---- Shown from the group, and from the person ----------------------- + + /** A member's wallet as the guarding group's page lists it: certified, or asked for and not yet put to the group. */ + data class GroupMemberWallet( + val walletId: String, + val ownerPublicKey: HexKey, + /** The member's profile name on this device, or null. */ + val ownerName: String?, + val label: String?, + val request: Event, + val isCertified: Boolean, + ) + + /** + * The member wallets [chatRoomId] guards, and the requests still waiting for + * a signer to put them to it -- the group's page's *Members' guarded + * wallets*, which is never mixed into its subgroups: a row there is a + * person, not a room. + */ + suspend fun memberWalletsOf(database: BennuDatabase, chatRoomId: String): List { + suspend fun nameOf(publicKey: HexKey) = database.profileDao().getProfileByPublicKey(publicKey)?.humanReadableNameOrPubkey() + val certified = certificatesOf(database, chatRoomId).map { + GroupMemberWallet(it.walletId, it.memberPublicKey, nameOf(it.memberPublicKey), it.label, it.request, isCertified = true) + } + val waiting = awaitingSponsor(database, chatRoomId).map { + GroupMemberWallet(it.reading.walletId, it.reading.memberPublicKey, nameOf(it.reading.memberPublicKey), it.reading.label, it.request, isCertified = false) + } + return certified + waiting + } + + /** + * Every guarded wallet of [ownerPublicKey]'s that a group [viewerPublicKey] + * is in on this device guards, as that group holds it -- the person's page's *Wallets your + * groups guard*. One entry per guarding group: a wallet guarded by a group + * and its parent, both here, is two ways in, each spending through its own + * leaf. + */ + suspend fun guardedByGroupsHere(database: BennuDatabase, viewerPublicKey: HexKey, ownerPublicKey: HexKey): List = + database.chatRoomDao().getChatRoomListByUserPublicKey(viewerPublicKey) + .filter { it.chatRoom.mlsGroupState != null } + .flatMap { room -> + val wallets = runCatching { GuardianManager.guardedWalletsOf(database, room.chatRoom.id) }.getOrDefault(emptyList()) + .filter { (it.subject as? GuardianManager.GuardedSubject.Member)?.ownerPublicKey.equals(ownerPublicKey, ignoreCase = true) } + if (wallets.isEmpty()) return@flatMap emptyList() + val canSpend = FrostSigningManager.canSign(database, room.chatRoom.id) + wallets.map { GuardedHere(it, room.chatRoom.subject?.takeIf { name -> name.isNotBlank() }, canSpend) } + } + + /** A member's wallet as one of the guarding groups on this device holds it. */ + data class GuardedHere( + val wallet: GuardianManager.GuardedWallet, + /** The guarding group's room name here. */ + val guardianName: String?, + /** Whether this device holds a share of that group's key, and so can propose a spend through its leaf. */ + val canSpend: Boolean, + ) + private suspend fun noticesIn(database: BennuDatabase, chatRoomId: String): List = database.marmotInnerEventDao() .getByChatRoomAndKinds(chatRoomId, listOf(GroupKeyNoticeEvent.KIND)) diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/repository/MemberWalletRepository.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/repository/MemberWalletRepository.kt index 8238c2e8..812ca85c 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/repository/MemberWalletRepository.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/repository/MemberWalletRepository.kt @@ -1,6 +1,9 @@ package com.machankura.bennu.compose.repository +import com.machankura.bennu.compose.database.model.FrostSigningSession import com.machankura.bennu.compose.database.model.MemberWallet +import com.machankura.bennu.compose.managers.GuardianManager +import com.vitorpamplona.quartz.nip01Core.core.Event import com.machankura.bennu.compose.database.model.MemberWalletSpend import fr.acinq.bitcoin.Transaction import fr.acinq.bitcoin.psbt.Psbt @@ -61,6 +64,15 @@ interface MemberWalletRepository { /** The spends the member signed from [walletId], newest first. */ fun observeSpends(walletId: String): Flow> + /** The member wallets [chatRoomId] guards, and the requests waiting for a signer to put them to it. */ + suspend fun memberWalletsOf(chatRoomId: String): List + + /** Puts a member's request to [chatRoomId]'s quorum as the active profile, which counts as its approval. */ + suspend fun putToGroup(chatRoomId: String, request: Event): FrostSigningSession + + /** Every wallet of [ownerPublicKey]'s a group the active profile is in guards. */ + suspend fun guardedByGroupsHere(ownerPublicKey: HexKey): List + companion object { val NO_OP = object : MemberWalletRepository { override suspend fun groupsOf(ownerPublicKey: HexKey): List = emptyList() @@ -78,6 +90,9 @@ interface MemberWalletRepository { override suspend fun signSpend(walletId: String, psbt: Psbt): Transaction = throw UnsupportedOperationException("no repository") override suspend fun recordChain(txid: String, confirmations: Int?, broadcastAt: Instant?) = Unit override fun observeSpends(walletId: String): Flow> = flowOf(emptyList()) + override suspend fun memberWalletsOf(chatRoomId: String): List = emptyList() + override suspend fun putToGroup(chatRoomId: String, request: Event): FrostSigningSession = throw UnsupportedOperationException("no repository") + override suspend fun guardedByGroupsHere(ownerPublicKey: HexKey): List = emptyList() } } } diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/ChatRoomDetailScreen.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/ChatRoomDetailScreen.kt index 8b86d17a..80e17e69 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/ChatRoomDetailScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/ChatRoomDetailScreen.kt @@ -1,5 +1,21 @@ package com.machankura.bennu.compose.ui.composable +import com.machankura.bennu.compose.managers.MemberWalletManager +import com.machankura.bennu.compose.repository.MemberWalletRepository +import com.machankura.bennu.compose.ui.composable.navigation.routes.NewMemberWalletRoute +import com.machankura.bennu.compose.ui.composable.navigation.routes.FrostSigningRoute +import bennu.composeapp.generated.resources.members_guarded_wallets +import bennu.composeapp.generated.resources.ask_this_group_to_guard_a_wallet_for_you +import bennu.composeapp.generated.resources.asked_by_s_not_yet_signed +import bennu.composeapp.generated.resources.put_to_the_group +import bennu.composeapp.generated.resources.couldn_t_put_it_to_the_group +import bennu.composeapp.generated.resources.at_s +import bennu.composeapp.generated.resources.s_dot_s +import androidx.compose.material.icons.filled.AccountBalanceWallet +import androidx.compose.material3.ListItem +import androidx.compose.material3.minimumInteractiveComponentSize +import androidx.compose.foundation.clickable +import androidx.compose.ui.text.style.TextOverflow import bennu.composeapp.generated.resources.unguarded_wallet import bennu.composeapp.generated.resources.guarded_wallet import com.machankura.bennu.compose.nostr.subgroup.WalletPolicyReading @@ -11,7 +27,6 @@ import bennu.composeapp.generated.resources.open_on_s import bennu.composeapp.generated.resources.not_opened_yet import bennu.composeapp.generated.resources.group_wallet import bennu.composeapp.generated.resources.s_onchain_wallet -import androidx.compose.material.icons.filled.AccountBalanceWallet import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Column import androidx.compose.foundation.layout.Spacer @@ -45,7 +60,6 @@ import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi import androidx.compose.material3.HorizontalDivider import androidx.compose.material3.Icon import androidx.compose.material3.IconButton -import androidx.compose.material3.ListItem import androidx.compose.material3.MaterialTheme import androidx.compose.material3.Scaffold import androidx.compose.material3.Surface @@ -66,7 +80,6 @@ import androidx.compose.ui.platform.LocalClipboardManager import androidx.compose.ui.text.AnnotatedString import androidx.compose.ui.text.font.FontFamily import androidx.compose.ui.text.style.TextAlign -import androidx.compose.ui.text.style.TextOverflow import androidx.compose.ui.unit.dp import androidx.lifecycle.viewmodel.compose.viewModel import com.machankura.bennu.compose.database.model.ChatRoom @@ -154,6 +167,7 @@ fun ChatRoomDetailScreen( initialChatRoomDetailUIState: ChatRoomDetailUIState = ChatRoomDetailUIState.Loading, nostrRepository: NostrRepository, chatRepository: ChatRepository, + memberWalletRepository: MemberWalletRepository = MemberWalletRepository.NO_OP, onNavigateToRoute: (Route) -> Unit, onPopBackToRoute: (Route) -> Unit, onNavigateBack: () -> Unit, @@ -165,9 +179,11 @@ fun ChatRoomDetailScreen( initialChatRoomDetailUIState = initialChatRoomDetailUIState, nostrRepository = nostrRepository, chatRepository = chatRepository, - activeUserPublicKey = activeUserPublicKey + activeUserPublicKey = activeUserPublicKey, + memberWalletRepository = memberWalletRepository, ) ) + val couldNotPutToGroup = stringResource(Res.string.couldn_t_put_it_to_the_group) // Read outside the click handlers: stringResource and rememberNotifier are both // composable, and a lambda passed to onClick is not. @@ -447,6 +463,59 @@ fun ChatRoomDetailScreen( } } + // A member's wallet is a person, not a room, so it is its + // own section and its row opens the person -- there is no + // chat to open. docs/member-guarded-wallets.md, Phase 11. + if (chatRoomDetailUIState.memberWallets.isNotEmpty() || chatRoomDetailUIState.canAskForMemberWallet) { + item { HorizontalDivider() } + item { + Text( + text = stringResource(Res.string.members_guarded_wallets), + style = MaterialTheme.typography.labelMedium + ) + } + items( + items = chatRoomDetailUIState.memberWallets, + key = { "member-wallet-" + it.walletId } + ) { wallet -> + MemberWalletRow( + wallet = wallet, + isPending = chatRoomDetailViewModel.isActionPending.value, + onOpen = { + onNavigateToRoute.invoke( + ProfilePreviewRoute(activeUserPublicKey = activeUserPublicKey, profilePublicKey = wallet.ownerPublicKey) + ) + }, + onPutToGroup = if (!wallet.isCertified && chatRoomDetailUIState.canSponsor) { + { + chatRoomDetailViewModel.putToGroup( + request = wallet.request, + onSuccess = { sessionId -> + onNavigateToRoute.invoke( + FrostSigningRoute(activeUserPublicKey = activeUserPublicKey, chatRoomId = chatRoomId, sessionId = sessionId) + ) + }, + onFailure = { notify(couldNotPutToGroup) }, + ) + } + } else null, + ) + } + if (chatRoomDetailUIState.canAskForMemberWallet) { + item { + TextButton( + onClick = { + onNavigateToRoute.invoke(NewMemberWalletRoute(activeUserPublicKey = activeUserPublicKey, chatRoomId = chatRoomId)) + } + ) { + Icon(Icons.Default.AccountBalanceWallet, contentDescription = Decorative) + Spacer(modifier = Modifier.width(MaterialTheme.spacing.space125)) + Text(stringResource(Res.string.ask_this_group_to_guard_a_wallet_for_you)) + } + } + } + } + item { HorizontalDivider() } @@ -1035,6 +1104,39 @@ private fun SignedWorkRow( } } +/** + * One member's guarded wallet, as the guarding group's page lists it: the + * person, by the live name of their profile, and the label they gave it. A + * request no signer has put to the group yet says so, and offers the one thing + * a signer can do about it. + */ +@Composable +private fun MemberWalletRow( + wallet: MemberWalletManager.GroupMemberWallet, + isPending: Boolean, + onOpen: () -> Unit, + onPutToGroup: (() -> Unit)?, +) { + val name = stringResource(Res.string.at_s, wallet.ownerName ?: wallet.ownerPublicKey.take(8)) + ListItem( + modifier = Modifier.clickable(onClick = onOpen).minimumInteractiveComponentSize(), + leadingContent = { Icon(Icons.Default.AccountBalanceWallet, contentDescription = Decorative) }, + headlineContent = { + Text( + text = wallet.label?.let { stringResource(Res.string.s_dot_s, name, it) } ?: name, + maxLines = 1, + overflow = TextOverflow.Ellipsis, + ) + }, + supportingContent = if (wallet.isCertified) null else { + { Text(stringResource(Res.string.asked_by_s_not_yet_signed, name)) } + }, + trailingContent = onPutToGroup?.let { put -> + { TextButton(onClick = put, enabled = !isPending) { Text(stringResource(Res.string.put_to_the_group)) } } + }, + ) +} + /** * One subgroup, as the parent's record and this device's rooms together have it. * diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/ProfilePreviewScreen.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/ProfilePreviewScreen.kt index 087150f4..1814fa9e 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/ProfilePreviewScreen.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/ProfilePreviewScreen.kt @@ -1,5 +1,19 @@ package com.machankura.bennu.compose.ui.composable +import com.machankura.bennu.compose.repository.MemberWalletRepository +import com.machankura.bennu.compose.managers.MemberWalletManager +import com.machankura.bennu.compose.managers.GuardianManager +import com.machankura.bennu.compose.ui.view.model.PersonGuardedWalletsViewModel +import com.machankura.bennu.compose.ui.composable.navigation.routes.GroupSendRoute +import bennu.composeapp.generated.resources.wallets_your_groups_guard +import bennu.composeapp.generated.resources.guarded_by_s +import bennu.composeapp.generated.resources.a_group +import bennu.composeapp.generated.resources.s_dot_s +import bennu.composeapp.generated.resources.spend +import androidx.compose.material.icons.filled.AccountBalanceWallet +import androidx.compose.material3.ListItem +import androidx.compose.material3.Icon +import com.machankura.bennu.compose.ui.composable.widgets.Decorative import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Column import androidx.compose.foundation.layout.fillMaxSize @@ -14,7 +28,6 @@ import androidx.compose.material3.BottomAppBar import androidx.compose.material3.ExperimentalMaterial3Api import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi import androidx.compose.material3.LoadingIndicator -import androidx.compose.material3.Icon import androidx.compose.material3.MaterialTheme import androidx.compose.material3.Scaffold import androidx.compose.material3.SnackbarHost @@ -46,7 +59,6 @@ import com.machankura.bennu.compose.repository.ChatRepository import com.machankura.bennu.compose.repository.NostrRepository import com.machankura.bennu.compose.ui.composable.navigation.routes.ChatRoomMessagingRoute import com.machankura.bennu.compose.ui.composable.navigation.routes.Route -import com.machankura.bennu.compose.ui.composable.widgets.Decorative import com.machankura.bennu.compose.ui.composable.widgets.EmptyState import com.machankura.bennu.compose.ui.composable.widgets.ErrorState import com.machankura.bennu.compose.ui.composable.widgets.LoadingDataIndicator @@ -91,7 +103,16 @@ fun ProfilePreviewScreen( chatRepository: ChatRepository, onStartChat: (Route) -> Unit, onNavigateBack: () -> Unit, + // The person's guarded wallets that this profile's groups guard + // (docs/member-guarded-wallets.md, Phase 11), and where a spend from one goes. + memberWalletRepository: MemberWalletRepository = MemberWalletRepository.NO_OP, + onNavigateToRoute: (Route) -> Unit = {}, ) { + val personWalletsViewModel: PersonGuardedWalletsViewModel = viewModel( + factory = PersonGuardedWalletsViewModel.factory(ownerPublicKey = profilePublicKey, memberWalletRepository = memberWalletRepository), + ) + LaunchedEffect(true) { personWalletsViewModel.initiate() } + val profilePreviewViewModel: ProfilePreviewViewModel = viewModel( factory = ProfilePreviewViewModel.factory( activeUserPublicKey = activeUserPublicKey, @@ -187,6 +208,24 @@ fun ProfilePreviewScreen( onRetry = { profilePreviewViewModel.retry() }, ) } + + // One's own wallets are listed on one's own profile, with their + // keys; this is the guardians' view of somebody else's. + if (profilePublicKey != activeUserPublicKey && personWalletsViewModel.rows.isNotEmpty()) { + GuardedByYourGroups( + rows = personWalletsViewModel.rows, + onSpend = { row -> + onNavigateToRoute( + GroupSendRoute( + activeUserPublicKey = activeUserPublicKey, + chatRoomId = row.wallet.ancestorChatRoomId, + relayHint = null, + guardedChatRoomId = row.wallet.descendantChatRoomId, + ) + ) + }, + ) + } } } @@ -223,6 +262,33 @@ fun ProfilePreviewScreen( } } +/** + * The person's guarded wallets as this profile's groups hold them: one row per + * guarding group, and -- where this device holds a share of that group's key -- + * the way to spend through its leaf, which is the guardian spend the group's + * wallet screen already offers. + */ +@Composable +private fun GuardedByYourGroups( + rows: List, + onSpend: (MemberWalletManager.GuardedHere) -> Unit, +) { + Column(verticalArrangement = Arrangement.spacedBy(MaterialTheme.spacing.relatedGap)) { + Text(stringResource(Res.string.wallets_your_groups_guard), style = MaterialTheme.typography.titleMedium) + rows.forEach { row -> + val guardian = stringResource(Res.string.guarded_by_s, row.guardianName ?: stringResource(Res.string.a_group)) + val label = (row.wallet.subject as? GuardianManager.GuardedSubject.Member)?.label + ListItem( + leadingContent = { Icon(Icons.Default.AccountBalanceWallet, contentDescription = Decorative) }, + headlineContent = { Text(label?.let { stringResource(Res.string.s_dot_s, it, guardian) } ?: guardian) }, + trailingContent = if (row.canSpend) { + { TextButton(onClick = { onSpend(row) }) { Text(stringResource(Res.string.spend)) } } + } else null, + ) + } + } +} + /** * Who this is: leading-aligned, because rows with an avatar align to a leading edge * and centring is for a block that is the only thing on the screen, which this is 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 8873e5c1..c7f3168c 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 @@ -1081,6 +1081,7 @@ fun BennuNavHost( relayHint = route.relayHint, nostrRepository = databaseNostrRepository, chatRepository = databaseChatRepository, + memberWalletRepository = databaseMemberWalletRepository, onNavigateToRoute = { actionRoute -> navController.navigate( route = actionRoute @@ -1369,6 +1370,8 @@ fun BennuNavHost( profilePublicKey = route.profilePublicKey, nostrRepository = databaseNostrRepository, chatRepository = databaseChatRepository, + memberWalletRepository = databaseMemberWalletRepository, + onNavigateToRoute = { actionRoute -> navController.navigate(route = actionRoute) }, // The room replaces the preview, as it replaces the profile detail // above: back from a chat is the list, not the person it was started // from. diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/ChatRoomDetailViewModel.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/ChatRoomDetailViewModel.kt index cb19cf0e..bbcbb863 100644 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/ChatRoomDetailViewModel.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/ChatRoomDetailViewModel.kt @@ -24,6 +24,9 @@ import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.IO import kotlinx.coroutines.launch import com.machankura.bennu.compose.database.model.types.MarmotReindexReport +import com.machankura.bennu.compose.managers.MemberWalletManager +import com.machankura.bennu.compose.repository.MemberWalletRepository +import com.vitorpamplona.quartz.nip01Core.core.Event class ChatRoomDetailViewModel( val chatRoomId: String, @@ -32,6 +35,8 @@ class ChatRoomDetailViewModel( initialChatRoomDetailUIState: ChatRoomDetailUIState, val nostrRepository: NostrRepository, val chatRepository: ChatRepository, + /** The member wallets this group guards -- `docs/member-guarded-wallets.md`. The no-op lists none. */ + val memberWalletRepository: MemberWalletRepository = MemberWalletRepository.NO_OP, ): ViewModel() { var chatRoomDetailUIState: ChatRoomDetailUIState by mutableStateOf(initialChatRoomDetailUIState) @@ -97,11 +102,38 @@ class ChatRoomDetailViewModel( canAddSubgroup = canSign, canGovern = canGovern, isDisbanded = isDisbanded, + memberWallets = memberWalletRepository.memberWalletsOf(chatRoomId), + // Offered wherever the new-wallet screen could get somewhere: + // a group, a profile that signs, a network it is open on. A key + // this device does not know yet is that screen's to ask for. + canAskForMemberWallet = !isDisbanded && memberWalletRepository.refusal(chatRoomId, NodeParamsManager.chain).let { + it == null || it == MemberWalletManager.Refusal.KEY_UNKNOWN + }, + canSponsor = canSign, ) } } } + /** + * Puts a member's request for a guarded wallet to the group, as this device: + * a signing session over the certificate it asks for, which proposing counts + * as approving. [onSuccess] gets the session, for the screen to move onto. + */ + fun putToGroup(request: Event, onSuccess: (sessionId: String) -> Unit, onFailure: () -> Unit) { + if (isActionPending.value) return + isActionPending.value = true + viewModelScope.launch(Dispatchers.IO) { + val session = runCatching { memberWalletRepository.putToGroup(chatRoomId, request) } + .onFailure { logger.e("Couldn't put a member's wallet to $chatRoomId", it) } + .getOrNull() + viewModelScope.launch(Dispatchers.Main) { + isActionPending.value = false + if (session != null) onSuccess(session.id) else onFailure() + } + } + } + /** * Removes [memberPublicKey] as an admin, and reloads the screen. The commit is * applied when a relay accepts it, so the member's row stays until then; the @@ -214,6 +246,7 @@ class ChatRoomDetailViewModel( initialChatRoomDetailUIState: ChatRoomDetailUIState = ChatRoomDetailUIState.Loading, nostrRepository: NostrRepository, chatRepository: ChatRepository, + memberWalletRepository: MemberWalletRepository = MemberWalletRepository.NO_OP, ): ViewModelProvider.Factory = viewModelFactory { initializer { ChatRoomDetailViewModel( @@ -223,6 +256,7 @@ class ChatRoomDetailViewModel( initialChatRoomDetailUIState = initialChatRoomDetailUIState, nostrRepository = nostrRepository, chatRepository = chatRepository, + memberWalletRepository = memberWalletRepository, ) } } diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/PersonGuardedWalletsViewModel.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/PersonGuardedWalletsViewModel.kt new file mode 100644 index 00000000..fcc13d8f --- /dev/null +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/model/PersonGuardedWalletsViewModel.kt @@ -0,0 +1,39 @@ +package com.machankura.bennu.compose.ui.view.model + +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.setValue +import androidx.lifecycle.ViewModel +import androidx.lifecycle.ViewModelProvider +import androidx.lifecycle.viewModelScope +import androidx.lifecycle.viewmodel.initializer +import androidx.lifecycle.viewmodel.viewModelFactory +import com.machankura.bennu.compose.managers.MemberWalletManager +import com.machankura.bennu.compose.repository.MemberWalletRepository +import com.vitorpamplona.quartz.nip01Core.core.HexKey +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.launch + +/** + * A person's guarded wallets as the groups this profile is in guard them -- + * the person's page's *Wallets your groups guard*. Where a group's page lists a + * member's wallet, its row leads here, since a person is someone to look at, + * not a room to go into. + */ +class PersonGuardedWalletsViewModel( + private val ownerPublicKey: HexKey, + private val memberWalletRepository: MemberWalletRepository, +) : ViewModel() { + var rows: List by mutableStateOf(emptyList()) + private set + + fun initiate() { + viewModelScope.launch(Dispatchers.IO) { rows = memberWalletRepository.guardedByGroupsHere(ownerPublicKey) } + } + + companion object { + fun factory(ownerPublicKey: HexKey, memberWalletRepository: MemberWalletRepository): ViewModelProvider.Factory = viewModelFactory { + initializer { PersonGuardedWalletsViewModel(ownerPublicKey, memberWalletRepository) } + } + } +} diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/ChatRoomDetailUIState.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/ChatRoomDetailUIState.kt index 895ed60f..6a067b82 100755 --- a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/ChatRoomDetailUIState.kt +++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/view/state/ChatRoomDetailUIState.kt @@ -1,5 +1,6 @@ package com.machankura.bennu.compose.ui.view.state +import com.machankura.bennu.compose.managers.MemberWalletManager import com.machankura.bennu.compose.nostr.subgroup.WalletPolicyReading import com.machankura.bennu.compose.nostr.wallet.GroupWallet import com.vitorpamplona.quartz.nip01Core.core.HexKey @@ -86,6 +87,16 @@ sealed interface ChatRoomDetailUIState { * and nobody rejoins, so every write entrance is hidden and the room says so. */ val isDisbanded: Boolean = false, + /** + * The member wallets this group guards, and the requests for one still + * waiting for a signer -- `docs/member-guarded-wallets.md`. Its own + * section, never mixed into [subgroups]: a row here is a person. + */ + val memberWallets: List = emptyList(), + /** Whether this profile could ask this group to guard a wallet for it. */ + val canAskForMemberWallet: Boolean = false, + /** Whether this device holds a share, and so can put a member's request to the group. */ + val canSponsor: Boolean = false, ): ChatRoomDetailUIState data class Error( diff --git a/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/MemberWalletPagesJvmTest.kt b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/MemberWalletPagesJvmTest.kt new file mode 100644 index 00000000..14d50912 --- /dev/null +++ b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/managers/MemberWalletPagesJvmTest.kt @@ -0,0 +1,103 @@ +package com.machankura.bennu.compose.managers + +import androidx.room3.Room +import com.machankura.bennu.compose.database.BennuDatabase +import com.machankura.bennu.compose.database.builder.getRoomDatabase +import com.machankura.bennu.compose.database.model.GroupSignedEvent +import com.machankura.bennu.compose.database.model.MarmotInnerEvent +import com.machankura.bennu.compose.managers.GroupFixtures.fileKeyState +import com.machankura.bennu.compose.managers.GroupFixtures.guardedCertificate +import com.machankura.bennu.compose.managers.GroupFixtures.keyMaterial +import com.machankura.bennu.compose.managers.GroupFixtures.roomOf +import com.machankura.bennu.compose.managers.GroupFixtures.signedAsRoom +import com.machankura.bennu.compose.managers.GroupFixtures.signingRoom +import com.machankura.bennu.compose.nostr.wallet.GuardedWalletNoticeEvent +import com.machankura.bennu.compose.nostr.wallet.MemberWalletCertificateEvent +import com.vitorpamplona.quartz.nip01Core.core.Event +import fr.acinq.bitcoin.ByteVector32 +import fr.acinq.bitcoin.Chain +import fr.acinq.bitcoin.PrivateKey +import fr.acinq.secp256k1.Hex +import kotlinx.coroutines.runBlocking +import kotlin.test.AfterTest +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertTrue +import kotlin.time.Instant + +/** + * What the group's page and the person's page say about member wallets: the + * group lists its members' wallets apart from its subgroups, with the requests + * still waiting for a signer, and the person's page lists every group here that + * guards them. + */ +class MemberWalletPagesJvmTest { + private val db: BennuDatabase = getRoomDatabase(Room.inMemoryDatabaseBuilder()) + + @AfterTest + fun closeDb() = db.close() + + private val chain = Chain.Regtest + + private fun privateKey(seed: Long): PrivateKey = PrivateKey(ByteVector32(Hex.decode(seed.toString(16).padStart(64, '0')))) + + private val parent = keyMaterial("9a9e") + private val group = keyMaterial("6a0b") + private val groupRoom = roomOf(group) + private val parentRoom = roomOf(parent) + + private val alice = privateKey(0xa11ce5) + private val alicePublicKey = alice.xOnlyPublicKey().value.toHex() + private val bob = privateKey(0xb0b5) + private val bobPublicKey = bob.xOnlyPublicKey().value.toHex() + + private suspend fun certify(requestJson: String): Event { + val template = MemberWalletCertificateEvent.template(Event.fromJson(requestJson)) + val signed = signedAsRoom(group, template.kind, template.tags, template.content, template.createdAt) + db.groupSignedEventDao().upsert(GroupSignedEvent.fromEvent(signed, chatRoomId = groupRoom, derivationPath = SharedKeyDerivation.formatPath(GroupFixtures.path), frostSigningSessionId = null)) + return signed + } + + @Test + fun `the group lists its members' wallets, certified and waiting, and never as subgroups`(): Unit = runBlocking { + GroupFixtures.seedProfile(db, alicePublicKey, name = "alice") + signingRoom(db, group, members = listOf(alicePublicKey, bobPublicKey), holdsShare = false) + fileKeyState(db, group, guardedCertificate(parent, group)) + + val certified = MemberWalletManager.request(db, groupRoom, alice, chain, label = "Savings") + certify(certified.requestJson) + val waiting = MemberWalletManager.request(db, groupRoom, bob, chain, label = null) + + val listed = MemberWalletManager.memberWalletsOf(db, groupRoom) + assertEquals(listOf(certified.walletId to true, waiting.walletId to false), listed.map { it.walletId to it.isCertified }) + assertEquals("alice", listed.first().ownerName) + assertEquals("Savings", listed.first().label) + assertEquals(bobPublicKey, listed.last().ownerPublicKey) + assertTrue(SubgroupManager.subgroupsOf(db, groupRoom).isEmpty()) + } + + @Test + fun `the person's page lists every group here that guards them`(): Unit = runBlocking { + signingRoom(db, group, members = listOf(alicePublicKey)) + fileKeyState(db, group, guardedCertificate(parent, group)) + signingRoom(db, parent, members = listOf(alicePublicKey), holdsShare = false, subject = "#Root") + fileKeyState(db, parent) + + val wallet = MemberWalletManager.request(db, groupRoom, alice, chain, label = null) + val certificate = certify(wallet.requestJson) + db.marmotInnerEventDao().upsert( + MarmotInnerEvent( + id = "9".repeat(64), publicKey = alicePublicKey, kind = GuardedWalletNoticeEvent.KIND, + createdAt = Instant.fromEpochSeconds(1_700_000_100), tags = arrayOf(arrayOf("h", parentRoom)), + content = certificate.toJson(), chatRoomId = parentRoom, + ) + ) + + val here = MemberWalletManager.guardedByGroupsHere(db, GroupFixtures.owner, alicePublicKey) + assertEquals(setOf(groupRoom, parentRoom), here.map { it.wallet.ancestorChatRoomId }.toSet()) + assertEquals(true, here.single { it.wallet.ancestorChatRoomId == groupRoom }.canSpend, "a share of the group's key") + assertEquals(false, here.single { it.wallet.ancestorChatRoomId == parentRoom }.canSpend, "none of the root's") + assertEquals("#Root", here.single { it.wallet.ancestorChatRoomId == parentRoom }.guardianName) + assertTrue(MemberWalletManager.guardedByGroupsHere(db, GroupFixtures.owner, bobPublicKey).isEmpty()) + } +} From d2e5fa082db9b005384e05c8be622cb17ef83297 Mon Sep 17 00:00:00 2001 From: Kgothatso Ngako Date: Sat, 24 Oct 2026 08:00:46 +0200 Subject: [PATCH 21/21] docs: member guarded wallets are built, and the notes they touched say so (Phase 12) The plan is marked built, with a table of the thirteen places the build chose differently -- the key notice carrying the key rather than the signed key state, the request travelling whole inside an inner event, Put to the group living on the group's page, the wallet screen following a member's spends while open, and the signet run still to make before the mainnet gate lifts. The guardians and subgroups notes point here, and the README says it has been built. Co-Authored-By: Claude Opus 5.5 --- docs/README.md | 5 +++-- docs/group-wallet-guardians.md | 11 +++++++++++ docs/member-guarded-wallets.md | 25 ++++++++++++++++++++++++- docs/subgroups.md | 4 ++++ 4 files changed, 42 insertions(+), 3 deletions(-) diff --git a/docs/README.md b/docs/README.md index 03f314b8..10a760db 100644 --- a/docs/README.md +++ b/docs/README.md @@ -54,10 +54,11 @@ Phases 4 and 5 first, and its own table of where the build chose differently before the code. The group-wallet-guardians note is a phased plan that has been built; it assumes the subgroups and group-chain-wallet notes, and changes one sentence in each. -The member-guarded-wallets note is a phased plan that has not been built. It +The member-guarded-wallets note is a phased plan that has been built. It takes the guardians note's derivation unchanged and gives the key path to one person: read that note and the policy note's D2 first, then this note's table -of why a birth certificate will not do, and its Phase 0. +of why a birth certificate will not do, its Phase 0, and its table of where the +build chose differently before the code. The subgroup-wallet-policy note is a phased plan that has been built. It reads as the guardians note's *whose choice it is* reversed: read that section, then this note's Phase 0, whose five decisions shape every phase diff --git a/docs/group-wallet-guardians.md b/docs/group-wallet-guardians.md index 074c1126..7195d032 100644 --- a/docs/group-wallet-guardians.md +++ b/docs/group-wallet-guardians.md @@ -330,6 +330,10 @@ every address and a root that cannot find a coin to use it on. A statement forwarded into the middle group can be forwarded again from there, so overlap is needed one level at a time, not between the grandchild and the root directly. +Since [member-guarded-wallets.md](./member-guarded-wallets.md) the thing +forwarded may also be a member wallet certificate, which the guarding group +signed itself and so needs no forwarding into that group. + Once it has the statement, the ancestor watches the descendant's addresses on the Electrum client it already holds — unknown script hashes are ignored, so this costs subscriptions and nothing else — and its wallet screen grows a *Guarded @@ -420,6 +424,13 @@ One commit each. ## What this does not do +**It does not, on its own, guard one person.** That is +[member-guarded-wallets.md](./member-guarded-wallets.md): a wallet whose key +path is one member's random key, carrying exactly the leaves a guarded subgroup +of their group would, under a member wallet certificate (30334) the group signs +over the member's own request. Forwarding, the ancestor's walk and the guardian +spend are the ones here, with the line of descent ending in the wallet's id. + **It does not guard a wallet that is already open.** A subgroup that opened a plain wallet before its certificate carried keys keeps it. Guarding it would be a second account and a spend into it, and the wallet screen shows one account per diff --git a/docs/member-guarded-wallets.md b/docs/member-guarded-wallets.md index 5e46a350..ab9ace7c 100644 --- a/docs/member-guarded-wallets.md +++ b/docs/member-guarded-wallets.md @@ -24,7 +24,30 @@ grant, the leaf, the tree, the signing cache, the forwarding notice and the guardian spend. What is new is who holds the key path, and the artefact the group signs to agree to it. -**Not built.** Written against the code as it stood at `8cb6f04e`, schema v29. +**Built**, phases 1-12, one commit each (Phase 9 in two), written against the +code as it stood at `8cb6f04e`, schema v29; the build is schema v30. +`MemberWalletDerivation`, `MemberWalletRequestEvent`, `MemberWalletCertificateEvent`, +`MemberWalletManager` and `GuardianManager.GuardedSubject` are the entry points, +and `GroupWalletRollout.MEMBER_WALLETS_ON_MAINNET` is the gate, shut. The phases +below are kept as written; where the build chose differently the table says so. + +| what the plan said | what it turned out to be | +|---|---| +| Phase 2: the answer carries the signed `GroupKeyStateEvent`, whole | it carries the threshold key, its path and the group's certificate. A `GroupKeyState` row keeps what the state said and not the event, and nothing in the event is needed beyond what checks itself: the key at the path rederives the room, and the certificate certifies it and names that key | +| Phase 2: the first share-holder by npub answers at once, the rest after a minute | every device holding the verified state answers a request no answer names yet, as the chronicle's request is answered. Duplicates cost bandwidth and nothing else | +| Phase 3: the request is an inner event signed by the member | an inner event is an unsigned rumor, and the row it travels in keeps no `sig`. The signed request travels whole as the content of an inner event of the same kind -- `MemberWalletRequestEvent.carried` -- the way a 30333 notice carries a statement, and only from the member who signed it | +| Phase 5: `MemberWalletSpend` in a later bump | the same bump, v30, beside `MemberWallet` | +| Phase 6: the screens talk to `ChatRepository` | a `MemberWalletRepository` of their own, which holds the active identity: nothing above it touches a key | +| Phase 6: the gate arrives in Phase 12 | with Phase 6, where an entrance is first offered, as the guardians note's gate came with its Phase 5 | +| Phase 7: requests join `observeProposalsAwaitingYou` | *Put to the group* is on the request's row in the group page's *Members' guarded wallets* (Phase 11). The transcript says a request arrived; the proposal list still lists only sessions | +| Phase 7: the summary names the member | `ProposedEvent.summarize` takes a `nameOf`, and the callers that have no profiles to hand pass none, so the proposal list and signing screen say *Guard a member's wallet* without the name. The certificate's `p` tag is the member either way | +| Phase 8: the wipe callers warn first | `wipeDatabase` has no callers and `BennuDatabase.wipeData` deletes nothing. There is nothing to guard yet; a note on `wipeData` says what a caller must do once it does | +| Phase 9: `GroupTransactionWatcher` generalised | a member's spend has no session, so `MemberWalletViewModel` follows the member's spends while the wallet screen is open, sending again any Electrum has not heard of -- the economy the guardian-spend notice makes. *Bump the fee* is not built for a member's spend | +| Phase 10: `descendantChatRoomId` becomes `subject.id`, `statement` becomes `signedEvent` | both keep their names -- `descendantChatRoomId` is `subject.id`, and `statement` is the 30334 for a member -- so the guardian spend path did not change a line. `Spender.Guardian.name` is `@name` for a member | +| Phase 11: the person's page shows the amount within each group's reach | it does not watch the chain, so it shows the guarding group and *Spend*; the group's wallet screen has the amount. On one's own profile the section is not drawn: the profile's own list is the answer there | +| Phase 12: the three-emulator run | not made. It is what lifts the gate | + +Still to do by hand: Phase 12's run on signet. --- diff --git a/docs/subgroups.md b/docs/subgroups.md index 099b6c83..027262cf 100644 --- a/docs/subgroups.md +++ b/docs/subgroups.md @@ -168,6 +168,10 @@ tags: ["p", ] ``` +A member's guarded wallet is not a subgroup and never a 30329: every reader of +this kind assumes a room. It has its own certificate, 30334 -- +[member-guarded-wallets.md](./member-guarded-wallets.md). + With those, a parent admin's device can check the thing that actually matters before it signs — `marmotGroupId(subgroup_key, frost_path) == content` — and `ProposedEvent` can render "Translation team, for Alice, Bob and Carol" rather