The automatic ceremony lets a device sign, without asking its owner, the
one key state that can be true for a ceremony it finished
(GroupKeyStateManager.vouchesFor). Its seventh condition -- no state for
the room already signed here -- was what kept a share rotation's key
state out, and only in rooms that already had one. An eighth makes it
explicit: a state naming a share generation or a member binding says
more than the ceremony did, and its owner is asked.
Found by ShareRefreshRitualJvmTest after the merge: its devices hold no
first state, and the generation-1 state signed itself. jvmTest
1229/1229, compileDebugKotlinAndroid, audits.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
ShareGenerations.recover rebuilds a device's share of every generation
from its host secret key alone: ChillDKG's recovery data gives generation
0, and each refresh's recovery data, applied to the generation before,
gives the next. It stops at a generation the host key was withheld from,
since a repaired share leaves no recovery data. Nothing calls it yet.
Tested three refreshes on, against every device's live share and each
generation's table. With the release-build test, jvmTest 1200/1200,
compileDebugKotlinAndroid and the audits pass.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The room detail screen shows a key share by share: the generation the
group signs with, who holds a share, who waits to be brought back and who
was removed for good; what this device is being asked (take part in a
rotation, store the new share, help bring a member back), with approve
and abandon; and the two things it may start -- rotate the shares, or ask
to be brought back. The copy says what a rotation does not do.
ExperimentalFeatures.shareRefresh gates all of it (D4): on in debug and
development builds, off in release until the zkp modules are reviewed.
Off, nothing is offered, and a rotation this device is asked into is
declined out loud. The desktop build can opt in with
-Dgiza.experimental=true. The iOS actual was not built.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
ShareRepairManager brings back a participant id a refresh left stale, with
FrostReducedEnrollment in repair mode, on kinds 30346-30349. t live helpers
approve and run it; their round-1.1 shares and round-1.2 sums are raw
additive shares, so each goes NIP-44-encrypted between the two parties'
ChillDKG host keys. The target checks the result against the public share
the group signed -- never one the helpers supply -- stores it, and proves
it with a Schnorr signature by the share, which every device checks before
marking the id live. The share is a point of the new polynomial that the
old device never had.
10b: a new identity at an id -- a lost device, a compromised account -- is
bound by a group-signed key state first (frost_member, GroupKeyState
.memberBindings, schema 40), applied only to an id that is not live. Until
then its request waits, with nothing sent. A key state amending one at the
same generation is stamped a second later, so a binding can never tie with
the state it adds to.
jvmTest 1198/1198, compileDebugKotlinAndroid, audits.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A removal takes a member out of the room, not out of the key: their share
still helps sign. After an admin removes a member who holds a live share,
the room screen offers to rotate without them -- a second act, never
folded into the removal, since it needs every remaining holder.
ShareRefreshManager.proposeWithout withholds them for good (RETIRED); the
refusals say when that would leave fewer than t holders (the group could
not sign at all) or not a majority (remove fewer at a time).
Tested in the ritual harness: in a 2-of-3, the other two sign at
generation 1 and the removed member's old share signs nothing with a new
one. jvmTest 1195/1195, compileDebugKotlinAndroid, audits.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
When a refresh completes the coordinator asks the group to sign the key
state at the new generation -- the same room, key, path and parentage, plus
frost_generation, a hash of the public-share table, the refresh and any
retired ids. It is the new shares' first signature, and what D6 waits on:
a device that files that state, holds the generation active and agrees
with the group's table fails every signing session left at an older
generation, out loud, and deletes the older shares, the ceremony's
randomness that rebuilds generation 0's, and the WAL's page images of them.
A key state at a higher generation wins whatever its timestamp, in the
DAO and among signed events. A proposal at a generation this device has
confirmed and is still waiting on the certificate for waits instead of
declining, and resumes when the generation activates.
jvmTest 1193/1193, compileDebugKotlinAndroid, audits.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
For a ceremony a device finished there is one true statement of what
its room signs with: its key, at the admin path, naming the room that
derives, with the parent's certificate for a subgroup. A signing
proposal that is exactly that statement is approved on arrival.
GroupKeyStateManager.vouchesFor checks it with the rules stateFrom
applies to a signed state, minus the signature; anything else, a key
state included, is asked about as before.
SignedGroupKeyStateTest's two approval-gate tests now assert the new
rule. CeremonyNetwork relays signing messages, so a ceremony runs from
the joins to a signed key state with nobody asked.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
ShareRefreshManager runs a FROST share refresh in the Marmot room the key
derives, on kinds 30340-30345, in the image of ChillDkgRitualManager:
every inbound message stored, every step recomputed from stored inputs,
nothing of a member's own published before they approve, at two gates
(DEAL, CONFIRM). Recipients are at least t and a majority of the ids not
retired, and a device confirms one refresh per base generation --
ShareRefreshConfirmation, written in the same transaction as the pending
generation it confirms -- so two refreshes from one generation cannot both
complete. The certificate activates the new generation; a withheld device
learns its table from the recovery data and files it with no share.
Schema 39 (AutoMigration): ShareRefreshSession, ShareRefreshMessage,
ShareRefreshConfirmation. Transcript lines as system lines; dispatch in
the Marmot inbound path.
ShareRefreshRitualJvmTest: three devices with real host keys refresh
through bitcoin-kmp's FrostRefresh and then sign at generation 1 as the
same room. jvmTest 1190/1190, compileDebugKotlinAndroid, audits.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
CeremonyFollowThrough asks a subgroup's parent to certify it, asks the
group to sign the key state, and creates the room, from stored rows and
one step at a time. It runs beside the live subscription, outside the
inbound lock, since creating a room waits on key packages the inbound
path delivers. It looks again when a ceremony finishes, a certificate
or key state is signed, or a key package arrives.
Only the coordinator's device acts on its own, and never again after a
signing session failed; the ladder keeps the buttons for both. Once the
room exists the ladder's last rung opens it.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Once everyone has joined nothing is asked, so a ceremony that sits still
is waiting on a device that is not answering. After a day without a new
message, the ritual screen names who it is waiting on and since when,
with the abandon action beside it. Nothing abandons on its own.
A ceremony message is now stored once, on first arrival, so its time is
when it first came and a relay's redelivery does not restart the clock.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The join screen carries what the round-one screen showed, the members
in particular, and says the device takes it from there. The round-one
and round-two screens, their routes and their strings are gone; the
ritual screen offers only the join, and the ladder describes each round
as something the device does.
Old request lines still read as answered: the automatic round writes
the same line a tapped one did.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A ritual moved on an arriving message or a member's tap. Without the
tap, a ceremony holding every message it needs -- one an older build
left waiting to be told to contribute, or one interrupted between
storing a message and acting on it -- would never move.
resumeRunning advances every ceremony this user has joined. Sync runs
it once per activation, after reopening the inbox.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
advance no longer stops at rounds 1 and 2. Contributing follows from
having joined, and confirming is ChillDKG's own check, which refuses a
substituted result whether or not anybody is looking. pendingApproval
returns the join or nothing, and approving a round is a no-op.
ROUND_1 and ROUND_2 stay in the enum, and their timestamps in the
schema, so rows written by older builds keep decoding.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Schema 38 (AutoMigration): KeyShareGeneration and KeyShareMember for every
generation a refresh makes, FrostSigningSession.generation, and
GroupKeyState.generation and publicSharesHash. Generation 0 has no row: it
stays where ChillDKG wrote it, with ids derived from the host keys as
before.
ShareGenerations is the one door signing reads a share through.
FrostSigningManager fixes a session to the generation the group signs with
when it is proposed, carries it as frost_generation from generation 1 (a
generation-0 proposal is byte for byte what it was), and a device holding
no share of the named generation declines out loud with
GENERATION_REFUSAL instead of waiting or signing with the wrong share.
ShareGenerationsJvmTest refreshes a 2-of-3 group's shares by hand with a
zero-constant polynomial; the new shares sign and the signature verifies
as the unchanged room. jvmTest 1183/1183, compileDebugKotlinAndroid, and
the M3, brand and wallet audits pass.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Every connection opens with PRAGMA secure_delete = ON (SecureDeleteDriver),
and GizaDatabase.scrubFreedPages truncates the write-ahead log, which keeps
whole page images of a share after its row is gone. Android backups and
device-to-device transfers carry none of the app's data: aux.db holds FROST
shares in plaintext, and a share copied somewhere the app cannot reach
cannot be rotated away from.
SecureDeleteJvmTest reads the database's files byte by byte; its two
controls find the share with secure_delete off and before the scrub.
jvmTest 1176/1176.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The piece Phase 7 deferred, in both directions, because they are one question:
a group's state is a few kilobytes of ratchet tree, group context and epoch
secrets, and the app was rewriting all of it to record things that moved a
counter.
Sending an application message advances exactly one thing -- this leaf's entry
in the secret tree (RFC 9420 §9) -- so the library carries the position as its
own record, `MlsGroupStateStore.saveSenderRatchet`, in the spirit of OpenMLS
keeping `message_secrets` apart from `group_state`. Giza defaulted that to
false, which sent the manager back to a full save per message. It is now a
`MarmotSenderRatchet` row, one per room, schema 36 -> 37 with an AutoMigration.
The bytes are stored as the library wrote them -- the `MarmotPublishObligation`
precedent, not the retained-epoch one -- because a record whose whole job is to
never go backwards is safest when nothing here re-encodes it; the epoch, leaf
and generation sit beside it, read off those same bytes, so they cannot drift.
The hazard this introduces is an ordering, and it is in the app's code, not the
library's. `MlsGroupManager.restoreAll` applies the record itself. A room joined
after the engine restored is loaded from its row by `MarmotEngine.groupFor`
instead, and that has to apply the record BEFORE `adoptGroup`, because adopting
persists and persisting rewrites the row from the group being adopted. The other
way round, the next restart re-emits generations already published, under AEAD
keys and nonces already used.
Finding the test that could tell the two orders apart took two goes. The first
asserted the row after a lazy load and passed with the order inverted: a state
saved before this leaf ever sent has no ratchet entry, `exportOwnSenderRatchet`
returns null, and the adopt writes nothing. The order cannot matter until the
stored state holds a position of its own behind the record's, and a received
message is what puts one there. With one receive in the middle the inverted
order fails with expected:<2> but was:<1>.
The receive side is a full save, from `MarmotEngine.processGroupEvent`, which
`NostrDao` now reads inbound events through so a second caller cannot forget it.
And a correction to Phase 5, which said an unwritten row still lost the late
message. It does not: mls-kmp writes the skipped keys beside the positions they
belong to, so an unwritten row is an older COHERENT state, and a position that
has not passed the late generation derives it forward. quartz's engine saved the
positions and dropped the keys -- that pair is what lost messages. The cost of
an unwritten row is the re-deriving, against SecretTree's thousand-step cap. The
reason the write lands now is the send side: until this change every send wrote
the whole state, so the row could not fall far behind inside an epoch.
1167 tests across 156 classes, 0 failures; Android and JVM compile clean; the
four audits unchanged. docs/mls-skipped-keys.md loses its mitigation claim and
gains the correction; docs/marmot-kmp.md gains Phase 8.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Phase 6 is a probe with no code of its own, so it rides along: both fork tests pass
unchanged, which means marmot-kmp 2.2.1 still scores a fork this device is half of the way
quartz 1.15.2 did. The assertion whose message is "the two sides agree -- the library has
been fixed" did not fire. What changed is that the fix docs/marmot-v2.md predicts is now a
first-class thing on the library's side -- MlsGroup.stageCommit, with the staged commit in
MlsGroupState from its STATE_VERSION 9 -- so it is a choice in MlsCandidateStateEngine
between replaying a branch and taking the state that was kept. Both notes say so.
Phase 5 is the skipped keys, and it is half closed. mls-kmp's state carries them:
skippedApplicationSecrets and skippedHandshakeSecrets, exported by saveState and imported
by restore, arriving at STATE_VERSION 5 so a version-4 blob reads them as an empty map.
That is steps 1 to 3 of the fix docs/mls-skipped-keys.md proposed. Step 4 is not done:
consumedGenerations, the replay guard, is still one SecretTree's field.
The app does not benefit yet, and the first draft of this test claimed it did.
MlsGroupManager.decrypt persists only when the message was a commit that advanced the
epoch, so the secret reaches the live group and never the row. The draft delivered
generation 1, rebuilt the engine, delivered generation 0 and asserted it decrypted -- and
it did, for the wrong reason: a rebuilt engine restores a blob whose sender ratchet never
moved, so generation 0 is simply the next one it expects. A green test proving nothing,
caught by the assertion beside it that looked redundant.
So the three tests say what is true: the secret is in the state the engine would save, a
group rebuilt from those bytes reads the late message, and the stored state does not carry
it. The last one is pinned in the style of the authored fork, with its KDoc saying what to
invert when the receive path starts persisting -- deliberately not done here, because it
is a write per inbound message that re-encodes the ratchet tree, the group context and
every epoch secret. saveSenderRatchet is the library's answer to that cost on the send
side.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Most of this phase was answered by Phase 1 rather than built. `GroupEventResult` still has
exactly nine variants -- `MarmotEngine.inRoom` is an exhaustive `when` used as an
expression, so the compiler says so rather than a reading of the source. The convergence
and lifecycle surface takes and returns what `settleLater` and `awaitSettled` already
expected, `allowsOutboundWork` included. `stageAddMember` -> `StagedCommit` ->
`gate.prepare` -> `installState` needed no edit. And no test's assertions moved: seven
fixtures now build their group with `MarmotGroupPolicy` as the app does, which is a
construction-site change, not a weakened expectation.
What was left is the six classes quartz 2.x renamed to match what the NIPs call the kinds,
and kept deprecated typealiases for: SealedRumorEvent -> SealEvent, ChatMessageRelayListEvent
-> DmRelayListEvent, RelayFeedsListEvent -> FavoriteRelayListEvent, LnZapEvent ->
ZapReceiptEvent, LongTextNoteEvent -> LongFormContentEvent, ChannelListEvent ->
PublicChatListEvent. 104 references in 25 files; same packages, so each is an identifier
rename. None reaches a string the app persists -- no Room column, no string resource, no
kind number -- and after it the build has no quartz deprecation warnings left.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
quartz 1.15.2 -> 2.7.3, and the engine it used to carry from marmot 2.2.1 over mls 1.3.0
over crypto 2.1.0. docs/scripts/marmot-kmp-imports.sh --apply moved 187 lines by the rule;
42 `quartz.marmot` imports stay, which are the event classes quartz kept.
The 854 non-Marmot quartz imports came through the major bump without an edit. All 45
compile errors were in the engine seam, and 44 were one thing: five accessors that were
members of `MlsGroup` in quartz's engine are extension functions in marmot-kmp
(`currentGroupState`, `currentMarmotData`, `currentNostrGroupId`, `currentAdminIdentities`,
`isLocalAdmin`), so 14 files import one now. The 45th, `buildCurrentProfileFrom`, likewise.
No constructor the app drives changed shape, and `GroupEventResult` still has exactly nine
variants -- `MarmotEngine`'s exhaustive `when` compiling is the proof there is no tenth to
drop on the floor.
One change here is not a rename. `MlsGroupPolicy` is new in mls-kmp: quartz's engine
hardcoded Marmot's rules, mls-kmp made them an argument, and every factory defaults it to
`Permissive` -- so the eleven places this app builds a group itself were building a
non-Marmot group. The loud half is that `commitExporter` is then null, `preCommitExporterSecret`
comes back empty and `GroupEventEncryption.encrypt` refuses it ("Group key must be 32
bytes"), which is the one test that failed. The silent half matters more: `Permissive`
greases the leaf's capabilities, which MDK has never been tested against; it knows neither
`0xF2EE` nor the app-data dictionary, so RFC 9420 13.4 refuses a GroupContextExtensions
proposal in a group we are a member of; and it authorizes every commit, proposal and
SelfRemove without a check. So `MarmotGroupPolicy` goes in at all eleven. The
current-profile paths needed none -- `CurrentProfileGroupFactory` and every
`MlsGroupManager` entry point pass it themselves.
1149 tests, 0 failures; compileDebugKotlinAndroid clean; the three audits unchanged.
Import blocks were re-sorted in the touched files only: 253 further files in composeApp
have blocks that were already out of order, and C2 is the reason to leave them be.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
The 23 wallet notes move to docs/retired/ with a banner; every link between
notes is rewritten for the move and checked. The index lists them as one
Retired paragraph, and seven kept notes carry a line on what changed. The
README and CLAUDE.md describe a Giza with no wallet.
brand-audit.sh loses its "bennu/ exception: every such tag was a wallet's,
so one now is a wallet coming back. wallet-audit.sh --check, in check and
in CI, fails on a retired kind in the app's code, a lightning-kmp import,
a file named for a wallet's pieces, or sats in a string.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
W3: a Lightning invoice in a note is a card that opens a lightning: link
in the device's own wallet app, undecoded -- decoding was lightning-kmp's,
and paying from the card was never wired. The dead pay and zap hooks go.
Lightning.randomBytes becomes quartz's RandomInstance; the tests'
LocalKeyManager becomes PhraseKeys; NodeParamsManager.chain becomes
PROFILE_CHAIN, the mainnet constant every profile's preference files are
named under.
What is left of the library is storage (keystore, credentials, seed file,
preferences). Moving it into the app and off the composite build is
Phase 7b, which needs an iOS build and a device to check, and is left for
its own branch.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
PhraseKeys derives a phrase's nostr key (NIP-06, m/44'/1237'/0'/0/0) and
its profile id (hash160 of m/50'/0', the old node key) with bitcoin-kmp's
DeterministicWallet. ForkCompatibilityTest's Phase 0 pins pass unchanged
through it, so the same phrase is the same person with the same
preference files.
No profile starts a node: Identity.business, startupNode and its state
machine, the platform start/schedule/stop actuals, LightningApplication,
BusinessManager.initialize, the NFC hooks and POST_NOTIFICATIONS go. A
switch is clearing the identity and nothing else. Copy that promised funds
or a wallet is reworded, and the switcher's badge says Recovery phrase.
Forgetting a phrase profile is still refused (now PhraseAttached): the
phrase would derive the key again, and offering it is new UI.
iosMain was edited without an iOS build.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
MIGRATION_35_36, by hand: the wallets' chat lines; GroupTransaction; every
signing session over a transaction or a sweep, with its items and its
members' messages; the other fifteen wallet tables, children first; and
FrostSigningItem.inputIndex, DkgSession.guardianDelay and
ChatMessage.lightningFactKey. DkgSession.walletPolicy stays: the join
screen reads a Bennu ceremony's tag from it. The 36 schema is committed.
The wallet line-type constants and the transcript's arms for them go with
the rows they named.
jvmTest: 1,150 run, 0 failed.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
wallet/ (Electrum included), nostr/wallet/, the policy and guardian tags,
GroupWalletDerivation, GroupWalletManager, GuardianDerivation,
GuardianManager, ProposedSpend, three screens with their view models,
states and routes, and FROST's spend half.
FROST is back to signing events. Every transaction proposal from a Bennu
peer is filed declined without being read, and the decline goes out
through advance(). Certificates and ceremonies carry no wallet tag; a
guarded subgroup's ceremony is filed and not joined, and its join screen
says why (W5). A key state carrying a wallet's certificate is declined.
The last bennu/ derivation tag leaves the code, and the last wallet pins
with it.
jvmTest: 1,148 run, 0 failed.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The member-wallet events, MemberWalletManager, MemberWalletDerivation, the
repository and DAO, five screens with their view models, states and routes,
and the 74 strings only they read. GuardianManager stops reading member
certificates. The entities stay until Phase 5's migration.
Guardians and the subgroup wallet policy move to Phase 4: they are built
into the group's on-chain wallet and cannot leave before it and compile.
jvmTest: 1,311 run, 0 failed.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The Lightning events, managers, Iceberg ceremony, wallet/lightning, the
repository, five screens with their view models, states and routes, the
four DAOs, and the regtest network with its build wiring. The entities
stay until Phase 5's migration.
FROST's sweep path goes here rather than in Phase 4, since it was built on
GroupSweep: a sweep that arrives is filed declined without being read.
Lightning kinds fall to the retired-kinds arm; existing Lightning lines
stay as settled lines that open nothing. The 147 strings Phases 1 and 2
left unread go, and a Phase 1 test name that said Bennu is renamed.
jvmTest: 1,440 run, 0 failed, 0 skipped.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A Bennu member can put a wallet to a group Giza is in. Giza can no longer
check one, so it declines on arrival, out loud: the proposal is filed as a
declined session and advance() publishes the DECLINE, which the group
counts. Refusing used to be silent, which looks like a phone in a pocket.
- RetiredKinds: 30331-30337 and 30350-30366 stay Bennu's, never reused.
- WalletRefusal: what is a wallet's to sign, read by tag name so it
outlives the wallet's parsers. approve() declines one instead.
- A retired kind is one line or none in the transcript, never a raw bubble.
- No Lightning dispatch, no guarded-wallet forwarding, no key answers.
- The detail and profile screens and the subgroup picker lose their
wallets; a guarded room says why it offers no subgroup (W5), and
certificates carry no wallet tags.
- The wallet tests this behaviour breaks are deleted with it.
jvmTest: 1,495 run, 0 failed, 2 skipped.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
- Strings: app_name and the giza key say Giza, as do the eight values that
named Bennu. Two keys that contained the name are renamed. Two messages that
meant "has no Marmot key package yet" now say so, since a Bennu user counts.
- Restore: when a recovery phrase is recognised, the sign-in screen says to stop
using it anywhere else. A seed running in Bennu and Giza at once is two copies
of one Lightning wallet, which can lose funds.
- Desktop: the window title and the unlock heading come from the catalogue.
The installers are named Giza (giza on Linux), with a fixed Windows upgrade
UUID of their own so a Giza MSI never upgrades a Bennu one.
- iOS: PRODUCT_NAME and the product reference are Giza.app.
- Wire: the client tags are Giza and giza. Nothing compares them.
- The twelve bennu/ derivation tags stay as they are. They are hash inputs like
mantra/, and a Bennu peer and a Giza peer derive the same keys through them.
Each now has a note saying so. The rebrand-history comments count four.
jvmTest: 1643 run, 0 failed, 2 skipped. compileDebugKotlinAndroid passes.
m3-audit: all budgets met. It differs from the baseline only by the new restore
line (one more stringResource and one more bodyMedium).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
docs/scripts/giza-rename.sh, run over the moves of Phase 3a:
- com.machankura.bennu.{compose,android,desktop} -> mobi.giza.{...}, in
package lines, imports, fully qualified references, the manifest, mainClass,
the Android namespace (one value with applicationId again), the m3Audit
source path, the six docs/scripts tools, and the source links in docs/;
- Res moves from bennu.composeapp.generated.resources to
mobi.giza.compose.resources, now pinned with packageOfResClass so a later
rename of the root project leaves the imports alone;
- BennuDatabase, BennuTheme and the other eleven Bennu identifiers are Giza*.
The script's search is now the same pattern as its sed expressions, so on a
renamed tree it finds nothing and changes nothing.
Checked against the Phase 0 baseline: jvmTest 1643 run (1642 + AppDirJvmTest),
0 failed, 2 skipped; compileDebugKotlinAndroid passes; m3-audit prints the
baseline report line for line. iOS is not compiled on this Linux host.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
docs/scripts/giza-rename.sh --moves-only: com/machankura/bennu becomes
mobi/giza in all six source sets, the nine files named Bennu* are named Giza*,
and the Room schema directory moves to mobi.giza.compose.database.GizaDatabase.
Every source file is a 100% rename, so log --follow and blame go straight
through.
This commit does not compile on purpose: the next one rewrites the contents.
The script, which does both, comes with it so a merge from Bennu can re-run it.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
GroupLightningRollout.LIQUIDITY_ENABLED is true, by decision, ahead of the plan's own Phase 0 check
on mainnet: ACINQ's LSP has not yet been seen to accept a splice whose funding key from us does not
change, so the first purchase there is that check. If it refuses, the splice aborts before anything is
signed into it and the purchase is reported failed. A purchase is bounded meanwhile by the mainnet
channel cap, the fee cap the group signs, and every co-signer's checks. The wallet screen now shows Add
liquidity, and the operator's node buys what the group authorises.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
GroupLightningLiquidityScreen asks as Phoenix asks its owner: Phoenix's amounts on a discrete slider,
less those the LSP does not sell and those past the channel cap; the miner fee, service fee, its year
and the total, priced on this device from the operator's report with lightning-kmp's own arithmetic
(LiquidityPrice, which matches what eclair charged on regtest to the sat); Phoenix's warning at a
quarter of the amount and its stop at the balance; a fee cap with room above the estimate; and a
review sheet with Phoenix's acknowledgement. Then a proposal, and the signing session it opens.
The wallet screen gains Add liquidity on its balance card, or the reason it is not there, a purchase's
state on its channel row, and Inbound liquidity added in its payment list (a nullable liquiditySat on
the payment row, in schema 35). The room gets a line when a purchase locks or fails.
All of it is behind GroupLightningRollout.LIQUIDITY_ENABLED, off until the regtest run passes; the
operator's node buys nothing while it is off. m3Audit meets every budget.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
GroupLightningNode.buyAuthorised runs with the node's other actions, on the watch of kind 30363: for
each open buy-liquidity it has not taken on, it finds the LSP's rate for the amount, estimates at the
node's own feerate, and splices only if the estimate is within the authorisation's cap, buying at the
feerate the estimate raised to, as Phoenix does. Once per authorisation; not while the channel has a
splice that has not locked, which eclair would refuse; a failure is reported and not retried.
The snapshot now carries the LSP's rates and the node's feerate, for a member to price a purchase from,
each purchase's state (waiting, pending, locked, failed with its reason), how many funding outputs each
channel has live, and the purchase as a `liquidity` payment.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A co-signer keeps a ledger per funding output now (schema 35: IcebergChannelLedger keyed by output,
with its index, the parent it spent and the purchase that let it). A commitment on an output it has
no ledger for is the first commitment on a splice's new one: it must follow the newest output by one
index, rebuild from its context, and open from the parent's ledger at the same number with the same
HTLCs, the group's balance lower by no more than an open buy-liquidity authorisation's fee cap
(CoSignerPolicy.openSplice). The shared input is then held to that authorisation: it spends the pinned
output, makes one new output of the group's key with the LSP's under the cap, buys the amount the
group named, is paid from the channel balance alone, costs what the first commitment took to the
msat and no more than the cap, and the LSP puts in what it is paid for. An authorisation is bound to
the parent of the first splice it let, so however many attempts there are, one confirms.
While two outputs are live a payment settles on both at one commitment number; each ledger records
what its last commitment consumed, and a sibling spends only the difference. Before this the second
commitment was refused as under its floor.
GroupLightningSpliceCoSigningJvmTest, seven four-device tests on regtest and mainnet: a purchase the
group signs and the script interpreter accepts, payments over both live outputs, and each refusal.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A fourth action for kind 30363, `buy-liquidity`: one channel, an amount of inbound, a cap on the fee
(our share of the splice's mining fee and the purchase's own together), an expiry, and an id so two
purchases for one channel are two events. An older build reads it as no authorisation at all, and
refuses the splice that follows.
GroupLightningAuthorisations gains liquidityPurchases, prepareBuyLiquidity -- which refuses a purchase
of nothing, or one past the mainnet channel cap, with a LiquidityProblem of its own -- and
proposeBuyLiquidity. The proposal reads "Add 500,000 sats of inbound liquidity", with the fee cap and
the LSP's year, and the room gets a line once the group signs.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A splice's shared input now reaches every co-signer with what it is: CoSigningWire.Context type
`splice`, with the parent funding output, the new one by index, the counterparty's new key, both
contributions, the liquidity purchase and the feerate. A commitment's context names its funding index,
and a request carries every other output the transaction spends.
messageOf computes the taproot sighash at the input that spends the funding output, over every spent
output, and is null when the request leaves one out; check 3 lets a splice spend the funding output
once beside the counterparty's inputs, and refuses a request with no hash to compute. A splice is
still refused, now by name, until the co-signer checks one (Phase 5). The context's spec is optional,
since a splice has none, and every check that reads one refuses a context without it.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Advances lightning-kmp to the splice signing context: a splice's shared input is signed with a
SigningContext.Splice that names the parent and new funding outputs, both contributions and the
liquidity purchase, and every commitment's context names the funding output it is on. The app maps
the new context to nothing on the wire for now, so a co-signer still reads a splice as unsaid and
refuses it, as before; Phase 3 carries it.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Joining is now the only approval. Every check in the other two rounds --
a contribution against its commitment, everyone's transcript hash, the
public shares making one key -- is the device's, so after joining it sends
its contributions and confirms by itself. Asking a person to tap through
them only let a member who joined and never came back hold the ceremony
open for everybody.
A ceremony that has not finished 24 hours after its proposal is abandoned
by the first participant's device to notice, checked each minute beside
the group nodes, naming who had not taken their part. The deadline runs
from the proposal's own timestamp, so every device agrees on it, and a
proposal read after its deadline is not filed. Any participant can also
abandon a ceremony from its screen. Before this a ceremony nobody finished
blocked the room for good, since a room runs one at a time.
The group screen's Lightning row test now covers both sides of the row
waiting for an onchain wallet.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The Lightning wallet's key is made by the onchain wallet's signers and its
channels close to that wallet, so until the group has opened one the row
has nothing behind it. It now stays on the page disabled, and says that
Lightning is only available once the group has an onchain wallet.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The same two misreadings the regtest run found in the room's lines, on the
wallet screen: a channel's close, which lightning-kmp files as an outgoing
payment with no payment hash, was listed as sent, and a sent amount
included its fee. Both now read through GroupLightningReports.isChannelClose
and recipientMsat, which the room's lines use too. A close is listed as one,
or as closing until it confirms.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Found by the regtest run, now that it checks the transcript. lightning-kmp
files a channel's close as an outgoing payment with no payment hash, which
wrote "sent" beside each closed line, and an outgoing payment's amount
includes its fee, so 20,000 sats with an 84-sat fee read as 20,084 sent.
GroupLightningRegtestJvmTest now asserts every device's lines: one per
channel opened and closed, one per payment, and no raw JSON, refusal or
alarm.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The wallet's plan said a person sees a refusal as a transcript line, and
that two hashes echoed for one label raise the alarm in the transcript;
both were logger calls. A refusal is now said on the refusing device only,
once per request, with the check that failed; an operator asking for two
messages under one label is said on every device that sees it, once per
label, in the error tint.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A channel opening or closing, and a payment received, sent or failed, each
get one line however many snapshots repeat them. The snapshot restates the
whole wallet, so the line is keyed on the fact, not the message:
ChatMessage.lightningFactKey (v34, an AutoMigration) holds the channel's or
the payment's id. A payment's line sits where the payment happened, and a
channel a newer snapshot no longer holds is said to have closed.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The node seed being handed out, an invoice asked for and made, and an
operator's node stopping now each write one line, through
GroupLightningLines: on the way out by the device that sends the message,
which never reads its own back, and on arrival by every other, keyed on the
inner event so a redelivery is not a second line. An invoice request and a
stop are filed on arrival for the first time, and a stop is believed only
from the operator of the term it names.
The operator election line names the operator, the Lightning wallet's
signed lines get icons of their own, and every Lightning line opens the
wallet's screen.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A ceremony stopped on another device was recorded as "Abandoned by" a key
prefix and the sender's exception message, and the screen showed it after
"Abandoned:". IcebergRitualManager.describe now says each fault as a
sentence naming the member at fault, sends that sentence in the failure
message, and the screen shows it in the error card the shared key ceremony
uses.
RitualNotice's chevron was described as opening the shared key ceremony on
every line; each family now says what it opens, the lines that lead nowhere
draw none, and only a request line can carry the approved tick.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The standing notice under the newest message read only the shared key's
ceremonies, so a member owed the Lightning wallet's join, reveal or confirm
had to scroll to its request line. AwaitingCeremony now says which ceremony
and what it wants, the chat's view model observes the Lightning ceremonies
beside the shared key's, and a tap opens the screen that ceremony has.
The member who opened the Lightning ceremony is also asked, once its key is
made, to open the wallet -- the counterpart to ChillDKG's room awaiting
creation -- until a wallet statement for it is being signed.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Every kind the group Lightning wallet's devices send each other -- the
Iceberg ceremony, the co-signing, the operator's snapshots and invoices --
reached applyInnerEvent's last arm and was written as an unsupported line
holding the event's JSON, beside the lines the managers already write.
GroupLightningEvents.PROTOCOL now joins the ChillDKG and FROST families as
protocol, and MIGRATION_32_33 deletes the bubbles already in rooms, found by
the kind of the inner event behind them, as MIGRATION_26_27 did.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
On the first mainnet run, most of the wait for an invoice (six seconds) and for an authorised
payment to leave (five) was the node's ten-second poll. The node now watches the room's
invoice requests (30364) and authorisations (30363, which carry channel actions too), and acts
the moment either changes. The poll stays, for expiries and snapshots. Answering, paying and
closing each take one lock, so a wakeup, the poll and a direct call never act twice on the
same request: payAuthorised checks hasPaid, which suspends, before it marks a payment in hand.
Advances lightning-kmp-app to the commit that keeps payment preimages out of a release build's
Logcat.
The plan doc records the run with ACINQ's mainnet LSP: an on-the-fly 25,000-sat taproot
channel, 8,558 sats received, and a 21-sat payment sent. Every co-signer approved every
commitment. The doc also notes that a payment larger than the channel's 16,442 sats of
inbound would need the splice the co-signers still refuse.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
ACINQ's mainnet LSP hung up on the group's node seven milliseconds after init, every time. The
node required simple taproot channels (bit 564). The LSP's init lists neither 564 nor 565, and
BOLT 9 obliges a peer to hang up on a required feature it does not offer. Phoenix leaves the
feature optional and stays connected. Nothing is lost by matching it: lightning-kmp asks for the
taproot channel type in every channel it opens, and the co-signers rebuild every funding output
and commitment as taproot.
The node now takes Phoenix's setup wherever the group's terms allow:
- lightning-kmp's default features and peer storage
- connect and handshake timeouts that grow with each attempt, tripled over Tor
- the LSP's onion address while the identity has Tor on, and no clearnet dial over Tor
- the 50% relative cap on liquidity fees
The absolute fee cap stays the statement's, and the redial backoff stays: Phoenix's resets at
every handshake, which against an LSP that hangs up after init would redial every 0.1 s.
On the operator's emulator, the group's connection to ACINQ now holds. The regtest run still
opens a simple_taproot_channel and passes. Whether ACINQ opens a taproot channel to the group's
node is still unknown until one is opened on mainnet. The plan doc says so, and Phase 0's
instruction to require the feature is corrected.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>