feat(cli): print the logo in block characters as the startup banner (#631)

## Motivation

The startup banner becomes the ethlambda logo, drawn with block
characters from the code page 437 set (`█ ▀ ▄ ░`):

```
                █               ▄
          ▀▀    █   ▄█▀▀▀▄▄     ▄   ▄
       ▄▄ ▀▀ ▄  ░░░██░░░░░▀▄░░░ ▀   █  ░
      █░░    ▄ ░░  ░░░▀▀▀░░░  ░░ █  ▄  ░░░
   ▄██░      ▀ ░▄█▀░░█▀▀▀█░░▀█▄░ █  ▄   ░▄▄▄
   █▀▀    ▀▀  ░░█▀▄▄░░▄▄▄░░▄▄▀█░░   ▀  ▀ ▀▀█
   █░░ ▄  ▄▄ ░░ █░░█▄▀░▄░▀▄█░░█ ░░ ▄▄    ░░█
   █░░░  ░▀▀░░  █▄░░█▄▀█▀▄█░░▄█  ░░▀▀█  ░░░█
   ░██▄░░░░ ▄▄▄░ ▀█▄▄█▄░▄█▄▄█▀ ▄▄▄  ░░░░▄██░
     ▀█░▄▄▀▀░░░░░ ▄░▀▀░░░▀▀░▄ ░░░░░▀▀ ▄▄█▀
      ██▀░░░░░▄░░░█ ░░▀▀▀░░ █░░░░░░░░ ░▀█
    ▄██░░░░▄▄ █░░░░█▄ ▄ ▄ ▄█░░░  ███░ ░░▀█▄
   █▀░░░▄█▀   █░░▄░░▀█▄▄▄█▀░░░░░  ░░ █▄░░░░▀
   ▀░░░██      ▄█▀░░▄  ▄  ░▄░░░▀▄     ██░░░░
    ░░░▀█▄    █▀░░▄█▀░▄▀ ░▄█ ░▄░░▀  ▄  ▀░░░░
      ░██▄░   █░░▄█  ░█▄  ██▄ ██░░    ██░░░░
   ▀▄  ░░█░    ░░▀█▄  ░█░  ░█ █▀░░   ██░░
    ▀▄░▄█▀    ▄  ░░██  █░ ▄▀▀█░░     ▀█▄░░  ▄
 ▀▀ ▀▀█▀  █      ▄▄█▀ ▄▀▄█   █▄     ▄  ▀███▀
  ▀       ▄   ▀ ▀▀ ▄ ▀▀ ▀▀▄   ▀▀    ░    ▀   ▀
█▀▀▀▀█▀▀▀█▀██▀█▀█████▀▀██▀███▀█▀▀▀██▀▀▀███▀▀██
█ ▀▀███ ██ ▀▀ █ ████ ▀▀ █ ▄▀▄ █ ▀▀▄█ ██ █ ▀▀ █
█ ▀▀▀██ ██ ██ █ ▀▀▀█ ██ █ ███ █ ▀▀▄█ ▀▀▄█ ██ █
▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
```

Those characters only render on a terminal that decodes UTF-8, and a
process cannot ask its terminal which encoding it uses. So the banner
follows the locale the terminal advertises, and anything that is not a
UTF-8 locale keeps printing the current ASCII wordmark.

## Changes

- `bin/ethlambda/assets/ethlambda_banner.txt`: the new logo.
- `bin/ethlambda/assets/ethlambda_banner_ascii.txt`: the previous
banner, moved out of `main.rs` unchanged.
- `bin/ethlambda/src/banner.rs`: embeds both with `include_str!`, and
`for_locale()` picks one.
- The first non-empty of `LC_ALL`, `LC_CTYPE` and `LANG` decides, which
is POSIX precedence. It counts as UTF-8 when it contains `utf-8` or
`utf8`, in any case. With none of them set the locale is `C`, so ASCII.
- Values are read with `env::var_os`: a set variable whose bytes are not
valid Unicode still takes precedence, where `env::var` would skip it and
let a lower-ranked variable decide.
- `bin/ethlambda/src/main.rs`: drops the `ASCII_ART` constant and prints
`banner::for_locale()`.

## Behavior

- On a non-UTF-8 locale the output is byte for byte what it was: a blank
line, the wordmark, a blank line.
- The Docker image does not set `LANG`, so containers keep printing the
ASCII banner unless run with `-e LANG=C.UTF-8`.
- The choice is made by the process writing the output. `docker logs` or
a log file read somewhere else shows whatever the writer's locale
picked.

## Tests

- 8 unit tests in `banner::tests`: variable precedence, empty values,
non-UTF-8 encodings, a non-Unicode `LC_ALL`, and that the fallback file
is pure ASCII. They pass the variables in through a closure, so they
never touch the process environment.
- Ran the binary with `LANG=en_US.UTF-8`, `LANG=C` and no `LANG`: the
block logo, then the ASCII wordmark both times.

## ✅ Verification Checklist

- [x] `cargo fmt --all -- --check`: clean
- [x] `cargo clippy -p ethlambda --profile release-fast --all-targets --
-D warnings`: clean. Scoped to this crate, since the change touches
nothing else
- [x] `cargo test -p ethlambda --profile release-fast --bins banner`: 8
passing. The full `make test` was not run

Author: MegaRedHand

bin/ethlambda/assets/ethlambda_banner.txt

@@ -0,0 +1,24 @@
+                █               ▄
+          ▀▀    █   ▄█▀▀▀▄▄     ▄   ▄
+       ▄▄ ▀▀ ▄  ░░░██░░░░░▀▄░░░ ▀   █  ░
+      █░░    ▄ ░░  ░░░▀▀▀░░░  ░░ █  ▄  ░░░
+   ▄██░      ▀ ░▄█▀░░█▀▀▀█░░▀█▄░ █  ▄   ░▄▄▄
+   █▀▀    ▀▀  ░░█▀▄▄░░▄▄▄░░▄▄▀█░░   ▀  ▀ ▀▀█
+   █░░ ▄  ▄▄ ░░ █░░█▄▀░▄░▀▄█░░█ ░░ ▄▄    ░░█
+   █░░░  ░▀▀░░  █▄░░█▄▀█▀▄█░░▄█  ░░▀▀█  ░░░█
+   ░██▄░░░░ ▄▄▄░ ▀█▄▄█▄░▄█▄▄█▀ ▄▄▄  ░░░░▄██░
+     ▀█░▄▄▀▀░░░░░ ▄░▀▀░░░▀▀░▄ ░░░░░▀▀ ▄▄█▀
+      ██▀░░░░░▄░░░█ ░░▀▀▀░░ █░░░░░░░░ ░▀█
+    ▄██░░░░▄▄ █░░░░█▄ ▄ ▄ ▄█░░░  ███░ ░░▀█▄
+   █▀░░░▄█▀   █░░▄░░▀█▄▄▄█▀░░░░░  ░░ █▄░░░░▀
+   ▀░░░██      ▄█▀░░▄  ▄  ░▄░░░▀▄     ██░░░░
+    ░░░▀█▄    █▀░░▄█▀░▄▀ ░▄█ ░▄░░▀  ▄  ▀░░░░
+      ░██▄░   █░░▄█  ░█▄  ██▄ ██░░    ██░░░░
+   ▀▄  ░░█░    ░░▀█▄  ░█░  ░█ █▀░░   ██░░
+    ▀▄░▄█▀    ▄  ░░██  █░ ▄▀▀█░░     ▀█▄░░  ▄
+ ▀▀ ▀▀█▀  █      ▄▄█▀ ▄▀▄█   █▄     ▄  ▀███▀
+  ▀       ▄   ▀ ▀▀ ▄ ▀▀ ▀▀▄   ▀▀    ░    ▀   ▀
+█▀▀▀▀█▀▀▀█▀██▀█▀█████▀▀██▀███▀█▀▀▀██▀▀▀███▀▀██
+█ ▀▀███ ██ ▀▀ █ ████ ▀▀ █ ▄▀▄ █ ▀▀▄█ ██ █ ▀▀ █
+█ ▀▀▀██ ██ ██ █ ▀▀▀█ ██ █ ███ █ ▀▀▄█ ▀▀▄█ ██ █
+▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀

bin/ethlambda/assets/ethlambda_banner_ascii.txt

@@ -0,0 +1,5 @@
+      _   _     _                 _         _
+  ___| |_| |__ | | __ _ _ __ ___ | |__   __| | __ _
+ / _ \ __| '_ \| |/ _` | '_ ` _ \| '_ \ / _` |/ _` |
+|  __/ |_| | | | | (_| | | | | | | |_) | (_| | (_| |
+ \___|\__|_| |_|_|\__,_|_| |_| |_|_.__/ \__,_|\__,_|

bin/ethlambda/src/banner.rs

@@ -0,0 +1,112 @@
+//! The startup banner, in one of two encodings.
+
+use std::ffi::OsString;
+
+/// The logo, drawn with block characters from the code page 437 set.
+const UTF8: &str = include_str!("../assets/ethlambda_banner.txt");
+
+/// The wordmark in plain ASCII, for terminals that cannot decode `UTF8`.
+const ASCII: &str = include_str!("../assets/ethlambda_banner_ascii.txt");
+
+/// The banner this process's terminal can display.
+///
+/// A terminal's encoding is not something a process can query, so this reads
+/// the locale, which is how terminals and their shells advertise it.
+pub fn for_locale() -> &'static str {
+    if locale_is_utf8(|name| std::env::var_os(name)) {
+        UTF8
+    } else {
+        ASCII
+    }
+}
+
+/// Whether the locale's character encoding is UTF-8.
+///
+/// Follows POSIX precedence: the first of `LC_ALL`, `LC_CTYPE` and `LANG` that
+/// is set and non-empty decides. With none of them set the locale is `C`, whose
+/// encoding is ASCII.
+///
+/// Values are read as `OsString` because a variable holding bytes that are not
+/// valid Unicode is still set: `env::var` would report it as absent, handing the
+/// decision to a variable POSIX ranks below it.
+fn locale_is_utf8(var: impl Fn(&str) -> Option<OsString>) -> bool {
+    ["LC_ALL", "LC_CTYPE", "LANG"]
+        .into_iter()
+        .find_map(|name| var(name).filter(|value| !value.is_empty()))
+        .is_some_and(|locale| {
+            let locale = locale.to_string_lossy().to_ascii_lowercase();
+            locale.contains("utf-8") || locale.contains("utf8")
+        })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn env<'a>(vars: &'a [(&str, &str)]) -> impl Fn(&str) -> Option<OsString> + 'a {
+        |name| {
+            vars.iter()
+                .find(|(key, _)| *key == name)
+                .map(|(_, value)| OsString::from(value))
+        }
+    }
+
+    #[test]
+    fn a_utf8_lang_selects_utf8() {
+        assert!(locale_is_utf8(env(&[("LANG", "en_US.UTF-8")])));
+        assert!(locale_is_utf8(env(&[("LANG", "C.utf8")])));
+    }
+
+    #[test]
+    fn no_locale_is_ascii() {
+        assert!(!locale_is_utf8(env(&[])));
+    }
+
+    #[test]
+    fn a_non_utf8_encoding_is_ascii() {
+        assert!(!locale_is_utf8(env(&[("LANG", "en_US.ISO-8859-1")])));
+        assert!(!locale_is_utf8(env(&[("LANG", "C")])));
+    }
+
+    #[test]
+    fn lc_all_overrides_everything() {
+        let vars = [
+            ("LC_ALL", "C"),
+            ("LC_CTYPE", "en_US.UTF-8"),
+            ("LANG", "en_US.UTF-8"),
+        ];
+        assert!(!locale_is_utf8(env(&vars)));
+    }
+
+    #[test]
+    fn lc_ctype_overrides_lang() {
+        let utf8_ctype = [("LC_CTYPE", "en_US.UTF-8"), ("LANG", "C")];
+        assert!(locale_is_utf8(env(&utf8_ctype)));
+        let c_ctype = [("LC_CTYPE", "C"), ("LANG", "en_US.UTF-8")];
+        assert!(!locale_is_utf8(env(&c_ctype)));
+    }
+
+    #[test]
+    fn an_empty_variable_counts_as_unset() {
+        let vars = [("LC_ALL", ""), ("LANG", "en_US.UTF-8")];
+        assert!(locale_is_utf8(env(&vars)));
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn a_non_unicode_value_still_takes_precedence() {
+        use std::os::unix::ffi::OsStrExt;
+
+        let var = |name: &str| match name {
+            "LC_ALL" => Some(std::ffi::OsStr::from_bytes(b"\xff").to_os_string()),
+            "LANG" => Some(OsString::from("en_US.UTF-8")),
+            _ => None,
+        };
+        assert!(!locale_is_utf8(var));
+    }
+
+    #[test]
+    fn the_fallback_is_ascii() {
+        assert!(ASCII.is_ascii());
+    }
+}

bin/ethlambda/src/main.rs

@@ -1,3 +1,4 @@
+mod banner;
 mod benchmark;
 mod checkpoint_sync;
 mod cli;
@@ -62,14 +63,6 @@ use ethlambda_storage::{
     MAX_RESUMABLE_DB_STATE_AGE, StorageBackend, Store, backend::RocksDBBackend,
 };
 
-const ASCII_ART: &str = r#"
-      _   _     _                 _         _
-  ___| |_| |__ | | __ _ _ __ ___ | |__   __| | __ _
- / _ \ __| '_ \| |/ _` | '_ ` _ \| '_ \ / _` |/ _` |
-|  __/ |_| | | | | (_| | | | | | | |_) | (_| | (_| |
- \___|\__|_| |_|_|\__,_|_| |_| |_|_.__/ \__,_|\__,_|
-"#;
-
 fn main() -> eyre::Result<()> {
     match command::parse() {
         Command::Node(options) => {
@@ -165,7 +158,7 @@ async fn run_node(options: NodeOptions) -> eyre::Result<()> {
         version: version::CLIENT_VERSION,
     };
 
-    println!("{ASCII_ART}");
+    println!("\n{}", banner::for_locale());
 
     info!(version = version::CLIENT_VERSION, "Starting ethlambda");