diff --git a/src/test/fuzz/block.cpp b/src/test/fuzz/block.cpp
--- a/src/test/fuzz/block.cpp
+++ b/src/test/fuzz/block.cpp
@@ -43,18 +43,30 @@
     BlockValidationState validation_state_pow_and_merkle;
     const bool valid_incl_pow_and_merkle = CheckBlock(
         block, validation_state_pow_and_merkle, consensus_params, options);
+    assert(validation_state_pow_and_merkle.IsValid() ||
+           validation_state_pow_and_merkle.IsInvalid() ||
+           validation_state_pow_and_merkle.IsError());
+    (void)validation_state_pow_and_merkle.Error("");
     BlockValidationState validation_state_pow;
     const bool valid_incl_pow =
         CheckBlock(block, validation_state_pow, consensus_params,
                    options.withCheckMerkleRoot(false));
+    assert(validation_state_pow.IsValid() || validation_state_pow.IsInvalid() ||
+           validation_state_pow.IsError());
     BlockValidationState validation_state_merkle;
     const bool valid_incl_merkle =
         CheckBlock(block, validation_state_merkle, consensus_params,
                    options.withCheckPoW(false));
+    assert(validation_state_merkle.IsValid() ||
+           validation_state_merkle.IsInvalid() ||
+           validation_state_merkle.IsError());
     BlockValidationState validation_state_none;
     const bool valid_incl_none =
         CheckBlock(block, validation_state_none, consensus_params,
                    options.withCheckPoW(false).withCheckMerkleRoot(false));
+    assert(validation_state_none.IsValid() ||
+           validation_state_none.IsInvalid() ||
+           validation_state_none.IsError());
     if (valid_incl_pow_and_merkle) {
         assert(valid_incl_pow && valid_incl_merkle && valid_incl_none);
     } else if (valid_incl_merkle || valid_incl_pow) {
diff --git a/src/test/fuzz/block_header.cpp b/src/test/fuzz/block_header.cpp
--- a/src/test/fuzz/block_header.cpp
+++ b/src/test/fuzz/block_header.cpp
@@ -40,4 +40,13 @@
         block.SetNull();
         assert(block.GetBlockHeader().GetHash() == mut_block_header.GetHash());
     }
+    {
+        std::optional<CBlockLocator> block_locator =
+            ConsumeDeserializable<CBlockLocator>(fuzzed_data_provider);
+        if (block_locator) {
+            (void)block_locator->IsNull();
+            block_locator->SetNull();
+            assert(block_locator->IsNull());
+        }
+    }
 }
diff --git a/src/test/fuzz/script.cpp b/src/test/fuzz/script.cpp
--- a/src/test/fuzz/script.cpp
+++ b/src/test/fuzz/script.cpp
@@ -20,7 +20,11 @@
 #include <test/fuzz/util.h>
 #include <univalue.h>
 
+#include <cstdint>
 #include <memory>
+#include <optional>
+#include <string>
+#include <vector>
 
 void initialize() {
     // Fuzzers using pubkey must hold an ECCVerifyHandle.
diff --git a/src/test/fuzz/string.cpp b/src/test/fuzz/string.cpp
--- a/src/test/fuzz/string.cpp
+++ b/src/test/fuzz/string.cpp
@@ -133,4 +133,10 @@
             fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 1024),
             &amount_out);
     }
+    {
+        (void)Untranslated(random_string_1);
+        const bilingual_str bs1{random_string_1, random_string_2};
+        const bilingual_str bs2{random_string_2, random_string_1};
+        (void)(bs1 + bs2);
+    }
 }
diff --git a/src/test/fuzz/strprintf.cpp b/src/test/fuzz/strprintf.cpp
--- a/src/test/fuzz/strprintf.cpp
+++ b/src/test/fuzz/strprintf.cpp
@@ -3,6 +3,7 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <util/strencodings.h>
+#include <util/translation.h>
 
 #include <test/fuzz/FuzzedDataProvider.h>
 #include <test/fuzz/fuzz.h>
@@ -18,6 +19,7 @@
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
     const std::string format_string =
         fuzzed_data_provider.ConsumeRandomLengthString(64);
+    const bilingual_str bilingual_string{format_string, format_string};
 
     const int digits_in_format_specifier =
         std::count_if(format_string.begin(), format_string.end(), IsDigit);
@@ -54,50 +56,62 @@
 
     try {
         (void)strprintf(format_string, (signed char *)nullptr);
+        (void)tinyformat::format(bilingual_string, (signed char *)nullptr);
     } catch (const tinyformat::format_error &) {
     }
     try {
         (void)strprintf(format_string, (uint8_t *)nullptr);
+        (void)tinyformat::format(bilingual_string, (uint8_t *)nullptr);
     } catch (const tinyformat::format_error &) {
     }
     try {
         (void)strprintf(format_string, (void *)nullptr);
+        (void)tinyformat::format(bilingual_string, (void *)nullptr);
     } catch (const tinyformat::format_error &) {
     }
     try {
         (void)strprintf(format_string, (bool *)nullptr);
+        (void)tinyformat::format(bilingual_string, (bool *)nullptr);
     } catch (const tinyformat::format_error &) {
     }
     try {
         (void)strprintf(format_string, (float *)nullptr);
+        (void)tinyformat::format(bilingual_string, (float *)nullptr);
     } catch (const tinyformat::format_error &) {
     }
     try {
         (void)strprintf(format_string, (double *)nullptr);
+        (void)tinyformat::format(bilingual_string, (double *)nullptr);
     } catch (const tinyformat::format_error &) {
     }
     try {
         (void)strprintf(format_string, (int16_t *)nullptr);
+        (void)tinyformat::format(bilingual_string, (int16_t *)nullptr);
     } catch (const tinyformat::format_error &) {
     }
     try {
         (void)strprintf(format_string, (uint16_t *)nullptr);
+        (void)tinyformat::format(bilingual_string, (uint16_t *)nullptr);
     } catch (const tinyformat::format_error &) {
     }
     try {
         (void)strprintf(format_string, (int32_t *)nullptr);
+        (void)tinyformat::format(bilingual_string, (int32_t *)nullptr);
     } catch (const tinyformat::format_error &) {
     }
     try {
         (void)strprintf(format_string, (uint32_t *)nullptr);
+        (void)tinyformat::format(bilingual_string, (uint32_t *)nullptr);
     } catch (const tinyformat::format_error &) {
     }
     try {
         (void)strprintf(format_string, (int64_t *)nullptr);
+        (void)tinyformat::format(bilingual_string, (int64_t *)nullptr);
     } catch (const tinyformat::format_error &) {
     }
     try {
         (void)strprintf(format_string, (uint64_t *)nullptr);
+        (void)tinyformat::format(bilingual_string, (uint64_t *)nullptr);
     } catch (const tinyformat::format_error &) {
     }
 
@@ -107,29 +121,46 @@
                 (void)strprintf(
                     format_string,
                     fuzzed_data_provider.ConsumeRandomLengthString(32));
+                (void)tinyformat::format(
+                    bilingual_string,
+                    fuzzed_data_provider.ConsumeRandomLengthString(32));
                 break;
             case 1:
                 (void)strprintf(
                     format_string,
                     fuzzed_data_provider.ConsumeRandomLengthString(32).c_str());
+                (void)tinyformat::format(
+                    bilingual_string,
+                    fuzzed_data_provider.ConsumeRandomLengthString(32).c_str());
                 break;
             case 2:
                 (void)strprintf(
                     format_string,
                     fuzzed_data_provider.ConsumeIntegral<signed char>());
+                (void)tinyformat::format(
+                    bilingual_string,
+                    fuzzed_data_provider.ConsumeIntegral<signed char>());
                 break;
             case 3:
                 (void)strprintf(
                     format_string,
                     fuzzed_data_provider.ConsumeIntegral<uint8_t>());
+                (void)tinyformat::format(
+                    bilingual_string,
+                    fuzzed_data_provider.ConsumeIntegral<uint8_t>());
                 break;
             case 4:
                 (void)strprintf(format_string,
                                 fuzzed_data_provider.ConsumeIntegral<char>());
+                (void)tinyformat::format(
+                    bilingual_string,
+                    fuzzed_data_provider.ConsumeIntegral<char>());
                 break;
             case 5:
                 (void)strprintf(format_string,
                                 fuzzed_data_provider.ConsumeBool());
+                (void)tinyformat::format(bilingual_string,
+                                         fuzzed_data_provider.ConsumeBool());
                 break;
         }
     } catch (const tinyformat::format_error &) {
@@ -163,41 +194,65 @@
                 (void)strprintf(
                     format_string,
                     fuzzed_data_provider.ConsumeFloatingPoint<float>());
+                (void)tinyformat::format(
+                    bilingual_string,
+                    fuzzed_data_provider.ConsumeFloatingPoint<float>());
                 break;
             case 1:
                 (void)strprintf(
                     format_string,
                     fuzzed_data_provider.ConsumeFloatingPoint<double>());
+                (void)tinyformat::format(
+                    bilingual_string,
+                    fuzzed_data_provider.ConsumeFloatingPoint<double>());
                 break;
             case 2:
                 (void)strprintf(
                     format_string,
                     fuzzed_data_provider.ConsumeIntegral<int16_t>());
+                (void)tinyformat::format(
+                    bilingual_string,
+                    fuzzed_data_provider.ConsumeIntegral<int16_t>());
                 break;
             case 3:
                 (void)strprintf(
                     format_string,
                     fuzzed_data_provider.ConsumeIntegral<uint16_t>());
+                (void)tinyformat::format(
+                    bilingual_string,
+                    fuzzed_data_provider.ConsumeIntegral<uint16_t>());
                 break;
             case 4:
                 (void)strprintf(
                     format_string,
                     fuzzed_data_provider.ConsumeIntegral<int32_t>());
+                (void)tinyformat::format(
+                    bilingual_string,
+                    fuzzed_data_provider.ConsumeIntegral<int32_t>());
                 break;
             case 5:
                 (void)strprintf(
                     format_string,
                     fuzzed_data_provider.ConsumeIntegral<uint32_t>());
+                (void)tinyformat::format(
+                    bilingual_string,
+                    fuzzed_data_provider.ConsumeIntegral<uint32_t>());
                 break;
             case 6:
                 (void)strprintf(
                     format_string,
                     fuzzed_data_provider.ConsumeIntegral<int64_t>());
+                (void)tinyformat::format(
+                    bilingual_string,
+                    fuzzed_data_provider.ConsumeIntegral<int64_t>());
                 break;
             case 7:
                 (void)strprintf(
                     format_string,
                     fuzzed_data_provider.ConsumeIntegral<uint64_t>());
+                (void)tinyformat::format(
+                    bilingual_string,
+                    fuzzed_data_provider.ConsumeIntegral<uint64_t>());
                 break;
         }
     } catch (const tinyformat::format_error &) {