Commit Graph
799 Commits
Author SHA1 Message Date
Kgothatso NgakoandClaude Opus 5.5 5c77853cfa feat(wallet): change goes to an address the group can find (Phase 3)
Two open spends with change both paid to the first unused change
address, since a spend waiting for signatures has not used it yet.
Change indices are now reserved like coins: reservedChangeIndices reads
the claims of every open spend, and the builder takes the lowest watched,
unused, unheld index. It chooses among generated addresses only, so
change never lands outside the window; CHANGE_LOOKAHEAD rises to 10 and
past it a spend with change returns TooManyOpen.

The change branch not having answered is FindingChange rather than
NothingToSpend, and change too small to send back is reported as
Built.absorbed and said in the preview.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 12:22:32 +02:00
Kgothatso NgakoandClaude Opus 5.5 bc348419bc feat(wallet): read an amount as whole sats, or say why not (Phase 1)
The gated amount field read its text by dropping every non-digit, so
21000.5 became 210,005 sats and 0.0005 became 5. parseSats accepts
thousands grouping and refuses decimals, grouping that groups nothing,
non-ASCII digits and more sats than exist; the preview reports which.
The field shows plain digits grouped and keeps what was typed.

Also plans the rest in docs/group-send-an-amount.md: send-an-amount
opens on every network at once, held on mainnet by the existing cap.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 12:15:17 +02:00
Kgothatso NgakoandClaude Opus 5.5 96055da584 feat(wallet): call it the group onchain wallet
The wallet screen's title, the room's detail row, the button that opens
one and the proposal summary a member agrees to all said "group wallet".
They now say "group onchain wallet", which is what it holds, and agrees
with GroupOnchainWallet in the code. Sentence case, as every string is.
Resource keys are unchanged.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 11:51:36 +02:00
Kgothatso NgakoandClaude Opus 5.5 707e1465e2 fix(wallet): escape the brace Android's regex engine refuses
DERIVATION_PAYLOAD closed its JSON object with a bare `}`. The JVM reads
that as a literal; ICU, which backs Regex on Android, rejects the
pattern. It was a private val of FrostSigningManager, so the throw came
from the class initialiser, which Android does not retry: every signing
session on the device failed with NoClassDefFoundError until restart.
The first symptom was a ceremony that "couldn't ask the group to agree
its signing key".

The JVM suite cannot ask ICU, so RegexPortabilityJvmTest reads every
Regex literal out of the main source sets and holds it to the stricter
rule: a `}` is escaped, inside a class, or the end of a quantifier. With
the old pattern restored it fails on FrostSigningManager.kt.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 11:12:14 +02:00
Kgothatso NgakoandClaude Opus 5.5 cd7aa36cd0 Merge remote-tracking branch 'origin/bennu' into claude/group-chain-wallet-plan-93f0e1
Every conflict was the curated-lists removal on bennu meeting a wallet
line added beside it: the removal is taken and the wallet lines kept.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 10:04:53 +02:00
Kgothatso NgakoandClaude Opus 5.5 b8194a4ba3 refactor(wallet): GroupChainWallet is GroupOnchainWallet
And its registry, GroupChainWallets, is GroupOnchainWallets, with the
files, the test and the plan's references following.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 09:52:25 +02:00
Kgothatso NgakoandClaude Opus 5.5 f83fe35a45 feat(wallet): ship behind the rollout gates (Phase 10)
GroupWalletRollout holds the three gates, each with what lifts it. The
flag is on, its condition met. Send-an-amount is off, so the form sends
everything confirmed to one address and says so. A spend proposed from
this device on mainnet may send at most 100,000 sats; test networks
have no cap. The gates are on the composer and nothing else: a device
behind them still accepts, shows and signs what another member
proposes, through every check GroupSpend makes.

The plan is marked built, with its table of where the build chose
differently. Full JVM suite: 1474 tests, none failing; the Android
target compiles; every M3 budget is met.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 08:52:16 +02:00
Kgothatso NgakoandClaude Opus 5.5 0db1fe8fc8 feat(wallet): the group's spends on its wallet screen (Phase 9, part 2)
Every spend the room proposed, newest first, for every member whether
or not they have a node: what it sends and where it has got to --
waiting for signatures, abandoned, signed, sent (reported back by
Electrum, not merely broadcast), confirmed, or replaced by a later
spend. A signed spend Electrum has not reported can be sent again; a
signed, unconfirmed one can be bumped to twice its feerate, a new
session over the same coins that whichever confirms settles. Each row
opens its signing session.

Full JVM suite: 1473 tests, none failing.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 08:48:19 +02:00
Kgothatso NgakoandClaude Opus 5.5 58da7c1285 feat(wallet): broadcast signed spends and settle what a confirmation decides (Phase 9, part 1)
GroupTransactionWatcher, one per identity beside its wallets: every
signed spend still on its way is sent from this device too, sent again
every ten minutes while Electrum has not reported it -- its broadcast
reports success whatever the server said -- and followed to a
confirmation. FrostSigningManager.recordConfirmed then settles every
other spend of the same coins: one still collecting is abandoned as
spent by another transaction, one already signed is marked replaced
rather than failed, and the room gets one line saying it confirmed.

GroupSpendBuilder.bump re-spends the same coins at a higher feerate,
the extra taken from the change or, for a send-all, the one payment.

The test caught a stale write: a pass followed each spend from the list
it started with, so settling one spend was undone by writing the next
back from its old copy. follow() reads its row again first.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 08:43:19 +02:00
Kgothatso NgakoandClaude Opus 5.5 b1d5963b53 feat(wallet): a form to propose a spend from the group's wallet (Phase 8, part 2)
GroupSendRoute and GroupSendScreen, behind a Send button on the wallet
screen for a member who holds a share and has a node to see the coins
with. Address, amount or send everything, and a feerate prefilled from
Electrum's six-block estimate. The preview is GroupSpendBuilder over the
same inputs the proposal is built from -- what leaves, the fee, what
comes back as change, or why it cannot be built -- and proposing moves
onto the signing session, replacing the form.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 08:38:19 +02:00
Kgothatso NgakoandClaude Opus 5.5 6d066e19c0 feat(wallet): build a spend and show it for approval (Phase 8, part 1)
GroupSpendBuilder: send-all, as Phoenix's final wallet does, and an
amount paid largest coin first with change to the next change address,
or to fees when it would be dust. Confirmed coins only, never one an
open spend already holds; the fee is exact before signing because every
witness is 64 bytes. Every built spend passes GroupSpend.check.

The signing screen draws a spend where it draws events: every output
with its address and amount, change labelled, the fee and feerate, and
the coins spent -- read from FrostSigningManager.checkedSpend, the
stored PSBT checked again, and unsignable when this device cannot check
it. The proposal list and the chat notice say "Spend from the group's
wallet". FrostSigningRepository gains proposeSpend, checkedSpend and
reservedOutPoints.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 08:33:36 +02:00
Kgothatso NgakoandClaude Opus 5.5 a24c107b26 feat(wallet): the signing manager signs a spend from the group's wallet (Phase 7)
Kind 30332 opens a session over a PSBT, one item per input, each its own
FROST instance over that input's BIP341 sighash with its own nonce seed
and its own tweak cache. proposeSpend and acceptSpendProposal run the
same GroupSpend checks: every input derives under the account the
room's verified statement gives -- looked up under the ceremony's own
key -- default sighash only, no script-path fields, replaceable, change
only where its claim derives, and a fee under a ceiling. A second
proposal under one id is ignored. completeSpend checks each signature
against its coin's output key and the whole transaction with
correctlySpends before writing it.

An old build does not route 30332, so it never signs a transaction it
cannot show. Resend repeats the PSBT byte for byte. Two-device test:
a quorum spends two coins and both devices hold a transaction that
correctlySpends; each check refuses a hand-built proposal outright.
Full JVM suite: 1458 tests, none failing.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 08:28:32 +02:00
Kgothatso NgakoandClaude Opus 5.5 f7a9e05bbc feat(wallet): schema v26 for spends from a group's wallet (Phase 6)
FrostSigningSession.subject, NOT NULL with a default of EVENTS, says
what a session's items are messages of; FrostSigningItem.inputIndex
names the input a transaction item signs, with message and payload as
getters over the existing columns. GroupTransaction holds a spend from
proposal on: the PSBT, written once with IGNORE, the txid fixed before
signing, and the signed transaction, broadcast, seen and confirmed.

AutoMigration(25, 26) is three ADD COLUMNs and a CREATE TABLE -- no
rebuild of either signing table, so no cascade fires.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 08:15:00 +02:00
Kgothatso NgakoandClaude Opus 5.5 24d06d2eee feat(wallet): a screen to open a group's wallet and receive into it (Phase 5)
GroupWalletRoute and GroupWalletScreen, reached from a Group wallet row
on the group's screen. A group that has not opened a wallet gets an
empty state with, for a member who can sign, what opening one asks of
everybody -- including that shares are unencrypted at rest -- and the
button that proposes the statement. An open wallet shows the balance,
confirmed and on the way said apart, the next receive address as a
BIP21 QR code, selectable text and a copy button, the coins, and an
export of the two watch-only descriptors with what they give away.

The wallets are watched on the identity's own Electrum client and made
per PhoenixBusiness in BennuNavHost; a profile with no node sees the
wallet and is told it cannot watch the chain.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 08:11:47 +02:00
Kgothatso NgakoandClaude Opus 5.5 4ab47ba432 feat(wallet): watch a group's wallet on the identity's Electrum client (Phase 4)
GroupChainWallet is Phoenix's FinalWallet for a group: two
ElectrumMiniWallets, one per BIP44 branch since a mini-wallet holds one
generator, gap-limited at 10 for receive and 3 for change, on the shared
client. GroupWalletState gives the coins with the derivation that spends
each, the confirmed and pending balances, the next receive address and
change index, and derivationOf -- bounded by the addresses the wallet
has generated, which is how far a check of a claim will look.

Tested against a fake IElectrumClient: a payment moves the receive
address on, change is counted and never offered, and two groups on one
client see only their own coins.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 08:05:28 +02:00
Kgothatso NgakoandClaude Opus 5.5 caddfdc107 feat(wallet): the group opens its wallet by signing a statement (Phase 3)
Kind 30331, inner only: the account xpub, the network, the account
number and both descriptors. A reader believes one only when the room
signed it and the room's threshold key rederives every value it
carries -- GroupWallet.of, used by the repository and by the transcript
arm alike. The broadcast screen refuses the kind twice, at the loader
and in sendToRelays, because the xpub on a relay is the whole balance.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 08:00:59 +02:00
Kgothatso NgakoandClaude Opus 5.5 283e576a98 test(wallet): a ceremony's shares spend the group's coins (Phase 2)
Real ChillDKG, real FROST, no manager: two wallet inputs signed as two
independent instances, each over its own BIP341 sighash with its own
cache, judged by correctlySpends. The negatives are the ones a positive
cannot catch -- another input's cache, a cache missing the tail or the
key-path tweak, and a sighash over a lied-about amount all produce
signatures the script interpreter rejects.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 07:56:14 +02:00
Kgothatso NgakoandClaude Opus 5.5 4330faacd7 feat(wallet): derive a group wallet's keys from its threshold key (Phase 1)
GroupWalletDerivation: a public account step -- a tagged HMAC over the
threshold key, the network and an account number -- gives a depth-0 xpub,
and below it BIP86's own unhardened tail, /<change>/<index>, with the
key-path tweak on top. Each address is computed twice, as points and as
tweaks on a FROST cache, and refused if the two disagree.

Tests: BIP86's published vectors through the cache prove the tail; a
pinned vector freezes the account step; a sweep covers both parities.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 07:55:01 +02:00
Kgothatso NgakoandClaude Opus 5.5 56a942c610 Remove the curated-lists feature
Bennu no longer speaks curare.to's list protocol. The schemas, templates,
entries and the suggestion queue go, with their six screens, routes, view
models, strings and tests, and the hooks into the group screen, the paste
proposal, proposal summaries, broadcast relay seeding, the chat repository
and the transcript.

The two transcript message types stay as private legacy names so rows
already stored still render as system lines rather than chat bubbles.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-21 11:45:45 +02:00
Kgothatso NgakoandClaude Opus 5.5 b75d4b427f Rebrand Curare to Bennu under com.machankura.bennu
Move the packages to com.machankura.bennu.{compose,android,desktop}, the
Android applicationId to com.machankura.bennu.android and the iOS bundle
id to com.machankura.bennu.ios. The root project, launcher label, iOS
product, desktop window, user-facing strings, client tags and the
Curare* classes all say Bennu now.

Left alone on purpose: the mantra/ derivation tags, the `curated` desktop
data directory, the mantra.press relay and the curare.to references.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-20 13:53:45 +02:00
Kgothatso Ngako dddfa68b38 Update version number 2026-10-20 12:38:40 +02:00
Kgothatso 80b7490de7 Make test run locally 2026-10-19 18:42:08 +02:00
Kgothatso NgakoandClaude Opus 5 72cfb561c4 feat(proposals): ask again about everything the filter is showing
The bulk control I argued against, built -- and the objection turned out to be
solvable rather than fatal, so it is worth recording what happened to it.

Half of it was already handled. Two resends in the same second do not collide
on the outbound row id: `broadcast` hashes that id over the session's own tags
and steps a second forward when it finds a collision rather than overwriting.
Different sessions were never at risk.

The other half was real. A resend publishes two messages, and `resend` keeps to
two deliberately because "publishing in bursts is what the skipped-keys bug
feeds on"; three proposals at once is six, in the same second that "two events
published in the same second race, and exactly one survives" was written about.
So the sessions are spaced rather than the budget quietly raised --
`resendAll` waits `RESEND_SPACING` between them, one second, which is the
resolution the protocol works in because `created_at` is stored to the second.

The pacing lives in the manager and not in the loop that wanted it, because
everything that justifies it does: MLS generations, relay ordering, outbound
ids. A caller that launched `resend` per session would put every burst into one
second, and the call site is the wrong place to know why that matters. There is
a test against the real manager that three sessions take longer than two
spacings and claim three different seconds.

What it acts on is `visible`, not the room: a bulk control reaching rows the
reader cannot see is its one unforgivable move. A cooling-down row is left out
of the count rather than included and skipped, because the count is what the
button says out loud and offering three while able to send two is a lie told
before the tap. Offered from two up: one is what the row's own button is for.

Every covered row goes quiet for the whole run rather than for its own turn --
a paced run means a row whose turn has not come is still about to publish, and
a row button offering to send it meanwhile would send it twice. A session
already in flight on its own is left out of the run for the same reason.

It is offered on any filter showing two it can act on, not only "being signed".
That filter is where it earns its place -- three rows stalled for one reason --
but the rule is about what is on screen, not about which chip put it there.

1419 jvm tests pass, the Android target compiles, all audit budgets met.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-10-08 16:04:13 -05:00
Kgothatso NgakoandClaude Opus 5 4330d718be feat(proposals): ask the quiet members again from the row
The offer the signing screen already makes, reached from the list. A
coordinator whose room has stalled should not have to open each proposal in
turn to find the button, and filtering to "being signed" now puts every stalled
one in front of them at once.

It is on the row and not on the chip, which is where it was asked for, for
three reasons. A chip is a selection control, and giving it a second action
would make the control that publishes the one you cannot undo. A chip stands
for several proposals while `resend` takes one session, so a chip-level button
means resending all of them -- and the manager caps itself at two messages per
resend precisely because "publishing in bursts is what the skipped-keys bug
feeds on", which three proposals at six messages would re-create. And the offer
is the coordinator's alone and only exists while somebody owes, so on a chip
standing for a mixed set it would be enabled for proposals it cannot act on.

It is called "ask again" rather than "re-broadcast" for the same reason the
list calls a review a review: somebody who found the button on the signing
screen and then found this one should not have to work out that two labels are
one button.

Whether to offer it is asked of `membersOwing`, not derived from the signature
count. Past the nonces a signer who refused has answered and is owed nothing
while the count is still short by one, so a row reading `have < need` would
offer to knock on a door that has already been shut. That is one query per row
and the only one on this screen, so it is asked for as few rows as possible:
not ours to send, nothing to send, and already ended all answer without
touching the database. An ended session is left out although the manager would
take it -- re-sending a completed one delivers the signature to a member who
never applied it, which is worth a button on the one proposal's screen rather
than a query per row on a list that only grows. The signing screen still offers
it.

Guarded per session rather than by one flag for the screen, because these rooms
have several proposals open at once and a coordinator working down the list
should not be locked out of the second by the first still publishing. The
cooldown disables rather than hides, as it does on the signing screen: a
control that vanishes after a tap reads as one that failed.

1396 jvm tests pass, the Android target compiles, all audit budgets met.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-10-08 15:45:58 -05:00
Kgothatso Ngako 1f82d66f57 Merge branch 'curated' into claude/proposal-state-filters-8cc06c 2026-10-08 14:56:24 -05:00
Kgothatso NgakoandClaude Opus 5 7c6e9b0a84 feat(proposals): say how far a proposal has got, not just what it is waiting for
A row said "waiting for 2 of 3 members to take part" on the day a proposal was
made and on the day before it completed. That is the rule, not the progress.
Now it says "1 of 3 members have offered to sign", and on the next stage "2 of
3 signatures are in" -- the fractions that actually move.

Nothing is counted once it has ended, which is both endings and not only the
happy one. A signed session has nothing left to gather; an abandoned one has
counts frozen where they stopped, and "2 of 3" beside a failure invites the
reader to wait for a third that is never coming. The failure reason is what
that row has to say.

The denominators are the ones the protocol gates on. `orderedNonces` returns
nothing until `threshold` nonces have arrived and then takes the first
`threshold` of them, so the threshold is both what is needed and what is used --
the room's size is a bigger number nothing waits for. Once the signer set
exists it is the set being waited on, which is the same count from the other
side.

The numerator is the part that had to be got right. A nonce or a partial
signature is recorded with no check on who sent it, unlike a refusal, and
`orderedNonces` drops the ones from members holding no share when it
aggregates. So the tally joins `DkgParticipantMessage` on HOST_KEY and counts
members rather than rows: a count including strangers would have a row read
ahead of the coordinator, saying the group has what it needs while the session
sits still. That is the one direction a progress figure must never be wrong in,
and there is a DAO test for it. A count that still runs ahead -- a nonce
landing before this device runs `advance` -- is clamped, because a fraction
over one reads as a bug rather than as a session about to move.

The counts travel as their own `GROUP BY` flow, combined with the sessions in
the view model. They change far more often than the rows do, and carrying the
messages themselves would carry every nonce payload the room has ever exchanged
to a screen that only wants to count them.

The progress is its own line rather than a clause, so a reader scanning for the
one that is nearly there does not have to read a sentence to find out. That
left `statusOf` saying only who the reader is in the proposal, and since this
adds user-facing text its remaining literals moved to the catalogue with it --
nine strings that had been raw in the screen since before the catalogue rule.

1367 jvm tests pass, the Android target compiles, all audit budgets met.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-10-08 14:53:59 -05:00
Kgothatso Ngako f0cbb2785b Merge branch 'curated' into claude/partial-signature-collection-d44dab 2026-10-08 14:38:13 -05:00
Kgothatso NgakoandClaude Opus 5 a9532ff115 fix(frost): resume a session whose own turn was cut short
Every step a session takes is driven by a message arriving, and a device
killed part way through its own pass is waiting on one that has already
been delivered. The signer set is recorded, so it will never be processed
again; the partial signature it would have produced was never made. The
coordinator asking again cannot reach past it either -- what a resend
asks a member for is the message this device believes it already sent --
so the session is a dead end on both sides, and in a room with several
open proposals it is the one that was mid-pass that stops.

So one sweep that no message drives: on opening a room, every session in
it that is not settled and whose owner has answered is handed to
`advance`, which does what it always does. It publishes nothing new --
each step asks whether its output exists rather than whether a stage says
it ran -- and only answered sessions are passed in, so the approval gate
is not approached, let alone reached past. A refusal counts as an answer
for the same reason: a device killed between deciding and publishing says
it on the next open rather than never.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-10-08 14:33:13 -05:00
Kgothatso NgakoandClaude Opus 5 1e59fd2334 fix(frost): a knock past the nonces is for the signers, not the quiet
A resend had one idea of who it was for at every stage -- the share
holders it had heard nothing at all from -- and that is a question only
the first stage can answer. A session reaches
COLLECTING_PARTIAL_SIGNATURES because enough members offered a nonce, so
every member who could be holding it up has been heard from: the set came
back holding the members who were never chosen and owe nothing, while the
chosen signer whose partial signature went missing was named nowhere.
Once the unchosen had answered or refused the set was empty, and the
control gave up before it reached the branch written for the stall it was
meant to repair.

So the set asks what the stage can answer. Of the signers the coordinator
chose, who has yet to send a partial signature -- which is the half of a
resend only they can carry out, since a partial signature is read by
nobody but the coordinator and no other device can repeat it. COMPLETE
keeps the old reading, and correctly: the signature is the coordinator's
own and nobody answers it.

The screen now asks the manager who is owed rather than deriving it from
the rows beside the button, the way it already asks about approvals: the
same reading decides whether a resend publishes anything, and two copies
of a rule that changes with the stage is a screen offering a knock the
manager would refuse. The transcript line and the notice say what the
members named are short of, since past the nonces they have answered once
already.

The test that looked like it covered this passed because it wrote the
stage into the row with no nonce on file anywhere -- a state the protocol
cannot produce, and exactly the state that hid the bug. It now reaches
the stage by offering a real nonce.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-10-08 14:32:09 -05:00
Kgothatso NgakoandClaude Opus 5 13ae0a1def feat(proposals): tell the two open stages apart, because they are not alike
"In progress" was one chip over two situations that ask different things of
the reader, and collapsing them was the wrong call.

Short of members, a proposal can still die of indifference: refusals are
counted against `declinesThatAbandon`, so one more may end it, and a member who
is offline is indistinguishable from one who has not looked. It is also the
only stage the coordinator's resend is for. These are the proposals somebody
may have to do something about.

Once the signer set is written, none of that is true. `signerIds` is written
once and never revised, so no further refusal is counted against it, and what
is left is arithmetic the chosen devices have already committed to. Where one
asks whether this will happen, the other says it is happening.

So: WAITING_ON_MEMBERS and BEING_SIGNED, named for what the reader is waiting
on rather than for the protocol step -- "collecting nonces" is true and says
nothing. The icons carry it as well as the labels, people against machinery,
which is the only signal a monochrome display has.

What is *not* split, and the comments say why: whether this device was picked
to sign, and whether the reader agreed or declined. Those are facts about the
reader rather than states of the proposal, so they stay a sentence on the row.
Splitting on them would be splitting every state by who is looking.

The classification is now the stage plus one, which is the shape it was always
going to take -- the one being NEEDS_YOU, which no stage can express.

Six chips means the last two now sit past the fold at phone widths, so the
screen test measures order only over what the viewport lays out and the full
lifecycle order is pinned on the enum, where no viewport is involved.

1342 jvm tests pass, the Android target compiles, all audit budgets met.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-10-08 14:26:25 -05:00
Kgothatso NgakoandClaude Opus 5 18c6245181 feat(proposals): open on the queue when that is what was asked for
The transcript's notice counts the proposals waiting on this member and says
so. A tap on it that then showed the room's whole signing history would have
the reader go and find the three it had just named for them, so the route
carries a filter and the notice asks for the queue.

`ProposalListRoute.filter` defaults to ALL, which is both the honest default
and what every caller predating it reads back as -- the group's own Proposals
row still means "show me the room".

The transcript's other way in turns out to be two ways, not one, and they
wanted different lists. A line too old to name its session could be about
anything the group has ever signed, so it opens the room. A tap held back
*because several decisions are waiting* was held back for those decisions, not
for the history -- so it opens on them. That decision now lives in
`proposalDestination` instead of in a condition nine levels down a LazyColumn,
which is the only way anything could be held to it.

Nine tests over the three branches, including that the queue is offered only
for the proposal actually tapped -- a line about something already signed is
history, and handing its reader the queue would invert what
`hidesOtherDecisions` is for. The filter's ride on a type-safe route is pinned
too: navigation reads an argument's NavType off the serial descriptor and takes
an ENUM as a string, so the test fails if the filter ever becomes a shape
navigation cannot place.

The notice's own one-line wiring is not itself covered -- it builds a route
inside the transcript's lambda -- so it rests on the route tests and on review.

1338 jvm tests pass, the Android target compiles, all audit budgets met.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-10-08 12:01:40 -05:00
Kgothatso NgakoandClaude Opus 5 ef2b461c5c feat(proposals): a chip row over the list, and four ways of being empty
Five chips under the app bar, each carrying its count, scrolling sideways. The
row is outside the list rather than its first item, because a control that
scrolls away is a control the reader has to scroll back for -- and the list it
filters is as long as the group's whole signing history. It scrolls rather than
wraps for the same reason from the other side: five counted chips do not fit
the sixty characters `readableContent` holds the column to at the largest text
size a reader can ask for, and a row reflowing to a second line moves the list
under the thumb about to tap it.

Unfiltered, the two sections stay. Filtered, they go: "waiting for you" against
"everything else" is a distinction the reader has already made by tapping, and
heading a single-state list with it would answer a question nobody asked.

A room with nothing in it gets no chips at all. Five chips reading 0 over an
empty screen would be five ways of saying what the empty state says once.

The screen also picks up the state widgets it never had -- `LoadingDataIndicator`,
`ErrorState` with an explicit `onRetry = null` because a room missing from this
device will not appear by looking again, and `EmptyState` with a message per
filter. That last one is the point: one shared default is how five different
absences here came to say one thing. A group never asked to sign and a queue
the reader has worked through are not the same fact, and the second is not an
absence at all -- it keeps the queue's own icon and reads as finished.

`initialFilter` reaches the screen and is applied in the view model's `init`,
so a `Loaded` handed in for a preview cannot open with its chips saying one
thing and its rows showing another. Nothing passes it yet.

Fourteen screen tests, and the audit's budgets all still met: 0 hardcoded
colours, 0 dp literals in spacing positions, 0 title-case strings, both floors
held. 1329 jvm tests pass; the Android target compiles.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-10-08 11:53:45 -05:00
Kgothatso NgakoandClaude Opus 5 f42f4913c4 feat(proposals): a filter over those states, that a busy room cannot clear
`Loaded` gains the selection, the rows it selects and a count per state. The
rows come from the selection and the numbers come from the room, on purpose: a
chip reading its own count off the filtered list would say 0 for every filter
but the one already chosen, which is the one number the reader does not need.

Every state gets a chip, zero included. A row that gains and loses chips as
sessions advance moves under the thumb of the person reading it -- and sessions
advance while this screen is open, because someone else signing is exactly when
a member comes to look.

The selection lives on the view model and not only on the state drawn from it,
which is the part worth the comment it carries. `observeSessionsForChatRoom`
re-emits whenever any member's message moves any session in the room, and the
collect block builds a whole new `Loaded` each time; one built with the field's
default would snap the chips back to "all" mid-scroll, most often in the
busiest rooms. Four of the seven view-model tests fail if that line goes, which
was checked by removing it.

`initialFilter` is threaded through the constructor and the factory so a caller
can land on a filter -- the first emission is then already filtered, and the
reader never sees the unfiltered list flash past. Nothing passes it yet.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-10-08 11:40:51 -05:00
Kgothatso NgakoandClaude Opus 5 6a55889676 feat(proposals): name the four states a proposal can be in
The list screen asks "where has this got to" in four places -- the section
split, the row's icon, that icon's description and its status line -- and each
worked it out for itself from the stage and the approval timestamps. A filter
over those states would have been a fifth derivation, and a fifth derivation is
how a chip comes to count a proposal the row beneath it describes differently.

So the question is asked once, on `Proposal`, and the four readers read it.

The classification deliberately is not `FrostSigningStage`. The one state
anybody opens this screen looking for -- waiting on me -- is not a stage at all:
an open session waiting on this member and one waiting on everybody else are
both COLLECTING_NONCES, and what separates them is `signApprovedAt` and
`signDeclinedAt` being null. `awaitsYou` is tried first and wins; the stage
decides only among the rest, exhaustively and with no `else`, so a stage added
later fails to compile here rather than landing quietly in IN_PROGRESS.

`statusOf` still switches on the stage, and has to: the three things it says
about an open session -- you agreed, you declined, you were picked to sign --
are exactly the distinctions IN_PROGRESS collapses.

Two behaviours are pinned rather than fixed, because both are parity with
`isAwaitingApproval` and the signing screen gates its buttons on that:

 - a session whose proposal has not arrived yet classifies NEEDS_YOU, although
   the card says there is nothing in it to read;
 - a batch the group finished without this member is IN_PROGRESS until
   `advance` closes it, which is also what the row already said.

The preview gains an in-progress and an abandoned sample, so the conformance
sweep renders every icon and every status line in all six schemes.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-10-08 11:34:36 -05:00
Kgothatso NgakoandClaude Opus 5 e4657df08e test(frost): cover the transport every ordinary session actually uses
Nine tests for gaps found by auditing the suite against the branches rather than
by counting tests.

The big one: every existing resend test ran on a NIP-17 room, which is only a
group's *first* signature. Every ordinary session runs in the Marmot admin room,
and that path had never executed -- no coverage at all for the store it writes
to, the tags it omits, or the id guard on that store. Given the bug fixed in
daf8365a was transport-specific, this was the gap most likely to hide the next
one. Three tests now cover it: a resend is one group event naming nobody with
the silent tag still on it, a nudged member republishes the same bytes as an
inner event, and the id guard holds on that store too.

Also covered, each of them a branch that had never run:

 - resending while collecting partial signatures, which repeats the signer set.
   One of three arms of the stage table, and the arm a stalled signer needs: they
   have the proposal and their nonce is in, and the signer set that says what to
   sign against never arrived.
 - the same stage table sending no signer set before one is chosen.
 - republishing a partial signature -- the third kind `republishOwn` repeats, and
   the one whose loss stalls a session that has every other piece.
 - refusing a resend whose stored events will not parse.
 - ignoring a silent tag on anything but a proposal, so the nudge cannot be
   triggered by any message at all.
 - the singular transcript wording.

Two notes on what is still not covered. `broadcast` returning false needs four
identical publishes in four consecutive seconds behind a five-minute cooldown;
forcing it means injecting a clock, and a racy test of it would be worse than
the guard. And neither the screen section nor the view model has a test, though
both are established patterns in this project.

Found the same `maxBy`-on-a-shared-second trap again while writing these, which
is now a helper per transport rather than a thing to remember.

1288 tests, no failures. m3Audit: all budgets met.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-10-06 15:33:10 -05:00
Kgothatso NgakoandClaude Opus 5 daf8365a6e fix(frost): a resend names the whole room, because the p-tags are its identity
The resend narrowed its NIP-17 p-tags to the members it was for, on the
reasoning that a wrap is sealed per recipient so repeating one for the whole
room wastes wraps. Both halves of that were wrong.

A receiver does not read the p-tags as a recipient list. It hashes them together
with the sender to work out which room the payload belongs to --
`GiftWrapPayload.aggregatedParticipantsPublicKey`, via
`ChatRoom.deriveChatRoomId`, which is what `GiftWrapSeal.decryptGiftWrapPayload`
files an inbound payload under. Leave a member out and the id changes, so the
resend is filed under a room that does not exist; `getOrCreateChatRoom` then
mints that room rather than rejecting it. A repaired session would have become a
phantom two-person conversation in the reader's list, and the session would have
stayed stalled.

There was no saving to trade against it either: `sealGiftWrapPayload` wraps for
every participant of the room it looks up, not for the p-tags it was handed, so
a narrowed payload cost exactly as many wraps as a full one.

Who a resend is for travels in `frost_silent`, which is not part of that hash,
so nothing is lost by naming everybody.

Marmot was never affected -- a group event names nobody and is routed by its
h-tag.

The two tests that asserted the narrowing now assert the opposite, which is the
property worth having: the p-tag set does not change between a publish and its
repeat. The p-tags were the right thing to assert all along; they just mean
something other than what they look like.

Found while answering whether this is backwards compatible with older receivers.
It is -- no new kind, an unknown tag that old builds ignore, and every
duplicate-folding gate in `record` and `acceptProposal` predates this work. This
bug was never a compatibility bug; it broke old and new receivers identically.

1279 tests, no failures. m3Audit: all budgets met.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-10-06 15:22:52 -05:00
Kgothatso NgakoandClaude Opus 5 2edd05f3ca fix(frost): a broadcast that queued nothing records nothing
`broadcast` now says whether it queued anything, and `publishOwn` records the
local copy only when it did. The copy is what stops `advance` from publishing
that message again, so writing one for a message that never went out is a
message the group waits on forever -- the exact opposite of the trade the
queue-then-record order exists to make. The comment on `publishOwn` had that
trade written down in one direction only.

Reachable only through the id-collision guard added with the resend, which
refuses after four tries rather than overwriting a sent row. Four consecutive
seconds of the same message is not something a person with a button can do, but
"unreachable" and "safe when reached" are different claims.

Also brings the docs up to what was built: the resend note is in the index, the
skipped-keys note points at it as the recovery for the failure it describes --
a new message is encrypted at a generation the receiver has not passed, which is
the whole mechanism -- and the plan records the two things landing it turned up,
plus `ask_again` being reused from the catalogue rather than duplicated.

1279 tests, no failures. m3Audit: all budgets met.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-10-06 15:09:57 -05:00
Kgothatso NgakoandClaude Opus 5 e0f20b2b63 test(frost): the case the resend exists for, end to end
The headline test is the one that goes through `acceptProposal` from the outside:
Bob's device has no session at all -- his copy of the first proposal decrypted to
nothing, which is terminal and which the sender cannot see -- and the resent
proposal opens it.

Two databases rather than a hand-written row, because an event's id is rebuilt
from its own fields under the author the *receiver* resolves, never the
proposer's word for it. A fabricated event cannot pass that check, which is the
point of the check, so the proposal has to be one a coordinator really made.

What the rest of them pin, in rough order of how much it would cost to get
wrong:

 - a named member republishes the *same bytes*, not a fresh nonce. Two nonces
   for one message against two aggregates is how a secret share is extracted.
 - a named member whose owner has not decided publishes nothing, and is still
   asked. A message from the coordinator must never put a device's share behind
   events its owner has not agreed to.
 - a nudge from somebody who is not the coordinator does nothing.
 - a resent proposal delivered twice mints no new nonce seeds.
 - a republished refusal is counted once. A resend makes duplicates routine, and
   counting one twice abandons a 2-of-3 session on a single no.
 - two resends in one second get two ids.

Plus the state the screen reads: who counts as quiet (not the refusers, not this
device), who is offered the resend (the coordinator), and that the cooldown
leaves the offer standing while quieting the button.

1279 tests, no failures. m3Audit: all budgets met.

Plan: docs/frost-session-resend.md, Phase 8.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-10-06 15:06:04 -05:00
Kgothatso NgakoandClaude Opus 5 aee19737f6 feat(frost): the knock, under the list of doors it is for
The resend gets its affordance on the signing screen, below the member list and
above the approval block. The list is already the screen's answer to whose door
to knock on; this is the knock.

Coordinator only, and the state says why rather than leaving it to the button:
`acceptProposal` takes a session's coordinator from the author of the proposal
that opened it, so a resend from anybody else would have a member who was
missing the session believe the resender coordinates -- and then drop the real
coordinator's signer set.

`silent` is derived on the UI state rather than collected. Everything it is made
of is already there -- the share holders, who offered a nonce, who signed, who
refused -- and a second flow would be a second thing that can disagree with the
rows the screen draws. A member who refused is not silent: they answered.

The cooldown disables the button rather than hiding the section, because a
control that vanishes after a tap reads as one that failed, and what happened is
that it worked. `resend` hands back whether anything went out, so the snackbar
says which: asked again, or everyone has since answered and there was nobody
left to ask.

The transcript line gets its own icon. A resend must not read as a second
proposal, which is the one thing a session can never have -- two proposals under
one session id would be asking for two signatures out of one secret nonce.

`ask_again` already existed in the catalogue for re-querying a list's relays and
means exactly this, so it is reused rather than duplicated.

m3Audit: all budgets met. jvmTest: 1260 tests, no failures.

Plan: docs/frost-session-resend.md, Phases 5-7.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-10-06 15:01:09 -05:00
Kgothatso NgakoandClaude Opus 5 01e022fdcc feat(frost): a proposer can resend a signing session
A session can sit in COLLECTING_NONCES forever waiting on a member who would
have agreed, because the message asking them never arrived. MLS moved its
ratchet past the generation it came in at, which is terminal at the receiver and
invisible to the sender (docs/mls-skipped-keys.md); or a disappearing-message
group expired it off the relay; or the member joined the room after the proposal
was made, holding a share from an earlier ceremony. None of them heals on its
own, and nothing asked the sender to resend.

`FrostSigningManager.resend` repeats what the coordinator wrote -- the proposal,
and whichever of the signer set or the signature the stage has reached. A resent
message is a *new* message: new created_at, new id, encrypted at a generation
the receiver has not passed, carrying a fresh expiry. That is why it works where
the first copy did not.

Two and never three. Publishing in bursts is what the skipped-keys bug feeds on,
and a recovery for it that re-creates it is no recovery, so the stage table is a
minimum rather than "send everything".

The resent proposal names the members the coordinator has heard nothing from, and
a named device republishes what *it* already sent -- the stored bytes, under its
own key. That is the only half that can repair a nonce lost on the way *to* the
coordinator: `advance` republishes a message it has no local copy of, so a device
that published and recorded its nonce would never send it again. It publishes
nothing new, so a nudge cannot talk a device into putting its share behind events
its owner has not approved.

Coordinator-only, both halves, and that is correctness rather than etiquette:
`acceptProposal` takes coordinatorPublicKey from the proposal's author, so a
non-coordinator resending to a member with no session row would have that member
drop the real coordinator's signer set.

Also fixes a bug `broadcast` had all along. An outbound row's primary key is a
hash over its created_at, stored to the second, so a message re-published inside
that second hashes to the id of the copy it repeats -- and the upsert put an
already-sent row back on the queue with marmotGroupEventId cleared, double-sending
it and losing its mapping to the group event it became. It now steps past a taken
id rather than writing over it, and refuses after four tries.

Schema 24 -> 25 for FrostSigningSession.resentAt, which is the cooldown and the
second line of defence on that collision. Phase 4's column, pulled forward
because Phase 2 needs it.

Plan: docs/frost-session-resend.md, Phases 2-4.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-10-06 14:56:15 -05:00
Kgothatso NgakoandClaude Opus 5 7bc00af304 feat(frost): a tag naming the members a resend is for
A proposer can resend what the proposer wrote and nothing else. A nonce or a
refusal relayed by somebody else is filed under the relayer -- `record` keys a
signer's message on the inner event's own pubkey -- and for a refusal that is a
way to manufacture one, which in an n-of-n group abandons a session nobody
refused.

So a resent proposal names the quiet members instead, and their own devices
republish what they already said, under the keys that said it. This is the tag
that names them: `frost_silent`, all-or-nothing like `frost_signers`, because a
list naming the wrong people is worse than no list at all.

Additive on the wire. A build that does not know the tag ignores it and accepts
the proposal it rides on, which is the half of a resend that fixes the common
case -- a member who never saw the proposal because MLS dropped the generation
it arrived at (docs/mls-skipped-keys.md) or a disappearing-message group expired
it off the relay.

Plan: docs/frost-session-resend.md, Phase 1.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-10-06 14:46:18 -05:00
Kgothatso Ngako a673c85e93 Update version name. 2026-09-18 18:20:09 +02:00
Kgothatso b9140c6a27 fix(ios): build ktor clients on Darwin so wss/https work on a device
CIO has no TLS implementation on kotlin/native, so every secure
connection died at the handshake with "TLS sessions are not supported
on Native platform". Pick the engine per platform -- CIO on android
and the desktop jvm, Darwin on ios -- and pin both the relay socket
client and coil's image fetcher to it.
2026-09-15 09:42:38 +02:00
Kgothatso aa9312f0ee build(ios): unbreak the ios link tasks
linkDebugTestIosArm64: Kotlin/Native rejects backticked test names
containing a comma ("Name contains illegal characters: ','"), so the
commas come out of the commonTest names.

linkReleaseFrameworkIosArm64: Kotlin 2.4.10's release backend crashes
in StaticInitializersOptimization on this module's call graph, so
RemoveRedundantCallsToStaticInitializersPhase is disabled for the
release native links. The pass is an optimization only.
2026-09-15 08:58:59 +02:00
Kgothatso 987df2c8f6 feat(ios): declare publish cancellation and the Room constructor to swift
@Throws(CancellationException) on the publish path so swift sees a
cancellation as one, @ConstructedBy so Room can build the database on
ios, an unused import out of Platform.ios.kt, and the development
TEAM_ID for signing.
2026-09-15 08:58:53 +02:00
Kgothatso NgakoandClaude Opus 5 79ff9ee1fc fix(chat): the detail pane's view models are the selected room's, not the first one's
In an expanded window the transcript beside the room list showed the
first room opened and stayed there: pick another room and the list
moved on while the pane did not. HomeScreen wraps the pane in
key(chatRoomId), which rebuilds the composition when the selection
changes, but viewModel() does not read composition keys. It scopes to
the nearest ViewModelStoreOwner, and in the pane that is the home
destination's one back stack entry for every room, so the second room's
viewModel(factory = ...) got the first room's ChatRoomMessagingViewModel
and ChatMessageListViewModel back with its factory ignored. A phone never
showed it because a pushed room is its own entry with its own store.

The pane now provides LocalViewModelStoreOwner with
rememberViewModelStoreOwner() under the room key: a store per room,
cleared when the selection moves on, and parked in the home entry's
store so that it survives a rotation. Keying the two viewModel() calls
on the room would have unstuck the pane too, at the price of keeping
every room ever opened -- four DB collectors each -- in the home entry's
store for as long as the home screen lives.

ChatPaneSelectionJvmTest opens two rooms and comes back to the first,
told apart by what was said in them since a name is on the row as well
as the bar; its third case checks the room left behind stops collecting,
which is the case the keyed alternative fails. The conformance doc's
account of the hand-built pair records the trap.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-14 20:10:13 +02:00
Kgothatso NgakoandClaude Opus 5 30685924db feat(curated): the date field type, and an unknown type is kept aside rather than dropped
CuratedFieldType had no `date`, so a schema declaring one lost the field
at parse: entries were read without it, the accept flow copied a
suggestion into a canonical entry without it, validation never asked for
it, and the entry published cleanly -- and was refused by every client
that did know the type, for the required field it lacked. Fourteen of
bitcoin.necropolis.report's entries went out that way without a `died`.

`Date` is the NIP's tenth type: `YYYY`, `YYYY-MM` or `YYYY-MM-DD`, at
whatever precision the record allows, with `min` and `max` bounding the
year. `CuratedDate.parse` is the check -- month 1-12, day on the calendar
for that month and year, leap days included -- and the value is kept as
written. `checkValue` returns early the way the numeric branch does, so
`max` is a year and never a length cap. The value is not numeric, so
`isNumeric` stays false; `isBounded` is what the editor keys its min/max
inputs off instead, labelled as years for a date.

The root failure was wider than one type: any type this build does not
know was dropped the same way. A `field` tag of an unknown type is now
kept aside as CuratedUnsupportedField, the way CuratedFieldConfig.others
keeps unknown config keys. Reading is unchanged -- an entry is checked
against the fields a reader understands, which is the NIP's tolerance --
but the accept flow refuses to propose under a required one, naming the
type, and the schema editor carries it through an edit and writes it back
as it came, so re-signing a list here cannot change its rules unseen.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-14 19:30:02 +02:00
Kgothatso NgakoandClaude Opus 5 984db0a180 Merge branch 'curated' into claude/quartz-1-15-2-compat-c8267f
Both sides had taken schema version 21: curated for the nullable
FrostSigningSession.signDeclinedAt (one refusal takes a member out of the n),
this branch for the Marmot current profile's three columns, with 22 and 23
behind it for the routing table and the publish obligations. Curated keeps 21.
This branch's three migrations move up one -- 21->22, 22->23, 23->24 -- and
the database is at 24; the comment on 22 says they moved and why.

The exported schemas for 22 and 23 could not be hand-edited, since each is a
snapshot of the whole entity set with an identity hash over it, and could
not be produced from the merged tree, which only exports its own version. So
each was regenerated the way the originals were: the tree of the commit that
introduced it (Phase 3 for 22, Phase 4 for 23), with curated's entity change
and its 21.json dropped in, the version bumped, and KSP run. The result is
what a device on curated's 21 migrates through: 22 adds the three columns
and nothing else, 23 adds MarmotRouting, 24 adds MarmotPublishObligation and
MarmotOutboundGate together with MarmotCommitResult.obligationId, and every
one of them carries signDeclinedAt. 24.json is the merged tree's own export.

Everything else merged itself: ChatMessage's kinds and line types, the
transcript's icons, the strings, the nav host. Full jvmTest 1220 green,
Android debug compile, M3 audit.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-14 08:09:54 +02:00
Kgothatso NgakoandClaude Opus 5 9b404e2035 fix(frost): the signing screen lists the key's share holders, not the room
The members list on "Sign with the group's key" was the room's roster, and a
room is not the set that can sign with its key. A member invited after the
ceremony holds no share: the proposal they receive is dropped before it
becomes a session on their device, and no nonce or refusal of theirs would
count. The screen drew them a row anyway, in a list whose whole purpose is to
say whose door to knock on.

The list is now the ceremony's share holders -- the members who put a host
key into it, read off DkgParticipantMessage through the new
FrostSigningRepository.observeShareHolders. That is the same set
FrostSigningManager places signer ids over, so what the screen lists cannot
disagree with whose messages the session counts, and a ceremony cannot
complete without every participant's host key, so for a completed one it is
the whole participant set. Names still come off the room, in the room's
order; a share holder the room no longer holds keeps a placeholder row, since
their share did not leave with them.

The view model follows the session to its ceremony with flatMapLatest, and
the list is empty until the ceremony has been read rather than falling back
to the room -- a fallback would flash everybody and then correct itself.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-14 07:53:21 +02:00
Kgothatso NgakoandClaude Opus 5 a7f3917e65 fix(frost): one refusal takes a member out of the n; it takes n - t + 1 to abandon
"Don't sign" ended the session for everybody: decline() failed it locally and
broadcast a FAILURE, which every other device failed on arrival. In a group
whose whole reason for running a ceremony was that no one member is needed,
one member's no was everybody's.

A refusal is now its own kind, DECLINE (30330), and one FrostSignerMessage per
member, like a nonce. Every device counts the refusals it has received from
ceremony participants against the same arithmetic -- FrostSigningSession.
declinesThatAbandon(), which is n - t + 1 -- and fails the session only on the
refusal that leaves fewer than t who could still sign. Nobody broadcasts the
abandonment, because nobody has to: each device reaches it the way each writes
its own transcript, and a FAILURE sent to say so would blame one member for the
group's arithmetic. In a 2-of-3 group the first refusal changes nothing the
other two can do; the second ends it. FAILURE keeps meaning abandon-and-blame,
for the faults no quorum can work around, and a build predating the new kind
still sends its refusals that way and is honoured as it always was.

decline() takes approve()'s shape: the decision goes on the row, as the new
nullable signDeclinedAt (Room v21, an AutoMigration), and advance() publishes
it whenever the row says so and no copy is on file -- so a device killed
between deciding and sending says it on the next message rather than never. A
member who refused is not asked again, but the session stays open around them
and closes when the group's signature arrives. Refusals from a member holding
no share of the key are turned away at the door.

fail() now leaves a COMPLETE session alone. A member who refused before their
device had seen the signature has refused something that no longer needed
them, and a late FAILURE used to flip a signed session to failed.

The transcript gets a TYPE_FROST_DECLINED line for a refusal the session
survives, with the count -- "declined to sign. It takes 2 of 3 members, and 2
could still sign." -- and the tipping refusal is written as the FAILED line in
that member's name, saying both that they declined and that it was the one
that ended it. A reader's own refusal settles their request line, and only
theirs; nothing earns a tick. The signing screen marks who declined and says
how many could still sign, and the proposal list says "You declined." where it
said "You agreed."

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-14 07:37:29 +02:00