diff --git a/composeApp/src/commonMain/composeResources/values/strings.xml b/composeApp/src/commonMain/composeResources/values/strings.xml
index 52c5e968..cf0d7e0a 100644
--- a/composeApp/src/commonMain/composeResources/values/strings.xml
+++ b/composeApp/src/commonMain/composeResources/values/strings.xml
@@ -563,4 +563,31 @@
The subgroup's wallet will not be guarded: only the subgroup can spend from it.
The group above this one decided this group's wallet is guarded. Each group above it can spend any coin in it once it has %1$d confirmations, without this group agreeing.
The group above this one decided this group's wallet is not guarded. Only this group can spend from it.
+
+
+ %1$s, %2$s
+
+ - %1$s block
+ - %1$s blocks
+
+
+ - about %1$d minute
+ - about %1$d minutes
+
+
+ - about %1$d hour
+ - about %1$d hours
+
+
+ - about %1$d day
+ - about %1$d days
+
+
+ - about %1$d month
+ - about %1$d months
+
+
+ - about %1$d year
+ - about %1$d years
+
diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/text/BlockDuration.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/text/BlockDuration.kt
new file mode 100644
index 00000000..6b0ca476
--- /dev/null
+++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/text/BlockDuration.kt
@@ -0,0 +1,59 @@
+package com.machankura.bennu.compose.text
+
+import kotlin.math.abs
+import kotlin.math.roundToInt
+
+/**
+ * A number of blocks said in time, roughly -- `docs/guardian-delay.md`, D5.
+ *
+ * Always beside the block count, never instead of it: blocks are what a
+ * guardian's leaf counts, and ten minutes is the target, not a promise, so a
+ * delay of 144 blocks can take twenty hours or thirty. Hence *about*.
+ *
+ * The rule:
+ *
+ * 1. within 5% of exactly one hour, day, month or year, that unit, singular --
+ * 6 blocks is *about 1 hour*, 4,320 *about 1 month*;
+ * 2. otherwise the largest of years, months, days, hours and minutes in which
+ * the delay comes to at least 2, rounded -- 216 blocks is *about 36 hours*,
+ * 65,535 *about 15 months*.
+ *
+ * Years therefore appear only near exactly one year: the longest delay a leaf
+ * can carry is 1.25 years, and *about 15 months* says more than *about 1 year*.
+ */
+object BlockDuration {
+ /** Bitcoin's target, and the testnets' and signet's. Regtest has none. */
+ const val MINUTES_PER_BLOCK: Long = 10L
+
+ /** The units, each with its length in minutes: a month is a twelfth of a Julian year. */
+ enum class Unit(val minutes: Double) {
+ MINUTES(1.0),
+ HOURS(60.0),
+ DAYS(1_440.0),
+ MONTHS(43_830.0),
+ YEARS(525_960.0),
+ }
+
+ data class Approximate(val count: Int, val unit: Unit)
+
+ /** How close to exactly one of a unit a delay has to be to be said as one. */
+ private const val ONE_TOLERANCE = 0.05
+
+ fun approximate(blocks: Long): Approximate {
+ require(blocks > 0) { "a duration is at least one block, not $blocks" }
+ val minutes = (blocks * MINUTES_PER_BLOCK).toDouble()
+ val largestFirst = Unit.entries.reversed()
+
+ largestFirst.filter { it != Unit.MINUTES }.forEach { unit ->
+ if (abs(minutes / unit.minutes - 1.0) <= ONE_TOLERANCE) return Approximate(1, unit)
+ }
+ largestFirst.forEach { unit ->
+ val count = minutes / unit.minutes
+ if (count >= 2.0) return Approximate(count.roundToInt(), unit)
+ }
+ return Approximate(minutes.roundToInt(), Unit.MINUTES)
+ }
+}
+
+/** A count of blocks, its thousands grouped: `65,535`. */
+fun Long.groupedBlocks(): String = toString().reversed().chunked(3).joinToString(",").reversed()
diff --git a/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/widgets/DelayText.kt b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/widgets/DelayText.kt
new file mode 100644
index 00000000..ef7458aa
--- /dev/null
+++ b/composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ui/composable/widgets/DelayText.kt
@@ -0,0 +1,46 @@
+package com.machankura.bennu.compose.ui.composable.widgets
+
+import androidx.compose.runtime.Composable
+import bennu.composeapp.generated.resources.Res
+import bennu.composeapp.generated.resources.about_n_days
+import bennu.composeapp.generated.resources.about_n_hours
+import bennu.composeapp.generated.resources.about_n_minutes
+import bennu.composeapp.generated.resources.about_n_months
+import bennu.composeapp.generated.resources.about_n_years
+import bennu.composeapp.generated.resources.blocks_and_about
+import bennu.composeapp.generated.resources.n_blocks
+import com.machankura.bennu.compose.text.BlockDuration
+import com.machankura.bennu.compose.text.groupedBlocks
+import fr.acinq.bitcoin.Chain
+import org.jetbrains.compose.resources.pluralStringResource
+import org.jetbrains.compose.resources.stringResource
+
+/**
+ * A guardian's delay as a member reads it: *144 blocks, about 1 day*.
+ * `docs/guardian-delay.md`, D5.
+ *
+ * Blocks only on regtest, whose blocks come when somebody mines one, so a time
+ * there would be wrong. [chain] is null where a delay is for no network in
+ * particular -- a birth certificate is not -- and then the estimate is
+ * mainnet's, as every network but regtest shares its target.
+ */
+@Composable
+fun delayText(blocks: Long, chain: Chain? = null): String {
+ val count = pluralStringResource(Res.plurals.n_blocks, blocks.toInt(), blocks.groupedBlocks())
+ if (chain == Chain.Regtest) return count
+ return stringResource(Res.string.blocks_and_about, count, approximateDuration(blocks))
+}
+
+/** *about 1 day*: [BlockDuration.approximate] in words. */
+@Composable
+fun approximateDuration(blocks: Long): String {
+ val approximate = BlockDuration.approximate(blocks)
+ val plural = when (approximate.unit) {
+ BlockDuration.Unit.MINUTES -> Res.plurals.about_n_minutes
+ BlockDuration.Unit.HOURS -> Res.plurals.about_n_hours
+ BlockDuration.Unit.DAYS -> Res.plurals.about_n_days
+ BlockDuration.Unit.MONTHS -> Res.plurals.about_n_months
+ BlockDuration.Unit.YEARS -> Res.plurals.about_n_years
+ }
+ return pluralStringResource(plural, approximate.count, approximate.count)
+}
diff --git a/composeApp/src/commonTest/kotlin/com/machankura/bennu/compose/text/BlockDurationTest.kt b/composeApp/src/commonTest/kotlin/com/machankura/bennu/compose/text/BlockDurationTest.kt
new file mode 100644
index 00000000..7982be8e
--- /dev/null
+++ b/composeApp/src/commonTest/kotlin/com/machankura/bennu/compose/text/BlockDurationTest.kt
@@ -0,0 +1,68 @@
+package com.machankura.bennu.compose.text
+
+import com.machankura.bennu.compose.managers.GuardianDerivation
+import com.machankura.bennu.compose.text.BlockDuration.Approximate
+import com.machankura.bennu.compose.text.BlockDuration.Unit.DAYS
+import com.machankura.bennu.compose.text.BlockDuration.Unit.HOURS
+import com.machankura.bennu.compose.text.BlockDuration.Unit.MINUTES
+import com.machankura.bennu.compose.text.BlockDuration.Unit.MONTHS
+import com.machankura.bennu.compose.text.BlockDuration.Unit.YEARS
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+/**
+ * How a guardian's delay is said in time -- `docs/guardian-delay.md`, D5. The
+ * table is the plan's, row for row, so the words a member reads are the words
+ * the plan argued for.
+ */
+class BlockDurationTest {
+ @Test
+ fun `every row of the plan's table`() {
+ val table = mapOf(
+ 6L to Approximate(1, HOURS),
+ 12L to Approximate(2, HOURS),
+ 100L to Approximate(17, HOURS),
+ 144L to Approximate(1, DAYS),
+ 216L to Approximate(36, HOURS),
+ 1_008L to Approximate(7, DAYS),
+ 4_320L to Approximate(1, MONTHS),
+ 13_140L to Approximate(3, MONTHS),
+ 26_280L to Approximate(6, MONTHS),
+ 52_560L to Approximate(1, YEARS),
+ 65_535L to Approximate(15, MONTHS),
+ )
+ table.forEach { (blocks, expected) -> assertEquals(expected, BlockDuration.approximate(blocks), "$blocks blocks") }
+ }
+
+ @Test
+ fun `exactly one of a unit is a five percent window either side`() {
+ // A day is 144 blocks: 137 is 95.1% of it and 151 is 104.9%.
+ assertEquals(Approximate(1, DAYS), BlockDuration.approximate(137))
+ assertEquals(Approximate(1, DAYS), BlockDuration.approximate(151))
+ assertEquals(Approximate(23, HOURS), BlockDuration.approximate(136))
+ assertEquals(Approximate(25, HOURS), BlockDuration.approximate(152))
+ }
+
+ @Test
+ fun `under an hour is minutes`() {
+ assertEquals(Approximate(10, MINUTES), BlockDuration.approximate(1))
+ assertEquals(Approximate(50, MINUTES), BlockDuration.approximate(5))
+ }
+
+ @Test
+ fun `nothing a leaf can carry comes out as zero or past a year`() {
+ GuardianDerivation.DELAY_RANGE.forEach { blocks ->
+ val approximate = BlockDuration.approximate(blocks)
+ assertTrue(approximate.count >= 1, "$blocks blocks came out as $approximate")
+ assertTrue(approximate.unit != YEARS || approximate.count == 1, "$blocks blocks came out as $approximate")
+ }
+ }
+
+ @Test
+ fun `a block count is grouped in thousands`() {
+ assertEquals("6", 6L.groupedBlocks())
+ assertEquals("1,008", 1_008L.groupedBlocks())
+ assertEquals("65,535", 65_535L.groupedBlocks())
+ }
+}
diff --git a/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/ui/StringCatalogueJvmTest.kt b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/ui/StringCatalogueJvmTest.kt
index b581c572..675ab4a5 100644
--- a/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/ui/StringCatalogueJvmTest.kt
+++ b/composeApp/src/jvmTest/kotlin/com/machankura/bennu/compose/ui/StringCatalogueJvmTest.kt
@@ -8,6 +8,9 @@ import bennu.composeapp.generated.resources.something_went_wrong
import bennu.composeapp.generated.resources.recovered_of_still_unreadable
import bennu.composeapp.generated.resources.sent_a_private_message_to
import org.jetbrains.compose.resources.getString
+import org.jetbrains.compose.resources.getPluralString
+import bennu.composeapp.generated.resources.about_n_hours
+import bennu.composeapp.generated.resources.n_blocks
import kotlin.test.Test
import kotlin.test.assertEquals
@@ -74,4 +77,14 @@ class StringCatalogueJvmTest {
getString(Res.string.recovered_of_still_unreadable, "3", "12", "9", ""),
)
}
+
+ @Test
+ fun `a plural picks its form by the count, and substitutes it`() = runBlocking {
+ // The catalogue's first plurals, for a guardian's delay. A plain
+ // `%1$d hours` reads "about 1 hours", and no audit catches that.
+ assertEquals("about 1 hour", getPluralString(Res.plurals.about_n_hours, 1, 1))
+ assertEquals("about 36 hours", getPluralString(Res.plurals.about_n_hours, 36, 36))
+ assertEquals("1 block", getPluralString(Res.plurals.n_blocks, 1, "1"))
+ assertEquals("65,535 blocks", getPluralString(Res.plurals.n_blocks, 65_535, "65,535"))
+ }
}