feat(lightning): a distributed key generation for Iceberg (Phase 1)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Kgothatso NgakoandClaude Opus 5.5 committed 2026-10-23 16:23:15 +02:00
1 parent cd385ec82d
commit a1e87d92e5
3 files changed
+537

No files matched your search

@@ -0,0 +1,325 @@
package com.machankura.bennu.compose.managers
import fr.acinq.bitcoin.ByteVector32
import fr.acinq.bitcoin.Crypto
import fr.acinq.bitcoin.PublicKey
import fr.acinq.bitcoin.crypto.Pack
import fr.acinq.bitcoin.crypto.iceberg.Iceberg
import fr.acinq.bitcoin.crypto.iceberg.PublicShare
import fr.acinq.bitcoin.crypto.iceberg.Share
import fr.acinq.bitcoin.utils.Either
/**
* A distributed key generation for Iceberg, which ships only a trusted dealer.
*
* An Iceberg share is replicated secret sharing, not a Shamir point: every
* `(t-1)`-subset `T` of the participants has its own 32-byte seed, held by every
* participant *outside* `T`, and a participant's share is the seeds of the
* subsets it is outside of, in the lexicographic rank order `rss.h` fixes. So a
* DKG only has to agree each seed among its holders without any member of `T`
* learning it:
*
* ```
* round 1 each holder j of each T: c[j,T] = random, publish h[j,T] = H(commit, sid, T, j, c[j,T])
* round 2 send c[j,T] to every other holder of T, encrypted to them
* round 3 each k checks every c[j,T] it was sent against h[j,T], then
* s[T] = H(seed, sid, T, c[j,T] for each holder j, ascending)
* share = 1 | n | t | k | s[T] for each T not containing k, in rank order
* and publishes its public share and a signature over the transcript
* done Iceberg.groupPublicKey over all n public shares
* ```
*
* Why it is safe, in the three sentences it takes:
*
* - **Every seed is random.** `T` has `n - t + 1 >= t` holders and at most
* `t - 1` members are corrupt, so some holder's contribution is honest.
* - **Every seed is secret from `T`.** Its contributions only go to its holders,
* so a coalition of `t - 1` lacks exactly the seed named after itself, which
* is the scheme's whole margin (`rss.h`).
* - **Nobody chooses last.** Contributions are committed before any is revealed,
* so a contributor cannot grind the group key.
*
* A contributor who reveals something other than what it committed to is named
* ([Fault.BadReveal]). One who commits to two different values in front of two
* different members is not caught here; the transcript signature is what catches
* that, because the two members then sign different transcripts.
*
* ### Repair, which RSS gives away
*
* Every seed a participant holds is also held by `n - t` others. A participant
* that has lost its share can be sent its seeds again ([repairSeeds]); the share
* it rebuilds ([repair]) must reproduce the public share it published, which is
* the check on what it was sent. That replaces ChillDKG's recovery data.
*
* ### What this is not
*
* Reviewed. `iceberg.md` says the scheme must not protect anything of value, and
* this protocol is newer than the scheme. It lives in the app rather than in the
* bitcoin-kmp fork beside [Iceberg] only because it needs nothing from inside
* the library; see the build table in `docs/group-lightning-wallet.md`.
*
* Every function here is pure over inputs the ritual has stored, as
* [fr.acinq.bitcoin.crypto.dkg.chill.ChillDKG]'s are, so a ceremony resumes from
* its persisted messages after the app is killed.
*/
object IcebergDkg {
/** `SECP256K1_ICEBERG_MAX_PARTICIPANTS`, which sizes the library's ABI. */
const val MAX_PARTICIPANTS = 10
private const val TAG_SESSION = "bennu/iceberg-dkg/session/v1"
private const val TAG_CONTRIBUTION = "bennu/iceberg-dkg/contribution/v1"
private const val TAG_COMMIT = "bennu/iceberg-dkg/commit/v1"
private const val TAG_SEED = "bennu/iceberg-dkg/seed/v1"
private const val TAG_TRANSCRIPT = "bennu/iceberg-dkg/transcript/v1"
/** The share format version `secp256k1_iceberg_share_parse` accepts. */
private const val SHARE_VERSION: Byte = 1
/**
* Whether a group of [n] with threshold [t] can be *expressed* by Iceberg:
* a round-one quorum of `2t-1` has to exist.
*/
fun isExpressible(n: Int, t: Int): Boolean = n in 1..MAX_PARTICIPANTS && t >= 1 && t <= (n + 1) / 2
/**
* Whether it can be *deployed*: expressible, a real threshold, and big
* enough for the group to agree what it signs while `t - 1` members
* misbehave, `n >= 3t - 2` (`secp256k1_iceberg.h`, constraint 3). 2-of-4 is
* the smallest group this admits, and 4-of-10 the largest threshold.
*/
fun isDeployable(n: Int, t: Int): Boolean = isExpressible(n, t) && t >= 2 && n >= 3 * t - 2
/** Every threshold a group of [n] could deploy, smallest first. */
fun deployableThresholds(n: Int): List<Int> = (2..n).filter { isDeployable(n, it) }
/**
* A ceremony's parameters, the same on every device.
*
* [hostKeys] are sorted bytewise and participant `k` is `hostKeys[k - 1]`,
* for the reason the ChillDKG ritual sorts its own: an order every device
* reaches without being told. [sessionId] binds all of it, so a device
* that ordered the participants differently computes another session and
* gets no key rather than a weaker one.
*/
class Params private constructor(
val n: Int,
val t: Int,
val hostKeys: List<PublicKey>,
val sessionId: ByteVector32,
) {
/** The `(t-1)`-subsets, as bitmasks over participants 1..n, in rank order. */
val subsets: List<Int> = subsetsInRankOrder(n, t - 1)
fun holders(subset: Int): List<Int> = (1..n).filter { subset and (1 shl it) == 0 }
fun isHolder(participant: Int, subset: Int): Boolean = subset and (1 shl participant) == 0
/** The ranks whose seeds [participant] holds, ascending: its share's layout. */
fun heldRanks(participant: Int): List<Int> = subsets.indices.filter { isHolder(participant, subsets[it]) }
fun indexOf(hostKey: PublicKey): Int? = hostKeys.indexOf(hostKey).takeIf { it >= 0 }?.plus(1)
companion object {
/**
* @param ceremonyId the proposal's own id, so two ceremonies over the
* same people and threshold are two sessions.
*/
fun of(t: Int, hostKeys: Collection<PublicKey>, ceremonyId: ByteVector32): Params {
val sorted = hostKeys.distinct().sortedWith { a, b -> compareBytes(a.value.toByteArray(), b.value.toByteArray()) }
require(sorted.size == hostKeys.size) { "a participant appears twice" }
require(isDeployable(sorted.size, t)) { "$t-of-${sorted.size} is not a deployable Iceberg group" }
val sid = Crypto.taggedHash(
byteArrayOf(sorted.size.toByte(), t.toByte()) + sorted.flatMap { it.value.toByteArray().asList() } + ceremonyId.toByteArray(),
TAG_SESSION,
)
return Params(sorted.size, t, sorted, sid)
}
}
}
/** What went wrong, as a value: a faulty participant is an outcome of a DKG, not a bug in it. */
sealed class Fault(val participant: Int?, message: String) : Exception(message) {
class MissingCommitment(participant: Int) : Fault(participant, "participant $participant sent no commitment")
class MissingReveal(participant: Int) : Fault(participant, "participant $participant revealed nothing to us")
class BadReveal(participant: Int) : Fault(participant, "participant $participant revealed a value it had not committed to")
class MalformedMessage(participant: Int, reason: String) : Fault(participant, "participant $participant sent a malformed message: $reason")
class InconsistentShares(reason: String) : Fault(null, "the public shares do not lie on one polynomial: $reason")
class RepairMismatch(reason: String) : Fault(null, "the repaired share does not reproduce the published public share: $reason")
}
/** One participant's round-1 message: a commitment per subset it holds, by rank. */
data class Commitments(val participant: Int, val byRank: Map<Int, ByteVector32>)
/**
* [participant]'s contribution to the seed at [rank], derived from the
* 32 random bytes it stored when it joined. Storing the root rather than the
* contributions is what lets a ritual stay a function of its stored inputs.
* The root is as secret as the share it becomes; drop it once the share is
* assembled.
*/
fun contribution(params: Params, participant: Int, root: ByteVector32, rank: Int): ByteVector32 {
require(params.isHolder(participant, params.subsets[rank])) { "participant $participant does not hold the seed at rank $rank" }
return Crypto.taggedHash(root.toByteArray() + params.sessionId.toByteArray() + Pack.writeInt32BE(rank) + byteArrayOf(participant.toByte()), TAG_CONTRIBUTION)
}
fun commitment(params: Params, participant: Int, rank: Int, contribution: ByteVector32): ByteVector32 =
Crypto.taggedHash(params.sessionId.toByteArray() + Pack.writeInt32BE(rank) + byteArrayOf(participant.toByte()) + contribution.toByteArray(), TAG_COMMIT)
/** Round 1: commit to every contribution, to be published to everyone. */
fun round1(params: Params, participant: Int, root: ByteVector32): Commitments =
Commitments(participant, params.heldRanks(participant).associateWith { commitment(params, participant, it, contribution(params, participant, root, it)) })
/**
* Round 2: what [participant] reveals to [recipient], by rank -- its
* contributions to the seeds they both hold, and nothing else. The caller
* encrypts it to the recipient; it must never travel in the clear.
*/
fun round2(params: Params, participant: Int, root: ByteVector32, recipient: Int): Map<Int, ByteVector32> {
require(participant != recipient) { "a participant does not reveal to itself" }
return params.heldRanks(participant)
.filter { params.isHolder(recipient, params.subsets[it]) }
.associateWith { contribution(params, participant, root, it) }
}
/**
* Round 3: check every reveal against its commitment and assemble this
* participant's share.
*
* @param commitments every participant's round-1 message, own included.
* @param reveals what every other participant revealed to this one, by sender.
*/
fun assemble(
params: Params,
participant: Int,
root: ByteVector32,
commitments: Map<Int, Commitments>,
reveals: Map<Int, Map<Int, ByteVector32>>,
): Either<Fault, Share> {
for (j in 1..params.n) {
val c = commitments[j] ?: return Either.Left(Fault.MissingCommitment(j))
if (c.byRank.keys != params.heldRanks(j).toSet()) return Either.Left(Fault.MalformedMessage(j, "commitments for the wrong subsets"))
}
val seeds = params.heldRanks(participant).map { rank ->
val contributions = params.holders(params.subsets[rank]).map { j ->
val value = if (j == participant) {
contribution(params, participant, root, rank)
} else {
reveals[j]?.get(rank) ?: return Either.Left(Fault.MissingReveal(j))
}
if (commitment(params, j, rank, value) != commitments.getValue(j).byRank.getValue(rank)) return Either.Left(Fault.BadReveal(j))
value
}
seed(params, rank, contributions)
}
return Either.Right(share(params.n, params.t, participant, seeds))
}
/** The seed at [rank], from its holders' contributions in ascending participant order. */
fun seed(params: Params, rank: Int, contributions: List<ByteVector32>): ByteVector32 =
Crypto.taggedHash(params.sessionId.toByteArray() + Pack.writeInt32BE(rank) + contributions.flatMap { it.toByteArray().asList() }, TAG_SEED)
/**
* A share in `secp256k1_iceberg_share_serialize`'s encoding: version, n, t,
* the participant's index, then its seeds in rank order. Which seed is which
* follows from n, t and the index, so the order of [seeds] is the whole of
* the layout and has to be [Params.heldRanks]'s.
*/
fun share(n: Int, t: Int, participant: Int, seeds: List<ByteVector32>): Share {
require(isExpressible(n, t) && participant in 1..n)
require(seeds.size == binomial(n - 1, t - 1)) { "a share holds C(n-1, t-1) seeds" }
return Share(byteArrayOf(SHARE_VERSION, n.toByte(), t.toByte(), participant.toByte()) + seeds.flatMap { it.toByteArray().asList() })
}
/**
* The hash every participant signs once it has its share: the parameters,
* every commitment and every public share. Two members who were shown
* different commitments, or different public shares, sign different hashes,
* and the ritual refuses to finish on signatures that do not all agree.
*/
fun transcriptHash(params: Params, commitments: Map<Int, Commitments>, publicShares: List<PublicShare>, groupPublicKey: PublicKey): ByteVector32 {
require(publicShares.size == params.n && commitments.size == params.n)
val bytes = buildList {
addAll(params.sessionId.toByteArray().asList())
for (j in 1..params.n) {
val c = commitments.getValue(j)
for (rank in params.heldRanks(j)) addAll(c.byRank.getValue(rank).toByteArray().asList())
}
publicShares.forEach { addAll(it.toByteArray().asList()) }
addAll(groupPublicKey.value.toByteArray().asList())
}
return Crypto.taggedHash(bytes.toByteArray(), TAG_TRANSCRIPT)
}
/**
* The group key, from every participant's public share in participant
* order. Using all `n` rather than a quorum is the point: `groupPublicKey`
* checks the shares lie on one polynomial of degree `t-1`, and every share
* past `t` is one more constraint a wrong one has to satisfy.
*/
fun groupPublicKey(params: Params, publicShares: List<PublicShare>): Either<Fault, PublicKey> {
if (publicShares.size != params.n) return Either.Left(Fault.InconsistentShares("expected ${params.n} public shares, got ${publicShares.size}"))
return when (val key = Iceberg.groupPublicKey(publicShares, params.n, params.t)) {
is Either.Right -> Either.Right(key.value)
is Either.Left -> Either.Left(Fault.InconsistentShares(key.value.message ?: "rejected"))
}
}
/**
* What [helper] sends [participant] to repair its share: the seeds they
* both hold. Encrypted to the participant, like a round-2 reveal.
*/
fun repairSeeds(params: Params, helper: Int, helperShare: Share, participant: Int): Map<Int, ByteVector32> {
require(helper != participant)
val bytes = helperShare.toByteArray()
require(bytes[3].toInt() == helper) { "that is not the helper's share" }
return params.heldRanks(helper).withIndex()
.filter { (_, rank) -> params.isHolder(participant, params.subsets[rank]) }
.associate { (i, rank) -> rank to ByteVector32(bytes.copyOfRange(4 + 32 * i, 36 + 32 * i)) }
}
/**
* Rebuild [participant]'s share from what helpers sent ([repairSeeds]).
* Where several helpers sent one seed they must agree, and the result must
* reproduce [publishedPublicShare] -- a wrong seed from anybody fails here
* rather than at a signature.
*/
fun repair(params: Params, participant: Int, received: Map<Int, Map<Int, ByteVector32>>, publishedPublicShare: PublicShare): Either<Fault, Share> {
val seeds = params.heldRanks(participant).map { rank ->
val offered = received.values.mapNotNull { it[rank] }.toSet()
when (offered.size) {
0 -> return Either.Left(Fault.RepairMismatch("nobody sent the seed at rank $rank"))
1 -> offered.single()
else -> return Either.Left(Fault.RepairMismatch("helpers disagree on the seed at rank $rank"))
}
}
val share = share(params.n, params.t, participant, seeds)
if (Iceberg.publicShare(share, null) != publishedPublicShare) return Either.Left(Fault.RepairMismatch("public share differs"))
return Either.Right(share)
}
/** All [size]-subsets of 1..[n] as bitmasks (bit j for participant j), in `rss.h`'s lexicographic rank order. */
fun subsetsInRankOrder(n: Int, size: Int): List<Int> {
val out = mutableListOf<Int>()
fun walk(next: Int, remaining: Int, mask: Int) {
if (remaining == 0) { out += mask; return }
for (j in next..(n - remaining + 1)) walk(j + 1, remaining - 1, mask or (1 shl j))
}
walk(1, size, 0)
return out
}
fun binomial(n: Int, k: Int): Int {
if (k < 0 || k > n) return 0
var r = 1L
for (i in 0 until k) r = r * (n - i) / (i + 1)
return r.toInt()
}
private fun compareBytes(a: ByteArray, b: ByteArray): Int {
for (i in 0 until minOf(a.size, b.size)) {
val c = (a[i].toInt() and 0xff) - (b[i].toInt() and 0xff)
if (c != 0) return c
}
return a.size - b.size
}
}
@@ -0,0 +1,210 @@
package com.machankura.bennu.compose.managers
import fr.acinq.bitcoin.ByteVector32
import fr.acinq.bitcoin.Crypto
import fr.acinq.bitcoin.PrivateKey
import fr.acinq.bitcoin.PublicKey
import fr.acinq.bitcoin.byteVector32
import fr.acinq.bitcoin.crypto.Pack
import fr.acinq.bitcoin.crypto.iceberg.Iceberg
import fr.acinq.bitcoin.crypto.iceberg.PublicShare
import fr.acinq.bitcoin.crypto.iceberg.Share
import fr.acinq.bitcoin.crypto.musig2.IndividualNonce
import fr.acinq.bitcoin.crypto.musig2.KeyAggCache
import fr.acinq.bitcoin.crypto.musig2.SecretNonce
import fr.acinq.bitcoin.crypto.musig2.Session
import fr.acinq.bitcoin.utils.Either
import kotlin.random.Random
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertFailsWith
import kotlin.test.assertFalse
import kotlin.test.assertIs
import kotlin.test.assertNotEquals
import kotlin.test.assertTrue
/**
* The Iceberg DKG, run between simulated participants against the real library.
*
* The layout test is the one to read first: it proves, against the library's
* own dealer, that a share this DKG assembles is laid out the way
* `secp256k1_iceberg_share_parse` reads it. Everything after it would pass for a
* DKG whose seeds were in the wrong order -- the shares would still parse and
* still aggregate -- right up to the signature that did not verify.
*/
class IcebergDkgTest {
private val random = Random(0x1ceb)
private fun bytes32() = random.nextBytes(32).byteVector32()
private fun hostKeys(n: Int): List<PublicKey> = (1..n).map { PrivateKey(bytes32()).publicKey() }
private class Run(val params: IcebergDkg.Params, val shares: List<Share>, val publicShares: List<PublicShare>, val groupKey: PublicKey)
/** Every participant runs every round, honestly. */
private fun run(n: Int, t: Int): Run {
val params = IcebergDkg.Params.of(t, hostKeys(n), bytes32())
val roots = (1..n).associateWith { bytes32() }
val commitments = (1..n).associateWith { IcebergDkg.round1(params, it, roots.getValue(it)) }
val shares = (1..n).map { k ->
val reveals = (1..n).filter { it != k }.associateWith { j -> IcebergDkg.round2(params, j, roots.getValue(j), k) }
val share = IcebergDkg.assemble(params, k, roots.getValue(k), commitments, reveals)
assertIs<Either.Right<Share>>(share).value
}
val publicShares = shares.map { Iceberg.publicShare(it, null) }
val key = assertIs<Either.Right<PublicKey>>(IcebergDkg.groupPublicKey(params, publicShares)).value
return Run(params, shares, publicShares, key)
}
/** One signature by [signers] (1-based) beside a stock MuSig2 cosigner, judged by BIP340. */
private fun signs(run: Run, signers: List<Int>): Boolean {
val n = run.params.n
val t = run.params.t
val cosigner = PrivateKey(bytes32())
val msg = bytes32()
val sid = bytes32()
val keys = listOf(run.groupKey, cosigner.publicKey())
val (aggregateKey, cache) = KeyAggCache.create(keys)
val contributions = signers.map { Iceberg.generateNonce(run.shares[it - 1], null, sid) }
val groupNonce = Iceberg.aggregateNonces(contributions, n, t, run.groupKey).right ?: return false
val (cosignerSecret, cosignerPublic) = SecretNonce.generate(bytes32(), Either.Left(cosigner), msg, cache, null)
val aggregated = IndividualNonce.aggregate(listOf(groupNonce, cosignerPublic)).right ?: return false
val cosignerAggregated = IndividualNonce.aggregate(listOf(cosignerPublic)).right ?: return false
val session = Session.create(aggregated, msg, cache)
val signatureShares = signers.map {
Iceberg.partialSign(run.shares[it - 1], null, sid, contributions, run.groupKey, cache, msg, cosignerAggregated).right ?: return false
}
val groupPartial = Iceberg.aggregatePartialSignatures(signatureShares, n, t).right ?: return false
val cosignerPartial = session.sign(cosignerSecret, cosigner).right ?: return false
val sig = session.aggregateSigs(listOf(groupPartial, cosignerPartial)).right ?: return false
return Crypto.verifySignatureSchnorr(msg, sig, aggregateKey)
}
private fun quorums(n: Int, t: Int): List<List<Int>> =
IcebergDkg.subsetsInRankOrder(n, 2 * t - 1).map { mask -> (1..n).filter { mask and (1 shl it) != 0 } }
@Test
fun `an assembled share is laid out as the library's dealer lays one out`() {
for ((n, t) in listOf(4 to 2, 7 to 3, 10 to 4, 5 to 3)) {
val root = bytes32()
val dealt = Iceberg.dealShares(n, t, root)
val ranks = IcebergDkg.subsetsInRankOrder(n, t - 1)
for (k in 1..n) {
// keygen_impl.h: seed(rank) = H_"Iceberg/dealer"(root || n || t || rank), appended for every subset k is outside of.
val seeds = ranks.indices.filter { ranks[it] and (1 shl k) == 0 }.map {
Crypto.taggedHash(root.toByteArray() + byteArrayOf(n.toByte(), t.toByte()) + Pack.writeInt32BE(it), "Iceberg/dealer")
}
assertEquals(dealt[k - 1], IcebergDkg.share(n, t, k, seeds), "participant $k of $t-of-$n")
}
}
}
@Test
fun `the rank order is rss_h's`() {
// The example rss.h writes out because the reference's docstring was off by one.
val expected = listOf(setOf(1, 2), setOf(1, 3), setOf(1, 4), setOf(1, 5), setOf(2, 3), setOf(2, 4), setOf(2, 5), setOf(3, 4), setOf(3, 5), setOf(4, 5))
assertEquals(expected, IcebergDkg.subsetsInRankOrder(5, 2).map { mask -> (1..5).filter { mask and (1 shl it) != 0 }.toSet() })
}
@Test
fun `2-of-4 and 3-of-7 sign from every quorum, and every quorum agrees on the key`() {
for ((n, t) in listOf(4 to 2, 7 to 3)) {
val run = run(n, t)
for (q in quorums(n, t)) {
assertTrue(signs(run, q), "quorum $q of $t-of-$n")
val key = Iceberg.groupPublicKey(q.map { run.publicShares[it - 1] }, n, t).right
assertEquals(run.groupKey, key, "key over $q")
}
}
}
@Test
fun `4-of-10 signs`() {
val run = run(10, 4)
assertTrue(signs(run, listOf(1, 2, 3, 4, 5, 6, 7)))
assertTrue(signs(run, listOf(4, 5, 6, 7, 8, 9, 10)))
assertTrue(signs(run, listOf(1, 3, 5, 7, 8, 9, 10)))
}
@Test
fun `a reveal that was not committed to names its sender`() {
val params = IcebergDkg.Params.of(2, hostKeys(4), bytes32())
val roots = (1..4).associateWith { bytes32() }
val commitments = (1..4).associateWith { IcebergDkg.round1(params, it, roots.getValue(it)) }
val reveals = (2..4).associateWith { j -> IcebergDkg.round2(params, j, roots.getValue(j), 1) }.toMutableMap()
reveals[3] = reveals.getValue(3).mapValues { bytes32() }
val result = IcebergDkg.assemble(params, 1, roots.getValue(1), commitments, reveals)
val fault = assertIs<IcebergDkg.Fault.BadReveal>(assertIs<Either.Left<IcebergDkg.Fault>>(result).value)
assertEquals(3, fault.participant)
}
@Test
fun `a silent participant is named`() {
val params = IcebergDkg.Params.of(2, hostKeys(4), bytes32())
val roots = (1..4).associateWith { bytes32() }
val commitments = (1..4).associateWith { IcebergDkg.round1(params, it, roots.getValue(it)) }
val reveals = (2..3).associateWith { j -> IcebergDkg.round2(params, j, roots.getValue(j), 1) }
assertEquals(4, (IcebergDkg.assemble(params, 1, roots.getValue(1), commitments, reveals) as Either.Left).value.participant)
assertEquals(2, (IcebergDkg.assemble(params, 1, roots.getValue(1), commitments - 2, reveals) as Either.Left).value.participant)
}
@Test
fun `a share off the polynomial fails the group key`() {
val run = run(4, 2)
val bytes = run.shares[2].toByteArray().also { it[10] = (it[10] + 1).toByte() }
val tampered = run.publicShares.toMutableList().apply { this[2] = Iceberg.publicShare(Share(bytes), null) }
assertIs<Either.Left<IcebergDkg.Fault>>(IcebergDkg.groupPublicKey(run.params, tampered))
}
@Test
fun `the session binds the participants, the threshold and the ceremony, but not the order they were listed in`() {
val keys = hostKeys(5)
val ceremony = bytes32()
val base = IcebergDkg.Params.of(2, keys, ceremony)
assertEquals(base.sessionId, IcebergDkg.Params.of(2, keys.reversed(), ceremony).sessionId)
assertEquals(base.hostKeys, IcebergDkg.Params.of(2, keys.shuffled(random), ceremony).hostKeys)
assertNotEquals(base.sessionId, IcebergDkg.Params.of(2, keys, bytes32()).sessionId)
assertNotEquals(base.sessionId, IcebergDkg.Params.of(2, keys.dropLast(1), ceremony).sessionId)
assertFailsWith<IllegalArgumentException> { IcebergDkg.Params.of(2, keys + keys.first(), ceremony) }
}
@Test
fun `only deployable groups are offered`() {
assertEquals(emptyList(), IcebergDkg.deployableThresholds(3))
assertEquals(listOf(2), IcebergDkg.deployableThresholds(4))
assertEquals(listOf(2), IcebergDkg.deployableThresholds(6))
assertEquals(listOf(2, 3), IcebergDkg.deployableThresholds(7))
assertEquals(listOf(2, 3, 4), IcebergDkg.deployableThresholds(10))
assertEquals(emptyList(), IcebergDkg.deployableThresholds(11))
assertTrue(IcebergDkg.isExpressible(3, 2))
assertFalse(IcebergDkg.isDeployable(3, 2))
assertFalse(IcebergDkg.isExpressible(4, 3))
assertFailsWith<IllegalArgumentException> { IcebergDkg.Params.of(3, hostKeys(5), bytes32()) }
}
@Test
fun `a lost share is repaired from the other holders' seeds`() {
val run = run(7, 3)
val lost = 4
val received = (1..7).filter { it != lost }.associateWith { IcebergDkg.repairSeeds(run.params, it, run.shares[it - 1], lost) }
val repaired = IcebergDkg.repair(run.params, lost, received, run.publicShares[lost - 1])
assertEquals(run.shares[lost - 1], assertIs<Either.Right<Share>>(repaired).value)
// One helper lying about one seed is caught, whether or not another helper sent the same seed.
val lying = received.toMutableMap().apply { this[1] = getValue(1).mapValues { bytes32() } }
assertIs<Either.Left<IcebergDkg.Fault>>(IcebergDkg.repair(run.params, lost, lying, run.publicShares[lost - 1]))
val onlyTheLiar = mapOf(1 to lying.getValue(1)) + received.filterKeys { it != 1 }.mapValues { (_, seeds) -> seeds - lying.getValue(1).keys }
assertIs<Either.Left<IcebergDkg.Fault>>(IcebergDkg.repair(run.params, lost, onlyTheLiar, run.publicShares[lost - 1]))
}
@Test
fun `members shown different commitments sign different transcripts`() {
val params = IcebergDkg.Params.of(2, hostKeys(4), bytes32())
val roots = (1..4).associateWith { bytes32() }
val commitments = (1..4).associateWith { IcebergDkg.round1(params, it, roots.getValue(it)) }
val run = run(4, 2)
val honest = IcebergDkg.transcriptHash(params, commitments, run.publicShares, run.groupKey)
val other = commitments + (2 to IcebergDkg.round1(params, 2, bytes32()))
assertNotEquals(honest, IcebergDkg.transcriptHash(params, other, run.publicShares, run.groupKey))
}
}
+2
View File
@@ -30,11 +30,13 @@ build chose differently, this table says so.
| phase | state |
|---|---|
| 0 | done, except the two spikes (see below) |
| 1 | done: `IcebergDkg`, 11 tests, among them a byte-for-byte match against the library's dealer and a signature from every 2-of-4 and 3-of-7 quorum |
| what the plan said | what it turned out to be |
|---|---|
| Phase 0's two spikes run against the testnet3 LSP | **not run.** Both need a channel that somebody pays into, and the regtest alternative means creating docker containers on a development machine that already runs other stacks. That should be somebody's deliberate act, not a side effect of a build. The signer's deadline is therefore a parameter, `RemoteIcebergFundingSigner.deadline`, and not a measured constant. Measuring it is the first thing to do with a funded testnet3 node |
| the DKG goes in the bitcoin-kmp fork, beside `Iceberg.kt` | in the app, as `IcebergDkg` beside `GroupWalletDerivation`. It uses only `Iceberg`'s public API and SHA-256, so it needs nothing from inside the library, and putting it there would add a third nested fork branch to every bump. It moves down once it has been reviewed |
| a complaint round is left out, so equivocation is caught but not blamed | a reveal that does not match its commitment *is* blamed, as `Fault.BadReveal`. Only committing to two values in front of two members goes unblamed, and the transcript signature still catches it |
| the kinds are reserved | in code: `GroupLightningEvents`, 30333-30349, with a test asserting the run is unbroken and touches no kind the app already dispatches on |
| library phases land in the forks' `threshold` branches | on a new branch, `claude/group-lightning-wallet`, in `lightning-kmp-app` and in `experimental/lightning-kmp`. It is local and not pushed. The app's submodule pointer follows it, so a checkout of this branch needs those commits from the same machine until they are pushed |