feat(wallet): every member refuses and ignores a wallet its parent ruled out (Phase 7)
Signing: FrostSigningManager refuses a wallet statement proposal whose guardedness the room's own certificate does not allow, before it is shown, reading the policy off this device's key state. Reading: GroupWallet.newestAmong takes the policy and drops a statement it does not allow before rule 1 -- under a guarded policy a plain statement is no wallet even alone, so an older client's plain wallet has no addresses derived, no coins watched and no spends signed. walletFor passes GroupWalletManager.walletPolicyFor. An undecided room reads exactly as before. GuardianManager.verify refuses a forwarded statement whose certificate's policy contradicts its keys or decided unguarded. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
47df6f51f7
commit
1069059174
7 files changed
+208
No files matched your search
+20
@@ -1,5 +1,6 @@
|
||||
package com.machankura.bennu.compose.managers
|
||||
|
||||
import com.machankura.bennu.compose.nostr.subgroup.allows
|
||||
import com.machankura.bennu.compose.nostr.frost.GroupKeyStateEvent
|
||||
import fr.acinq.bitcoin.OutPoint
|
||||
import com.machankura.bennu.compose.database.model.GroupTransaction
|
||||
@@ -580,6 +581,25 @@ object FrostSigningManager {
|
||||
// decision none of its members agreed to. [key] is the child's own
|
||||
// ceremony here, which is where the policy was filed.
|
||||
// `docs/subgroup-wallet-policy.md`, Phase 5.
|
||||
// A wallet statement has to be one the room's parent allows: a subgroup
|
||||
// decided guarded opens a guarded wallet and nothing else, and one decided
|
||||
// unguarded a plain one. Read off this device's own certificate for the
|
||||
// room, never the proposal's, and refused before it is shown -- a member
|
||||
// should not be asked to approve what their device already knows the
|
||||
// room has ruled out. docs/subgroup-wallet-policy.md, Phase 7.
|
||||
unsignedEvents.forEach { rebuilt ->
|
||||
if (rebuilt.kind != GroupWalletStatementEvent.KIND) return@forEach
|
||||
val guarded = GroupWalletStatementEvent.read(rebuilt.tags, rebuilt.content)?.guardians?.isNotEmpty() ?: return@forEach
|
||||
val policy = SubgroupManager.walletPolicyOf(database, rebuilt.pubKey)
|
||||
if (!policy.allows(guarded)) {
|
||||
logger.w(
|
||||
"Signing proposal $sessionId opens ${if (guarded) "a guarded" else "an unguarded"} wallet, " +
|
||||
"and this group's parent decided otherwise; dropping"
|
||||
)
|
||||
return null
|
||||
}
|
||||
}
|
||||
|
||||
unsignedEvents.forEach { rebuilt ->
|
||||
if (rebuilt.kind != GroupKeyStateEvent.KIND) return@forEach
|
||||
SubgroupManager.refuseKeyState(key, rebuilt)?.let { reason ->
|
||||
|
||||
+13
@@ -1,5 +1,6 @@
|
||||
package com.machankura.bennu.compose.managers
|
||||
|
||||
import com.machankura.bennu.compose.nostr.subgroup.WalletPolicyReading
|
||||
import com.machankura.bennu.compose.database.BennuDatabase
|
||||
import com.machankura.bennu.compose.nostr.wallet.GroupWallet
|
||||
import com.machankura.bennu.compose.nostr.wallet.GroupWalletStatementEvent
|
||||
@@ -90,6 +91,7 @@ object GroupWalletManager {
|
||||
thresholdPublicKey = thresholdPublicKey,
|
||||
chain = chain,
|
||||
account = account,
|
||||
policy = walletPolicyFor(database, chatRoomId),
|
||||
)
|
||||
|
||||
/** The wallet [chatRoomId] has opened on [chain], or null when the group has not opened one. */
|
||||
@@ -107,6 +109,17 @@ object GroupWalletManager {
|
||||
thresholdPublicKey = thresholdPublicKey,
|
||||
chain = chain,
|
||||
account = account,
|
||||
policy = walletPolicyFor(database, chatRoomId),
|
||||
)
|
||||
}
|
||||
|
||||
/**
|
||||
* What [chatRoomId]'s parent decided about its wallet at its birth, or null
|
||||
* for a room with no certificate -- `docs/subgroup-wallet-policy.md`. The
|
||||
* same reading the picker and every parent signer make, through
|
||||
* `SubgroupManager.walletPolicyOf`, so the wallet a device opens, offers and
|
||||
* signs for cannot disagree with what the group was made as.
|
||||
*/
|
||||
suspend fun walletPolicyFor(database: BennuDatabase, chatRoomId: String): WalletPolicyReading? =
|
||||
SubgroupManager.walletPolicyOf(database, chatRoomId)
|
||||
}
|
||||
+5
@@ -1,5 +1,6 @@
|
||||
package com.machankura.bennu.compose.managers
|
||||
|
||||
import com.machankura.bennu.compose.nostr.subgroup.allows
|
||||
import co.touchlab.kermit.Logger
|
||||
import com.machankura.bennu.compose.database.BennuDatabase
|
||||
import com.machankura.bennu.compose.database.model.ChatMessage
|
||||
@@ -95,6 +96,10 @@ object GuardianManager {
|
||||
val reading = GroupWalletStatementEvent.read(statement.tags, statement.content) ?: return null
|
||||
if (reading.guardians.isEmpty()) return null
|
||||
val certificate = reading.certificate ?: return null
|
||||
// A guarded wallet the certificate's own policy does not allow -- one it
|
||||
// contradicts, or decided unguarded -- is not one an honest descendant
|
||||
// opens, so it is not one to list. docs/subgroup-wallet-policy.md.
|
||||
if (!SubgroupBirthCertificateEvent.parseWalletPolicy(certificate.tags).let { it != null && it.allows(guarded = true) }) return null
|
||||
|
||||
val descendantKey = SubgroupBirthCertificateEvent.parseThresholdPublicKey(certificate.tags) ?: return null
|
||||
if (!SharedKeyDerivation.marmotGroupId(descendantKey).equals(descendantChatRoomId, ignoreCase = true)) return null
|
||||
|
||||
+10
@@ -48,3 +48,13 @@ sealed interface WalletPolicyReading {
|
||||
/** Whether this reading is the parent having decided [policy]. */
|
||||
fun WalletPolicyReading?.isDecided(policy: SubgroupWalletPolicy): Boolean =
|
||||
(this as? WalletPolicyReading.Decided)?.policy == policy
|
||||
|
||||
/**
|
||||
* Whether a wallet that is [guarded] -- or plain, when false -- is one this
|
||||
* reading allows: a decided policy allows its own kind only, and an undecided
|
||||
* or absent one allows either, as before policies.
|
||||
*/
|
||||
fun WalletPolicyReading?.allows(guarded: Boolean): Boolean = when (this) {
|
||||
is WalletPolicyReading.Decided -> guarded == (policy == SubgroupWalletPolicy.GUARDED)
|
||||
WalletPolicyReading.Undecided, null -> true
|
||||
}
|
||||
+11
@@ -1,5 +1,7 @@
|
||||
package com.machankura.bennu.compose.nostr.wallet
|
||||
|
||||
import com.machankura.bennu.compose.nostr.subgroup.allows
|
||||
import com.machankura.bennu.compose.nostr.subgroup.WalletPolicyReading
|
||||
import com.machankura.bennu.compose.database.model.GroupSignedEvent
|
||||
import com.machankura.bennu.compose.managers.GroupWalletDerivation
|
||||
import com.vitorpamplona.quartz.nip01Core.core.HexKey
|
||||
@@ -63,17 +65,26 @@ data class GroupWallet(
|
||||
* 2. among guarded ones the earliest decides the guardians, and a later one
|
||||
* naming others is ignored. Changing who guards a wallet is another
|
||||
* account.
|
||||
*
|
||||
* And before either, a statement [policy] does not allow is no wallet at
|
||||
* all -- `docs/subgroup-wallet-policy.md`. Under a parent that decided
|
||||
* *guarded* a plain statement is ignored even with no guarded one beside
|
||||
* it, which is stronger than rule 1: an older client's plain wallet then
|
||||
* opens nothing on this device, no addresses derived and no coins
|
||||
* watched, rather than a wallet the rest of the group refuses to spend.
|
||||
*/
|
||||
fun newestAmong(
|
||||
signedEvents: List<GroupSignedEvent>,
|
||||
thresholdPublicKey: HexKey,
|
||||
chain: Chain,
|
||||
account: Long = 0L,
|
||||
policy: WalletPolicyReading? = null,
|
||||
): GroupWallet? {
|
||||
val order = compareBy<GroupWallet>({ it.openedAt }, { it.signedEvent.id })
|
||||
val opened = signedEvents
|
||||
.mapNotNull { of(it, thresholdPublicKey) }
|
||||
.filter { it.chain == chain && it.account.account == account }
|
||||
.filter { policy.allows(it.account.isGuarded) }
|
||||
|
||||
val guarded = opened.filter { it.account.isGuarded }
|
||||
val first = guarded.minWithOrNull(order)
|
||||
|
||||
+48
@@ -1,5 +1,7 @@
|
||||
package com.machankura.bennu.compose.nostr.wallet
|
||||
|
||||
import com.machankura.bennu.compose.nostr.subgroup.WalletPolicyReading
|
||||
import com.machankura.bennu.compose.nostr.subgroup.SubgroupWalletPolicy
|
||||
import com.machankura.bennu.compose.database.model.GroupSignedEvent
|
||||
import com.machankura.bennu.compose.managers.GroupWalletDerivation
|
||||
import com.machankura.bennu.compose.managers.GuardianDerivation
|
||||
@@ -218,6 +220,52 @@ class GroupWalletStatementEventTest {
|
||||
assertEquals(laterPlain.id, GroupWallet.newestAmong(listOf(laterPlain), thresholdKey, Chain.Mainnet)?.signedEvent?.id)
|
||||
}
|
||||
|
||||
// ---- the parent's decision: docs/subgroup-wallet-policy.md -------------
|
||||
|
||||
private val decidedGuarded = WalletPolicyReading.Decided(SubgroupWalletPolicy.GUARDED)
|
||||
private val decidedUnguarded = WalletPolicyReading.Decided(SubgroupWalletPolicy.UNGUARDED)
|
||||
|
||||
@Test
|
||||
fun `under a guarded policy a plain statement is no wallet, even alone`() {
|
||||
// Stronger than rule 1: an older client's plain wallet opens nothing,
|
||||
// so no device derives its addresses or watches its coins.
|
||||
val plain = statement(mainnet)
|
||||
|
||||
assertNull(GroupWallet.newestAmong(listOf(plain), thresholdKey, Chain.Mainnet, policy = decidedGuarded))
|
||||
|
||||
val guarded = guardedStatement(createdAt = 1_700_000_100)
|
||||
assertEquals(
|
||||
guarded.id,
|
||||
GroupWallet.newestAmong(listOf(plain, guarded), thresholdKey, Chain.Mainnet, policy = decidedGuarded)?.signedEvent?.id,
|
||||
)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `under an unguarded policy a guarded statement is no wallet`() {
|
||||
val plain = statement(mainnet, createdAt = 1_700_000_000)
|
||||
val guarded = guardedStatement(createdAt = 1_700_000_100)
|
||||
|
||||
assertEquals(
|
||||
plain.id,
|
||||
GroupWallet.newestAmong(listOf(plain, guarded), thresholdKey, Chain.Mainnet, policy = decidedUnguarded)?.signedEvent?.id,
|
||||
"rule 1 would have picked the guarded one; the parent ruled it out",
|
||||
)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `an undecided room reads exactly as before policies`() {
|
||||
val plain = statement(mainnet, createdAt = 1_700_000_200)
|
||||
val guarded = guardedStatement(createdAt = 1_700_000_000)
|
||||
|
||||
listOf(WalletPolicyReading.Undecided, null).forEach { policy ->
|
||||
assertEquals(
|
||||
guarded.id,
|
||||
GroupWallet.newestAmong(listOf(plain, guarded), thresholdKey, Chain.Mainnet, policy = policy)?.signedEvent?.id,
|
||||
)
|
||||
assertEquals(plain.id, GroupWallet.newestAmong(listOf(plain), thresholdKey, Chain.Mainnet, policy = policy)?.signedEvent?.id)
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `every network name round trips`() {
|
||||
listOf(Chain.Mainnet, Chain.Testnet3, Chain.Testnet4, Chain.Signet, Chain.Regtest).forEach {
|
||||
|
||||
+101
@@ -1,5 +1,7 @@
|
||||
package com.machankura.bennu.compose.managers
|
||||
|
||||
import com.machankura.bennu.compose.database.model.GroupKeyState
|
||||
import com.machankura.bennu.compose.nostr.subgroup.SubgroupWalletPolicy
|
||||
import androidx.room3.Room
|
||||
import com.machankura.bennu.compose.database.BennuDatabase
|
||||
import com.machankura.bennu.compose.database.builder.getRoomDatabase
|
||||
@@ -213,6 +215,105 @@ class GuardianSigningJvmTest {
|
||||
assertNull(other.session(session.id), "refused at acceptance, so nothing of the member's is ever published for it")
|
||||
}
|
||||
|
||||
// ---- The parent's decision: docs/subgroup-wallet-policy.md ------------
|
||||
|
||||
/** A parent of this room, as a key whose certificate this test files without signing. */
|
||||
private val decidingParentKey = PrivateKey(ByteVector32(ByteArray(32) { 0x4d })).publicKey().toString()
|
||||
private val decidingParentRoomId = SharedKeyDerivation.marmotGroupId(decidingParentKey)
|
||||
private val grantedToRoom = GuardianDerivation.grant(decidingParentKey, decidingParentRoomId, emptyList(), roomId)
|
||||
|
||||
/**
|
||||
* This room as a subgroup its parent made under [policy], filed on [device]
|
||||
* the way a verified key state leaves it. The policy is read off the
|
||||
* certificate's tags; whether the parent signed it was `stateFrom`'s
|
||||
* question, asked before the row was written.
|
||||
*/
|
||||
private suspend fun madeUnder(device: Device, policy: SubgroupWalletPolicy?): Event {
|
||||
val tags = SubgroupBirthCertificateEvent.assembleTags(
|
||||
subgroupChatRoomId = roomId,
|
||||
parentChatRoomId = decidingParentRoomId,
|
||||
thresholdPublicKey = thresholdPublicKey,
|
||||
adminPublicKeys = members,
|
||||
name = "Council",
|
||||
guardians = if (policy == SubgroupWalletPolicy.UNGUARDED) emptyList() else grantedToRoom,
|
||||
walletPolicy = policy,
|
||||
)
|
||||
val certificate = Event("d".repeat(64), decidingParentRoomId, 1_700_000_000, SubgroupBirthCertificateEvent.KIND, tags, roomId, "f".repeat(128))
|
||||
device.db.groupKeyStateDao().upsert(
|
||||
GroupKeyState(
|
||||
chatRoomId = roomId,
|
||||
dkgSessionId = ceremonyId,
|
||||
thresholdPublicKey = thresholdPublicKey,
|
||||
derivationPath = SharedKeyDerivation.formatPath(SharedKeyDerivation.MARMOT_ADMIN_GROUP_PATH),
|
||||
announcedBy = roomId,
|
||||
announcedAt = Instant.fromEpochSeconds(1_700_000_000),
|
||||
parentChatRoomId = decidingParentRoomId,
|
||||
birthCertificateJson = certificate.toJson(),
|
||||
)
|
||||
)
|
||||
return certificate
|
||||
}
|
||||
|
||||
private suspend fun proposeStatement(proposer: Device, guarded: Boolean, certificate: Event) = run {
|
||||
val template = if (guarded) {
|
||||
GroupWalletStatementEvent.template(
|
||||
GroupWalletDerivation.account(thresholdPublicKey, Chain.Regtest, guardians = grantedToRoom),
|
||||
certificate,
|
||||
)
|
||||
} else {
|
||||
GroupWalletStatementEvent.template(GroupWalletDerivation.account(thresholdPublicKey, Chain.Regtest))
|
||||
}
|
||||
FrostSigningManager.proposeSigning(proposer.db, proposer.room, proposer.publicKey, template.kind, template.tags, template.content)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a plain wallet is never put to a member whose parent decided guarded`(): Unit = runBlocking {
|
||||
val proposer = device(members[0], signerIndex = 0)
|
||||
val other = device(members[1], signerIndex = 1)
|
||||
madeUnder(proposer, SubgroupWalletPolicy.GUARDED)
|
||||
val certificate = madeUnder(other, SubgroupWalletPolicy.GUARDED)
|
||||
|
||||
// What an older build, or a skipped screen, would propose.
|
||||
val plain = proposeStatement(proposer, guarded = false, certificate)
|
||||
val guarded = proposeStatement(proposer, guarded = true, certificate)
|
||||
pump(proposer, other)
|
||||
|
||||
assertNull(other.session(plain.id), "refused before it is shown")
|
||||
assertNotNull(other.session(guarded.id), "the guarded one is asked")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `a guarded wallet is never put to a member whose parent decided unguarded`(): Unit = runBlocking {
|
||||
val proposer = device(members[0], signerIndex = 0)
|
||||
val other = device(members[1], signerIndex = 1)
|
||||
madeUnder(proposer, SubgroupWalletPolicy.UNGUARDED)
|
||||
madeUnder(other, SubgroupWalletPolicy.UNGUARDED)
|
||||
|
||||
// A certificate granting keys, as a modified client might carry; the
|
||||
// room's own decided none.
|
||||
val guarded = proposeStatement(proposer, guarded = true, madeUnder(device(members[2], signerIndex = 2), SubgroupWalletPolicy.GUARDED))
|
||||
val plain = proposeStatement(proposer, guarded = false, madeUnder(proposer, SubgroupWalletPolicy.UNGUARDED))
|
||||
pump(proposer, other)
|
||||
|
||||
assertNull(other.session(guarded.id))
|
||||
assertNotNull(other.session(plain.id))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `an undecided room is asked about either, as before`(): Unit = runBlocking {
|
||||
val proposer = device(members[0], signerIndex = 0)
|
||||
val other = device(members[1], signerIndex = 1)
|
||||
madeUnder(proposer, null)
|
||||
val certificate = madeUnder(other, null)
|
||||
|
||||
val plain = proposeStatement(proposer, guarded = false, certificate)
|
||||
val guarded = proposeStatement(proposer, guarded = true, certificate)
|
||||
pump(proposer, other)
|
||||
|
||||
assertNotNull(other.session(plain.id))
|
||||
assertNotNull(other.session(guarded.id))
|
||||
}
|
||||
|
||||
// ---- Telling an ancestor about a guarded wallet -----------------------
|
||||
|
||||
/** The child as a group of its own, so its room can sign its statement. */
|
||||
|
||||
Reference in new issue
Block a user