Merge branch 'main' into cuprated-config

Cargo.lock

@@ -29,6 +29,15 @@ dependencies = [
  "zerocopy",
 ]
 
+[[package]]
+name = "aho-corasick"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "android-tzdata"
 version = "0.1.1"
@@ -44,6 +53,12 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "anes"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
+
 [[package]]
 name = "anstyle"
 version = "1.0.10"
@@ -68,6 +83,16 @@ version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
 
+[[package]]
+name = "assert-json-diff"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47e4f2b81832e72834d7518d8487a0396a28cc408186a2e8854c0f98011faf12"
+dependencies = [
+ "serde",
+ "serde_json",
+]
+
 [[package]]
 name = "async-stream"
 version = "0.3.6"
@@ -337,6 +362,12 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "cast"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
+
 [[package]]
 name = "cc"
 version = "1.1.31"
@@ -370,6 +401,33 @@ dependencies = [
  "windows-targets 0.52.6",
 ]
 
+[[package]]
+name = "ciborium"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e"
+dependencies = [
+ "ciborium-io",
+ "ciborium-ll",
+ "serde",
+]
+
+[[package]]
+name = "ciborium-io"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757"
+
+[[package]]
+name = "ciborium-ll"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9"
+dependencies = [
+ "ciborium-io",
+ "half",
+]
+
 [[package]]
 name = "clap"
 version = "4.5.20"
@@ -469,6 +527,42 @@ dependencies = [
  "cfg-if",
 ]
 
+[[package]]
+name = "criterion"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2b12d017a929603d80db1831cd3a24082f8137ce19c69e6447f54f5fc8d692f"
+dependencies = [
+ "anes",
+ "cast",
+ "ciborium",
+ "clap",
+ "criterion-plot",
+ "is-terminal",
+ "itertools",
+ "num-traits",
+ "once_cell",
+ "oorandom",
+ "plotters",
+ "rayon",
+ "regex",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "tinytemplate",
+ "walkdir",
+]
+
+[[package]]
+name = "criterion-plot"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1"
+dependencies = [
+ "cast",
+ "itertools",
+]
+
 [[package]]
 name = "crossbeam"
 version = "0.8.4"
@@ -525,6 +619,12 @@ version = "0.8.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "22ec99545bb0ed0ea7bb9b8e1e9122ea386ff8a48c0922e43f36d45ab09e0e80"
 
+[[package]]
+name = "crunchy"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
+
 [[package]]
 name = "crypto-bigint"
 version = "0.5.5"
@@ -574,6 +674,30 @@ dependencies = [
  "tokio",
 ]
 
+[[package]]
+name = "cuprate-benchmark"
+version = "0.0.0"
+dependencies = [
+ "cfg-if",
+ "cuprate-benchmark-example",
+ "cuprate-benchmark-lib",
+ "serde",
+ "serde_json",
+ "tracing",
+ "tracing-subscriber",
+]
+
+[[package]]
+name = "cuprate-benchmark-example"
+version = "0.0.0"
+dependencies = [
+ "cuprate-benchmark-lib",
+]
+
+[[package]]
+name = "cuprate-benchmark-lib"
+version = "0.0.0"
+
 [[package]]
 name = "cuprate-blockchain"
 version = "0.0.0"
@@ -676,6 +800,25 @@ dependencies = [
 name = "cuprate-constants"
 version = "0.1.0"
 
+[[package]]
+name = "cuprate-criterion-example"
+version = "0.0.0"
+dependencies = [
+ "criterion",
+ "function_name",
+ "serde_json",
+]
+
+[[package]]
+name = "cuprate-criterion-json-rpc"
+version = "0.0.0"
+dependencies = [
+ "criterion",
+ "cuprate-json-rpc",
+ "function_name",
+ "serde_json",
+]
+
 [[package]]
 name = "cuprate-cryptonight"
 version = "0.1.0"
@@ -839,7 +982,6 @@ dependencies = [
  "cuprate-test-utils",
  "cuprate-types",
  "cuprate-wire",
- "dashmap",
  "futures",
  "indexmap",
  "monero-serai",
@@ -1015,6 +1157,17 @@ dependencies = [
  "thiserror",
 ]
 
+[[package]]
+name = "cuprate-zmq-types"
+version = "0.1.0"
+dependencies = [
+ "assert-json-diff",
+ "cuprate-types",
+ "hex",
+ "serde",
+ "serde_json",
+]
+
 [[package]]
 name = "cuprated"
 version = "0.0.1"
@@ -1286,6 +1439,21 @@ dependencies = [
  "percent-encoding",
 ]
 
+[[package]]
+name = "function_name"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1ab577a896d09940b5fe12ec5ae71f9d8211fff62c919c03a3750a9901e98a7"
+dependencies = [
+ "function_name-proc-macro",
+]
+
+[[package]]
+name = "function_name-proc-macro"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "673464e1e314dd67a0fd9544abc99e8eb28d0c7e3b69b033bcff9b2d00b87333"
+
 [[package]]
 name = "funty"
 version = "2.0.0"
@@ -1435,6 +1603,16 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "half"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6dd08c532ae367adf81c312a4580bc67f1d0fe8bc9c460520283f4c0ff277888"
+dependencies = [
+ "cfg-if",
+ "crunchy",
+]
+
 [[package]]
 name = "hashbrown"
 version = "0.14.5"
@@ -1662,6 +1840,26 @@ dependencies = [
  "hashbrown 0.15.0",
 ]
 
+[[package]]
+name = "is-terminal"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f23ff5ef2b80d608d61efee834934d862cd92461afc0560dedf493e4c033738b"
+dependencies = [
+ "hermit-abi",
+ "libc",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "itertools"
+version = "0.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
+dependencies = [
+ "either",
+]
+
 [[package]]
 name = "itoa"
 version = "1.0.11"
@@ -1758,6 +1956,15 @@ version = "0.4.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
 
+[[package]]
+name = "matchers"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8263075bb86c5a1b1427b5ae862e8889656f126e9f77c484496e8b47cf5c5558"
+dependencies = [
+ "regex-automata 0.1.10",
+]
+
 [[package]]
 name = "matchit"
 version = "0.7.3"
@@ -2013,6 +2220,12 @@ version = "1.20.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1261fe7e33c73b354eab43b1273a57c8f967d0391e80353e51f764ac02cf6775"
 
+[[package]]
+name = "oorandom"
+version = "11.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575"
+
 [[package]]
 name = "openssl-probe"
 version = "0.1.5"
@@ -2150,6 +2363,34 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
 
+[[package]]
+name = "plotters"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a15b6eccb8484002195a3e44fe65a4ce8e93a625797a063735536fd59cb01cf3"
+dependencies = [
+ "num-traits",
+ "plotters-backend",
+ "plotters-svg",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "plotters-backend"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "414cec62c6634ae900ea1c56128dfe87cf63e7caece0852ec76aba307cebadb7"
+
+[[package]]
+name = "plotters-svg"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81b30686a7d9c3e010b84284bdd26a29f2138574f52f5eb6f794fc0ad924e705"
+dependencies = [
+ "plotters-backend",
+]
+
 [[package]]
 name = "ppv-lite86"
 version = "0.2.20"
@@ -2224,7 +2465,7 @@ dependencies = [
  "rand",
  "rand_chacha",
  "rand_xorshift",
- "regex-syntax",
+ "regex-syntax 0.8.5",
  "rusty-fork",
  "tempfile",
  "unarray",
@@ -2390,6 +2631,44 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "regex"
+version = "1.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b91213439dad192326a0d7c6ee3955910425f441d7038e0d6933b0aec5c4517f"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata 0.4.7",
+ "regex-syntax 0.8.5",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
+dependencies = [
+ "regex-syntax 0.6.29",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38caf58cc5ef2fed281f89292ef23f6365465ed9a41b7a7754eb4e26496c92df"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax 0.8.5",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.6.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
+
 [[package]]
 name = "regex-syntax"
 version = "0.8.5"
@@ -2517,6 +2796,15 @@ version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
 
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
 [[package]]
 name = "schannel"
 version = "0.1.26"
@@ -2890,6 +3178,16 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a693d0c8cf16973fac5a93fbe47b8c6452e7097d4fcac49f3d7a18e39c76e62e"
 
+[[package]]
+name = "tinytemplate"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc"
+dependencies = [
+ "serde",
+ "serde_json",
+]
+
 [[package]]
 name = "tinyvec"
 version = "1.8.0"
@@ -3123,10 +3421,14 @@ version = "0.3.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ad0f048c97dbd9faa9b7df56362b8ebcaa52adb06b498c050d2f4e32f90a7a8b"
 dependencies = [
+ "matchers",
  "nu-ansi-term",
+ "once_cell",
+ "regex",
  "sharded-slab",
  "smallvec",
  "thread_local",
+ "tracing",
  "tracing-core",
  "tracing-log",
 ]
@@ -3232,6 +3534,16 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "walkdir"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
 [[package]]
 name = "want"
 version = "0.3.1"
@@ -3302,6 +3614,16 @@ version = "0.2.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "65fc09f10666a9f147042251e0dda9c18f166ff7de300607007e96bdebc1068d"
 
+[[package]]
+name = "web-sys"
+version = "0.3.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77afa9a11836342370f4817622a2f0f418b134426d91a82dfb48f532d2ec13ef"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "webpki-roots"
 version = "0.26.6"
@@ -3327,6 +3649,15 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
 
+[[package]]
+name = "winapi-util"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4d4cc384e1e73b93bafa6fb4f1df8c41695c8a91cf9c4c64358067d15a7b6c6b"
+dependencies = [
+ "windows-sys 0.52.0",
+]
+
 [[package]]
 name = "winapi-x86_64-pc-windows-gnu"
 version = "0.4.0"

Cargo.toml

@@ -1,35 +1,57 @@
 [workspace]
 resolver = "2"
-
 members = [
+	# Binaries
 	"binaries/cuprated",
-	"constants",
+
+	# Benchmarks
+	"benches/benchmark/bin",
+	"benches/benchmark/lib",
+	"benches/benchmark/example",
+	"benches/criterion/example",
+	"benches/criterion/cuprate-json-rpc",
+
+	# Consensus
 	"consensus",
 	"consensus/context",
 	"consensus/fast-sync",
 	"consensus/rules",
-	"cryptonight",
+
-	"helper",
+	# Net
 	"net/epee-encoding",
 	"net/fixed-bytes",
 	"net/levin",
 	"net/wire",
+
+	# P2P
 	"p2p/p2p",
 	"p2p/p2p-core",
 	"p2p/bucket",
 	"p2p/dandelion-tower",
 	"p2p/async-buffer",
 	"p2p/address-book",
+
+	# Storage
 	"storage/blockchain",
 	"storage/service",
 	"storage/txpool",
 	"storage/database",
-	"pruning",
+
-	"test-utils",
+	# RPC
-	"types",
 	"rpc/json-rpc",
 	"rpc/types",
 	"rpc/interface",
+
+	# ZMQ
+	"zmq/types",
+
+	# Misc
+	"constants",
+	"cryptonight",
+	"helper",
+	"pruning",
+	"test-utils",
+	"types",
 ]
 
 [profile.release]
@@ -53,6 +75,8 @@ opt-level = 3
 
 [workspace.dependencies]
 # Cuprate members
+cuprate-benchmark-lib     = { path = "benches/benchmark/lib",     default-features = false }
+cuprate-benchmark-example = { path = "benches/benchmark/example", default-features = false }
 cuprate-fast-sync         = { path = "consensus/fast-sync",       default-features = false }
 cuprate-consensus-rules   = { path = "consensus/rules",           default-features = false }
 cuprate-constants         = { path = "constants",                 default-features = false }
@@ -80,6 +104,7 @@ cuprate-types               = { path = "types"                  ,default-feature
 cuprate-json-rpc          = { path = "rpc/json-rpc",              default-features = false }
 cuprate-rpc-types         = { path = "rpc/types",                 default-features = false }
 cuprate-rpc-interface     = { path = "rpc/interface",             default-features = false }
+cuprate-zmq-types         = { path = "zmq/types",                 default-features = false }
 
 # External dependencies
 anyhow                = { version = "1", default-features = false }
@@ -125,6 +150,8 @@ tracing-subscriber    = { version = "0.3", default-features = false }
 tracing               = { version = "0.1", default-features = false }
 
 ## workspace.dev-dependencies
+criterion                 = { version = "0.5" }
+function_name             = { version = "0.3" }
 monero-rpc                = { git = "https://github.com/Cuprate/serai.git", rev = "d5205ce" }
 monero-simple-request-rpc = { git = "https://github.com/Cuprate/serai.git", rev = "d5205ce" }
 tempfile                  = { version = "3" }
@@ -254,6 +281,9 @@ rest_pat_in_fully_bound_structs = "deny"
 redundant_type_annotations = "deny"
 infinite_loop = "deny"
 zero_repeat_side_effects = "deny"
+non_zero_suggestions = "deny"
+manual_is_power_of_two = "deny"
+used_underscore_items = "deny"
 
 # Warm
 cast_possible_truncation = "deny"
@@ -346,6 +376,7 @@ unused_lifetimes = "deny"
 unused_macro_rules = "deny"
 ambiguous_glob_imports = "deny"
 unused_unsafe = "deny"
+rust_2024_compatibility = "deny"
 
 # Warm
 let_underscore = { level = "deny", priority = -1 }

benches/README.md

@@ -1 +1,5 @@
-# TODO
+# Benches
+This directory contains Cuprate's benchmarks and benchmarking utilities.
+
+See the [`Benchmarking` section in the Architecture book](https://architecture.cuprate.org/benchmarking/intro.html)
+to see how to create and run these benchmarks.

benches/benchmark/bin/Cargo.toml

@@ -0,0 +1,43 @@
+[package]
+name        = "cuprate-benchmark"
+version     = "0.0.0"
+edition     = "2021"
+description = "Cuprate's benchmarking binary"
+license     = "MIT"
+authors     = ["hinto-janai"]
+repository  = "https://github.com/Cuprate/cuprate/tree/main/benches/benchmark/bin"
+keywords    = ["cuprate", "benchmarking", "binary"]
+
+[features]
+# All new benchmarks should be added here!
+all = ["example"]
+
+# Non-benchmark features.
+default = []
+json    = []
+trace   = []
+debug   = []
+warn    = []
+info    = []
+error   = []
+
+# Benchmark features.
+# New benchmarks should be added here!
+example = [
+	"dep:cuprate-benchmark-example"
+]
+
+[dependencies]
+cuprate-benchmark-lib     = { workspace = true }
+cuprate-benchmark-example = { workspace = true, optional = true }
+
+cfg-if             = { workspace = true }
+serde              = { workspace = true, features = ["derive"] }
+serde_json         = { workspace = true, features = ["std"] }
+tracing            = { workspace = true, features = ["std", "attributes"] }
+tracing-subscriber = { workspace = true, features = ["fmt", "std", "env-filter"] }
+
+[dev-dependencies]
+
+[lints]
+workspace = true

benches/benchmark/bin/README.md

@@ -0,0 +1,27 @@
+## `cuprate-benchmark`
+This crate links all benchmarks together into a single binary that can be run as: `cuprate-benchmark`.
+
+`cuprate-benchmark` will run all enabled benchmarks sequentially and print data at the end.
+
+## Benchmarks
+Benchmarks are opt-in and enabled via features.
+
+| Feature  | Enables which benchmark crate? |
+|----------|--------------------------------|
+| example  | cuprate-benchmark-example      |
+| database | cuprate-benchmark-database     |
+
+## Features
+These are features that aren't for enabling benchmarks, but rather for other things.
+
+Since `cuprate-benchmark` is built right before it is ran,
+these features almost act like command line arguments.
+
+| Features | Does what |
+|----------|-----------|
+| json     | Prints JSON timings instead of a markdown table
+| trace    | Use the `trace` log-level
+| debug    | Use the `debug` log-level
+| warn     | Use the `warn` log-level
+| info     | Use the `info` log-level (default)
+| error    | Use the `error` log-level

benches/benchmark/bin/src/log.rs

@@ -0,0 +1,29 @@
+use cfg_if::cfg_if;
+use tracing::{info, instrument, Level};
+use tracing_subscriber::FmtSubscriber;
+
+/// Initializes the `tracing` logger.
+#[instrument]
+pub(crate) fn init_logger() {
+    const LOG_LEVEL: Level = {
+        cfg_if! {
+            if #[cfg(feature = "trace")] {
+                Level::TRACE
+            } else if #[cfg(feature = "debug")] {
+                Level::DEBUG
+            } else if #[cfg(feature = "warn")] {
+                Level::WARN
+            } else if #[cfg(feature = "info")] {
+                Level::INFO
+            } else if #[cfg(feature = "error")] {
+                Level::ERROR
+            } else {
+                Level::INFO
+            }
+        }
+    };
+
+    FmtSubscriber::builder().with_max_level(LOG_LEVEL).init();
+
+    info!("Log level: {LOG_LEVEL}");
+}

benches/benchmark/bin/src/main.rs

@@ -0,0 +1,49 @@
+#![doc = include_str!("../README.md")]
+#![allow(
+    unused_crate_dependencies,
+    reason = "this crate imports many potentially unused dependencies"
+)]
+
+mod log;
+mod print;
+mod run;
+mod timings;
+
+use cfg_if::cfg_if;
+
+/// What `main()` does:
+/// 1. Run all enabled benchmarks
+/// 2. Record benchmark timings
+/// 3. Print timing data
+///
+/// To add a new benchmark to be ran here:
+/// 1. Copy + paste a `cfg_if` block
+/// 2. Change it to your benchmark's feature flag
+/// 3. Change it to your benchmark's type
+#[allow(
+    clippy::allow_attributes,
+    unused_variables,
+    unused_mut,
+    unreachable_code,
+    reason = "clippy does not account for all cfg()s"
+)]
+fn main() {
+    log::init_logger();
+
+    let mut timings = timings::Timings::new();
+
+    cfg_if! {
+        if #[cfg(not(any(feature = "example")))] {
+            println!("No feature specified. Use `--features $BENCHMARK_FEATURE` when building.");
+            return;
+        }
+    }
+
+    cfg_if! {
+        if #[cfg(feature = "example")] {
+            run::run_benchmark::<cuprate_benchmark_example::Example>(&mut timings);
+        }
+    }
+
+    print::print_timings(&timings);
+}

benches/benchmark/bin/src/print.rs

@@ -0,0 +1,38 @@
+#![expect(dead_code, reason = "code hidden behind feature flags")]
+
+use cfg_if::cfg_if;
+
+use crate::timings::Timings;
+
+/// Print the final the final markdown table of benchmark timings.
+pub(crate) fn print_timings(timings: &Timings) {
+    println!("\nFinished all benchmarks, printing results:");
+
+    cfg_if! {
+        if #[cfg(feature = "json")] {
+            print_timings_json(timings);
+        } else {
+            print_timings_markdown(timings);
+        }
+    }
+}
+
+/// Default timing formatting.
+pub(crate) fn print_timings_markdown(timings: &Timings) {
+    let mut s = String::new();
+    s.push_str("| Benchmark                          | Time (seconds) |\n");
+    s.push_str("|------------------------------------|----------------|");
+
+    #[expect(clippy::iter_over_hash_type)]
+    for (k, v) in timings {
+        s += &format!("\n| {k:<34} | {v:<14} |");
+    }
+
+    println!("\n{s}");
+}
+
+/// Enabled via `json` feature.
+pub(crate) fn print_timings_json(timings: &Timings) {
+    let json = serde_json::to_string_pretty(timings).unwrap();
+    println!("\n{json}");
+}

benches/benchmark/bin/src/run.rs

@@ -0,0 +1,36 @@
+use tracing::{info, instrument, trace};
+
+use cuprate_benchmark_lib::Benchmark;
+
+use crate::timings::Timings;
+
+/// Run a [`Benchmark`] and record its timing.
+#[instrument(skip_all)]
+pub(crate) fn run_benchmark<B: Benchmark>(timings: &mut Timings) {
+    // Get the benchmark name.
+    let name = B::name();
+    trace!("Running benchmark: {name}");
+
+    // Setup the benchmark input.
+    let input = B::SETUP();
+
+    // Sleep before running the benchmark.
+    trace!("Pre-benchmark, sleeping for: {:?}", B::POST_SLEEP_DURATION);
+    std::thread::sleep(B::PRE_SLEEP_DURATION);
+
+    // Run/time the benchmark.
+    let now = std::time::Instant::now();
+    B::MAIN(input);
+    let time = now.elapsed().as_secs_f32();
+
+    // Print the benchmark timings.
+    info!("{name:>34} ... {time}");
+    assert!(
+        timings.insert(name, time).is_none(),
+        "There were 2 benchmarks with the same name - this collides the final output: {name}",
+    );
+
+    // Sleep for a cooldown period after the benchmark run.
+    trace!("Post-benchmark, sleeping for: {:?}", B::POST_SLEEP_DURATION);
+    std::thread::sleep(B::POST_SLEEP_DURATION);
+}

benches/benchmark/bin/src/timings.rs

@@ -0,0 +1,5 @@
+/// Benchmark timing data.
+///
+/// - Key = benchmark name
+/// - Value = benchmark time in seconds
+pub(crate) type Timings = std::collections::HashMap<&'static str, f32>;

benches/benchmark/example/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name        = "cuprate-benchmark-example"
+version     = "0.0.0"
+edition     = "2021"
+description = "Example showcasing Cuprate's benchmarking harness"
+license     = "MIT"
+authors     = ["hinto-janai"]
+repository  = "https://github.com/Cuprate/cuprate/tree/main/benches/benchmark/example"
+keywords    = ["cuprate", "benchmarking", "example"]
+
+[dependencies]
+cuprate-benchmark-lib = { path = "../lib" }
+
+[dev-dependencies]
+
+[lints]
+workspace = true

benches/benchmark/example/README.md

@@ -0,0 +1,3 @@
+## `cuprate-benchmark-example`
+This crate contains a short example benchmark that shows how to implement and use
+`cuprate-benchmark-lib` so that it can be ran by `cuprate-benchmark`.

benches/benchmark/example/src/lib.rs

@@ -0,0 +1,42 @@
+#![doc = include_str!("../README.md")]
+
+use std::hint::black_box;
+
+use cuprate_benchmark_lib::Benchmark;
+
+/// Marker struct that implements [`Benchmark`]
+pub struct Example;
+
+/// The input to our benchmark function.
+pub type ExampleBenchmarkInput = u64;
+
+/// The setup function that creates the input.
+pub const fn example_benchmark_setup() -> ExampleBenchmarkInput {
+    1
+}
+
+/// The main benchmarking function.
+#[expect(clippy::unit_arg)]
+pub fn example_benchmark_main(input: ExampleBenchmarkInput) {
+    // In this case, we're simply benchmarking the
+    // performance of simple arithmetic on the input data.
+
+    fn math(input: ExampleBenchmarkInput, number: u64) {
+        let x = input;
+        let x = black_box(x * number);
+        let x = black_box(x / number);
+        let x = black_box(x + number);
+        let _ = black_box(x - number);
+    }
+
+    for number in 1..100_000_000 {
+        black_box(math(input, number));
+    }
+}
+
+// This implementation will be run by `cuprate-benchmark`.
+impl Benchmark for Example {
+    type Input = ExampleBenchmarkInput;
+    const SETUP: fn() -> Self::Input = example_benchmark_setup;
+    const MAIN: fn(Self::Input) = example_benchmark_main;
+}

benches/benchmark/lib/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name        = "cuprate-benchmark-lib"
+version     = "0.0.0"
+edition     = "2021"
+description = "Cuprate's benchmarking library"
+license     = "MIT"
+authors     = ["hinto-janai"]
+repository  = "https://github.com/Cuprate/cuprate/tree/main/benches/benchmark/lib"
+keywords    = ["cuprate", "benchmarking", "library"]
+
+[features]
+
+[dependencies]
+
+[dev-dependencies]
+
+[lints]
+workspace = true

benches/benchmark/lib/README.md

@@ -0,0 +1,15 @@
+## `cuprate-benchmark-lib`
+This crate is the glue between
+[`cuprate-benchmark`](https://github.com/Cuprate/cuprate/tree/benches/benches/benchmark/bin)
+and all the benchmark crates.
+
+It defines the [`crate::Benchmark`] trait, which is the behavior of all benchmarks.
+
+See the [`cuprate-benchmark-example`](https://github.com/Cuprate/cuprate/tree/benches/benches/benchmark/example)
+crate to see an example implementation of this trait.
+
+After implementing this trait, a few steps must
+be done such that the `cuprate-benchmark` binary
+can actually run your benchmark crate; see the
+[`Benchmarking` section in the Architecture book](https://architecture.cuprate.org/benchmarking/intro.html)
+to see how to do this.

benches/benchmark/lib/src/benchmark.rs

@@ -0,0 +1,45 @@
+//! Benchmarking trait.
+
+use std::time::Duration;
+
+/// A benchmarking function and its inputs.
+pub trait Benchmark {
+    /// The benchmark's name.
+    ///
+    /// This is automatically implemented
+    /// as the name of the [`Self`] type.
+    //
+    // FIXME: use `const` instead of `fn` when stable
+    // <https://github.com/rust-lang/rust/issues/63084>
+    fn name() -> &'static str {
+        std::any::type_name::<Self>()
+    }
+
+    /// Input to the main benchmarking function.
+    ///
+    /// This is passed to [`Self::MAIN`].
+    type Input;
+
+    /// Setup function to generate the input.
+    ///
+    /// This function is not timed.
+    const SETUP: fn() -> Self::Input;
+
+    /// The main function to benchmark.
+    ///
+    /// The start of the timer begins right before
+    /// this function is called and ends after the
+    /// function returns.
+    const MAIN: fn(Self::Input);
+
+    /// `cuprate-benchmark` will sleep for this [`Duration`] after
+    /// creating the [`Self::Input`], but before starting [`Self::MAIN`].
+    ///
+    /// 1 second by default.
+    const PRE_SLEEP_DURATION: Duration = Duration::from_secs(1);
+
+    /// `cuprate-benchmark` will sleep for this [`Duration`] after [`Self::MAIN`].
+    ///
+    /// 1 second by default.
+    const POST_SLEEP_DURATION: Duration = Duration::from_secs(1);
+}

benches/benchmark/lib/src/lib.rs

@@ -0,0 +1,5 @@
+#![doc = include_str!("../README.md")]
+
+mod benchmark;
+
+pub use benchmark::Benchmark;

benches/criterion/cuprate-json-rpc/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name        = "cuprate-criterion-json-rpc"
+version     = "0.0.0"
+edition     = "2021"
+description = "Criterion benchmarking for cuprate-json-rpc"
+license     = "MIT"
+authors     = ["hinto-janai"]
+repository  = "https://github.com/Cuprate/cuprate/tree/main/benches/criterion/cuprate-json-rpc"
+keywords    = ["cuprate", "json-rpc", "criterion", "benchmark"]
+
+[dependencies]
+cuprate-json-rpc = { workspace = true }
+
+criterion     = { workspace = true }
+function_name = { workspace = true }
+serde_json    = { workspace = true, features = ["default"] }
+
+[[bench]]
+name    = "main"
+harness = false
+
+[lints]
+workspace = true

benches/criterion/cuprate-json-rpc/benches/main.rs

@@ -0,0 +1,8 @@
+//! Benchmarks for `cuprate-json-rpc`.
+#![allow(unused_crate_dependencies)]
+
+mod response;
+
+criterion::criterion_main! {
+    response::serde,
+}

benches/criterion/cuprate-json-rpc/benches/response.rs

@@ -0,0 +1,110 @@
+//! Benchmarks for [`Response`].
+#![allow(unused_attributes, unused_crate_dependencies)]
+
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use function_name::named;
+use serde_json::{from_str, to_string_pretty};
+
+use cuprate_json_rpc::{Id, Response};
+
+// `serde` benchmarks on `Response`.
+//
+// These are benchmarked as `Response` has a custom serde implementation.
+criterion_group! {
+    name = serde;
+    config = Criterion::default();
+    targets =
+    response_from_str_u8,
+    response_from_str_u64,
+    response_from_str_string_5_len,
+    response_from_str_string_10_len,
+    response_from_str_string_100_len,
+    response_from_str_string_500_len,
+    response_to_string_pretty_u8,
+    response_to_string_pretty_u64,
+    response_to_string_pretty_string_5_len,
+    response_to_string_pretty_string_10_len,
+    response_to_string_pretty_string_100_len,
+    response_to_string_pretty_string_500_len,
+    response_from_str_bad_field_1,
+    response_from_str_bad_field_5,
+    response_from_str_bad_field_10,
+    response_from_str_bad_field_100,
+    response_from_str_missing_field,
+}
+criterion_main!(serde);
+
+/// Generate `from_str` deserialization benchmark functions for [`Response`].
+macro_rules! impl_from_str_benchmark {
+    (
+        $(
+            $fn_name:ident => $request_type:ty => $request_string:literal,
+        )*
+    ) => {
+        $(
+            #[named]
+            fn $fn_name(c: &mut Criterion) {
+                let request_string = $request_string;
+
+                c.bench_function(function_name!(), |b| {
+                    b.iter(|| {
+                        let _r = from_str::<Response<$request_type>>(
+                            black_box(request_string)
+                        );
+                    });
+                });
+            }
+        )*
+    };
+}
+
+impl_from_str_benchmark! {
+    response_from_str_u8 => u8 => r#"{"jsonrpc":"2.0","id":123,"result":0}"#,
+    response_from_str_u64 => u64 => r#"{"jsonrpc":"2.0","id":123,"result":0}"#,
+    response_from_str_string_5_len => String => r#"{"jsonrpc":"2.0","id":123,"result":"hello"}"#,
+    response_from_str_string_10_len => String => r#"{"jsonrpc":"2.0","id":123,"result":"hellohello"}"#,
+    response_from_str_string_100_len => String => r#"{"jsonrpc":"2.0","id":123,"result":"helloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworld"}"#,
+    response_from_str_string_500_len => String => r#"{"jsonrpc":"2.0","id":123,"result":"helloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworld"}"#,
+
+    // The custom serde currently looks at all fields.
+    // These are for testing the performance if the serde
+    // has to parse through a bunch of unrelated fields.
+    response_from_str_bad_field_1 => u8 => r#"{"bad_field":0,"jsonrpc":"2.0","id":123,"result":0}"#,
+    response_from_str_bad_field_5 => u8 => r#"{"bad_field_1":0,"bad_field_2":0,"bad_field_3":0,"bad_field_4":0,"bad_field_5":0,"jsonrpc":"2.0","id":123,"result":0}"#,
+    response_from_str_bad_field_10 => u8 => r#"{"bad_field_1":0,"bad_field_2":0,"bad_field_3":0,"bad_field_4":0,"bad_field_5":0,"bad_field_6":0,"bad_field_7":0,"bad_field_8":0,"bad_field_9":0,"bad_field_10":0,"jsonrpc":"2.0","id":123,"result":0}"#,
+    response_from_str_bad_field_100 => u8 => r#"{"1":0,"2":0,"3":0,"4":0,"5":0,"6":0,"7":0,"8":0,"9":0,"10":0,"11":0,"12":0,"13":0,"14":0,"15":0,"16":0,"17":0,"18":0,"19":0,"20":0,"21":0,"22":0,"23":0,"24":0,"25":0,"26":0,"27":0,"28":0,"29":0,"30":0,"31":0,"32":0,"33":0,"34":0,"35":0,"36":0,"37":0,"38":0,"39":0,"40":0,"41":0,"42":0,"43":0,"44":0,"45":0,"46":0,"47":0,"48":0,"49":0,"50":0,"51":0,"52":0,"53":0,"54":0,"55":0,"56":0,"57":0,"58":0,"59":0,"60":0,"61":0,"62":0,"63":0,"64":0,"65":0,"66":0,"67":0,"68":0,"69":0,"70":0,"71":0,"72":0,"73":0,"74":0,"75":0,"76":0,"77":0,"78":0,"79":0,"80":0,"81":0,"82":0,"83":0,"84":0,"85":0,"86":0,"87":0,"88":0,"89":0,"90":0,"91":0,"92":0,"93":0,"94":0,"95":0,"96":0,"97":0,"98":0,"99":0,"100":0,"jsonrpc":"2.0","id":123,"result":0}"#,
+
+    // These are missing the `jsonrpc` field.
+    response_from_str_missing_field => u8 => r#"{"id":123,"result":0}"#,
+}
+
+/// Generate `to_string_pretty` serialization benchmark functions for [`Response`].
+macro_rules! impl_to_string_pretty_benchmark {
+    (
+        $(
+            $fn_name:ident => $request_constructor:expr_2021,
+        )*
+    ) => {
+        $(
+            #[named]
+            fn $fn_name(c: &mut Criterion) {
+                let request = $request_constructor;
+
+                c.bench_function(function_name!(), |b| {
+                    b.iter(|| {
+                        let _s = to_string_pretty(black_box(&request)).unwrap();
+                    });
+                });
+            }
+        )*
+    };
+}
+
+impl_to_string_pretty_benchmark! {
+    response_to_string_pretty_u8 => Response::<u8>::ok(Id::Null, 0),
+    response_to_string_pretty_u64 => Response::<u64>::ok(Id::Null, 0),
+    response_to_string_pretty_string_5_len => Response::ok(Id::Null, String::from("hello")),
+    response_to_string_pretty_string_10_len => Response::ok(Id::Null, String::from("hellohello")),
+    response_to_string_pretty_string_100_len => Response::ok(Id::Null, String::from("helloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworld")),
+    response_to_string_pretty_string_500_len => Response::ok(Id::Null, String::from("helloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworld")),
+}

benches/criterion/cuprate-json-rpc/src/lib.rs

@@ -0,0 +1,2 @@
+//! Benchmark lib for `cuprate-json-rpc`.
+#![allow(unused_crate_dependencies, reason = "used in benchmarks")]

benches/criterion/example/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name        = "cuprate-criterion-example"
+version     = "0.0.0"
+edition     = "2021"
+description = "Criterion benchmarking example for Cuprate"
+license     = "MIT"
+authors     = ["hinto-janai"]
+repository  = "https://github.com/Cuprate/cuprate/tree/main/benches/criterion/example"
+keywords    = ["cuprate", "criterion", "benchmark", "example"]
+
+[dependencies]
+criterion     = { workspace = true }
+function_name = { workspace = true }
+serde_json    = { workspace = true, features = ["default"] }
+
+[[bench]]
+name    = "main"
+harness = false
+
+[lints]
+workspace = true

benches/criterion/example/README.md

@@ -0,0 +1,14 @@
+## `cuprate-criterion-example`
+An example of using Criterion for benchmarking Cuprate crates.
+
+Consider copy+pasting this crate to use as a base when creating new Criterion benchmark crates.
+
+## `src/`
+Benchmark crates have a `benches/` ran by `cargo bench`, but they are also crates themselves,
+as in, they have a `src` folder that `benches/` can pull code from.
+
+The `src` directories in these benchmarking crates are usually filled with
+helper functions, types, etc, that are used repeatedly in the benchmarks.
+
+## `benches/`
+These are the actual benchmarks ran by `cargo bench`.

benches/criterion/example/benches/example.rs

@@ -0,0 +1,48 @@
+//! Benchmarks.
+#![allow(unused_attributes, unused_crate_dependencies)]
+
+use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+use function_name::named;
+
+use cuprate_criterion_example::SomeHardToCreateObject;
+
+// This is how you register criterion benchmarks.
+criterion_group! {
+    name = benches;
+    config = Criterion::default();
+    targets = benchmark_1, benchmark_range,
+}
+criterion_main!(benches);
+
+/// Benchmark a single input.
+///
+/// <https://bheisler.github.io/criterion.rs/book/user_guide/benchmarking_with_inputs.html#benchmarking-with-one-input>
+#[named]
+fn benchmark_1(c: &mut Criterion) {
+    // It is recommended to use `function_name!()` as a benchmark
+    // identifier instead of manually re-typing the function name.
+    c.bench_function(function_name!(), |b| {
+        b.iter(|| {
+            black_box(SomeHardToCreateObject::from(1));
+        });
+    });
+}
+
+/// Benchmark a range of inputs.
+///
+/// <https://bheisler.github.io/criterion.rs/book/user_guide/benchmarking_with_inputs.html#benchmarking-with-a-range-of-values>
+#[named]
+fn benchmark_range(c: &mut Criterion) {
+    let mut group = c.benchmark_group(function_name!());
+
+    for i in 0..4 {
+        group.throughput(Throughput::Elements(i));
+        group.bench_with_input(BenchmarkId::from_parameter(i), &i, |b, &i| {
+            b.iter(|| {
+                black_box(SomeHardToCreateObject::from(i));
+            });
+        });
+    }
+
+    group.finish();
+}

benches/criterion/example/benches/main.rs

@@ -0,0 +1,10 @@
+//! Benchmarks examples.
+#![allow(unused_crate_dependencies)]
+
+// All modules within `benches/` are `mod`ed here.
+mod example;
+
+// And all the Criterion benchmarks are registered like so:
+criterion::criterion_main! {
+    example::benches,
+}

benches/criterion/example/src/lib.rs

@@ -0,0 +1,13 @@
+#![doc = include_str!("../README.md")] // See the README for crate documentation.
+#![allow(unused_crate_dependencies, reason = "used in benchmarks")]
+
+/// Shared type that all benchmarks can use.
+#[expect(dead_code)]
+pub struct SomeHardToCreateObject(u64);
+
+impl From<u64> for SomeHardToCreateObject {
+    /// Shared function that all benchmarks can use.
+    fn from(value: u64) -> Self {
+        Self(value)
+    }
+}

binaries/cuprated/src/blockchain/syncer.rs

@@ -12,7 +12,7 @@ use tracing::instrument;
 use cuprate_consensus::{BlockChainContext, BlockChainContextRequest, BlockChainContextResponse};
 use cuprate_p2p::{
     block_downloader::{BlockBatch, BlockDownloaderConfig, ChainSvcRequest, ChainSvcResponse},
-    NetworkInterface,
+    NetworkInterface, PeerSetRequest, PeerSetResponse,
 };
 use cuprate_p2p_core::ClearNet;
 
@@ -28,15 +28,11 @@ pub enum SyncerError {
 }
 
 /// The syncer tasks that makes sure we are fully synchronised with our connected peers.
-#[expect(
-    clippy::significant_drop_tightening,
-    reason = "Client pool which will be removed"
-)]
 #[instrument(level = "debug", skip_all)]
 pub async fn syncer<C, CN>(
     mut context_svc: C,
     our_chain: CN,
-    clearnet_interface: NetworkInterface<ClearNet>,
+    mut clearnet_interface: NetworkInterface<ClearNet>,
     incoming_block_batch_tx: mpsc::Sender<BlockBatch>,
     stop_current_block_downloader: Arc<Notify>,
     block_downloader_config: BlockDownloaderConfig,
@@ -67,8 +63,6 @@ where
         unreachable!();
     };
 
-    let client_pool = clearnet_interface.client_pool();
-
     tracing::debug!("Waiting for new sync info in top sync channel");
 
     loop {
@@ -79,9 +73,20 @@ where
         check_update_blockchain_context(&mut context_svc, &mut blockchain_ctx).await?;
         let raw_blockchain_context = blockchain_ctx.unchecked_blockchain_context();
 
-        if !client_pool.contains_client_with_more_cumulative_difficulty(
+        let PeerSetResponse::MostPoWSeen {
-            raw_blockchain_context.cumulative_difficulty,
+            cumulative_difficulty,
-        ) {
+            ..
+        } = clearnet_interface
+            .peer_set()
+            .ready()
+            .await?
+            .call(PeerSetRequest::MostPoWSeen)
+            .await?
+        else {
+            unreachable!();
+        };
+
+        if cumulative_difficulty <= raw_blockchain_context.cumulative_difficulty {
             continue;
         }
 

binaries/cuprated/src/statics.rs

@@ -13,7 +13,7 @@ use std::{
 macro_rules! define_init_lazylock_statics {
     ($(
         $( #[$attr:meta] )*
-        $name:ident: $t:ty = $init_fn:expr;
+        $name:ident: $t:ty = $init_fn:expr_2021;
     )*) => {
         /// Initialize global static `LazyLock` data.
         pub fn init_lazylock_statics() {

binaries/cuprated/src/txpool/dandelion.rs

@@ -59,7 +59,7 @@ pub fn dandelion_router(clear_net: NetworkInterface<ClearNet>) -> ConcreteDandel
         diffuse_service::DiffuseService {
             clear_net_broadcast_service: clear_net.broadcast_svc(),
         },
-        stem_service::OutboundPeerStream { clear_net },
+        stem_service::OutboundPeerStream::new(clear_net),
         DANDELION_CONFIG,
     )
 }

binaries/cuprated/src/txpool/dandelion/stem_service.rs

@@ -1,14 +1,15 @@
 use std::{
+    future::Future,
     pin::Pin,
-    task::{Context, Poll},
+    task::{ready, Context, Poll},
 };
 
 use bytes::Bytes;
-use futures::Stream;
+use futures::{future::BoxFuture, FutureExt, Stream};
 use tower::Service;
 
 use cuprate_dandelion_tower::{traits::StemRequest, OutboundPeer};
-use cuprate_p2p::{ClientPoolDropGuard, NetworkInterface};
+use cuprate_p2p::{ClientDropGuard, NetworkInterface, PeerSetRequest, PeerSetResponse};
 use cuprate_p2p_core::{
     client::{Client, InternalPeerID},
     ClearNet, NetworkZone, PeerRequest, ProtocolRequest,
@@ -19,7 +20,17 @@ use crate::{p2p::CrossNetworkInternalPeerId, txpool::dandelion::DandelionTx};
 
 /// The dandelion outbound peer stream.
 pub struct OutboundPeerStream {
-    pub clear_net: NetworkInterface<ClearNet>,
+    clear_net: NetworkInterface<ClearNet>,
+    state: OutboundPeerStreamState,
+}
+
+impl OutboundPeerStream {
+    pub const fn new(clear_net: NetworkInterface<ClearNet>) -> Self {
+        Self {
+            clear_net,
+            state: OutboundPeerStreamState::Standby,
+        }
+    }
 }
 
 impl Stream for OutboundPeerStream {
@@ -28,23 +39,49 @@ impl Stream for OutboundPeerStream {
         tower::BoxError,
     >;
 
-    fn poll_next(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        // TODO: make the outbound peer choice random.
+        loop {
-        Poll::Ready(Some(Ok(self
+            match &mut self.state {
-            .clear_net
+                OutboundPeerStreamState::Standby => {
-            .client_pool()
+                    let peer_set = self.clear_net.peer_set();
-            .outbound_client()
+                    let res = ready!(peer_set.poll_ready(cx));
-            .map_or(OutboundPeer::Exhausted, |client| {
+
-                OutboundPeer::Peer(
+                    self.state = OutboundPeerStreamState::AwaitingPeer(
-                    CrossNetworkInternalPeerId::ClearNet(client.info.id),
+                        peer_set.call(PeerSetRequest::StemPeer).boxed(),
-                    StemPeerService(client),
+                    );
-                )
+                }
-            }))))
+                OutboundPeerStreamState::AwaitingPeer(fut) => {
+                    let res = ready!(fut.poll_unpin(cx));
+
+                    return Poll::Ready(Some(res.map(|res| {
+                        let PeerSetResponse::StemPeer(stem_peer) = res else {
+                            unreachable!()
+                        };
+
+                        match stem_peer {
+                            Some(peer) => OutboundPeer::Peer(
+                                CrossNetworkInternalPeerId::ClearNet(peer.info.id),
+                                StemPeerService(peer),
+                            ),
+                            None => OutboundPeer::Exhausted,
+                        }
+                    })));
+                }
+            }
+        }
     }
 }
 
+/// The state of the [`OutboundPeerStream`].
+enum OutboundPeerStreamState {
+    /// Standby state.
+    Standby,
+    /// Awaiting a response from the peer-set.
+    AwaitingPeer(BoxFuture<'static, Result<PeerSetResponse<ClearNet>, tower::BoxError>>),
+}
+
 /// The stem service, used to send stem txs.
-pub struct StemPeerService<N: NetworkZone>(ClientPoolDropGuard<N>);
+pub struct StemPeerService<N: NetworkZone>(ClientDropGuard<N>);
 
 impl<N: NetworkZone> Service<StemRequest<DandelionTx>> for StemPeerService<N> {
     type Response = <Client<N> as Service<PeerRequest>>::Response;

books/architecture/src/SUMMARY.md

@@ -143,9 +143,16 @@
 
 ---
 
-- [⚪️ Benchmarking](benchmarking/intro.md)
+- [🟢 Benchmarking](benchmarking/intro.md)
-    - [⚪️ Criterion](benchmarking/criterion.md)
+    - [🟢 Criterion](benchmarking/criterion/intro.md)
-    - [⚪️ Harness](benchmarking/harness.md)
+        - [🟢 Creating](benchmarking/criterion/creating.md)
+        - [🟢 Running](benchmarking/criterion/running.md)
+    - [🟢 `cuprate-benchmark`](benchmarking/cuprate/intro.md)
+        - [🟢 Creating](benchmarking/cuprate/creating.md)
+        - [🟢 Running](benchmarking/cuprate/running.md)
+
+---
+
 - [⚪️ Testing](testing/intro.md)
     - [⚪️ Monero data](testing/monero-data.md)
     - [⚪️ RPC client](testing/rpc-client.md)
@@ -157,6 +164,11 @@
 
 ---
 
+- [🟢 Monero oddities](oddities/intro.md)
+    - [🟡 Little-endian IPv4 addresses](oddities/le-ipv4.md)
+
+---
+
 - [⚪️ Appendix](appendix/intro.md)
     - [🟢 Crates](appendix/crates.md)
     - [🔴 Contributing](appendix/contributing.md)

books/architecture/src/appendix/crates.md

@@ -54,6 +54,11 @@ cargo doc --open --package cuprate-blockchain
 | [`cuprate-rpc-interface`](https://doc.cuprate.org/cuprate_rpc_interface) | [`rpc/interface/`](https://github.com/Cuprate/cuprate/tree/main/rpc/interface) | RPC interface & routing
 | [`cuprate-rpc-handler`](https://doc.cuprate.org/cuprate_rpc_handler) | [`rpc/handler/`](https://github.com/Cuprate/cuprate/tree/main/rpc/handler) | RPC inner handlers
 
+## ZMQ
+| Crate | In-tree path | Purpose |
+|-------|--------------|---------|
+| [`cuprate-zmq-types`](https://doc.cuprate.org/cuprate_zmq_types) | [`zmq/types/`](https://github.com/Cuprate/cuprate/tree/main/zmq/types) | Message types for ZMQ Pub/Sub interface
+
 ## 1-off crates
 | Crate | In-tree path | Purpose |
 |-------|--------------|---------|
@@ -63,3 +68,11 @@ cargo doc --open --package cuprate-blockchain
 | [`cuprate-helper`](https://doc.cuprate.org/cuprate_helper) | [`helper/`](https://github.com/Cuprate/cuprate/tree/main/helper) | Kitchen-sink helper crate for Cuprate
 | [`cuprate-test-utils`](https://doc.cuprate.org/cuprate_test_utils) | [`test-utils/`](https://github.com/Cuprate/cuprate/tree/main/test-utils) | Testing utilities for Cuprate
 | [`cuprate-types`](https://doc.cuprate.org/cuprate_types) | [`types/`](https://github.com/Cuprate/cuprate/tree/main/types) | Shared types across Cuprate
+
+## Benchmarks
+| Crate | In-tree path | Purpose |
+|-------|--------------|---------|
+| [`cuprate-benchmark`](https://doc.cuprate.org/cuprate_benchmark) | [`benches/benchmark/bin/`](https://github.com/Cuprate/cuprate/tree/main/benches/benchmark/bin) | Cuprate benchmarking binary
+| [`cuprate-benchmark-lib`](https://doc.cuprate.org/cuprate_benchmark_lib) | [`benches/benchmark/lib/`](https://github.com/Cuprate/cuprate/tree/main/benches/benchmark/lib) | Cuprate benchmarking library
+| `cuprate-benchmark-*` | [`benches/benchmark/cuprate-*`](https://github.com/Cuprate/cuprate/tree/main/benches/benchmark/) | Benchmark for a Cuprate crate that uses `cuprate-benchmark`
+| `cuprate-criterion-*` | [`benches/criterion/cuprate-*`](https://github.com/Cuprate/cuprate/tree/main/benches/criterion) | Benchmark for a Cuprate crate that uses [Criterion](https://bheisler.github.io/criterion.rs/book)

books/architecture/src/benchmarking/criterion.md

@@ -1 +0,0 @@
-# ⚪️ Criterion

books/architecture/src/benchmarking/criterion/creating.md

@@ -0,0 +1,21 @@
+# Creating
+Creating a new Criterion-based benchmarking crate for one of Cuprate's crates is relatively simple,
+although, it requires knowledge of how to use Criterion first:
+
+1. Read the `Getting Started` section of <https://bheisler.github.io/criterion.rs/book>
+2. Copy [`benches/criterion/example`](https://github.com/Cuprate/cuprate/tree/main/benches/criterion/example) as base
+3. Get started
+
+## Naming
+New benchmark crates using Criterion should:
+- Be in [`benches/criterion/`](https://github.com/Cuprate/cuprate/tree/main/benches/criterion/)
+- Be in the `cuprate-criterion-$CRATE_NAME` format
+
+For a real example, see:
+[`cuprate-criterion-json-rpc`](https://github.com/Cuprate/cuprate/tree/main/benches/criterion/cuprate-json-rpc).
+
+## Workspace
+Finally, make sure to add the benchmark crate to the workspace
+[`Cargo.toml`](https://github.com/Cuprate/cuprate/blob/main/Cargo.toml) file.
+
+Your benchmark is now ready to be ran.

books/architecture/src/benchmarking/criterion/intro.md

@@ -0,0 +1,4 @@
+# Criterion
+Each sub-directory in [`benches/criterion/`](https://github.com/Cuprate/cuprate/tree/main/benches/criterion) is a crate that uses [Criterion](https://bheisler.github.io/criterion.rs/book) for timing single functions and/or groups of functions.
+
+They are generally be small in scope.

books/architecture/src/benchmarking/criterion/running.md

@@ -0,0 +1,15 @@
+# Running
+To run all Criterion benchmarks, run this from the repository root:
+```bash
+cargo bench
+```
+
+To run specific package(s), use:
+```bash
+cargo bench --package $CRITERION_BENCHMARK_CRATE_NAME
+```
+
+For example:
+```bash
+cargo bench --package cuprate-criterion-json-rpc
+```

books/architecture/src/benchmarking/cuprate/creating.md

@@ -0,0 +1,57 @@
+# Creating
+New benchmarks are plugged into `cuprate-benchmark` by:
+1. Implementing `cuprate_benchmark_lib::Benchmark`
+1. Registering the benchmark in the `cuprate_benchmark` binary
+
+See [`benches/benchmark/example`](https://github.com/Cuprate/cuprate/tree/main/benches/benchmark/example)
+for an example.
+
+## Creating the benchmark crate
+Before plugging into `cuprate-benchmark`, your actual benchmark crate must be created:
+
+1. Create a new crate inside `benches/benchmark` (consider copying `benches/benchmark/example` as a base)
+1. Pull in `cuprate_benchmark_lib` as a dependency
+1. Create a benchmark
+1. Implement `cuprate_benchmark_lib::Benchmark`
+
+New benchmark crates using `cuprate-database` should:
+- Be in [`benches/benchmark/`](https://github.com/Cuprate/cuprate/tree/main/benches/benchmark/)
+- Be in the `cuprate-benchmark-$CRATE_NAME` format
+
+For a real example, see:
+[`cuprate-benchmark-database`](https://github.com/Cuprate/cuprate/tree/main/benches/benchmark/cuprate-database).
+
+## `cuprate_benchmark_lib::Benchmark`
+This is the trait that standardizes all benchmarks ran under `cuprate-benchmark`.
+
+It must be implemented by your benchmarking crate.
+
+See `cuprate-benchmark-lib` crate documentation for a user-guide: <https://doc.cuprate.org/cuprate_benchmark_lib>.
+
+## Adding a feature to `cuprate-benchmark`
+After your benchmark's behavior is defined, it must be registered
+in the binary that is actually ran: `cuprate-benchmark`.
+
+If your benchmark is new, add a new crate feature to [`cuprate-benchmark`'s Cargo.toml file](https://github.com/Cuprate/cuprate/tree/main/benches/benchmark/bin/Cargo.toml) with an optional dependency to your benchmarking crate.
+
+Please remember to edit the feature table in the
+[`README.md`](https://github.com/Cuprate/cuprate/tree/main/benches/benchmark/bin/README.md) as well!
+
+## Adding to `cuprate-benchmark`'s `main()`
+After adding your crate's feature, add a conditional line that run the benchmark
+if the feature is enabled to the `main()` function:
+
+For example, if your crate's name is `egg`:
+```rust
+cfg_if! {
+	if #[cfg(feature = "egg")] {
+		run::run_benchmark::<cuprate_benchmark_egg::Benchmark>(&mut timings);
+	}
+}
+```
+
+## Workspace
+Finally, make sure to add the benchmark crate to the workspace
+[`Cargo.toml`](https://github.com/Cuprate/cuprate/blob/main/Cargo.toml) file.
+
+Your benchmark is now ready to be ran.

books/architecture/src/benchmarking/cuprate/intro.md

@@ -0,0 +1,37 @@
+# cuprate-benchmark
+Cuprate has 2 custom crates for general benchmarking:
+- `cuprate-benchmark`; the actual binary crate ran
+- `cuprate-benchmark-lib`; the library that other crates hook into
+
+The abstract purpose of `cuprate-benchmark` is very simple:
+1. Set-up the benchmark
+1. Start timer
+1. Run benchmark
+1. Output data
+
+`cuprate-benchmark` runs the benchmarks found in [`benches/benchmark/cuprate-*`](https://github.com/Cuprate/cuprate/tree/main/benches/benchmark).
+
+`cuprate-benchmark-lib` defines the `Benchmark` trait that all
+benchmark crates implement to "plug-in" to the benchmarking harness.
+
+## Diagram
+A diagram displaying the relation between `cuprate-benchmark` and related crates.
+
+```
+                    ┌─────────────────────┐
+                    │ cuprate_benchmark   │
+                    │ (actual binary ran) │
+                    └──────────┬──────────┘
+            ┌──────────────────┴───────────────────┐
+            │ cuprate_benchmark_lib                │
+            │ ┌───────────────────────────────────┐│
+            │ │ trait Benchmark                   ││
+            │ └───────────────────────────────────┘│
+            └──────────────────┬───────────────────┘
+┌───────────────────────────┐  │   ┌───────────────────────────┐
+│ cuprate_benchmark_example ├──┼───┤ cuprate_benchmark_*       │
+└───────────────────────────┘  │   └───────────────────────────┘
+┌───────────────────────────┐  │   ┌───────────────────────────┐
+│ cuprate_benchmark_*       ├──┴───┤ cuprate_benchmark_*       │
+└───────────────────────────┘      └───────────────────────────┘
+```

books/architecture/src/benchmarking/cuprate/running.md

@@ -0,0 +1,16 @@
+# Running
+`cuprate-benchmark` benchmarks are ran with this command:
+```bash
+cargo run --release --package cuprate-benchmark --features $BENCHMARK_CRATE_FEATURE
+```
+
+For example, to run the example benchmark:
+```bash
+cargo run --release --package cuprate-benchmark --features example
+```
+
+Use the `all` feature to run all benchmarks:
+```bash
+# Run all benchmarks
+cargo run --release --package cuprate-benchmark --features all
+```

books/architecture/src/benchmarking/harness.md

@@ -1 +0,0 @@
-# ⚪️ Harness

books/architecture/src/benchmarking/intro.md

@@ -1 +1,22 @@
-# ⚪️ Benchmarking
+# Benchmarking
+Cuprate has 2 types of benchmarks:
+- [Criterion](https://bheisler.github.io/criterion.rs/book/user_guide/advanced_configuration.html) benchmarks
+- `cuprate-benchmark` benchmarks
+
+Criterion is used for micro benchmarks; they time single functions, groups of functions, and generally are small in scope.
+
+`cuprate-benchmark` and [`cuprate-benchmark-lib`](https://doc.cuprate.org/cuprate_benchmark_lib) are custom in-house crates Cuprate uses for macro benchmarks; these test sub-systems, sections of a sub-system, or otherwise larger or more complicated code that isn't well-suited for micro benchmarks.
+
+## File layout and purpose
+All benchmarking related files are in the [`benches/`](https://github.com/Cuprate/cuprate/tree/main/benches) folder.
+
+This directory is organized like such:
+
+| Directory                     | Purpose |
+|-------------------------------|---------|
+| [`benches/criterion/`](https://github.com/Cuprate/cuprate/tree/main/benches/criterion) | Criterion (micro) benchmarks
+| `benches/criterion/cuprate-*` | Criterion benchmarks for the crate with the same name
+| [`benches/benchmark/`](https://github.com/Cuprate/cuprate/tree/main/benches/benchmark) | Cuprate's custom benchmarking files
+| [`benches/benchmark/bin`](https://github.com/Cuprate/cuprate/tree/main/benches/benchmark/bin) | The `cuprate-benchmark` crate; the actual binary run that links all benchmarks
+| [`benches/benchmark/lib`](https://github.com/Cuprate/cuprate/tree/main/benches/benchmark/lib) | The `cuprate-benchmark-lib` crate; the benchmarking framework all benchmarks plug into
+| `benches/benchmark/cuprate-*` | `cuprate-benchmark` benchmarks for the crate with the same name

books/architecture/src/oddities/intro.md

@@ -0,0 +1,37 @@
+# Monero oddities
+This section is a list of any peculiar, interesting,
+or non-standard behavior that Monero has that is not
+planned on being changed or deprecated.
+
+This section exists to hold all the small yet noteworthy knowledge in one place,
+instead of in any single contributor's mind.
+
+These are usually behaviors stemming from implementation rather than protocol/cryptography.
+
+## Formatting
+This is the markdown formatting for each entry in this section.
+
+If applicable, consider using this formatting when adding to this section.
+
+```md
+# <concise_title_of_the_behavior>
+
+## What
+A detailed description of the behavior.
+
+## Expected
+The norm or standard behavior that is usually expected.
+
+## Why
+The reasoning behind why this behavior exists and/or
+any links to more detailed discussion on the behavior.
+
+## Affects
+A (potentially non-exhaustive) list of places that this behavior can/does affect.
+
+## Example
+An example link or section of code where the behavior occurs.
+
+## Source
+A link to original `monerod` code that defines the behavior.
+```

books/architecture/src/oddities/le-ipv4.md

@@ -0,0 +1,24 @@
+# Little-endian IPv4 addresses
+
+## What
+Monero encodes IPv4 addresses in [little-endian](https://en.wikipedia.org/wiki/Endianness) byte order.
+
+## Expected
+In general, [networking-related protocols/code use _networking order_ (big-endian)](https://en.wikipedia.org/wiki/Endianness#Networking).
+
+## Why
+TODO
+
+- <https://github.com/monero-project/monero/issues/3826>
+- <https://github.com/monero-project/monero/pull/5544>
+
+## Affects
+Any representation and (de)serialization of IPv4 addresses must keep little
+endian in-mind, e.g. the P2P wire format or `int` encoded IPv4 addresses in RPC.
+
+For example, [the `ip` field in `set_bans`](https://www.getmonero.org/resources/developer-guides/daemon-rpc.html#set_bans).
+
+For Cuprate, this means Rust's [`Ipv4Addr::from_bits/from`](https://doc.rust-lang.org/1.82.0/src/core/net/ip_addr.rs.html#1182) cannot be used in these cases as [it assumes big-endian encoding](https://doc.rust-lang.org/1.82.0/src/core/net/ip_addr.rs.html#540).
+
+## Source
+- <https://github.com/monero-project/monero/blob/893916ad091a92e765ce3241b94e706ad012b62a/contrib/epee/include/net/net_utils_base.h#L97>

consensus/context/src/difficulty.rs

@@ -328,8 +328,8 @@ fn next_difficulty(
         time_span = 1;
     }
 
-    // TODO: do checked operations here and unwrap so we don't silently overflow?
+    // TODO: do `checked_mul` here and unwrap so we don't silently overflow?
-    (windowed_work * u128::from(hf.block_time().as_secs()) + time_span - 1) / time_span
+    (windowed_work * u128::from(hf.block_time().as_secs())).div_ceil(time_span)
 }
 
 /// Get the start and end of the window to calculate difficulty.

consensus/fast-sync/src/create.rs

@@ -9,7 +9,7 @@ use clap::Parser;
 use tower::{Service, ServiceExt};
 
 use cuprate_blockchain::{
-    config::ConfigBuilder, cuprate_database::RuntimeError, service::BlockchainReadHandle,
+    config::ConfigBuilder, cuprate_database::DbResult, service::BlockchainReadHandle,
 };
 use cuprate_types::{
     blockchain::{BlockchainReadRequest, BlockchainResponse},
@@ -23,7 +23,7 @@ const BATCH_SIZE: usize = 512;
 async fn read_batch(
     handle: &mut BlockchainReadHandle,
     height_from: usize,
-) -> Result<Vec<BlockId>, RuntimeError> {
+) -> DbResult<Vec<BlockId>> {
     let mut block_ids = Vec::<BlockId>::with_capacity(BATCH_SIZE);
 
     for height in height_from..(height_from + BATCH_SIZE) {

cryptonight/src/util.rs

@@ -49,7 +49,7 @@ pub(crate) fn subarray_copy<T: AsRef<[U]> + ?Sized, U: Copy, const LEN: usize>(
 /// A mutable reference to a fixed-size subarray of type `[U; LEN]`.
 ///
 /// # Panics
-/// Panics if `start + LEN > array.as_ref().len()`.
+/// Panics if `start + LEN > array.as_mut().len()`.
 #[inline]
 pub(crate) fn subarray_mut<T: AsMut<[U]> + ?Sized, U, const LEN: usize>(
     array: &mut T,

net/epee-encoding/src/macros.rs

@@ -76,14 +76,14 @@ macro_rules! epee_object {
     // All this does is return the second (right) arg if present otherwise the left is returned.
     (
         @internal_try_right_then_left
-        $a:expr, $b:expr
+        $a:expr_2021, $b:expr_2021
     ) => {
         $b
     };
 
     (
         @internal_try_right_then_left
-        $a:expr,
+        $a:expr_2021,
     ) => {
         $a
     };
@@ -122,7 +122,7 @@ macro_rules! epee_object {
     // ------------------------------------------------------------------------ Entry Point
     (
         $obj:ident,
-        $($field: ident $(($alt_name: literal))?: $ty:ty $(as $ty_as:ty )? $(= $default:expr)?  $(=> $read_fn:expr, $write_fn:expr, $should_write_fn:expr)?, )*
+        $($field: ident $(($alt_name: literal))?: $ty:ty $(as $ty_as:ty )? $(= $default:expr_2021)?  $(=> $read_fn:expr_2021, $write_fn:expr_2021, $should_write_fn:expr_2021)?, )*
         $(!flatten: $flat_field: ident: $flat_ty:ty ,)*
 
     ) => {

net/wire/src/network_address.rs

@@ -17,10 +17,12 @@
 //! Monero network. Core Monero has 4 main addresses: IPv4, IPv6, Tor,
 //! I2p. Currently this module only has IPv(4/6).
 //!
-use bytes::BufMut;
-use cuprate_epee_encoding::EpeeObject;
 use std::{hash::Hash, net, net::SocketAddr};
 
+use bytes::BufMut;
+
+use cuprate_epee_encoding::EpeeObject;
+
 mod epee_builder;
 use epee_builder::*;
 

net/wire/src/network_address/epee_builder.rs

@@ -1,9 +1,10 @@
-use bytes::Buf;
 use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6};
 
-use cuprate_epee_encoding::{epee_object, EpeeObjectBuilder};
+use bytes::Buf;
 use thiserror::Error;
 
+use cuprate_epee_encoding::{epee_object, EpeeObjectBuilder};
+
 use crate::NetworkAddress;
 
 #[derive(Default)]
@@ -77,7 +78,7 @@ impl From<NetworkAddress> for TaggedNetworkAddress {
                 SocketAddr::V4(addr) => Self {
                     ty: Some(1),
                     addr: Some(AllFieldsNetworkAddress {
-                        m_ip: Some(u32::from_be_bytes(addr.ip().octets())),
+                        m_ip: Some(u32::from_le_bytes(addr.ip().octets())),
                         m_port: Some(addr.port()),
                         addr: None,
                     }),
@@ -112,7 +113,10 @@ epee_object!(
 impl AllFieldsNetworkAddress {
     fn try_into_network_address(self, ty: u8) -> Option<NetworkAddress> {
         Some(match ty {
-            1 => NetworkAddress::from(SocketAddrV4::new(Ipv4Addr::from(self.m_ip?), self.m_port?)),
+            1 => NetworkAddress::from(SocketAddrV4::new(
+                Ipv4Addr::from(self.m_ip?.to_le_bytes()),
+                self.m_port?,
+            )),
             2 => NetworkAddress::from(SocketAddrV6::new(
                 Ipv6Addr::from(self.addr?),
                 self.m_port?,

p2p/async-buffer/src/lib.rs

@@ -157,7 +157,7 @@ pub struct BufferSinkSend<'a, T> {
     item: Option<T>,
 }
 
-impl<'a, T> Future for BufferSinkSend<'a, T> {
+impl<T> Future for BufferSinkSend<'_, T> {
     type Output = Result<(), BufferError>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
@@ -183,7 +183,7 @@ pub struct BufferSinkReady<'a, T> {
     size_needed: usize,
 }
 
-impl<'a, T> Future for BufferSinkReady<'a, T> {
+impl<T> Future for BufferSinkReady<'_, T> {
     type Output = ();
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

p2p/dandelion-tower/src/tests/mod.rs

@@ -12,6 +12,7 @@ use crate::{
     OutboundPeer, State,
 };
 
+#[expect(clippy::type_complexity)]
 pub(crate) fn mock_discover_svc<Req: Send + 'static>() -> (
     impl Stream<
         Item = Result<

p2p/p2p-core/src/client.rs

@@ -27,9 +27,11 @@ mod connector;
 pub mod handshaker;
 mod request_handler;
 mod timeout_monitor;
+mod weak;
 
 pub use connector::{ConnectRequest, Connector};
 pub use handshaker::{DoHandshakeRequest, HandshakeError, HandshakerBuilder};
+pub use weak::WeakClient;
 
 /// An internal identifier for a given peer, will be their address if known
 /// or a random u128 if not.
@@ -128,6 +130,17 @@ impl<Z: NetworkZone> Client<Z> {
         }
         .into()
     }
+
+    /// Create a [`WeakClient`] for this [`Client`].
+    pub fn downgrade(&self) -> WeakClient<Z> {
+        WeakClient {
+            info: self.info.clone(),
+            connection_tx: self.connection_tx.downgrade(),
+            semaphore: self.semaphore.clone(),
+            permit: None,
+            error: self.error.clone(),
+        }
+    }
 }
 
 impl<Z: NetworkZone> Service<PeerRequest> for Client<Z> {

p2p/p2p-core/src/client/weak.rs

@@ -0,0 +1,114 @@
+use std::task::{ready, Context, Poll};
+
+use futures::channel::oneshot;
+use tokio::sync::{mpsc, OwnedSemaphorePermit};
+use tokio_util::sync::PollSemaphore;
+use tower::Service;
+
+use cuprate_helper::asynch::InfallibleOneshotReceiver;
+
+use crate::{
+    client::{connection, PeerInformation},
+    NetworkZone, PeerError, PeerRequest, PeerResponse, SharedError,
+};
+
+/// A weak handle to a [`Client`](super::Client).
+///
+/// When this is dropped the peer will not be disconnected.
+pub struct WeakClient<N: NetworkZone> {
+    /// Information on the connected peer.
+    pub info: PeerInformation<N::Addr>,
+
+    /// The channel to the [`Connection`](connection::Connection) task.
+    pub(super) connection_tx: mpsc::WeakSender<connection::ConnectionTaskRequest>,
+
+    /// The semaphore that limits the requests sent to the peer.
+    pub(super) semaphore: PollSemaphore,
+    /// A permit for the semaphore, will be [`Some`] after `poll_ready` returns ready.
+    pub(super) permit: Option<OwnedSemaphorePermit>,
+
+    /// The error slot shared between the [`Client`] and [`Connection`](connection::Connection).
+    pub(super) error: SharedError<PeerError>,
+}
+
+impl<N: NetworkZone> WeakClient<N> {
+    /// Internal function to set an error on the [`SharedError`].
+    fn set_err(&self, err: PeerError) -> tower::BoxError {
+        let err_str = err.to_string();
+        match self.error.try_insert_err(err) {
+            Ok(()) => err_str,
+            Err(e) => e.to_string(),
+        }
+        .into()
+    }
+}
+
+impl<Z: NetworkZone> Service<PeerRequest> for WeakClient<Z> {
+    type Response = PeerResponse;
+    type Error = tower::BoxError;
+    type Future = InfallibleOneshotReceiver<Result<Self::Response, Self::Error>>;
+
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        if let Some(err) = self.error.try_get_err() {
+            return Poll::Ready(Err(err.to_string().into()));
+        }
+
+        if self.connection_tx.strong_count() == 0 {
+            let err = self.set_err(PeerError::ClientChannelClosed);
+            return Poll::Ready(Err(err));
+        }
+
+        if self.permit.is_some() {
+            return Poll::Ready(Ok(()));
+        }
+
+        let permit = ready!(self.semaphore.poll_acquire(cx))
+            .expect("Client semaphore should not be closed!");
+
+        self.permit = Some(permit);
+
+        Poll::Ready(Ok(()))
+    }
+
+    #[expect(clippy::significant_drop_tightening)]
+    fn call(&mut self, request: PeerRequest) -> Self::Future {
+        let permit = self
+            .permit
+            .take()
+            .expect("poll_ready did not return ready before call to call");
+
+        let (tx, rx) = oneshot::channel();
+        let req = connection::ConnectionTaskRequest {
+            response_channel: tx,
+            request,
+            permit: Some(permit),
+        };
+
+        match self.connection_tx.upgrade() {
+            None => {
+                self.set_err(PeerError::ClientChannelClosed);
+
+                let resp = Err(PeerError::ClientChannelClosed.into());
+                drop(req.response_channel.send(resp));
+            }
+            Some(sender) => {
+                if let Err(e) = sender.try_send(req) {
+                    // The connection task could have closed between a call to `poll_ready` and the call to
+                    // `call`, which means if we don't handle the error here the receiver would panic.
+                    use mpsc::error::TrySendError;
+
+                    match e {
+                        TrySendError::Closed(req) | TrySendError::Full(req) => {
+                            self.set_err(PeerError::ClientChannelClosed);
+
+                            let resp = Err(PeerError::ClientChannelClosed.into());
+                            drop(req.response_channel.send(resp));
+                        }
+                    }
+                }
+            }
+        }
+
+        rx.into()
+    }
+}

p2p/p2p-core/src/lib.rs

@@ -121,7 +121,6 @@ pub trait NetZoneAddress:
     ///
     /// - TODO: IP zone banning?
     /// - TODO: rename this to Host.
-
     type BanID: Debug + Hash + Eq + Clone + Copy + Send + 'static;
 
     /// Changes the port of this address to `port`.

p2p/p2p/Cargo.toml

@@ -20,12 +20,12 @@ monero-serai = { workspace = true, features = ["std"] }
 
 tower = { workspace = true, features = ["buffer"] }
 tokio = { workspace = true, features = ["rt", "rt-multi-thread"] }
-rayon = { workspace = true }
 tokio-util = { workspace = true }
+rayon = { workspace = true }
 tokio-stream = { workspace = true, features = ["sync", "time"] }
 futures = { workspace = true, features = ["std"] }
 pin-project = { workspace = true }
-dashmap = { workspace = true }
+indexmap = { workspace = true, features = ["std"] }
 
 thiserror = { workspace = true }
 bytes = { workspace = true, features = ["std"] }

p2p/p2p/src/block_downloader.rs

@@ -8,7 +8,6 @@
 use std::{
     cmp::{max, min, Reverse},
     collections::{BTreeMap, BinaryHeap},
-    sync::Arc,
     time::Duration,
 };
 
@@ -18,7 +17,7 @@ use tokio::{
     task::JoinSet,
     time::{interval, timeout, MissedTickBehavior},
 };
-use tower::{Service, ServiceExt};
+use tower::{util::BoxCloneService, Service, ServiceExt};
 use tracing::{instrument, Instrument, Span};
 
 use cuprate_async_buffer::{BufferAppender, BufferStream};
@@ -27,11 +26,11 @@ use cuprate_p2p_core::{handles::ConnectionHandle, NetworkZone};
 use cuprate_pruning::PruningSeed;
 
 use crate::{
-    client_pool::{ClientPool, ClientPoolDropGuard},
     constants::{
         BLOCK_DOWNLOADER_REQUEST_TIMEOUT, EMPTY_CHAIN_ENTRIES_BEFORE_TOP_ASSUMED, LONG_BAN,
         MAX_BLOCK_BATCH_LEN, MAX_DOWNLOAD_FAILURES,
     },
+    peer_set::ClientDropGuard,
 };
 
 mod block_queue;
@@ -41,6 +40,7 @@ mod request_chain;
 #[cfg(test)]
 mod tests;
 
+use crate::peer_set::{PeerSetRequest, PeerSetResponse};
 use block_queue::{BlockQueue, ReadyQueueBatch};
 use chain_tracker::{BlocksToRetrieve, ChainEntry, ChainTracker};
 use download_batch::download_batch_task;
@@ -135,7 +135,7 @@ pub enum ChainSvcResponse {
 /// call this function again, so it can start the search again.
 #[instrument(level = "error", skip_all, name = "block_downloader")]
 pub fn download_blocks<N: NetworkZone, C>(
-    client_pool: Arc<ClientPool<N>>,
+    peer_set: BoxCloneService<PeerSetRequest, PeerSetResponse<N>, tower::BoxError>,
     our_chain_svc: C,
     config: BlockDownloaderConfig,
 ) -> BufferStream<BlockBatch>
@@ -147,8 +147,7 @@ where
 {
     let (buffer_appender, buffer_stream) = cuprate_async_buffer::new_buffer(config.buffer_bytes);
 
-    let block_downloader =
+    let block_downloader = BlockDownloader::new(peer_set, our_chain_svc, buffer_appender, config);
-        BlockDownloader::new(client_pool, our_chain_svc, buffer_appender, config);
 
     tokio::spawn(
         block_downloader
@@ -186,8 +185,8 @@ where
 /// - download an already requested batch of blocks (this might happen due to an error in the previous request
 ///   or because the queue of ready blocks is too large, so we need the oldest block to clear it).
 struct BlockDownloader<N: NetworkZone, C> {
-    /// The client pool.
+    /// The peer set.
-    client_pool: Arc<ClientPool<N>>,
+    peer_set: BoxCloneService<PeerSetRequest, PeerSetResponse<N>, tower::BoxError>,
 
     /// The service that holds our current chain state.
     our_chain_svc: C,
@@ -208,7 +207,7 @@ struct BlockDownloader<N: NetworkZone, C> {
     ///
     /// Returns a result of the chain entry or an error.
     #[expect(clippy::type_complexity)]
-    chain_entry_task: JoinSet<Result<(ClientPoolDropGuard<N>, ChainEntry<N>), BlockDownloadError>>,
+    chain_entry_task: JoinSet<Result<(ClientDropGuard<N>, ChainEntry<N>), BlockDownloadError>>,
 
     /// The current inflight requests.
     ///
@@ -235,13 +234,13 @@ where
 {
     /// Creates a new [`BlockDownloader`]
     fn new(
-        client_pool: Arc<ClientPool<N>>,
+        peer_set: BoxCloneService<PeerSetRequest, PeerSetResponse<N>, tower::BoxError>,
         our_chain_svc: C,
         buffer_appender: BufferAppender<BlockBatch>,
         config: BlockDownloaderConfig,
     ) -> Self {
         Self {
-            client_pool,
+            peer_set,
             our_chain_svc,
             amount_of_blocks_to_request: config.initial_batch_len,
             amount_of_blocks_to_request_updated_at: 0,
@@ -259,7 +258,7 @@ where
     fn check_pending_peers(
         &mut self,
         chain_tracker: &mut ChainTracker<N>,
-        pending_peers: &mut BTreeMap<PruningSeed, Vec<ClientPoolDropGuard<N>>>,
+        pending_peers: &mut BTreeMap<PruningSeed, Vec<ClientDropGuard<N>>>,
     ) {
         tracing::debug!("Checking if we can give any work to pending peers.");
 
@@ -286,11 +285,11 @@ where
     /// This function will find the batch(es) that we are waiting on to clear our ready queue and sends another request
     /// for them.
     ///
-    /// Returns the [`ClientPoolDropGuard`] back if it doesn't have the batch according to its pruning seed.
+    /// Returns the [`ClientDropGuard`] back if it doesn't have the batch according to its pruning seed.
     fn request_inflight_batch_again(
         &mut self,
-        client: ClientPoolDropGuard<N>,
+        client: ClientDropGuard<N>,
-    ) -> Option<ClientPoolDropGuard<N>> {
+    ) -> Option<ClientDropGuard<N>> {
         tracing::debug!(
             "Requesting an inflight batch, current ready queue size: {}",
             self.block_queue.size()
@@ -336,13 +335,13 @@ where
     ///
     /// The batch requested will depend on our current state, failed batches will be prioritised.
     ///
-    /// Returns the [`ClientPoolDropGuard`] back if it doesn't have the data we currently need according
+    /// Returns the [`ClientDropGuard`] back if it doesn't have the data we currently need according
     /// to its pruning seed.
     fn request_block_batch(
         &mut self,
         chain_tracker: &mut ChainTracker<N>,
-        client: ClientPoolDropGuard<N>,
+        client: ClientDropGuard<N>,
-    ) -> Option<ClientPoolDropGuard<N>> {
+    ) -> Option<ClientDropGuard<N>> {
         tracing::trace!("Using peer to request a batch of blocks.");
         // First look to see if we have any failed requests.
         while let Some(failed_request) = self.failed_batches.peek() {
@@ -416,13 +415,13 @@ where
     /// This function will use our current state to decide if we should send a request for a chain entry
     /// or if we should request a batch of blocks.
     ///
-    /// Returns the [`ClientPoolDropGuard`] back if it doesn't have the data we currently need according
+    /// Returns the [`ClientDropGuard`] back if it doesn't have the data we currently need according
     /// to its pruning seed.
     fn try_handle_free_client(
         &mut self,
         chain_tracker: &mut ChainTracker<N>,
-        client: ClientPoolDropGuard<N>,
+        client: ClientDropGuard<N>,
-    ) -> Option<ClientPoolDropGuard<N>> {
+    ) -> Option<ClientDropGuard<N>> {
         // We send 2 requests, so if one of them is slow or doesn't have the next chain, we still have a backup.
         if self.chain_entry_task.len() < 2
             // If we have had too many failures then assume the tip has been found so no more chain entries.
@@ -463,7 +462,7 @@ where
     async fn check_for_free_clients(
         &mut self,
         chain_tracker: &mut ChainTracker<N>,
-        pending_peers: &mut BTreeMap<PruningSeed, Vec<ClientPoolDropGuard<N>>>,
+        pending_peers: &mut BTreeMap<PruningSeed, Vec<ClientDropGuard<N>>>,
     ) -> Result<(), BlockDownloadError> {
         tracing::debug!("Checking for free peers");
 
@@ -478,10 +477,19 @@ where
             panic!("Chain service returned wrong response.");
         };
 
-        for client in self
+        let PeerSetResponse::PeersWithMorePoW(clients) = self
-            .client_pool
+            .peer_set
-            .clients_with_more_cumulative_difficulty(current_cumulative_difficulty)
+            .ready()
-        {
+            .await?
+            .call(PeerSetRequest::PeersWithMorePoW(
+                current_cumulative_difficulty,
+            ))
+            .await?
+        else {
+            unreachable!();
+        };
+
+        for client in clients {
             pending_peers
                 .entry(client.info.pruning_seed)
                 .or_default()
@@ -497,9 +505,9 @@ where
     async fn handle_download_batch_res(
         &mut self,
         start_height: usize,
-        res: Result<(ClientPoolDropGuard<N>, BlockBatch), BlockDownloadError>,
+        res: Result<(ClientDropGuard<N>, BlockBatch), BlockDownloadError>,
         chain_tracker: &mut ChainTracker<N>,
-        pending_peers: &mut BTreeMap<PruningSeed, Vec<ClientPoolDropGuard<N>>>,
+        pending_peers: &mut BTreeMap<PruningSeed, Vec<ClientDropGuard<N>>>,
     ) -> Result<(), BlockDownloadError> {
         tracing::debug!("Handling block download response");
 
@@ -593,7 +601,7 @@ where
     /// Starts the main loop of the block downloader.
     async fn run(mut self) -> Result<(), BlockDownloadError> {
         let mut chain_tracker =
-            initial_chain_search(&self.client_pool, &mut self.our_chain_svc).await?;
+            initial_chain_search(&mut self.peer_set, &mut self.our_chain_svc).await?;
 
         let mut pending_peers = BTreeMap::new();
 
@@ -662,7 +670,7 @@ struct BlockDownloadTaskResponse<N: NetworkZone> {
     /// The start height of the batch.
     start_height: usize,
     /// A result containing the batch or an error.
-    result: Result<(ClientPoolDropGuard<N>, BlockBatch), BlockDownloadError>,
+    result: Result<(ClientDropGuard<N>, BlockBatch), BlockDownloadError>,
 }
 
 /// Returns if a peer has all the blocks in a range, according to its [`PruningSeed`].

p2p/p2p/src/block_downloader/download_batch.rs

@@ -16,8 +16,8 @@ use cuprate_wire::protocol::{GetObjectsRequest, GetObjectsResponse};
 
 use crate::{
     block_downloader::{BlockBatch, BlockDownloadError, BlockDownloadTaskResponse},
-    client_pool::ClientPoolDropGuard,
     constants::{BLOCK_DOWNLOADER_REQUEST_TIMEOUT, MAX_TRANSACTION_BLOB_SIZE, MEDIUM_BAN},
+    peer_set::ClientDropGuard,
 };
 
 /// Attempts to request a batch of blocks from a peer, returning [`BlockDownloadTaskResponse`].
@@ -32,7 +32,7 @@ use crate::{
 )]
 #[expect(clippy::used_underscore_binding)]
 pub async fn download_batch_task<N: NetworkZone>(
-    client: ClientPoolDropGuard<N>,
+    client: ClientDropGuard<N>,
     ids: ByteArrayVec<32>,
     previous_id: [u8; 32],
     expected_start_height: usize,
@@ -49,11 +49,11 @@ pub async fn download_batch_task<N: NetworkZone>(
 /// This function will validate the blocks that were downloaded were the ones asked for and that they match
 /// the expected height.
 async fn request_batch_from_peer<N: NetworkZone>(
-    mut client: ClientPoolDropGuard<N>,
+    mut client: ClientDropGuard<N>,
     ids: ByteArrayVec<32>,
     previous_id: [u8; 32],
     expected_start_height: usize,
-) -> Result<(ClientPoolDropGuard<N>, BlockBatch), BlockDownloadError> {
+) -> Result<(ClientDropGuard<N>, BlockBatch), BlockDownloadError> {
     let request = PeerRequest::Protocol(ProtocolRequest::GetObjects(GetObjectsRequest {
         blocks: ids.clone(),
         pruned: false,
@@ -146,9 +146,9 @@ fn deserialize_batch(
 
             // Check the height lines up as expected.
             // This must happen after the hash check.
-            if !block
+            if block
                 .number()
-                .is_some_and(|height| height == expected_height)
+                .is_none_or(|height| height != expected_height)
             {
                 tracing::warn!(
                     "Invalid chain, expected height: {expected_height}, got height: {:?}",

p2p/p2p/src/block_downloader/request_chain.rs

@@ -1,7 +1,7 @@
-use std::{mem, sync::Arc};
+use std::mem;
 
 use tokio::{task::JoinSet, time::timeout};
-use tower::{Service, ServiceExt};
+use tower::{util::BoxCloneService, Service, ServiceExt};
 use tracing::{instrument, Instrument, Span};
 
 use cuprate_p2p_core::{
@@ -15,11 +15,11 @@ use crate::{
         chain_tracker::{ChainEntry, ChainTracker},
         BlockDownloadError, ChainSvcRequest, ChainSvcResponse,
     },
-    client_pool::{ClientPool, ClientPoolDropGuard},
     constants::{
         BLOCK_DOWNLOADER_REQUEST_TIMEOUT, INITIAL_CHAIN_REQUESTS_TO_SEND,
         MAX_BLOCKS_IDS_IN_CHAIN_ENTRY, MEDIUM_BAN,
     },
+    peer_set::{ClientDropGuard, PeerSetRequest, PeerSetResponse},
 };
 
 /// Request a chain entry from a peer.
@@ -27,9 +27,9 @@ use crate::{
 /// Because the block downloader only follows and downloads one chain we only have to send the block hash of
 /// top block we have found and the genesis block, this is then called `short_history`.
 pub(crate) async fn request_chain_entry_from_peer<N: NetworkZone>(
-    mut client: ClientPoolDropGuard<N>,
+    mut client: ClientDropGuard<N>,
     short_history: [[u8; 32]; 2],
-) -> Result<(ClientPoolDropGuard<N>, ChainEntry<N>), BlockDownloadError> {
+) -> Result<(ClientDropGuard<N>, ChainEntry<N>), BlockDownloadError> {
     let PeerResponse::Protocol(ProtocolResponse::GetChain(chain_res)) = client
         .ready()
         .await?
@@ -80,7 +80,7 @@ pub(crate) async fn request_chain_entry_from_peer<N: NetworkZone>(
 /// We then wait for their response and choose the peer who claims the highest cumulative difficulty.
 #[instrument(level = "error", skip_all)]
 pub async fn initial_chain_search<N: NetworkZone, C>(
-    client_pool: &Arc<ClientPool<N>>,
+    peer_set: &mut BoxCloneService<PeerSetRequest, PeerSetResponse<N>, tower::BoxError>,
     mut our_chain_svc: C,
 ) -> Result<ChainTracker<N>, BlockDownloadError>
 where
@@ -102,9 +102,15 @@ where
 
     let our_genesis = *block_ids.last().expect("Blockchain had no genesis block.");
 
-    let mut peers = client_pool
+    let PeerSetResponse::PeersWithMorePoW(clients) = peer_set
-        .clients_with_more_cumulative_difficulty(cumulative_difficulty)
+        .ready()
-        .into_iter();
+        .await?
+        .call(PeerSetRequest::PeersWithMorePoW(cumulative_difficulty))
+        .await?
+    else {
+        unreachable!();
+    };
+    let mut peers = clients.into_iter();
 
     let mut futs = JoinSet::new();
 

p2p/p2p/src/block_downloader/tests.rs

@@ -14,8 +14,8 @@ use monero_serai::{
     transaction::{Input, Timelock, Transaction, TransactionPrefix},
 };
 use proptest::{collection::vec, prelude::*};
-use tokio::time::timeout;
+use tokio::{sync::mpsc, time::timeout};
-use tower::{service_fn, Service};
+use tower::{buffer::Buffer, service_fn, Service, ServiceExt};
 
 use cuprate_fixed_bytes::ByteArrayVec;
 use cuprate_p2p_core::{
@@ -31,7 +31,7 @@ use cuprate_wire::{
 
 use crate::{
     block_downloader::{download_blocks, BlockDownloaderConfig, ChainSvcRequest, ChainSvcResponse},
-    client_pool::ClientPool,
+    peer_set::PeerSet,
 };
 
 proptest! {
@@ -48,19 +48,20 @@ proptest! {
 
         let tokio_pool = tokio::runtime::Builder::new_multi_thread().enable_all().build().unwrap();
 
-        #[expect(clippy::significant_drop_tightening)]
         tokio_pool.block_on(async move {
             timeout(Duration::from_secs(600), async move {
-                let client_pool = ClientPool::new();
+                let (new_connection_tx, new_connection_rx) = mpsc::channel(peers);
+
+                let peer_set = PeerSet::new(new_connection_rx);
 
                 for _ in 0..peers {
                     let client = mock_block_downloader_client(Arc::clone(&blockchain));
 
-                    client_pool.add_new_client(client);
+                    new_connection_tx.try_send(client).unwrap();
                 }
 
                 let stream = download_blocks(
-                    client_pool,
+                    Buffer::new(peer_set, 10).boxed_clone(),
                     OurChainSvc {
                         genesis: *blockchain.blocks.first().unwrap().0
                     },

p2p/p2p/src/broadcast.rs

@@ -57,6 +57,7 @@ impl Default for BroadcastConfig {
 /// - The [`BroadcastSvc`]
 /// - A function that takes in [`InternalPeerID`]s and produces [`BroadcastMessageStream`]s to give to **outbound** peers.
 /// - A function that takes in [`InternalPeerID`]s and produces [`BroadcastMessageStream`]s to give to **inbound** peers.
+#[expect(clippy::type_complexity)]
 pub(crate) fn init_broadcast_channels<N: NetworkZone>(
     config: BroadcastConfig,
 ) -> (

p2p/p2p/src/client_pool.rs

@@ -1,188 +0,0 @@
-//! # Client Pool.
-//!
-//! The [`ClientPool`], is a pool of currently connected peers that can be pulled from.
-//! It does _not_ necessarily contain every connected peer as another place could have
-//! taken a peer from the pool.
-//!
-//! When taking peers from the pool they are wrapped in [`ClientPoolDropGuard`], which
-//! returns the peer to the pool when it is dropped.
-//!
-//! Internally the pool is a [`DashMap`] which means care should be taken in `async` code
-//! as internally this uses blocking `RwLock`s.
-use std::sync::Arc;
-
-use dashmap::DashMap;
-use tokio::sync::mpsc;
-use tracing::{Instrument, Span};
-
-use cuprate_p2p_core::{
-    client::{Client, InternalPeerID},
-    handles::ConnectionHandle,
-    ConnectionDirection, NetworkZone,
-};
-
-pub(crate) mod disconnect_monitor;
-mod drop_guard_client;
-
-pub use drop_guard_client::ClientPoolDropGuard;
-
-/// The client pool, which holds currently connected free peers.
-///
-/// See the [module docs](self) for more.
-pub struct ClientPool<N: NetworkZone> {
-    /// The connected [`Client`]s.
-    clients: DashMap<InternalPeerID<N::Addr>, Client<N>>,
-    /// A channel to send new peer ids down to monitor for disconnect.
-    new_connection_tx: mpsc::UnboundedSender<(ConnectionHandle, InternalPeerID<N::Addr>)>,
-}
-
-impl<N: NetworkZone> ClientPool<N> {
-    /// Returns a new [`ClientPool`] wrapped in an [`Arc`].
-    pub fn new() -> Arc<Self> {
-        let (tx, rx) = mpsc::unbounded_channel();
-
-        let pool = Arc::new(Self {
-            clients: DashMap::new(),
-            new_connection_tx: tx,
-        });
-
-        tokio::spawn(
-            disconnect_monitor::disconnect_monitor(rx, Arc::clone(&pool))
-                .instrument(Span::current()),
-        );
-
-        pool
-    }
-
-    /// Adds a [`Client`] to the pool, the client must have previously been taken from the
-    /// pool.
-    ///
-    /// See [`ClientPool::add_new_client`] to add a [`Client`] which was not taken from the pool before.
-    ///
-    /// # Panics
-    /// This function panics if `client` already exists in the pool.
-    fn add_client(&self, client: Client<N>) {
-        let handle = client.info.handle.clone();
-        let id = client.info.id;
-
-        // Fast path: if the client is disconnected don't add it to the peer set.
-        if handle.is_closed() {
-            return;
-        }
-
-        assert!(self.clients.insert(id, client).is_none());
-
-        // We have to check this again otherwise we could have a race condition where a
-        // peer is disconnected after the first check, the disconnect monitor tries to remove it,
-        // and then it is added to the pool.
-        if handle.is_closed() {
-            self.remove_client(&id);
-        }
-    }
-
-    /// Adds a _new_ [`Client`] to the pool, this client should be a new connection, and not already
-    /// from the pool.
-    ///
-    /// # Panics
-    /// This function panics if `client` already exists in the pool.
-    pub fn add_new_client(&self, client: Client<N>) {
-        self.new_connection_tx
-            .send((client.info.handle.clone(), client.info.id))
-            .unwrap();
-
-        self.add_client(client);
-    }
-
-    /// Remove a [`Client`] from the pool.
-    ///
-    /// [`None`] is returned if the client did not exist in the pool.
-    fn remove_client(&self, peer: &InternalPeerID<N::Addr>) -> Option<Client<N>> {
-        self.clients.remove(peer).map(|(_, client)| client)
-    }
-
-    /// Borrows a [`Client`] from the pool.
-    ///
-    /// The [`Client`] is wrapped in [`ClientPoolDropGuard`] which
-    /// will return the client to the pool when it's dropped.
-    ///
-    /// See [`Self::borrow_clients`] for borrowing multiple clients.
-    pub fn borrow_client(
-        self: &Arc<Self>,
-        peer: &InternalPeerID<N::Addr>,
-    ) -> Option<ClientPoolDropGuard<N>> {
-        self.remove_client(peer).map(|client| ClientPoolDropGuard {
-            pool: Arc::clone(self),
-            client: Some(client),
-        })
-    }
-
-    /// Borrows multiple [`Client`]s from the pool.
-    ///
-    /// Note that the returned iterator is not guaranteed to contain every peer asked for.
-    ///
-    /// See [`Self::borrow_client`] for borrowing a single client.
-    pub fn borrow_clients<'a, 'b>(
-        self: &'a Arc<Self>,
-        peers: &'b [InternalPeerID<N::Addr>],
-    ) -> impl Iterator<Item = ClientPoolDropGuard<N>> + sealed::Captures<(&'a (), &'b ())> {
-        peers.iter().filter_map(|peer| self.borrow_client(peer))
-    }
-
-    /// Borrows all [`Client`]s from the pool that have claimed a higher cumulative difficulty than
-    /// the amount passed in.
-    ///
-    /// The [`Client`]s are wrapped in [`ClientPoolDropGuard`] which
-    /// will return the clients to the pool when they are dropped.
-    pub fn clients_with_more_cumulative_difficulty(
-        self: &Arc<Self>,
-        cumulative_difficulty: u128,
-    ) -> Vec<ClientPoolDropGuard<N>> {
-        let peers = self
-            .clients
-            .iter()
-            .filter_map(|element| {
-                let peer_sync_info = element.value().info.core_sync_data.lock().unwrap();
-
-                if peer_sync_info.cumulative_difficulty() > cumulative_difficulty {
-                    Some(*element.key())
-                } else {
-                    None
-                }
-            })
-            .collect::<Vec<_>>();
-
-        self.borrow_clients(&peers).collect()
-    }
-
-    /// Checks all clients in the pool checking if any claim a higher cumulative difficulty than the
-    /// amount specified.
-    pub fn contains_client_with_more_cumulative_difficulty(
-        &self,
-        cumulative_difficulty: u128,
-    ) -> bool {
-        self.clients.iter().any(|element| {
-            let sync_data = element.value().info.core_sync_data.lock().unwrap();
-            sync_data.cumulative_difficulty() > cumulative_difficulty
-        })
-    }
-
-    /// Returns the first outbound peer when iterating over the peers.
-    pub fn outbound_client(self: &Arc<Self>) -> Option<ClientPoolDropGuard<N>> {
-        let client = self
-            .clients
-            .iter()
-            .find(|element| element.value().info.direction == ConnectionDirection::Outbound)?;
-        let id = *client.key();
-
-        Some(self.borrow_client(&id).unwrap())
-    }
-}
-
-mod sealed {
-    /// TODO: Remove me when 2024 Rust
-    ///
-    /// <https://rust-lang.github.io/rfcs/3498-lifetime-capture-rules-2024.html#the-captures-trick>
-    pub trait Captures<U> {}
-
-    impl<T: ?Sized, U> Captures<U> for T {}
-}

p2p/p2p/src/client_pool/disconnect_monitor.rs

@@ -1,83 +0,0 @@
-//! # Disconnect Monitor
-//!
-//! This module contains the [`disconnect_monitor`] task, which monitors connected peers for disconnection
-//! and then removes them from the [`ClientPool`] if they do.
-use std::{
-    future::Future,
-    pin::Pin,
-    sync::Arc,
-    task::{Context, Poll},
-};
-
-use futures::{stream::FuturesUnordered, StreamExt};
-use tokio::sync::mpsc;
-use tokio_util::sync::WaitForCancellationFutureOwned;
-use tracing::instrument;
-
-use cuprate_p2p_core::{client::InternalPeerID, handles::ConnectionHandle, NetworkZone};
-
-use super::ClientPool;
-
-/// The disconnect monitor task.
-#[instrument(level = "info", skip_all)]
-pub async fn disconnect_monitor<N: NetworkZone>(
-    mut new_connection_rx: mpsc::UnboundedReceiver<(ConnectionHandle, InternalPeerID<N::Addr>)>,
-    client_pool: Arc<ClientPool<N>>,
-) {
-    // We need to hold a weak reference otherwise the client pool and this would hold a reference to
-    // each other causing the pool to be leaked.
-    let weak_client_pool = Arc::downgrade(&client_pool);
-    drop(client_pool);
-
-    tracing::info!("Starting peer disconnect monitor.");
-
-    let mut futs: FuturesUnordered<PeerDisconnectFut<N>> = FuturesUnordered::new();
-
-    loop {
-        tokio::select! {
-            Some((con_handle, peer_id)) = new_connection_rx.recv() => {
-                tracing::debug!("Monitoring {peer_id} for disconnect");
-                futs.push(PeerDisconnectFut {
-                    closed_fut: con_handle.closed(),
-                    peer_id: Some(peer_id),
-                });
-            }
-            Some(peer_id) = futs.next() => {
-                tracing::debug!("{peer_id} has disconnected, removing from client pool.");
-                let Some(pool) = weak_client_pool.upgrade() else {
-                    tracing::info!("Peer disconnect monitor shutting down.");
-                    return;
-                };
-
-                pool.remove_client(&peer_id);
-                drop(pool);
-            }
-            else => {
-                tracing::info!("Peer disconnect monitor shutting down.");
-                return;
-            }
-        }
-    }
-}
-
-/// A [`Future`] that resolves when a peer disconnects.
-#[pin_project::pin_project]
-pub(crate) struct PeerDisconnectFut<N: NetworkZone> {
-    /// The inner [`Future`] that resolves when a peer disconnects.
-    #[pin]
-    pub(crate) closed_fut: WaitForCancellationFutureOwned,
-    /// The peers ID.
-    pub(crate) peer_id: Option<InternalPeerID<N::Addr>>,
-}
-
-impl<N: NetworkZone> Future for PeerDisconnectFut<N> {
-    type Output = InternalPeerID<N::Addr>;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.project();
-
-        this.closed_fut
-            .poll(cx)
-            .map(|()| this.peer_id.take().unwrap())
-    }
-}

p2p/p2p/src/client_pool/drop_guard_client.rs

@@ -1,41 +0,0 @@
-use std::{
-    ops::{Deref, DerefMut},
-    sync::Arc,
-};
-
-use cuprate_p2p_core::{client::Client, NetworkZone};
-
-use crate::client_pool::ClientPool;
-
-/// A wrapper around [`Client`] which returns the client to the [`ClientPool`] when dropped.
-pub struct ClientPoolDropGuard<N: NetworkZone> {
-    /// The [`ClientPool`] to return the peer to.
-    pub(super) pool: Arc<ClientPool<N>>,
-    /// The [`Client`].
-    ///
-    /// This is set to [`Some`] when this guard is created, then
-    /// [`take`](Option::take)n and returned to the pool when dropped.
-    pub(super) client: Option<Client<N>>,
-}
-
-impl<N: NetworkZone> Deref for ClientPoolDropGuard<N> {
-    type Target = Client<N>;
-
-    fn deref(&self) -> &Self::Target {
-        self.client.as_ref().unwrap()
-    }
-}
-
-impl<N: NetworkZone> DerefMut for ClientPoolDropGuard<N> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        self.client.as_mut().unwrap()
-    }
-}
-
-impl<N: NetworkZone> Drop for ClientPoolDropGuard<N> {
-    fn drop(&mut self) {
-        let client = self.client.take().unwrap();
-
-        self.pool.add_client(client);
-    }
-}

p2p/p2p/src/connection_maintainer.rs

@@ -21,7 +21,6 @@ use cuprate_p2p_core::{
 };
 
 use crate::{
-    client_pool::ClientPool,
     config::P2PConfig,
     constants::{HANDSHAKE_TIMEOUT, MAX_SEED_CONNECTIONS, OUTBOUND_CONNECTION_ATTEMPT_TIMEOUT},
 };
@@ -46,7 +45,7 @@ pub struct MakeConnectionRequest {
 /// This handles maintaining a minimum number of connections and making extra connections when needed, upto a maximum.
 pub struct OutboundConnectionKeeper<N: NetworkZone, A, C> {
     /// The pool of currently connected peers.
-    pub client_pool: Arc<ClientPool<N>>,
+    pub new_peers_tx: mpsc::Sender<Client<N>>,
     /// The channel that tells us to make new _extra_ outbound connections.
     pub make_connection_rx: mpsc::Receiver<MakeConnectionRequest>,
     /// The address book service
@@ -77,7 +76,7 @@ where
 {
     pub fn new(
         config: P2PConfig<N>,
-        client_pool: Arc<ClientPool<N>>,
+        new_peers_tx: mpsc::Sender<Client<N>>,
         make_connection_rx: mpsc::Receiver<MakeConnectionRequest>,
         address_book_svc: A,
         connector_svc: C,
@@ -86,7 +85,7 @@ where
             .expect("Gray peer percent is incorrect should be 0..=1");
 
         Self {
-            client_pool,
+            new_peers_tx,
             make_connection_rx,
             address_book_svc,
             connector_svc,
@@ -149,7 +148,7 @@ where
     /// Connects to a given outbound peer.
     #[instrument(level = "info", skip_all)]
     async fn connect_to_outbound_peer(&mut self, permit: OwnedSemaphorePermit, addr: N::Addr) {
-        let client_pool = Arc::clone(&self.client_pool);
+        let new_peers_tx = self.new_peers_tx.clone();
         let connection_fut = self
             .connector_svc
             .ready()
@@ -164,7 +163,7 @@ where
             async move {
                 #[expect(clippy::significant_drop_in_scrutinee)]
                 if let Ok(Ok(peer)) = timeout(HANDSHAKE_TIMEOUT, connection_fut).await {
-                    client_pool.add_new_client(peer);
+                    drop(new_peers_tx.send(peer).await);
                 }
             }
             .instrument(Span::current()),

p2p/p2p/src/inbound_server.rs

@@ -6,7 +6,7 @@ use std::{pin::pin, sync::Arc};
 
 use futures::{SinkExt, StreamExt};
 use tokio::{
-    sync::Semaphore,
+    sync::{mpsc, Semaphore},
     task::JoinSet,
     time::{sleep, timeout},
 };
@@ -24,7 +24,6 @@ use cuprate_wire::{
 };
 
 use crate::{
-    client_pool::ClientPool,
     constants::{
         HANDSHAKE_TIMEOUT, INBOUND_CONNECTION_COOL_DOWN, PING_REQUEST_CONCURRENCY,
         PING_REQUEST_TIMEOUT,
@@ -36,7 +35,7 @@ use crate::{
 /// and initiate handshake if needed, after verifying the address isn't banned.
 #[instrument(level = "warn", skip_all)]
 pub async fn inbound_server<N, HS, A>(
-    client_pool: Arc<ClientPool<N>>,
+    new_connection_tx: mpsc::Sender<Client<N>>,
     mut handshaker: HS,
     mut address_book: A,
     config: P2PConfig<N>,
@@ -111,13 +110,13 @@ where
                 permit: Some(permit),
             });
 
-            let cloned_pool = Arc::clone(&client_pool);
+            let new_connection_tx = new_connection_tx.clone();
 
             tokio::spawn(
                 async move {
                     let client = timeout(HANDSHAKE_TIMEOUT, fut).await;
                     if let Ok(Ok(peer)) = client {
-                        cloned_pool.add_new_client(peer);
+                        drop(new_connection_tx.send(peer).await);
                     }
                 }
                 .instrument(Span::current()),

p2p/p2p/src/lib.rs

@@ -18,17 +18,18 @@ use cuprate_p2p_core::{
 
 pub mod block_downloader;
 mod broadcast;
-pub mod client_pool;
 pub mod config;
 pub mod connection_maintainer;
 pub mod constants;
 mod inbound_server;
+mod peer_set;
 
 use block_downloader::{BlockBatch, BlockDownloaderConfig, ChainSvcRequest, ChainSvcResponse};
 pub use broadcast::{BroadcastRequest, BroadcastSvc};
-pub use client_pool::{ClientPool, ClientPoolDropGuard};
 pub use config::{AddressBookConfig, P2PConfig};
 use connection_maintainer::MakeConnectionRequest;
+use peer_set::PeerSet;
+pub use peer_set::{ClientDropGuard, PeerSetRequest, PeerSetResponse};
 
 /// Initializes the P2P [`NetworkInterface`] for a specific [`NetworkZone`].
 ///
@@ -54,7 +55,10 @@ where
         cuprate_address_book::init_address_book(config.address_book_config.clone()).await?;
     let address_book = Buffer::new(
         address_book,
-        config.max_inbound_connections + config.outbound_connections,
+        config
+            .max_inbound_connections
+            .checked_add(config.outbound_connections)
+            .unwrap(),
     );
 
     // Use the default config. Changing the defaults affects tx fluff times, which could affect D++ so for now don't allow changing
@@ -83,19 +87,25 @@ where
 
     let outbound_handshaker = outbound_handshaker_builder.build();
 
-    let client_pool = ClientPool::new();
+    let (new_connection_tx, new_connection_rx) = mpsc::channel(
-
+        config
+            .outbound_connections
+            .checked_add(config.max_inbound_connections)
+            .unwrap(),
+    );
     let (make_connection_tx, make_connection_rx) = mpsc::channel(3);
 
     let outbound_connector = Connector::new(outbound_handshaker);
     let outbound_connection_maintainer = connection_maintainer::OutboundConnectionKeeper::new(
         config.clone(),
-        Arc::clone(&client_pool),
+        new_connection_tx.clone(),
         make_connection_rx,
         address_book.clone(),
         outbound_connector,
     );
 
+    let peer_set = PeerSet::new(new_connection_rx);
+
     let mut background_tasks = JoinSet::new();
 
     background_tasks.spawn(
@@ -105,7 +115,7 @@ where
     );
     background_tasks.spawn(
         inbound_server::inbound_server(
-            Arc::clone(&client_pool),
+            new_connection_tx,
             inbound_handshaker,
             address_book.clone(),
             config,
@@ -121,7 +131,7 @@ where
     );
 
     Ok(NetworkInterface {
-        pool: client_pool,
+        peer_set: Buffer::new(peer_set, 10).boxed_clone(),
         broadcast_svc,
         make_connection_tx,
         address_book: address_book.boxed_clone(),
@@ -133,7 +143,7 @@ where
 #[derive(Clone)]
 pub struct NetworkInterface<N: NetworkZone> {
     /// A pool of free connected peers.
-    pool: Arc<ClientPool<N>>,
+    peer_set: BoxCloneService<PeerSetRequest, PeerSetResponse<N>, tower::BoxError>,
     /// A [`Service`] that allows broadcasting to all connected peers.
     broadcast_svc: BroadcastSvc<N>,
     /// A channel to request extra connections.
@@ -163,7 +173,7 @@ impl<N: NetworkZone> NetworkInterface<N> {
             + 'static,
         C::Future: Send + 'static,
     {
-        block_downloader::download_blocks(Arc::clone(&self.pool), our_chain_service, config)
+        block_downloader::download_blocks(self.peer_set.clone(), our_chain_service, config)
     }
 
     /// Returns the address book service.
@@ -173,8 +183,10 @@ impl<N: NetworkZone> NetworkInterface<N> {
         self.address_book.clone()
     }
 
-    /// Borrows the `ClientPool`, for access to connected peers.
+    /// Borrows the `PeerSet`, for access to connected peers.
-    pub const fn client_pool(&self) -> &Arc<ClientPool<N>> {
+    pub fn peer_set(
-        &self.pool
+        &mut self,
+    ) -> &mut BoxCloneService<PeerSetRequest, PeerSetResponse<N>, tower::BoxError> {
+        &mut self.peer_set
     }
 }

p2p/p2p/src/peer_set.rs

@@ -0,0 +1,217 @@
+use std::{
+    future::{ready, Future, Ready},
+    pin::{pin, Pin},
+    task::{Context, Poll},
+};
+
+use futures::{stream::FuturesUnordered, StreamExt};
+use indexmap::{IndexMap, IndexSet};
+use rand::{seq::index::sample, thread_rng};
+use tokio::sync::mpsc::Receiver;
+use tokio_util::sync::WaitForCancellationFutureOwned;
+use tower::Service;
+
+use cuprate_helper::cast::u64_to_usize;
+use cuprate_p2p_core::{
+    client::{Client, InternalPeerID},
+    ConnectionDirection, NetworkZone,
+};
+
+mod client_wrappers;
+
+pub use client_wrappers::ClientDropGuard;
+use client_wrappers::StoredClient;
+
+/// A request to the peer-set.
+pub enum PeerSetRequest {
+    /// The most claimed proof-of-work from a peer in the peer-set.
+    MostPoWSeen,
+    /// Peers with more cumulative difficulty than the given cumulative difficulty.
+    ///
+    /// Returned peers will be remembered and won't be returned from subsequent calls until the guard is dropped.
+    PeersWithMorePoW(u128),
+    /// A random outbound peer.
+    ///
+    /// The returned peer will be remembered and won't be returned from subsequent calls until the guard is dropped.
+    StemPeer,
+}
+
+/// A response from the peer-set.
+pub enum PeerSetResponse<N: NetworkZone> {
+    /// [`PeerSetRequest::MostPoWSeen`]
+    MostPoWSeen {
+        /// The cumulative difficulty claimed.
+        cumulative_difficulty: u128,
+        /// The height claimed.
+        height: usize,
+        /// The claimed hash of the top block.
+        top_hash: [u8; 32],
+    },
+    /// [`PeerSetRequest::PeersWithMorePoW`]
+    ///
+    /// Returned peers will be remembered and won't be returned from subsequent calls until the guard is dropped.
+    PeersWithMorePoW(Vec<ClientDropGuard<N>>),
+    /// [`PeerSetRequest::StemPeer`]
+    ///
+    /// The returned peer will be remembered and won't be returned from subsequent calls until the guard is dropped.
+    StemPeer(Option<ClientDropGuard<N>>),
+}
+
+/// A [`Future`] that completes when a peer disconnects.
+#[pin_project::pin_project]
+struct ClosedConnectionFuture<N: NetworkZone> {
+    #[pin]
+    fut: WaitForCancellationFutureOwned,
+    id: Option<InternalPeerID<N::Addr>>,
+}
+
+impl<N: NetworkZone> Future for ClosedConnectionFuture<N> {
+    type Output = InternalPeerID<N::Addr>;
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.project();
+
+        this.fut.poll(cx).map(|()| this.id.take().unwrap())
+    }
+}
+
+/// A collection of all connected peers on a [`NetworkZone`].
+pub(crate) struct PeerSet<N: NetworkZone> {
+    /// The connected peers.
+    peers: IndexMap<InternalPeerID<N::Addr>, StoredClient<N>>,
+    /// A [`FuturesUnordered`] that resolves when a peer disconnects.
+    closed_connections: FuturesUnordered<ClosedConnectionFuture<N>>,
+    /// The [`InternalPeerID`]s of all outbound peers.
+    outbound_peers: IndexSet<InternalPeerID<N::Addr>>,
+    /// A channel of new peers from the inbound server or outbound connector.
+    new_peers: Receiver<Client<N>>,
+}
+
+impl<N: NetworkZone> PeerSet<N> {
+    pub(crate) fn new(new_peers: Receiver<Client<N>>) -> Self {
+        Self {
+            peers: IndexMap::new(),
+            closed_connections: FuturesUnordered::new(),
+            outbound_peers: IndexSet::new(),
+            new_peers,
+        }
+    }
+
+    /// Polls the new peers channel for newly connected peers.
+    fn poll_new_peers(&mut self, cx: &mut Context<'_>) {
+        while let Poll::Ready(Some(new_peer)) = self.new_peers.poll_recv(cx) {
+            if new_peer.info.direction == ConnectionDirection::Outbound {
+                self.outbound_peers.insert(new_peer.info.id);
+            }
+
+            self.closed_connections.push(ClosedConnectionFuture {
+                fut: new_peer.info.handle.closed(),
+                id: Some(new_peer.info.id),
+            });
+
+            self.peers
+                .insert(new_peer.info.id, StoredClient::new(new_peer));
+        }
+    }
+
+    /// Remove disconnected peers from the peer set.
+    fn remove_dead_peers(&mut self, cx: &mut Context<'_>) {
+        while let Poll::Ready(Some(dead_peer)) = self.closed_connections.poll_next_unpin(cx) {
+            let Some(peer) = self.peers.swap_remove(&dead_peer) else {
+                continue;
+            };
+
+            if peer.client.info.direction == ConnectionDirection::Outbound {
+                self.outbound_peers.swap_remove(&peer.client.info.id);
+            }
+
+            self.peers.swap_remove(&dead_peer);
+        }
+    }
+
+    /// [`PeerSetRequest::MostPoWSeen`]
+    fn most_pow_seen(&self) -> PeerSetResponse<N> {
+        let most_pow_chain = self
+            .peers
+            .values()
+            .map(|peer| {
+                let core_sync_data = peer.client.info.core_sync_data.lock().unwrap();
+
+                (
+                    core_sync_data.cumulative_difficulty(),
+                    u64_to_usize(core_sync_data.current_height),
+                    core_sync_data.top_id,
+                )
+            })
+            .max_by_key(|(cumulative_difficulty, ..)| *cumulative_difficulty)
+            .unwrap_or_default();
+
+        PeerSetResponse::MostPoWSeen {
+            cumulative_difficulty: most_pow_chain.0,
+            height: most_pow_chain.1,
+            top_hash: most_pow_chain.2,
+        }
+    }
+
+    /// [`PeerSetRequest::PeersWithMorePoW`]
+    fn peers_with_more_pow(&self, cumulative_difficulty: u128) -> PeerSetResponse<N> {
+        PeerSetResponse::PeersWithMorePoW(
+            self.peers
+                .values()
+                .filter(|&client| {
+                    !client.is_downloading_blocks()
+                        && client
+                            .client
+                            .info
+                            .core_sync_data
+                            .lock()
+                            .unwrap()
+                            .cumulative_difficulty()
+                            > cumulative_difficulty
+                })
+                .map(StoredClient::downloading_blocks_guard)
+                .collect(),
+        )
+    }
+
+    /// [`PeerSetRequest::StemPeer`]
+    fn random_peer_for_stem(&self) -> PeerSetResponse<N> {
+        PeerSetResponse::StemPeer(
+            sample(
+                &mut thread_rng(),
+                self.outbound_peers.len(),
+                self.outbound_peers.len(),
+            )
+            .into_iter()
+            .find_map(|i| {
+                let peer = self.outbound_peers.get_index(i).unwrap();
+                let client = self.peers.get(peer).unwrap();
+                (!client.is_a_stem_peer()).then(|| client.stem_peer_guard())
+            }),
+        )
+    }
+}
+
+impl<N: NetworkZone> Service<PeerSetRequest> for PeerSet<N> {
+    type Response = PeerSetResponse<N>;
+    type Error = tower::BoxError;
+    type Future = Ready<Result<Self::Response, Self::Error>>;
+
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.poll_new_peers(cx);
+        self.remove_dead_peers(cx);
+
+        // TODO: should we return `Pending` if we don't have any peers?
+
+        Poll::Ready(Ok(()))
+    }
+
+    fn call(&mut self, req: PeerSetRequest) -> Self::Future {
+        ready(match req {
+            PeerSetRequest::MostPoWSeen => Ok(self.most_pow_seen()),
+            PeerSetRequest::PeersWithMorePoW(cumulative_difficulty) => {
+                Ok(self.peers_with_more_pow(cumulative_difficulty))
+            }
+            PeerSetRequest::StemPeer => Ok(self.random_peer_for_stem()),
+        })
+    }
+}

p2p/p2p/src/peer_set/client_wrappers.rs

@@ -0,0 +1,86 @@
+use std::{
+    ops::{Deref, DerefMut},
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc,
+    },
+};
+
+use cuprate_p2p_core::{
+    client::{Client, WeakClient},
+    NetworkZone,
+};
+
+/// A client stored in the peer-set.
+pub(super) struct StoredClient<N: NetworkZone> {
+    pub client: Client<N>,
+    /// An [`AtomicBool`] for if the peer is currently downloading blocks.
+    downloading_blocks: Arc<AtomicBool>,
+    /// An [`AtomicBool`] for if the peer is currently being used to stem txs.
+    stem_peer: Arc<AtomicBool>,
+}
+
+impl<N: NetworkZone> StoredClient<N> {
+    pub(super) fn new(client: Client<N>) -> Self {
+        Self {
+            client,
+            downloading_blocks: Arc::new(AtomicBool::new(false)),
+            stem_peer: Arc::new(AtomicBool::new(false)),
+        }
+    }
+
+    /// Returns [`true`] if the [`StoredClient`] is currently downloading blocks.
+    pub(super) fn is_downloading_blocks(&self) -> bool {
+        self.downloading_blocks.load(Ordering::Relaxed)
+    }
+
+    /// Returns [`true`] if the [`StoredClient`] is currently being used to stem txs.
+    pub(super) fn is_a_stem_peer(&self) -> bool {
+        self.stem_peer.load(Ordering::Relaxed)
+    }
+
+    /// Returns a [`ClientDropGuard`] that while it is alive keeps the [`StoredClient`] in the downloading blocks state.
+    pub(super) fn downloading_blocks_guard(&self) -> ClientDropGuard<N> {
+        self.downloading_blocks.store(true, Ordering::Relaxed);
+
+        ClientDropGuard {
+            client: self.client.downgrade(),
+            bool: Arc::clone(&self.downloading_blocks),
+        }
+    }
+
+    /// Returns a [`ClientDropGuard`] that while it is alive keeps the [`StoredClient`] in the stemming peers state.
+    pub(super) fn stem_peer_guard(&self) -> ClientDropGuard<N> {
+        self.stem_peer.store(true, Ordering::Relaxed);
+
+        ClientDropGuard {
+            client: self.client.downgrade(),
+            bool: Arc::clone(&self.stem_peer),
+        }
+    }
+}
+
+/// A [`Drop`] guard for a client returned from the peer-set.
+pub struct ClientDropGuard<N: NetworkZone> {
+    client: WeakClient<N>,
+    bool: Arc<AtomicBool>,
+}
+
+impl<N: NetworkZone> Deref for ClientDropGuard<N> {
+    type Target = WeakClient<N>;
+    fn deref(&self) -> &Self::Target {
+        &self.client
+    }
+}
+
+impl<N: NetworkZone> DerefMut for ClientDropGuard<N> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.client
+    }
+}
+
+impl<N: NetworkZone> Drop for ClientDropGuard<N> {
+    fn drop(&mut self) {
+        self.bool.store(false, Ordering::Relaxed);
+    }
+}

pruning/src/lib.rs

@@ -327,7 +327,7 @@ impl DecompressedPruningSeed {
     ///
     /// This function will also error if `block_height` > `blockchain_height`
     ///
-    pub fn get_next_unpruned_block(
+    pub const fn get_next_unpruned_block(
         &self,
         block_height: usize,
         blockchain_height: usize,

rpc/interface/src/route/bin.rs

@@ -68,7 +68,7 @@ macro_rules! generate_endpoints_with_no_input {
 /// - [`generate_endpoints_with_input`]
 /// - [`generate_endpoints_with_no_input`]
 macro_rules! generate_endpoints_inner {
-    ($variant:ident, $handler:ident, $request:expr) => {
+    ($variant:ident, $handler:ident, $request:expr_2021) => {
         paste::paste! {
             {
                 // Check if restricted.

rpc/interface/src/route/other.rs

@@ -71,7 +71,7 @@ macro_rules! generate_endpoints_with_no_input {
 /// - [`generate_endpoints_with_input`]
 /// - [`generate_endpoints_with_no_input`]
 macro_rules! generate_endpoints_inner {
-    ($variant:ident, $handler:ident, $request:expr) => {
+    ($variant:ident, $handler:ident, $request:expr_2021) => {
         paste::paste! {
             {
                 // Check if restricted.

rpc/types/src/bin.rs

@@ -9,26 +9,19 @@ use cuprate_fixed_bytes::ByteArrayVec;
 use serde::{Deserialize, Serialize};
 
 #[cfg(feature = "epee")]
-use cuprate_epee_encoding::{
+use cuprate_epee_encoding::container_as_blob::ContainerAsBlob;
-    container_as_blob::ContainerAsBlob,
-    epee_object, error,
-    macros::bytes::{Buf, BufMut},
-    read_epee_value, write_field, EpeeObject, EpeeObjectBuilder,
-};
 
 use cuprate_types::BlockCompleteEntry;
 
 use crate::{
     base::AccessResponseBase,
-    macros::{define_request, define_request_and_response, define_request_and_response_doc},
+    macros::define_request_and_response,
-    misc::{BlockOutputIndices, GetOutputsOut, OutKeyBin, PoolTxInfo, Status},
+    misc::{BlockOutputIndices, GetOutputsOut, OutKeyBin, PoolInfo},
     rpc_call::RpcCallValue,
 };
 
 #[cfg(any(feature = "epee", feature = "serde"))]
 use crate::defaults::{default_false, default_zero};
-#[cfg(feature = "epee")]
-use crate::misc::PoolInfoExtent;
 
 //---------------------------------------------------------------------------------------------------- Definitions
 define_request_and_response! {
@@ -115,15 +108,14 @@ define_request_and_response! {
     }
 }
 
-//---------------------------------------------------------------------------------------------------- GetBlocks
+define_request_and_response! {
-define_request! {
-    #[doc = define_request_and_response_doc!(
-        "response" => GetBlocksResponse,
     get_blocksbin,
-        cc73fe71162d564ffda8e549b79a350bca53c454,
+    cc73fe71162d564ffda8e549b79a350bca53c454 =>
-        core_rpc_server_commands_defs, h, 162, 262,
+    core_rpc_server_commands_defs.h => 162..=262,
-    )]
+
-    GetBlocksRequest {
+    GetBlocks,
+
+    Request {
         requested_info: u8 = default_zero::<u8>(), "default_zero",
         // FIXME: This is a `std::list` in `monerod` because...?
         block_ids: ByteArrayVec<32>,
@@ -131,259 +123,17 @@ define_request! {
         prune: bool,
         no_miner_tx: bool = default_false(), "default_false",
         pool_info_since: u64 = default_zero::<u64>(), "default_zero",
-    }
+    },
-}
 
-#[doc = define_request_and_response_doc!(
+    // TODO: add `top_block_hash` field
-    "request" => GetBlocksRequest,
+    // <https://github.com/monero-project/monero/blame/893916ad091a92e765ce3241b94e706ad012b62a/src/rpc/core_rpc_server_commands_defs.h#L263>
-    get_blocksbin,
+    AccessResponseBase {
-    cc73fe71162d564ffda8e549b79a350bca53c454,
-    core_rpc_server_commands_defs, h, 162, 262,
-)]
-///
-/// This response's variant depends upon [`PoolInfoExtent`].
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum GetBlocksResponse {
-    /// Will always serialize a [`PoolInfoExtent::None`] field.
-    PoolInfoNone(GetBlocksResponsePoolInfoNone),
-    /// Will always serialize a [`PoolInfoExtent::Incremental`] field.
-    PoolInfoIncremental(GetBlocksResponsePoolInfoIncremental),
-    /// Will always serialize a [`PoolInfoExtent::Full`] field.
-    PoolInfoFull(GetBlocksResponsePoolInfoFull),
-}
-
-impl Default for GetBlocksResponse {
-    fn default() -> Self {
-        Self::PoolInfoNone(GetBlocksResponsePoolInfoNone::default())
-    }
-}
-
-/// Data within [`GetBlocksResponse::PoolInfoNone`].
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Clone, Default, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct GetBlocksResponsePoolInfoNone {
-    pub status: Status,
-    pub untrusted: bool,
-    pub blocks: Vec<BlockCompleteEntry>,
-    pub start_height: u64,
-    pub current_height: u64,
-    pub output_indices: Vec<BlockOutputIndices>,
-    pub daemon_time: u64,
-}
-
-#[cfg(feature = "epee")]
-epee_object! {
-    GetBlocksResponsePoolInfoNone,
-    status: Status,
-    untrusted: bool,
         blocks: Vec<BlockCompleteEntry>,
         start_height: u64,
         current_height: u64,
         output_indices: Vec<BlockOutputIndices>,
         daemon_time: u64,
-}
+        pool_info: PoolInfo,
-
-/// Data within [`GetBlocksResponse::PoolInfoIncremental`].
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Clone, Default, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct GetBlocksResponsePoolInfoIncremental {
-    pub status: Status,
-    pub untrusted: bool,
-    pub blocks: Vec<BlockCompleteEntry>,
-    pub start_height: u64,
-    pub current_height: u64,
-    pub output_indices: Vec<BlockOutputIndices>,
-    pub daemon_time: u64,
-    pub added_pool_txs: Vec<PoolTxInfo>,
-    pub remaining_added_pool_txids: ByteArrayVec<32>,
-    pub removed_pool_txids: ByteArrayVec<32>,
-}
-
-#[cfg(feature = "epee")]
-epee_object! {
-    GetBlocksResponsePoolInfoIncremental,
-    status: Status,
-    untrusted: bool,
-    blocks: Vec<BlockCompleteEntry>,
-    start_height: u64,
-    current_height: u64,
-    output_indices: Vec<BlockOutputIndices>,
-    daemon_time: u64,
-    added_pool_txs: Vec<PoolTxInfo>,
-    remaining_added_pool_txids: ByteArrayVec<32>,
-    removed_pool_txids: ByteArrayVec<32>,
-}
-
-/// Data within [`GetBlocksResponse::PoolInfoFull`].
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Clone, Default, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct GetBlocksResponsePoolInfoFull {
-    pub status: Status,
-    pub untrusted: bool,
-    pub blocks: Vec<BlockCompleteEntry>,
-    pub start_height: u64,
-    pub current_height: u64,
-    pub output_indices: Vec<BlockOutputIndices>,
-    pub daemon_time: u64,
-    pub added_pool_txs: Vec<PoolTxInfo>,
-    pub remaining_added_pool_txids: ByteArrayVec<32>,
-}
-
-#[cfg(feature = "epee")]
-epee_object! {
-    GetBlocksResponsePoolInfoFull,
-    status: Status,
-    untrusted: bool,
-    blocks: Vec<BlockCompleteEntry>,
-    start_height: u64,
-    current_height: u64,
-    output_indices: Vec<BlockOutputIndices>,
-    daemon_time: u64,
-    added_pool_txs: Vec<PoolTxInfo>,
-    remaining_added_pool_txids: ByteArrayVec<32>,
-}
-
-#[cfg(feature = "epee")]
-/// [`EpeeObjectBuilder`] for [`GetBlocksResponse`].
-///
-/// Not for public usage.
-#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub struct __GetBlocksResponseEpeeBuilder {
-    pub status: Option<Status>,
-    pub untrusted: Option<bool>,
-    pub blocks: Option<Vec<BlockCompleteEntry>>,
-    pub start_height: Option<u64>,
-    pub current_height: Option<u64>,
-    pub output_indices: Option<Vec<BlockOutputIndices>>,
-    pub daemon_time: Option<u64>,
-    pub pool_info_extent: Option<PoolInfoExtent>,
-    pub added_pool_txs: Option<Vec<PoolTxInfo>>,
-    pub remaining_added_pool_txids: Option<ByteArrayVec<32>>,
-    pub removed_pool_txids: Option<ByteArrayVec<32>>,
-}
-
-#[cfg(feature = "epee")]
-impl EpeeObjectBuilder<GetBlocksResponse> for __GetBlocksResponseEpeeBuilder {
-    fn add_field<B: Buf>(&mut self, name: &str, r: &mut B) -> error::Result<bool> {
-        macro_rules! read_epee_field {
-            ($($field:ident),*) => {
-                match name {
-                    $(
-                        stringify!($field) => { self.$field = Some(read_epee_value(r)?); },
-                    )*
-                    _ => return Ok(false),
-                }
-            };
-        }
-
-        read_epee_field! {
-            status,
-            untrusted,
-            blocks,
-            start_height,
-            current_height,
-            output_indices,
-            daemon_time,
-            pool_info_extent,
-            added_pool_txs,
-            remaining_added_pool_txids,
-            removed_pool_txids
-        }
-
-        Ok(true)
-    }
-
-    fn finish(self) -> error::Result<GetBlocksResponse> {
-        const ELSE: error::Error = error::Error::Format("Required field was not found!");
-
-        let status = self.status.ok_or(ELSE)?;
-        let untrusted = self.untrusted.ok_or(ELSE)?;
-        let blocks = self.blocks.ok_or(ELSE)?;
-        let start_height = self.start_height.ok_or(ELSE)?;
-        let current_height = self.current_height.ok_or(ELSE)?;
-        let output_indices = self.output_indices.ok_or(ELSE)?;
-        let daemon_time = self.daemon_time.ok_or(ELSE)?;
-        let pool_info_extent = self.pool_info_extent.ok_or(ELSE)?;
-
-        let this = match pool_info_extent {
-            PoolInfoExtent::None => {
-                GetBlocksResponse::PoolInfoNone(GetBlocksResponsePoolInfoNone {
-                    status,
-                    untrusted,
-                    blocks,
-                    start_height,
-                    current_height,
-                    output_indices,
-                    daemon_time,
-                })
-            }
-            PoolInfoExtent::Incremental => {
-                GetBlocksResponse::PoolInfoIncremental(GetBlocksResponsePoolInfoIncremental {
-                    status,
-                    untrusted,
-                    blocks,
-                    start_height,
-                    current_height,
-                    output_indices,
-                    daemon_time,
-                    added_pool_txs: self.added_pool_txs.ok_or(ELSE)?,
-                    remaining_added_pool_txids: self.remaining_added_pool_txids.ok_or(ELSE)?,
-                    removed_pool_txids: self.removed_pool_txids.ok_or(ELSE)?,
-                })
-            }
-            PoolInfoExtent::Full => {
-                GetBlocksResponse::PoolInfoFull(GetBlocksResponsePoolInfoFull {
-                    status,
-                    untrusted,
-                    blocks,
-                    start_height,
-                    current_height,
-                    output_indices,
-                    daemon_time,
-                    added_pool_txs: self.added_pool_txs.ok_or(ELSE)?,
-                    remaining_added_pool_txids: self.remaining_added_pool_txids.ok_or(ELSE)?,
-                })
-            }
-        };
-
-        Ok(this)
-    }
-}
-
-#[cfg(feature = "epee")]
-impl EpeeObject for GetBlocksResponse {
-    type Builder = __GetBlocksResponseEpeeBuilder;
-
-    fn number_of_fields(&self) -> u64 {
-        // [`PoolInfoExtent`] + inner struct fields.
-        let inner_fields = match self {
-            Self::PoolInfoNone(s) => s.number_of_fields(),
-            Self::PoolInfoIncremental(s) => s.number_of_fields(),
-            Self::PoolInfoFull(s) => s.number_of_fields(),
-        };
-
-        1 + inner_fields
-    }
-
-    fn write_fields<B: BufMut>(self, w: &mut B) -> error::Result<()> {
-        match self {
-            Self::PoolInfoNone(s) => {
-                s.write_fields(w)?;
-                write_field(PoolInfoExtent::None.to_u8(), "pool_info_extent", w)?;
-            }
-            Self::PoolInfoIncremental(s) => {
-                s.write_fields(w)?;
-                write_field(PoolInfoExtent::Incremental.to_u8(), "pool_info_extent", w)?;
-            }
-            Self::PoolInfoFull(s) => {
-                s.write_fields(w)?;
-                write_field(PoolInfoExtent::Full.to_u8(), "pool_info_extent", w)?;
-            }
-        }
-
-        Ok(())
     }
 }
 

rpc/types/src/json.rs

@@ -37,7 +37,7 @@ macro_rules! serde_doc_test {
     (
         // `const` string from `cuprate_test_utils::rpc::data`
         //  v
-        $cuprate_test_utils_rpc_const:ident => $expected:expr
+        $cuprate_test_utils_rpc_const:ident => $expected:expr_2021
         //                                     ^
         //                     Expected value as an expression
     ) => {

rpc/types/src/macros.rs

@@ -77,7 +77,7 @@ macro_rules! define_request_and_response {
                 $( #[$request_field_attr:meta] )* // Field attribute.
                 $request_field:ident: $request_field_type:ty // field_name: field type
                 $(as $request_field_type_as:ty)? // (optional) alternative type (de)serialization
-                $(= $request_field_type_default:expr, $request_field_type_default_string:literal)?, // (optional) default value
+                $(= $request_field_type_default:expr_2021, $request_field_type_default_string:literal)?, // (optional) default value
             )*
         },
 
@@ -89,7 +89,7 @@ macro_rules! define_request_and_response {
                 $( #[$response_field_attr:meta] )*
                 $response_field:ident: $response_field_type:ty
                 $(as $response_field_type_as:ty)?
-                $(= $response_field_type_default:expr, $response_field_type_default_string:literal)?,
+                $(= $response_field_type_default:expr_2021, $response_field_type_default_string:literal)?,
             )*
         }
     ) => { paste::paste! {
@@ -229,7 +229,7 @@ macro_rules! define_request {
                 // field_name: FieldType
                 $field:ident: $field_type:ty
                 $(as $field_as:ty)?
-                $(= $field_default:expr, $field_default_string:literal)?,
+                $(= $field_default:expr_2021, $field_default_string:literal)?,
                 // The $field_default is an optional extra token that represents
                 // a default value to pass to [`cuprate_epee_encoding::epee_object`],
                 // see it for usage.
@@ -286,7 +286,7 @@ macro_rules! define_response {
                 $( #[$field_attr:meta] )*
                 $field:ident: $field_type:ty
                 $(as $field_as:ty)?
-                $(= $field_default:expr, $field_default_string:literal)?,
+                $(= $field_default:expr_2021, $field_default_string:literal)?,
             )*
         }
     ) => {
@@ -323,7 +323,7 @@ macro_rules! define_response {
                 $( #[$field_attr:meta] )*
                 $field:ident: $field_type:ty
                 $(as $field_as:ty)?
-                $(= $field_default:expr, $field_default_string:literal)?,
+                $(= $field_default:expr_2021, $field_default_string:literal)?,
             )*
         }
     ) => {

rpc/types/src/misc/misc.rs

@@ -11,11 +11,11 @@ use serde::{Deserialize, Serialize};
 #[cfg(feature = "epee")]
 use cuprate_epee_encoding::epee_object;
 
-use crate::macros::monero_definition_link;
-
 #[cfg(any(feature = "epee", feature = "serde"))]
 use crate::defaults::default_zero;
 
+use crate::macros::monero_definition_link;
+
 //---------------------------------------------------------------------------------------------------- Macros
 /// This macro (local to this file) defines all the misc types.
 ///
@@ -37,7 +37,7 @@ macro_rules! define_struct_and_impl_epee {
             $(
                 $( #[$field_attr:meta] )* // Field attributes
                 // Field name => the type => optional `epee_object` default value.
-                $field_name:ident: $field_type:ty $(= $field_default:expr)?,
+                $field_name:ident: $field_type:ty $(= $field_default:expr_2021)?,
             )*
         }
     ) => {

rpc/types/src/misc/mod.rs

@@ -17,6 +17,7 @@ mod distribution;
 mod key_image_spent_status;
 #[expect(clippy::module_inception)]
 mod misc;
+mod pool_info;
 mod pool_info_extent;
 mod status;
 mod tx_entry;
@@ -30,6 +31,7 @@ pub use misc::{
     OutputDistributionData, Peer, PoolTxInfo, PublicNode, SetBan, Span, SpentKeyImageInfo,
     SyncInfoPeer, TxBacklogEntry, TxInfo, TxOutputIndices, TxpoolHisto, TxpoolStats,
 };
+pub use pool_info::PoolInfo;
 pub use pool_info_extent::PoolInfoExtent;
 pub use status::Status;
 pub use tx_entry::TxEntry;

rpc/types/src/misc/pool_info.rs

@@ -0,0 +1,171 @@
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
+#[cfg(feature = "epee")]
+use crate::misc::PoolInfoExtent;
+#[cfg(feature = "epee")]
+use cuprate_epee_encoding::{
+    epee_object, error,
+    macros::bytes::{Buf, BufMut},
+    read_epee_value, write_field, EpeeObject, EpeeObjectBuilder,
+};
+
+use cuprate_fixed_bytes::ByteArrayVec;
+
+use crate::misc::PoolTxInfo;
+
+//---------------------------------------------------------------------------------------------------- PoolInfo
+#[doc = crate::macros::monero_definition_link!(
+    cc73fe71162d564ffda8e549b79a350bca53c454,
+    "rpc/core_rpc_server_commands_defs.h",
+    223..=228
+)]
+/// Used in [`crate::bin::GetBlocksResponse`].
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[repr(u8)]
+pub enum PoolInfo {
+    #[default]
+    None,
+    Incremental(PoolInfoIncremental),
+    Full(PoolInfoFull),
+}
+
+//---------------------------------------------------------------------------------------------------- Internal data
+/// Data within [`PoolInfo::Incremental`].
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[derive(Clone, Default, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct PoolInfoIncremental {
+    pub added_pool_txs: Vec<PoolTxInfo>,
+    pub remaining_added_pool_txids: ByteArrayVec<32>,
+    pub removed_pool_txids: ByteArrayVec<32>,
+}
+
+#[cfg(feature = "epee")]
+epee_object! {
+    PoolInfoIncremental,
+    added_pool_txs: Vec<PoolTxInfo>,
+    remaining_added_pool_txids: ByteArrayVec<32>,
+    removed_pool_txids: ByteArrayVec<32>,
+}
+
+/// Data within [`PoolInfo::Full`].
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[derive(Clone, Default, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct PoolInfoFull {
+    pub added_pool_txs: Vec<PoolTxInfo>,
+    pub remaining_added_pool_txids: ByteArrayVec<32>,
+}
+
+#[cfg(feature = "epee")]
+epee_object! {
+    PoolInfoFull,
+    added_pool_txs: Vec<PoolTxInfo>,
+    remaining_added_pool_txids: ByteArrayVec<32>,
+}
+
+//---------------------------------------------------------------------------------------------------- PoolInfo epee impl
+#[cfg(feature = "epee")]
+/// [`EpeeObjectBuilder`] for [`GetBlocksResponse`].
+///
+/// Not for public usage.
+#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct __PoolInfoEpeeBuilder {
+    /// This is a distinct field in `monerod`,
+    /// which as represented in this library with [`PoolInfo`]'s `u8` tag.
+    pub pool_info_extent: Option<PoolInfoExtent>,
+
+    pub added_pool_txs: Option<Vec<PoolTxInfo>>,
+    pub remaining_added_pool_txids: Option<ByteArrayVec<32>>,
+    pub removed_pool_txids: Option<ByteArrayVec<32>>,
+}
+
+// Custom epee implementation.
+//
+// HACK/INVARIANT:
+// If any data within [`PoolInfo`] changes, the below code should be changed as well.
+#[cfg(feature = "epee")]
+impl EpeeObjectBuilder<PoolInfo> for __PoolInfoEpeeBuilder {
+    fn add_field<B: Buf>(&mut self, name: &str, r: &mut B) -> error::Result<bool> {
+        macro_rules! read_epee_field {
+            ($($field:ident),*) => {
+                match name {
+                    $(
+                        stringify!($field) => { self.$field = Some(read_epee_value(r)?); },
+                    )*
+                    _ => return Ok(false),
+                }
+            };
+        }
+
+        read_epee_field! {
+            pool_info_extent,
+            added_pool_txs,
+            remaining_added_pool_txids,
+            removed_pool_txids
+        }
+
+        Ok(true)
+    }
+
+    fn finish(self) -> error::Result<PoolInfo> {
+        // INVARIANT:
+        // `monerod` omits serializing the field itself when a container is empty,
+        // `unwrap_or_default()` is used over `error()` in these cases.
+        // Some of the uses are when values have default fallbacks: `pool_info_extent`.
+
+        let pool_info_extent = self.pool_info_extent.unwrap_or_default();
+        let this = match pool_info_extent {
+            PoolInfoExtent::None => PoolInfo::None,
+            PoolInfoExtent::Incremental => PoolInfo::Incremental(PoolInfoIncremental {
+                added_pool_txs: self.added_pool_txs.unwrap_or_default(),
+                remaining_added_pool_txids: self.remaining_added_pool_txids.unwrap_or_default(),
+                removed_pool_txids: self.removed_pool_txids.unwrap_or_default(),
+            }),
+            PoolInfoExtent::Full => PoolInfo::Full(PoolInfoFull {
+                added_pool_txs: self.added_pool_txs.unwrap_or_default(),
+                remaining_added_pool_txids: self.remaining_added_pool_txids.unwrap_or_default(),
+            }),
+        };
+
+        Ok(this)
+    }
+}
+
+#[cfg(feature = "epee")]
+impl EpeeObject for PoolInfo {
+    type Builder = __PoolInfoEpeeBuilder;
+
+    fn number_of_fields(&self) -> u64 {
+        // Inner struct fields.
+        let inner_fields = match self {
+            Self::None => 0,
+            Self::Incremental(s) => s.number_of_fields(),
+            Self::Full(s) => s.number_of_fields(),
+        };
+
+        // [`PoolInfoExtent`] + inner struct fields
+        1 + inner_fields
+    }
+
+    fn write_fields<B: BufMut>(self, w: &mut B) -> error::Result<()> {
+        const FIELD: &str = "pool_info_extent";
+
+        match self {
+            Self::None => {
+                write_field(PoolInfoExtent::None.to_u8(), FIELD, w)?;
+            }
+            Self::Incremental(s) => {
+                s.write_fields(w)?;
+                write_field(PoolInfoExtent::Incremental.to_u8(), FIELD, w)?;
+            }
+            Self::Full(s) => {
+                s.write_fields(w)?;
+                write_field(PoolInfoExtent::Full.to_u8(), FIELD, w)?;
+            }
+        }
+
+        Ok(())
+    }
+}

rpc/types/src/misc/tx_entry.rs

@@ -2,8 +2,6 @@
 
 //---------------------------------------------------------------------------------------------------- Use
 #[cfg(feature = "serde")]
-use crate::serde::{serde_false, serde_true};
-#[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
 #[cfg(feature = "epee")]
@@ -13,6 +11,9 @@ use cuprate_epee_encoding::{
     EpeeObject, EpeeObjectBuilder,
 };
 
+#[cfg(feature = "serde")]
+use crate::serde::{serde_false, serde_true};
+
 //---------------------------------------------------------------------------------------------------- TxEntry
 #[doc = crate::macros::monero_definition_link!(
     cc73fe71162d564ffda8e549b79a350bca53c454,

rpc/types/src/other.rs

@@ -65,7 +65,7 @@ macro_rules! serde_doc_test {
     (
         // `const` string from `cuprate_test_utils::rpc::data`
         //  v
-        $cuprate_test_utils_rpc_const:ident => $expected:expr
+        $cuprate_test_utils_rpc_const:ident => $expected:expr_2021
         //                                     ^
         //                     Expected value as an expression
     ) => {

storage/blockchain/src/ops/alt_block/block.rs

@@ -1,7 +1,7 @@
 use bytemuck::TransparentWrapper;
 use monero_serai::block::{Block, BlockHeader};
 
-use cuprate_database::{DatabaseRo, DatabaseRw, RuntimeError, StorableVec};
+use cuprate_database::{DatabaseRo, DatabaseRw, DbResult, StorableVec};
 use cuprate_helper::map::{combine_low_high_bits_to_u128, split_u128_into_low_high_bits};
 use cuprate_types::{AltBlockInformation, Chain, ChainId, ExtendedBlockHeader, HardFork};
 
@@ -21,7 +21,7 @@ use crate::{
 pub fn flush_alt_blocks<'a, E: cuprate_database::EnvInner<'a>>(
     env_inner: &E,
     tx_rw: &mut E::Rw<'_>,
-) -> Result<(), RuntimeError> {
+) -> DbResult<()> {
     use crate::tables::{
         AltBlockBlobs, AltBlockHeights, AltBlocksInfo, AltChainInfos, AltTransactionBlobs,
         AltTransactionInfos,
@@ -47,10 +47,7 @@ pub fn flush_alt_blocks<'a, E: cuprate_database::EnvInner<'a>>(
 /// - `alt_block.height` is == `0`
 /// - `alt_block.txs.len()` != `alt_block.block.transactions.len()`
 ///
-pub fn add_alt_block(
+pub fn add_alt_block(alt_block: &AltBlockInformation, tables: &mut impl TablesMut) -> DbResult<()> {
-    alt_block: &AltBlockInformation,
-    tables: &mut impl TablesMut,
-) -> Result<(), RuntimeError> {
     let alt_block_height = AltBlockHeight {
         chain_id: alt_block.chain_id.into(),
         height: alt_block.height,
@@ -100,7 +97,7 @@ pub fn add_alt_block(
 pub fn get_alt_block(
     alt_block_height: &AltBlockHeight,
     tables: &impl Tables,
-) -> Result<AltBlockInformation, RuntimeError> {
+) -> DbResult<AltBlockInformation> {
     let block_info = tables.alt_blocks_info().get(alt_block_height)?;
 
     let block_blob = tables.alt_block_blobs().get(alt_block_height)?.0;
@@ -111,7 +108,7 @@ pub fn get_alt_block(
         .transactions
         .iter()
         .map(|tx_hash| get_alt_transaction(tx_hash, tables))
-        .collect::<Result<_, RuntimeError>>()?;
+        .collect::<DbResult<_>>()?;
 
     Ok(AltBlockInformation {
         block,
@@ -141,7 +138,7 @@ pub fn get_alt_block_hash(
     block_height: &BlockHeight,
     alt_chain: ChainId,
     tables: &impl Tables,
-) -> Result<BlockHash, RuntimeError> {
+) -> DbResult<BlockHash> {
     let alt_chains = tables.alt_chain_infos();
 
     // First find what [`ChainId`] this block would be stored under.
@@ -188,7 +185,7 @@ pub fn get_alt_block_hash(
 pub fn get_alt_block_extended_header_from_height(
     height: &AltBlockHeight,
     table: &impl Tables,
-) -> Result<ExtendedBlockHeader, RuntimeError> {
+) -> DbResult<ExtendedBlockHeader> {
     let block_info = table.alt_blocks_info().get(height)?;
 
     let block_blob = table.alt_block_blobs().get(height)?.0;

storage/blockchain/src/ops/alt_block/chain.rs

@@ -1,6 +1,6 @@
 use std::cmp::{max, min};
 
-use cuprate_database::{DatabaseRo, DatabaseRw, RuntimeError};
+use cuprate_database::{DatabaseRo, DatabaseRw, DbResult, RuntimeError};
 use cuprate_types::{Chain, ChainId};
 
 use crate::{
@@ -21,7 +21,7 @@ pub fn update_alt_chain_info(
     alt_block_height: &AltBlockHeight,
     prev_hash: &BlockHash,
     tables: &mut impl TablesMut,
-) -> Result<(), RuntimeError> {
+) -> DbResult<()> {
     let parent_chain = match tables.alt_block_heights().get(prev_hash) {
         Ok(alt_parent_height) => Chain::Alt(alt_parent_height.chain_id.into()),
         Err(RuntimeError::KeyNotFound) => Chain::Main,
@@ -74,7 +74,7 @@ pub fn get_alt_chain_history_ranges(
     range: std::ops::Range<BlockHeight>,
     alt_chain: ChainId,
     alt_chain_infos: &impl DatabaseRo<AltChainInfos>,
-) -> Result<Vec<(Chain, std::ops::Range<BlockHeight>)>, RuntimeError> {
+) -> DbResult<Vec<(Chain, std::ops::Range<BlockHeight>)>> {
     let mut ranges = Vec::with_capacity(5);
 
     let mut i = range.end;

storage/blockchain/src/ops/alt_block/tx.rs

@@ -1,7 +1,7 @@
 use bytemuck::TransparentWrapper;
 use monero_serai::transaction::Transaction;
 
-use cuprate_database::{DatabaseRo, DatabaseRw, RuntimeError, StorableVec};
+use cuprate_database::{DatabaseRo, DatabaseRw, DbResult, RuntimeError, StorableVec};
 use cuprate_types::VerifiedTransactionInformation;
 
 use crate::{
@@ -22,7 +22,7 @@ use crate::{
 pub fn add_alt_transaction_blob(
     tx: &VerifiedTransactionInformation,
     tables: &mut impl TablesMut,
-) -> Result<(), RuntimeError> {
+) -> DbResult<()> {
     tables.alt_transaction_infos_mut().put(
         &tx.tx_hash,
         &AltTransactionInfo {
@@ -51,7 +51,7 @@ pub fn add_alt_transaction_blob(
 pub fn get_alt_transaction(
     tx_hash: &TxHash,
     tables: &impl Tables,
-) -> Result<VerifiedTransactionInformation, RuntimeError> {
+) -> DbResult<VerifiedTransactionInformation> {
     let tx_info = tables.alt_transaction_infos().get(tx_hash)?;
 
     let tx_blob = match tables.alt_transaction_blobs().get(tx_hash) {

storage/blockchain/src/ops/block.rs

@@ -8,7 +8,7 @@ use monero_serai::{
 };
 
 use cuprate_database::{
-    RuntimeError, StorableVec, {DatabaseRo, DatabaseRw},
+    DbResult, RuntimeError, StorableVec, {DatabaseRo, DatabaseRw},
 };
 use cuprate_helper::{
     map::{combine_low_high_bits_to_u128, split_u128_into_low_high_bits},
@@ -42,12 +42,9 @@ use crate::{
 /// # Panics
 /// This function will panic if:
 /// - `block.height > u32::MAX` (not normally possible)
-/// - `block.height` is not != [`chain_height`]
+/// - `block.height` is != [`chain_height`]
 // no inline, too big.
-pub fn add_block(
+pub fn add_block(block: &VerifiedBlockInformation, tables: &mut impl TablesMut) -> DbResult<()> {
-    block: &VerifiedBlockInformation,
-    tables: &mut impl TablesMut,
-) -> Result<(), RuntimeError> {
     //------------------------------------------------------ Check preconditions first
 
     // Cast height to `u32` for storage (handled at top of function).
@@ -153,7 +150,7 @@ pub fn add_block(
 pub fn pop_block(
     move_to_alt_chain: Option<ChainId>,
     tables: &mut impl TablesMut,
-) -> Result<(BlockHeight, BlockHash, Block), RuntimeError> {
+) -> DbResult<(BlockHeight, BlockHash, Block)> {
     //------------------------------------------------------ Block Info
     // Remove block data from tables.
     let (block_height, block_info) = tables.block_infos_mut().pop_last()?;
@@ -195,7 +192,7 @@ pub fn pop_block(
                     tx,
                 })
             })
-            .collect::<Result<Vec<VerifiedTransactionInformation>, RuntimeError>>()?;
+            .collect::<DbResult<Vec<VerifiedTransactionInformation>>>()?;
 
         alt_block::add_alt_block(
             &AltBlockInformation {
@@ -239,7 +236,7 @@ pub fn pop_block(
 pub fn get_block_extended_header(
     block_hash: &BlockHash,
     tables: &impl Tables,
-) -> Result<ExtendedBlockHeader, RuntimeError> {
+) -> DbResult<ExtendedBlockHeader> {
     get_block_extended_header_from_height(&tables.block_heights().get(block_hash)?, tables)
 }
 
@@ -253,7 +250,7 @@ pub fn get_block_extended_header(
 pub fn get_block_extended_header_from_height(
     block_height: &BlockHeight,
     tables: &impl Tables,
-) -> Result<ExtendedBlockHeader, RuntimeError> {
+) -> DbResult<ExtendedBlockHeader> {
     let block_info = tables.block_infos().get(block_height)?;
     let block_header_blob = tables.block_header_blobs().get(block_height)?.0;
     let block_header = BlockHeader::read(&mut block_header_blob.as_slice())?;
@@ -279,7 +276,7 @@ pub fn get_block_extended_header_from_height(
 #[inline]
 pub fn get_block_extended_header_top(
     tables: &impl Tables,
-) -> Result<(ExtendedBlockHeader, BlockHeight), RuntimeError> {
+) -> DbResult<(ExtendedBlockHeader, BlockHeight)> {
     let height = chain_height(tables.block_heights())?.saturating_sub(1);
     let header = get_block_extended_header_from_height(&height, tables)?;
     Ok((header, height))
@@ -292,7 +289,7 @@ pub fn get_block_extended_header_top(
 pub fn get_block_info(
     block_height: &BlockHeight,
     table_block_infos: &impl DatabaseRo<BlockInfos>,
-) -> Result<BlockInfo, RuntimeError> {
+) -> DbResult<BlockInfo> {
     table_block_infos.get(block_height)
 }
 
@@ -302,7 +299,7 @@ pub fn get_block_info(
 pub fn get_block_height(
     block_hash: &BlockHash,
     table_block_heights: &impl DatabaseRo<BlockHeights>,
-) -> Result<BlockHeight, RuntimeError> {
+) -> DbResult<BlockHeight> {
     table_block_heights.get(block_hash)
 }
 
@@ -317,7 +314,7 @@ pub fn get_block_height(
 pub fn block_exists(
     block_hash: &BlockHash,
     table_block_heights: &impl DatabaseRo<BlockHeights>,
-) -> Result<bool, RuntimeError> {
+) -> DbResult<bool> {
     table_block_heights.contains(block_hash)
 }
 

storage/blockchain/src/ops/blockchain.rs

@@ -1,7 +1,7 @@
 //! Blockchain functions - chain height, generated coins, etc.
 
 //---------------------------------------------------------------------------------------------------- Import
-use cuprate_database::{DatabaseRo, RuntimeError};
+use cuprate_database::{DatabaseRo, DbResult, RuntimeError};
 
 use crate::{
     ops::macros::doc_error,
@@ -22,9 +22,7 @@ use crate::{
 /// So the height of a new block would be `chain_height()`.
 #[doc = doc_error!()]
 #[inline]
-pub fn chain_height(
+pub fn chain_height(table_block_heights: &impl DatabaseRo<BlockHeights>) -> DbResult<BlockHeight> {
-    table_block_heights: &impl DatabaseRo<BlockHeights>,
-) -> Result<BlockHeight, RuntimeError> {
     #[expect(clippy::cast_possible_truncation, reason = "we enforce 64-bit")]
     table_block_heights.len().map(|height| height as usize)
 }
@@ -45,7 +43,7 @@ pub fn chain_height(
 #[inline]
 pub fn top_block_height(
     table_block_heights: &impl DatabaseRo<BlockHeights>,
-) -> Result<BlockHeight, RuntimeError> {
+) -> DbResult<BlockHeight> {
     match table_block_heights.len()? {
         0 => Err(RuntimeError::KeyNotFound),
         #[expect(clippy::cast_possible_truncation, reason = "we enforce 64-bit")]
@@ -70,7 +68,7 @@ pub fn top_block_height(
 pub fn cumulative_generated_coins(
     block_height: &BlockHeight,
     table_block_infos: &impl DatabaseRo<BlockInfos>,
-) -> Result<u64, RuntimeError> {
+) -> DbResult<u64> {
     match table_block_infos.get(block_height) {
         Ok(block_info) => Ok(block_info.cumulative_generated_coins),
         Err(RuntimeError::KeyNotFound) if block_height == &0 => Ok(0),

storage/blockchain/src/ops/key_image.rs

@@ -1,7 +1,7 @@
 //! Key image functions.
 
 //---------------------------------------------------------------------------------------------------- Import
-use cuprate_database::{DatabaseRo, DatabaseRw, RuntimeError};
+use cuprate_database::{DatabaseRo, DatabaseRw, DbResult};
 
 use crate::{
     ops::macros::{doc_add_block_inner_invariant, doc_error},
@@ -17,7 +17,7 @@ use crate::{
 pub fn add_key_image(
     key_image: &KeyImage,
     table_key_images: &mut impl DatabaseRw<KeyImages>,
-) -> Result<(), RuntimeError> {
+) -> DbResult<()> {
     table_key_images.put(key_image, &())
 }
 
@@ -28,7 +28,7 @@ pub fn add_key_image(
 pub fn remove_key_image(
     key_image: &KeyImage,
     table_key_images: &mut impl DatabaseRw<KeyImages>,
-) -> Result<(), RuntimeError> {
+) -> DbResult<()> {
     table_key_images.delete(key_image)
 }
 
@@ -38,7 +38,7 @@ pub fn remove_key_image(
 pub fn key_image_exists(
     key_image: &KeyImage,
     table_key_images: &impl DatabaseRo<KeyImages>,
-) -> Result<bool, RuntimeError> {
+) -> DbResult<bool> {
     table_key_images.contains(key_image)
 }
 

storage/blockchain/src/ops/macros.rs

@@ -8,7 +8,7 @@
 macro_rules! doc_error {
     () => {
         r#"# Errors
-This function returns [`RuntimeError::KeyNotFound`] if the input (if applicable) doesn't exist or other `RuntimeError`'s on database errors."#
+This function returns [`cuprate_database::RuntimeError::KeyNotFound`] if the input (if applicable) doesn't exist or other `RuntimeError`'s on database errors."#
     };
 }
 pub(super) use doc_error;

storage/blockchain/src/ops/output.rs

@@ -5,7 +5,7 @@ use curve25519_dalek::edwards::CompressedEdwardsY;
 use monero_serai::transaction::Timelock;
 
 use cuprate_database::{
-    RuntimeError, {DatabaseRo, DatabaseRw},
+    DbResult, RuntimeError, {DatabaseRo, DatabaseRw},
 };
 use cuprate_helper::crypto::compute_zero_commitment;
 use cuprate_helper::map::u64_to_timelock;
@@ -30,7 +30,7 @@ pub fn add_output(
     amount: Amount,
     output: &Output,
     tables: &mut impl TablesMut,
-) -> Result<PreRctOutputId, RuntimeError> {
+) -> DbResult<PreRctOutputId> {
     // FIXME: this would be much better expressed with a
     // `btree_map::Entry`-like API, fix `trait DatabaseRw`.
     let num_outputs = match tables.num_outputs().get(&amount) {
@@ -61,7 +61,7 @@ pub fn add_output(
 pub fn remove_output(
     pre_rct_output_id: &PreRctOutputId,
     tables: &mut impl TablesMut,
-) -> Result<(), RuntimeError> {
+) -> DbResult<()> {
     // Decrement the amount index by 1, or delete the entry out-right.
     // FIXME: this would be much better expressed with a
     // `btree_map::Entry`-like API, fix `trait DatabaseRw`.
@@ -86,7 +86,7 @@ pub fn remove_output(
 pub fn get_output(
     pre_rct_output_id: &PreRctOutputId,
     table_outputs: &impl DatabaseRo<Outputs>,
-) -> Result<Output, RuntimeError> {
+) -> DbResult<Output> {
     table_outputs.get(pre_rct_output_id)
 }
 
@@ -95,7 +95,7 @@ pub fn get_output(
 /// This returns the amount of pre-RCT outputs currently stored.
 #[doc = doc_error!()]
 #[inline]
-pub fn get_num_outputs(table_outputs: &impl DatabaseRo<Outputs>) -> Result<u64, RuntimeError> {
+pub fn get_num_outputs(table_outputs: &impl DatabaseRo<Outputs>) -> DbResult<u64> {
     table_outputs.len()
 }
 
@@ -110,7 +110,7 @@ pub fn get_num_outputs(table_outputs: &impl DatabaseRo<Outputs>) -> Result<u64,
 pub fn add_rct_output(
     rct_output: &RctOutput,
     table_rct_outputs: &mut impl DatabaseRw<RctOutputs>,
-) -> Result<AmountIndex, RuntimeError> {
+) -> DbResult<AmountIndex> {
     let amount_index = get_rct_num_outputs(table_rct_outputs)?;
     table_rct_outputs.put(&amount_index, rct_output)?;
     Ok(amount_index)
@@ -123,7 +123,7 @@ pub fn add_rct_output(
 pub fn remove_rct_output(
     amount_index: &AmountIndex,
     table_rct_outputs: &mut impl DatabaseRw<RctOutputs>,
-) -> Result<(), RuntimeError> {
+) -> DbResult<()> {
     table_rct_outputs.delete(amount_index)
 }
 
@@ -133,7 +133,7 @@ pub fn remove_rct_output(
 pub fn get_rct_output(
     amount_index: &AmountIndex,
     table_rct_outputs: &impl DatabaseRo<RctOutputs>,
-) -> Result<RctOutput, RuntimeError> {
+) -> DbResult<RctOutput> {
     table_rct_outputs.get(amount_index)
 }
 
@@ -142,9 +142,7 @@ pub fn get_rct_output(
 /// This returns the amount of RCT outputs currently stored.
 #[doc = doc_error!()]
 #[inline]
-pub fn get_rct_num_outputs(
+pub fn get_rct_num_outputs(table_rct_outputs: &impl DatabaseRo<RctOutputs>) -> DbResult<u64> {
-    table_rct_outputs: &impl DatabaseRo<RctOutputs>,
-) -> Result<u64, RuntimeError> {
     table_rct_outputs.len()
 }
 
@@ -155,7 +153,7 @@ pub fn output_to_output_on_chain(
     output: &Output,
     amount: Amount,
     table_tx_unlock_time: &impl DatabaseRo<TxUnlockTime>,
-) -> Result<OutputOnChain, RuntimeError> {
+) -> DbResult<OutputOnChain> {
     let commitment = compute_zero_commitment(amount);
 
     let time_lock = if output
@@ -191,7 +189,7 @@ pub fn output_to_output_on_chain(
 pub fn rct_output_to_output_on_chain(
     rct_output: &RctOutput,
     table_tx_unlock_time: &impl DatabaseRo<TxUnlockTime>,
-) -> Result<OutputOnChain, RuntimeError> {
+) -> DbResult<OutputOnChain> {
     // INVARIANT: Commitments stored are valid when stored by the database.
     let commitment = CompressedEdwardsY::from_slice(&rct_output.commitment)
         .unwrap()
@@ -223,10 +221,7 @@ pub fn rct_output_to_output_on_chain(
 ///
 /// Note that this still support RCT outputs, in that case, [`PreRctOutputId::amount`] should be `0`.
 #[doc = doc_error!()]
-pub fn id_to_output_on_chain(
+pub fn id_to_output_on_chain(id: &PreRctOutputId, tables: &impl Tables) -> DbResult<OutputOnChain> {
-    id: &PreRctOutputId,
-    tables: &impl Tables,
-) -> Result<OutputOnChain, RuntimeError> {
     // v2 transactions.
     if id.amount == 0 {
         let rct_output = get_rct_output(&id.amount_index, tables.rct_outputs())?;

storage/blockchain/src/ops/property.rs

@@ -3,10 +3,9 @@
 //! SOMEDAY: the database `properties` table is not yet implemented.
 
 //---------------------------------------------------------------------------------------------------- Import
+use cuprate_database::DbResult;
 use cuprate_pruning::PruningSeed;
 
-use cuprate_database::RuntimeError;
-
 use crate::ops::macros::doc_error;
 
 //---------------------------------------------------------------------------------------------------- Free Functions
@@ -20,7 +19,7 @@ use crate::ops::macros::doc_error;
 /// // SOMEDAY
 /// ```
 #[inline]
-pub const fn get_blockchain_pruning_seed() -> Result<PruningSeed, RuntimeError> {
+pub const fn get_blockchain_pruning_seed() -> DbResult<PruningSeed> {
     // SOMEDAY: impl pruning.
     // We need a DB properties table.
     Ok(PruningSeed::NotPruned)
@@ -36,7 +35,7 @@ pub const fn get_blockchain_pruning_seed() -> Result<PruningSeed, RuntimeError>
 /// // SOMEDAY
 /// ```
 #[inline]
-pub const fn db_version() -> Result<u64, RuntimeError> {
+pub const fn db_version() -> DbResult<u64> {
     // SOMEDAY: We need a DB properties table.
     Ok(crate::constants::DATABASE_VERSION)
 }

storage/blockchain/src/ops/tx.rs

@@ -4,7 +4,7 @@
 use bytemuck::TransparentWrapper;
 use monero_serai::transaction::{Input, Timelock, Transaction};
 
-use cuprate_database::{DatabaseRo, DatabaseRw, RuntimeError, StorableVec};
+use cuprate_database::{DatabaseRo, DatabaseRw, DbResult, RuntimeError, StorableVec};
 use cuprate_helper::crypto::compute_zero_commitment;
 
 use crate::{
@@ -52,7 +52,7 @@ pub fn add_tx(
     tx_hash: &TxHash,
     block_height: &BlockHeight,
     tables: &mut impl TablesMut,
-) -> Result<TxId, RuntimeError> {
+) -> DbResult<TxId> {
     let tx_id = get_num_tx(tables.tx_ids_mut())?;
 
     //------------------------------------------------------ Transaction data
@@ -129,7 +129,7 @@ pub fn add_tx(
                 )?
                 .amount_index)
             })
-            .collect::<Result<Vec<_>, RuntimeError>>()?,
+            .collect::<DbResult<Vec<_>>>()?,
         Transaction::V2 { prefix, proofs } => prefix
             .outputs
             .iter()
@@ -186,10 +186,7 @@ pub fn add_tx(
 ///
 #[doc = doc_error!()]
 #[inline]
-pub fn remove_tx(
+pub fn remove_tx(tx_hash: &TxHash, tables: &mut impl TablesMut) -> DbResult<(TxId, Transaction)> {
-    tx_hash: &TxHash,
-    tables: &mut impl TablesMut,
-) -> Result<(TxId, Transaction), RuntimeError> {
     //------------------------------------------------------ Transaction data
     let tx_id = tables.tx_ids_mut().take(tx_hash)?;
     let tx_blob = tables.tx_blobs_mut().take(&tx_id)?;
@@ -267,7 +264,7 @@ pub fn get_tx(
     tx_hash: &TxHash,
     table_tx_ids: &impl DatabaseRo<TxIds>,
     table_tx_blobs: &impl DatabaseRo<TxBlobs>,
-) -> Result<Transaction, RuntimeError> {
+) -> DbResult<Transaction> {
     get_tx_from_id(&table_tx_ids.get(tx_hash)?, table_tx_blobs)
 }
 
@@ -277,7 +274,7 @@ pub fn get_tx(
 pub fn get_tx_from_id(
     tx_id: &TxId,
     table_tx_blobs: &impl DatabaseRo<TxBlobs>,
-) -> Result<Transaction, RuntimeError> {
+) -> DbResult<Transaction> {
     let tx_blob = table_tx_blobs.get(tx_id)?.0;
     Ok(Transaction::read(&mut tx_blob.as_slice())?)
 }
@@ -294,7 +291,7 @@ pub fn get_tx_from_id(
 /// - etc
 #[doc = doc_error!()]
 #[inline]
-pub fn get_num_tx(table_tx_ids: &impl DatabaseRo<TxIds>) -> Result<u64, RuntimeError> {
+pub fn get_num_tx(table_tx_ids: &impl DatabaseRo<TxIds>) -> DbResult<u64> {
     table_tx_ids.len()
 }
 
@@ -304,10 +301,7 @@ pub fn get_num_tx(table_tx_ids: &impl DatabaseRo<TxIds>) -> Result<u64, RuntimeE
 /// Returns `true` if it does, else `false`.
 #[doc = doc_error!()]
 #[inline]
-pub fn tx_exists(
+pub fn tx_exists(tx_hash: &TxHash, table_tx_ids: &impl DatabaseRo<TxIds>) -> DbResult<bool> {
-    tx_hash: &TxHash,
-    table_tx_ids: &impl DatabaseRo<TxIds>,
-) -> Result<bool, RuntimeError> {
     table_tx_ids.contains(tx_hash)
 }
 

storage/blockchain/src/service/read.rs

@@ -21,7 +21,7 @@ use rayon::{
 };
 use thread_local::ThreadLocal;
 
-use cuprate_database::{ConcreteEnv, DatabaseRo, Env, EnvInner, RuntimeError};
+use cuprate_database::{ConcreteEnv, DatabaseRo, DbResult, Env, EnvInner, RuntimeError};
 use cuprate_database_service::{init_thread_pool, DatabaseReadService, ReaderThreads};
 use cuprate_helper::map::combine_low_high_bits_to_u128;
 use cuprate_types::{
@@ -305,7 +305,7 @@ fn block_extended_header_in_range(
                 let tables = get_tables!(env_inner, tx_ro, tables)?.as_ref();
                 get_block_extended_header_from_height(&block_height, tables)
             })
-            .collect::<Result<Vec<ExtendedBlockHeader>, RuntimeError>>()?,
+            .collect::<DbResult<Vec<ExtendedBlockHeader>>>()?,
         Chain::Alt(chain_id) => {
             let ranges = {
                 let tx_ro = tx_ro.get_or_try(|| env_inner.tx_ro())?;
@@ -381,7 +381,7 @@ fn outputs(env: &ConcreteEnv, outputs: HashMap<Amount, HashSet<AmountIndex>>) ->
 
     // The 2nd mapping function.
     // This is pulled out from the below `map()` for readability.
-    let inner_map = |amount, amount_index| -> Result<(AmountIndex, OutputOnChain), RuntimeError> {
+    let inner_map = |amount, amount_index| -> DbResult<(AmountIndex, OutputOnChain)> {
         let tx_ro = tx_ro.get_or_try(|| env_inner.tx_ro())?;
         let tables = get_tables!(env_inner, tx_ro, tables)?.as_ref();
 
@@ -404,10 +404,10 @@ fn outputs(env: &ConcreteEnv, outputs: HashMap<Amount, HashSet<AmountIndex>>) ->
                 amount_index_set
                     .into_par_iter()
                     .map(|amount_index| inner_map(amount, amount_index))
-                    .collect::<Result<HashMap<AmountIndex, OutputOnChain>, RuntimeError>>()?,
+                    .collect::<DbResult<HashMap<AmountIndex, OutputOnChain>>>()?,
             ))
         })
-        .collect::<Result<HashMap<Amount, HashMap<AmountIndex, OutputOnChain>>, RuntimeError>>()?;
+        .collect::<DbResult<HashMap<Amount, HashMap<AmountIndex, OutputOnChain>>>>()?;
 
     Ok(BlockchainResponse::Outputs(map))
 }
@@ -456,7 +456,7 @@ fn number_outputs_with_amount(env: &ConcreteEnv, amounts: Vec<Amount>) -> Respon
                 }
             }
         })
-        .collect::<Result<HashMap<Amount, usize>, RuntimeError>>()?;
+        .collect::<DbResult<HashMap<Amount, usize>>>()?;
 
     Ok(BlockchainResponse::NumberOutputsWithAmount(map))
 }
@@ -522,7 +522,7 @@ fn compact_chain_history(env: &ConcreteEnv) -> ResponseResult {
         .map(compact_history_index_to_height_offset::<INITIAL_BLOCKS>)
         .map_while(|i| top_block_height.checked_sub(i))
         .map(|height| Ok(get_block_info(&height, &table_block_infos)?.block_hash))
-        .collect::<Result<Vec<_>, RuntimeError>>()?;
+        .collect::<DbResult<Vec<_>>>()?;
 
     if compact_history_genesis_not_included::<INITIAL_BLOCKS>(top_block_height) {
         block_ids.push(get_block_info(&0, &table_block_infos)?.block_hash);

storage/blockchain/src/service/types.rs

@@ -1,7 +1,7 @@
 //! Database service type aliases.
 
 //---------------------------------------------------------------------------------------------------- Use
-use cuprate_database::RuntimeError;
+use cuprate_database::DbResult;
 use cuprate_database_service::{DatabaseReadService, DatabaseWriteHandle};
 use cuprate_types::blockchain::{
     BlockchainReadRequest, BlockchainResponse, BlockchainWriteRequest,
@@ -11,7 +11,7 @@ use cuprate_types::blockchain::{
 /// The actual type of the response.
 ///
 /// Either our [`BlockchainResponse`], or a database error occurred.
-pub(super) type ResponseResult = Result<BlockchainResponse, RuntimeError>;
+pub(super) type ResponseResult = DbResult<BlockchainResponse>;
 
 /// The blockchain database write service.
 pub type BlockchainWriteHandle = DatabaseWriteHandle<BlockchainWriteRequest, BlockchainResponse>;

storage/blockchain/src/service/write.rs

@@ -2,7 +2,7 @@
 //---------------------------------------------------------------------------------------------------- Import
 use std::sync::Arc;
 
-use cuprate_database::{ConcreteEnv, DatabaseRo, Env, EnvInner, RuntimeError, TxRw};
+use cuprate_database::{ConcreteEnv, DatabaseRo, DbResult, Env, EnvInner, TxRw};
 use cuprate_database_service::DatabaseWriteHandle;
 use cuprate_types::{
     blockchain::{BlockchainResponse, BlockchainWriteRequest},
@@ -36,7 +36,7 @@ pub fn init_write_service(env: Arc<ConcreteEnv>) -> BlockchainWriteHandle {
 fn handle_blockchain_request(
     env: &ConcreteEnv,
     req: &BlockchainWriteRequest,
-) -> Result<BlockchainResponse, RuntimeError> {
+) -> DbResult<BlockchainResponse> {
     match req {
         BlockchainWriteRequest::WriteBlock(block) => write_block(env, block),
         BlockchainWriteRequest::WriteAltBlock(alt_block) => write_alt_block(env, alt_block),

storage/database/src/backend/heed/database.rs

@@ -6,7 +6,7 @@ use std::{cell::RefCell, ops::RangeBounds};
 use crate::{
     backend::heed::types::HeedDb,
     database::{DatabaseIter, DatabaseRo, DatabaseRw},
-    error::RuntimeError,
+    error::{DbResult, RuntimeError},
     table::Table,
 };
 
@@ -54,16 +54,13 @@ fn get<T: Table>(
     db: &HeedDb<T::Key, T::Value>,
     tx_ro: &heed::RoTxn<'_>,
     key: &T::Key,
-) -> Result<T::Value, RuntimeError> {
+) -> DbResult<T::Value> {
     db.get(tx_ro, key)?.ok_or(RuntimeError::KeyNotFound)
 }
 
 /// Shared [`DatabaseRo::len()`].
 #[inline]
-fn len<T: Table>(
+fn len<T: Table>(db: &HeedDb<T::Key, T::Value>, tx_ro: &heed::RoTxn<'_>) -> DbResult<u64> {
-    db: &HeedDb<T::Key, T::Value>,
-    tx_ro: &heed::RoTxn<'_>,
-) -> Result<u64, RuntimeError> {
     Ok(db.len(tx_ro)?)
 }
 
@@ -72,7 +69,7 @@ fn len<T: Table>(
 fn first<T: Table>(
     db: &HeedDb<T::Key, T::Value>,
     tx_ro: &heed::RoTxn<'_>,
-) -> Result<(T::Key, T::Value), RuntimeError> {
+) -> DbResult<(T::Key, T::Value)> {
     db.first(tx_ro)?.ok_or(RuntimeError::KeyNotFound)
 }
 
@@ -81,16 +78,13 @@ fn first<T: Table>(
 fn last<T: Table>(
     db: &HeedDb<T::Key, T::Value>,
     tx_ro: &heed::RoTxn<'_>,
-) -> Result<(T::Key, T::Value), RuntimeError> {
+) -> DbResult<(T::Key, T::Value)> {
     db.last(tx_ro)?.ok_or(RuntimeError::KeyNotFound)
 }
 
 /// Shared [`DatabaseRo::is_empty()`].
 #[inline]
-fn is_empty<T: Table>(
+fn is_empty<T: Table>(db: &HeedDb<T::Key, T::Value>, tx_ro: &heed::RoTxn<'_>) -> DbResult<bool> {
-    db: &HeedDb<T::Key, T::Value>,
-    tx_ro: &heed::RoTxn<'_>,
-) -> Result<bool, RuntimeError> {
     Ok(db.is_empty(tx_ro)?)
 }
 
@@ -100,7 +94,7 @@ impl<T: Table> DatabaseIter<T> for HeedTableRo<'_, T> {
     fn get_range<'a, Range>(
         &'a self,
         range: Range,
-    ) -> Result<impl Iterator<Item = Result<T::Value, RuntimeError>> + 'a, RuntimeError>
+    ) -> DbResult<impl Iterator<Item = DbResult<T::Value>> + 'a>
     where
         Range: RangeBounds<T::Key> + 'a,
     {
@@ -108,24 +102,17 @@ impl<T: Table> DatabaseIter<T> for HeedTableRo<'_, T> {
     }
 
     #[inline]
-    fn iter(
+    fn iter(&self) -> DbResult<impl Iterator<Item = DbResult<(T::Key, T::Value)>> + '_> {
-        &self,
-    ) -> Result<impl Iterator<Item = Result<(T::Key, T::Value), RuntimeError>> + '_, RuntimeError>
-    {
         Ok(self.db.iter(self.tx_ro)?.map(|res| Ok(res?)))
     }
 
     #[inline]
-    fn keys(
+    fn keys(&self) -> DbResult<impl Iterator<Item = DbResult<T::Key>> + '_> {
-        &self,
-    ) -> Result<impl Iterator<Item = Result<T::Key, RuntimeError>> + '_, RuntimeError> {
         Ok(self.db.iter(self.tx_ro)?.map(|res| Ok(res?.0)))
     }
 
     #[inline]
-    fn values(
+    fn values(&self) -> DbResult<impl Iterator<Item = DbResult<T::Value>> + '_> {
-        &self,
-    ) -> Result<impl Iterator<Item = Result<T::Value, RuntimeError>> + '_, RuntimeError> {
         Ok(self.db.iter(self.tx_ro)?.map(|res| Ok(res?.1)))
     }
 }
@@ -134,27 +121,27 @@ impl<T: Table> DatabaseIter<T> for HeedTableRo<'_, T> {
 // SAFETY: `HeedTableRo: !Send` as it holds a reference to `heed::RoTxn: Send + !Sync`.
 unsafe impl<T: Table> DatabaseRo<T> for HeedTableRo<'_, T> {
     #[inline]
-    fn get(&self, key: &T::Key) -> Result<T::Value, RuntimeError> {
+    fn get(&self, key: &T::Key) -> DbResult<T::Value> {
         get::<T>(&self.db, self.tx_ro, key)
     }
 
     #[inline]
-    fn len(&self) -> Result<u64, RuntimeError> {
+    fn len(&self) -> DbResult<u64> {
         len::<T>(&self.db, self.tx_ro)
     }
 
     #[inline]
-    fn first(&self) -> Result<(T::Key, T::Value), RuntimeError> {
+    fn first(&self) -> DbResult<(T::Key, T::Value)> {
         first::<T>(&self.db, self.tx_ro)
     }
 
     #[inline]
-    fn last(&self) -> Result<(T::Key, T::Value), RuntimeError> {
+    fn last(&self) -> DbResult<(T::Key, T::Value)> {
         last::<T>(&self.db, self.tx_ro)
     }
 
     #[inline]
-    fn is_empty(&self) -> Result<bool, RuntimeError> {
+    fn is_empty(&self) -> DbResult<bool> {
         is_empty::<T>(&self.db, self.tx_ro)
     }
 }
@@ -164,45 +151,45 @@ unsafe impl<T: Table> DatabaseRo<T> for HeedTableRo<'_, T> {
 // `HeedTableRw`'s write transaction is `!Send`.
 unsafe impl<T: Table> DatabaseRo<T> for HeedTableRw<'_, '_, T> {
     #[inline]
-    fn get(&self, key: &T::Key) -> Result<T::Value, RuntimeError> {
+    fn get(&self, key: &T::Key) -> DbResult<T::Value> {
         get::<T>(&self.db, &self.tx_rw.borrow(), key)
     }
 
     #[inline]
-    fn len(&self) -> Result<u64, RuntimeError> {
+    fn len(&self) -> DbResult<u64> {
         len::<T>(&self.db, &self.tx_rw.borrow())
     }
 
     #[inline]
-    fn first(&self) -> Result<(T::Key, T::Value), RuntimeError> {
+    fn first(&self) -> DbResult<(T::Key, T::Value)> {
         first::<T>(&self.db, &self.tx_rw.borrow())
     }
 
     #[inline]
-    fn last(&self) -> Result<(T::Key, T::Value), RuntimeError> {
+    fn last(&self) -> DbResult<(T::Key, T::Value)> {
         last::<T>(&self.db, &self.tx_rw.borrow())
     }
 
     #[inline]
-    fn is_empty(&self) -> Result<bool, RuntimeError> {
+    fn is_empty(&self) -> DbResult<bool> {
         is_empty::<T>(&self.db, &self.tx_rw.borrow())
     }
 }
 
 impl<T: Table> DatabaseRw<T> for HeedTableRw<'_, '_, T> {
     #[inline]
-    fn put(&mut self, key: &T::Key, value: &T::Value) -> Result<(), RuntimeError> {
+    fn put(&mut self, key: &T::Key, value: &T::Value) -> DbResult<()> {
         Ok(self.db.put(&mut self.tx_rw.borrow_mut(), key, value)?)
     }
 
     #[inline]
-    fn delete(&mut self, key: &T::Key) -> Result<(), RuntimeError> {
+    fn delete(&mut self, key: &T::Key) -> DbResult<()> {
         self.db.delete(&mut self.tx_rw.borrow_mut(), key)?;
         Ok(())
     }
 
     #[inline]
-    fn take(&mut self, key: &T::Key) -> Result<T::Value, RuntimeError> {
+    fn take(&mut self, key: &T::Key) -> DbResult<T::Value> {
         // LMDB/heed does not return the value on deletion.
         // So, fetch it first - then delete.
         let value = get::<T>(&self.db, &self.tx_rw.borrow(), key)?;
@@ -216,7 +203,7 @@ impl<T: Table> DatabaseRw<T> for HeedTableRw<'_, '_, T> {
     }
 
     #[inline]
-    fn pop_first(&mut self) -> Result<(T::Key, T::Value), RuntimeError> {
+    fn pop_first(&mut self) -> DbResult<(T::Key, T::Value)> {
         let tx_rw = &mut self.tx_rw.borrow_mut();
 
         // Get the value first...
@@ -235,7 +222,7 @@ impl<T: Table> DatabaseRw<T> for HeedTableRw<'_, '_, T> {
     }
 
     #[inline]
-    fn pop_last(&mut self) -> Result<(T::Key, T::Value), RuntimeError> {
+    fn pop_last(&mut self) -> DbResult<(T::Key, T::Value)> {
         let tx_rw = &mut self.tx_rw.borrow_mut();
 
         // Get the value first...

storage/database/src/backend/heed/env.rs

@@ -18,7 +18,7 @@ use crate::{
     config::{Config, SyncMode},
     database::{DatabaseIter, DatabaseRo, DatabaseRw},
     env::{Env, EnvInner},
-    error::{InitError, RuntimeError},
+    error::{DbResult, InitError, RuntimeError},
     key::{Key, KeyCompare},
     resize::ResizeAlgorithm,
     table::Table,
@@ -203,7 +203,7 @@ impl Env for ConcreteEnv {
         &self.config
     }
 
-    fn sync(&self) -> Result<(), RuntimeError> {
+    fn sync(&self) -> DbResult<()> {
         Ok(self.env.read().unwrap().force_sync()?)
     }
 
@@ -253,12 +253,12 @@ where
     type Rw<'a> = RefCell<heed::RwTxn<'a>>;
 
     #[inline]
-    fn tx_ro(&self) -> Result<Self::Ro<'_>, RuntimeError> {
+    fn tx_ro(&self) -> DbResult<Self::Ro<'_>> {
         Ok(self.read_txn()?)
     }
 
     #[inline]
-    fn tx_rw(&self) -> Result<Self::Rw<'_>, RuntimeError> {
+    fn tx_rw(&self) -> DbResult<Self::Rw<'_>> {
         Ok(RefCell::new(self.write_txn()?))
     }
 
@@ -266,7 +266,7 @@ where
     fn open_db_ro<T: Table>(
         &self,
         tx_ro: &Self::Ro<'_>,
-    ) -> Result<impl DatabaseRo<T> + DatabaseIter<T>, RuntimeError> {
+    ) -> DbResult<impl DatabaseRo<T> + DatabaseIter<T>> {
         // Open up a read-only database using our table's const metadata.
         //
         // INVARIANT: LMDB caches the ordering / comparison function from [`EnvInner::create_db`],
@@ -281,10 +281,7 @@ where
     }
 
     #[inline]
-    fn open_db_rw<T: Table>(
+    fn open_db_rw<T: Table>(&self, tx_rw: &Self::Rw<'_>) -> DbResult<impl DatabaseRw<T>> {
-        &self,
-        tx_rw: &Self::Rw<'_>,
-    ) -> Result<impl DatabaseRw<T>, RuntimeError> {
         // Open up a read/write database using our table's const metadata.
         //
         // INVARIANT: LMDB caches the ordering / comparison function from [`EnvInner::create_db`],
@@ -296,7 +293,7 @@ where
         })
     }
 
-    fn create_db<T: Table>(&self, tx_rw: &Self::Rw<'_>) -> Result<(), RuntimeError> {
+    fn create_db<T: Table>(&self, tx_rw: &Self::Rw<'_>) -> DbResult<()> {
         // Create a database using our:
         // - [`Table`]'s const metadata.
         // - (potentially) our [`Key`] comparison function
@@ -328,7 +325,7 @@ where
     }
 
     #[inline]
-    fn clear_db<T: Table>(&self, tx_rw: &mut Self::Rw<'_>) -> Result<(), RuntimeError> {
+    fn clear_db<T: Table>(&self, tx_rw: &mut Self::Rw<'_>) -> DbResult<()> {
         let tx_rw = tx_rw.get_mut();
 
         // Open the table. We don't care about flags or key

storage/database/src/backend/heed/transaction.rs

@@ -4,31 +4,31 @@ use std::cell::RefCell;
 
 //---------------------------------------------------------------------------------------------------- Import
 use crate::{
-    error::RuntimeError,
+    error::DbResult,
     transaction::{TxRo, TxRw},
 };
 
 //---------------------------------------------------------------------------------------------------- TxRo
 impl TxRo<'_> for heed::RoTxn<'_> {
-    fn commit(self) -> Result<(), RuntimeError> {
+    fn commit(self) -> DbResult<()> {
         Ok(heed::RoTxn::commit(self)?)
     }
 }
 
 //---------------------------------------------------------------------------------------------------- TxRw
 impl TxRo<'_> for RefCell<heed::RwTxn<'_>> {
-    fn commit(self) -> Result<(), RuntimeError> {
+    fn commit(self) -> DbResult<()> {
         TxRw::commit(self)
     }
 }
 
 impl TxRw<'_> for RefCell<heed::RwTxn<'_>> {
-    fn commit(self) -> Result<(), RuntimeError> {
+    fn commit(self) -> DbResult<()> {
         Ok(heed::RwTxn::commit(self.into_inner())?)
     }
 
     /// This function is infallible.
-    fn abort(self) -> Result<(), RuntimeError> {
+    fn abort(self) -> DbResult<()> {
         heed::RwTxn::abort(self.into_inner());
         Ok(())
     }

storage/database/src/backend/redb/database.rs

@@ -11,7 +11,7 @@ use crate::{
         types::{RedbTableRo, RedbTableRw},
     },
     database::{DatabaseIter, DatabaseRo, DatabaseRw},
-    error::RuntimeError,
+    error::{DbResult, RuntimeError},
     table::Table,
 };
 
@@ -25,7 +25,7 @@ use crate::{
 fn get<T: Table + 'static>(
     db: &impl ReadableTable<StorableRedb<T::Key>, StorableRedb<T::Value>>,
     key: &T::Key,
-) -> Result<T::Value, RuntimeError> {
+) -> DbResult<T::Value> {
     Ok(db.get(key)?.ok_or(RuntimeError::KeyNotFound)?.value())
 }
 
@@ -33,7 +33,7 @@ fn get<T: Table + 'static>(
 #[inline]
 fn len<T: Table>(
     db: &impl ReadableTable<StorableRedb<T::Key>, StorableRedb<T::Value>>,
-) -> Result<u64, RuntimeError> {
+) -> DbResult<u64> {
     Ok(db.len()?)
 }
 
@@ -41,7 +41,7 @@ fn len<T: Table>(
 #[inline]
 fn first<T: Table>(
     db: &impl ReadableTable<StorableRedb<T::Key>, StorableRedb<T::Value>>,
-) -> Result<(T::Key, T::Value), RuntimeError> {
+) -> DbResult<(T::Key, T::Value)> {
     let (key, value) = db.first()?.ok_or(RuntimeError::KeyNotFound)?;
     Ok((key.value(), value.value()))
 }
@@ -50,7 +50,7 @@ fn first<T: Table>(
 #[inline]
 fn last<T: Table>(
     db: &impl ReadableTable<StorableRedb<T::Key>, StorableRedb<T::Value>>,
-) -> Result<(T::Key, T::Value), RuntimeError> {
+) -> DbResult<(T::Key, T::Value)> {
     let (key, value) = db.last()?.ok_or(RuntimeError::KeyNotFound)?;
     Ok((key.value(), value.value()))
 }
@@ -59,7 +59,7 @@ fn last<T: Table>(
 #[inline]
 fn is_empty<T: Table>(
     db: &impl ReadableTable<StorableRedb<T::Key>, StorableRedb<T::Value>>,
-) -> Result<bool, RuntimeError> {
+) -> DbResult<bool> {
     Ok(db.is_empty()?)
 }
 
@@ -69,7 +69,7 @@ impl<T: Table + 'static> DatabaseIter<T> for RedbTableRo<T::Key, T::Value> {
     fn get_range<'a, Range>(
         &'a self,
         range: Range,
-    ) -> Result<impl Iterator<Item = Result<T::Value, RuntimeError>> + 'a, RuntimeError>
+    ) -> DbResult<impl Iterator<Item = DbResult<T::Value>> + 'a>
     where
         Range: RangeBounds<T::Key> + 'a,
     {
@@ -80,10 +80,7 @@ impl<T: Table + 'static> DatabaseIter<T> for RedbTableRo<T::Key, T::Value> {
     }
 
     #[inline]
-    fn iter(
+    fn iter(&self) -> DbResult<impl Iterator<Item = DbResult<(T::Key, T::Value)>> + '_> {
-        &self,
-    ) -> Result<impl Iterator<Item = Result<(T::Key, T::Value), RuntimeError>> + '_, RuntimeError>
-    {
         Ok(ReadableTable::iter(self)?.map(|result| {
             let (key, value) = result?;
             Ok((key.value(), value.value()))
@@ -91,9 +88,7 @@ impl<T: Table + 'static> DatabaseIter<T> for RedbTableRo<T::Key, T::Value> {
     }
 
     #[inline]
-    fn keys(
+    fn keys(&self) -> DbResult<impl Iterator<Item = DbResult<T::Key>> + '_> {
-        &self,
-    ) -> Result<impl Iterator<Item = Result<T::Key, RuntimeError>> + '_, RuntimeError> {
         Ok(ReadableTable::iter(self)?.map(|result| {
             let (key, _value) = result?;
             Ok(key.value())
@@ -101,9 +96,7 @@ impl<T: Table + 'static> DatabaseIter<T> for RedbTableRo<T::Key, T::Value> {
     }
 
     #[inline]
-    fn values(
+    fn values(&self) -> DbResult<impl Iterator<Item = DbResult<T::Value>> + '_> {
-        &self,
-    ) -> Result<impl Iterator<Item = Result<T::Value, RuntimeError>> + '_, RuntimeError> {
         Ok(ReadableTable::iter(self)?.map(|result| {
             let (_key, value) = result?;
             Ok(value.value())
@@ -115,27 +108,27 @@ impl<T: Table + 'static> DatabaseIter<T> for RedbTableRo<T::Key, T::Value> {
 // SAFETY: Both `redb`'s transaction and table types are `Send + Sync`.
 unsafe impl<T: Table + 'static> DatabaseRo<T> for RedbTableRo<T::Key, T::Value> {
     #[inline]
-    fn get(&self, key: &T::Key) -> Result<T::Value, RuntimeError> {
+    fn get(&self, key: &T::Key) -> DbResult<T::Value> {
         get::<T>(self, key)
     }
 
     #[inline]
-    fn len(&self) -> Result<u64, RuntimeError> {
+    fn len(&self) -> DbResult<u64> {
         len::<T>(self)
     }
 
     #[inline]
-    fn first(&self) -> Result<(T::Key, T::Value), RuntimeError> {
+    fn first(&self) -> DbResult<(T::Key, T::Value)> {
         first::<T>(self)
     }
 
     #[inline]
-    fn last(&self) -> Result<(T::Key, T::Value), RuntimeError> {
+    fn last(&self) -> DbResult<(T::Key, T::Value)> {
         last::<T>(self)
     }
 
     #[inline]
-    fn is_empty(&self) -> Result<bool, RuntimeError> {
+    fn is_empty(&self) -> DbResult<bool> {
         is_empty::<T>(self)
     }
 }
@@ -144,27 +137,27 @@ unsafe impl<T: Table + 'static> DatabaseRo<T> for RedbTableRo<T::Key, T::Value>
 // SAFETY: Both `redb`'s transaction and table types are `Send + Sync`.
 unsafe impl<T: Table + 'static> DatabaseRo<T> for RedbTableRw<'_, T::Key, T::Value> {
     #[inline]
-    fn get(&self, key: &T::Key) -> Result<T::Value, RuntimeError> {
+    fn get(&self, key: &T::Key) -> DbResult<T::Value> {
         get::<T>(self, key)
     }
 
     #[inline]
-    fn len(&self) -> Result<u64, RuntimeError> {
+    fn len(&self) -> DbResult<u64> {
         len::<T>(self)
     }
 
     #[inline]
-    fn first(&self) -> Result<(T::Key, T::Value), RuntimeError> {
+    fn first(&self) -> DbResult<(T::Key, T::Value)> {
         first::<T>(self)
     }
 
     #[inline]
-    fn last(&self) -> Result<(T::Key, T::Value), RuntimeError> {
+    fn last(&self) -> DbResult<(T::Key, T::Value)> {
         last::<T>(self)
     }
 
     #[inline]
-    fn is_empty(&self) -> Result<bool, RuntimeError> {
+    fn is_empty(&self) -> DbResult<bool> {
         is_empty::<T>(self)
     }
 }
@@ -173,19 +166,19 @@ impl<T: Table + 'static> DatabaseRw<T> for RedbTableRw<'_, T::Key, T::Value> {
     // `redb` returns the value after function calls so we end with Ok(()) instead.
 
     #[inline]
-    fn put(&mut self, key: &T::Key, value: &T::Value) -> Result<(), RuntimeError> {
+    fn put(&mut self, key: &T::Key, value: &T::Value) -> DbResult<()> {
         redb::Table::insert(self, key, value)?;
         Ok(())
     }
 
     #[inline]
-    fn delete(&mut self, key: &T::Key) -> Result<(), RuntimeError> {
+    fn delete(&mut self, key: &T::Key) -> DbResult<()> {
         redb::Table::remove(self, key)?;
         Ok(())
     }
 
     #[inline]
-    fn take(&mut self, key: &T::Key) -> Result<T::Value, RuntimeError> {
+    fn take(&mut self, key: &T::Key) -> DbResult<T::Value> {
         if let Some(value) = redb::Table::remove(self, key)? {
             Ok(value.value())
         } else {
@@ -194,13 +187,13 @@ impl<T: Table + 'static> DatabaseRw<T> for RedbTableRw<'_, T::Key, T::Value> {
     }
 
     #[inline]
-    fn pop_first(&mut self) -> Result<(T::Key, T::Value), RuntimeError> {
+    fn pop_first(&mut self) -> DbResult<(T::Key, T::Value)> {
         let (key, value) = redb::Table::pop_first(self)?.ok_or(RuntimeError::KeyNotFound)?;
         Ok((key.value(), value.value()))
     }
 
     #[inline]
-    fn pop_last(&mut self) -> Result<(T::Key, T::Value), RuntimeError> {
+    fn pop_last(&mut self) -> DbResult<(T::Key, T::Value)> {
         let (key, value) = redb::Table::pop_last(self)?.ok_or(RuntimeError::KeyNotFound)?;
         Ok((key.value(), value.value()))
     }

storage/database/src/backend/redb/env.rs

@@ -6,7 +6,7 @@ use crate::{
     config::{Config, SyncMode},
     database::{DatabaseIter, DatabaseRo, DatabaseRw},
     env::{Env, EnvInner},
-    error::{InitError, RuntimeError},
+    error::{DbResult, InitError, RuntimeError},
     table::Table,
     TxRw,
 };
@@ -105,7 +105,7 @@ impl Env for ConcreteEnv {
         &self.config
     }
 
-    fn sync(&self) -> Result<(), RuntimeError> {
+    fn sync(&self) -> DbResult<()> {
         // `redb`'s syncs are tied with write transactions,
         // so just create one, don't do anything and commit.
         let mut tx_rw = self.env.begin_write()?;
@@ -127,12 +127,12 @@ where
     type Rw<'a> = redb::WriteTransaction;
 
     #[inline]
-    fn tx_ro(&self) -> Result<redb::ReadTransaction, RuntimeError> {
+    fn tx_ro(&self) -> DbResult<redb::ReadTransaction> {
         Ok(self.0.begin_read()?)
     }
 
     #[inline]
-    fn tx_rw(&self) -> Result<redb::WriteTransaction, RuntimeError> {
+    fn tx_rw(&self) -> DbResult<redb::WriteTransaction> {
         // `redb` has sync modes on the TX level, unlike heed,
         // which sets it at the Environment level.
         //
@@ -146,7 +146,7 @@ where
     fn open_db_ro<T: Table>(
         &self,
         tx_ro: &Self::Ro<'_>,
-    ) -> Result<impl DatabaseRo<T> + DatabaseIter<T>, RuntimeError> {
+    ) -> DbResult<impl DatabaseRo<T> + DatabaseIter<T>> {
         // Open up a read-only database using our `T: Table`'s const metadata.
         let table: redb::TableDefinition<'static, StorableRedb<T::Key>, StorableRedb<T::Value>> =
             redb::TableDefinition::new(T::NAME);
@@ -155,10 +155,7 @@ where
     }
 
     #[inline]
-    fn open_db_rw<T: Table>(
+    fn open_db_rw<T: Table>(&self, tx_rw: &Self::Rw<'_>) -> DbResult<impl DatabaseRw<T>> {
-        &self,
-        tx_rw: &Self::Rw<'_>,
-    ) -> Result<impl DatabaseRw<T>, RuntimeError> {
         // Open up a read/write database using our `T: Table`'s const metadata.
         let table: redb::TableDefinition<'static, StorableRedb<T::Key>, StorableRedb<T::Value>> =
             redb::TableDefinition::new(T::NAME);
@@ -168,14 +165,14 @@ where
         Ok(tx_rw.open_table(table)?)
     }
 
-    fn create_db<T: Table>(&self, tx_rw: &redb::WriteTransaction) -> Result<(), RuntimeError> {
+    fn create_db<T: Table>(&self, tx_rw: &redb::WriteTransaction) -> DbResult<()> {
         // INVARIANT: `redb` creates tables if they don't exist.
         self.open_db_rw::<T>(tx_rw)?;
         Ok(())
     }
 
     #[inline]
-    fn clear_db<T: Table>(&self, tx_rw: &mut redb::WriteTransaction) -> Result<(), RuntimeError> {
+    fn clear_db<T: Table>(&self, tx_rw: &mut redb::WriteTransaction) -> DbResult<()> {
         let table: redb::TableDefinition<
             'static,
             StorableRedb<<T as Table>::Key>,

storage/database/src/backend/redb/transaction.rs

@@ -2,14 +2,14 @@
 
 //---------------------------------------------------------------------------------------------------- Import
 use crate::{
-    error::RuntimeError,
+    error::DbResult,
     transaction::{TxRo, TxRw},
 };
 
 //---------------------------------------------------------------------------------------------------- TxRo
 impl TxRo<'_> for redb::ReadTransaction {
     /// This function is infallible.
-    fn commit(self) -> Result<(), RuntimeError> {
+    fn commit(self) -> DbResult<()> {
         // `redb`'s read transactions cleanup automatically when all references are dropped.
         //
         // There is `close()`:
@@ -22,11 +22,11 @@ impl TxRo<'_> for redb::ReadTransaction {
 
 //---------------------------------------------------------------------------------------------------- TxRw
 impl TxRw<'_> for redb::WriteTransaction {
-    fn commit(self) -> Result<(), RuntimeError> {
+    fn commit(self) -> DbResult<()> {
         Ok(self.commit()?)
     }
 
-    fn abort(self) -> Result<(), RuntimeError> {
+    fn abort(self) -> DbResult<()> {
         Ok(self.abort()?)
     }
 }

storage/database/src/config/sync_mode.rs

@@ -9,7 +9,6 @@
 //! based on these values.
 
 //---------------------------------------------------------------------------------------------------- Import
-
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 

storage/database/src/database.rs

@@ -3,7 +3,10 @@
 //---------------------------------------------------------------------------------------------------- Import
 use std::ops::RangeBounds;
 
-use crate::{error::RuntimeError, table::Table};
+use crate::{
+    error::{DbResult, RuntimeError},
+    table::Table,
+};
 
 //---------------------------------------------------------------------------------------------------- DatabaseIter
 /// Generic post-fix documentation for `DatabaseIter` methods.
@@ -48,27 +51,22 @@ pub trait DatabaseIter<T: Table> {
     fn get_range<'a, Range>(
         &'a self,
         range: Range,
-    ) -> Result<impl Iterator<Item = Result<T::Value, RuntimeError>> + 'a, RuntimeError>
+    ) -> DbResult<impl Iterator<Item = DbResult<T::Value>> + 'a>
     where
         Range: RangeBounds<T::Key> + 'a;
 
     /// Get an [`Iterator`] that returns the `(key, value)` types for this database.
     #[doc = doc_iter!()]
     #[expect(clippy::iter_not_returning_iterator)]
-    fn iter(
+    fn iter(&self) -> DbResult<impl Iterator<Item = DbResult<(T::Key, T::Value)>> + '_>;
-        &self,
-    ) -> Result<impl Iterator<Item = Result<(T::Key, T::Value), RuntimeError>> + '_, RuntimeError>;
 
     /// Get an [`Iterator`] that returns _only_ the `key` type for this database.
     #[doc = doc_iter!()]
-    fn keys(&self)
+    fn keys(&self) -> DbResult<impl Iterator<Item = DbResult<T::Key>> + '_>;
-        -> Result<impl Iterator<Item = Result<T::Key, RuntimeError>> + '_, RuntimeError>;
 
     /// Get an [`Iterator`] that returns _only_ the `value` type for this database.
     #[doc = doc_iter!()]
-    fn values(
+    fn values(&self) -> DbResult<impl Iterator<Item = DbResult<T::Value>> + '_>;
-        &self,
-    ) -> Result<impl Iterator<Item = Result<T::Value, RuntimeError>> + '_, RuntimeError>;
 }
 
 //---------------------------------------------------------------------------------------------------- DatabaseRo
@@ -76,7 +74,7 @@ pub trait DatabaseIter<T: Table> {
 macro_rules! doc_database {
     () => {
         r"# Errors
-This will return [`RuntimeError::KeyNotFound`] if:
+This will return [`crate::RuntimeError::KeyNotFound`] if:
 - Input does not exist OR
 - Database is empty"
     };
@@ -111,7 +109,7 @@ This will return [`RuntimeError::KeyNotFound`] if:
 pub unsafe trait DatabaseRo<T: Table> {
     /// Get the value corresponding to a key.
     #[doc = doc_database!()]
-    fn get(&self, key: &T::Key) -> Result<T::Value, RuntimeError>;
+    fn get(&self, key: &T::Key) -> DbResult<T::Value>;
 
     /// Returns `true` if the database contains a value for the specified key.
     ///
@@ -120,7 +118,7 @@ pub unsafe trait DatabaseRo<T: Table> {
     /// as in that case, `Ok(false)` will be returned.
     ///
     /// Other errors may still occur.
-    fn contains(&self, key: &T::Key) -> Result<bool, RuntimeError> {
+    fn contains(&self, key: &T::Key) -> DbResult<bool> {
         match self.get(key) {
             Ok(_) => Ok(true),
             Err(RuntimeError::KeyNotFound) => Ok(false),
@@ -132,21 +130,21 @@ pub unsafe trait DatabaseRo<T: Table> {
     ///
     /// # Errors
     /// This will never return [`RuntimeError::KeyNotFound`].
-    fn len(&self) -> Result<u64, RuntimeError>;
+    fn len(&self) -> DbResult<u64>;
 
     /// Returns the first `(key, value)` pair in the database.
     #[doc = doc_database!()]
-    fn first(&self) -> Result<(T::Key, T::Value), RuntimeError>;
+    fn first(&self) -> DbResult<(T::Key, T::Value)>;
 
     /// Returns the last `(key, value)` pair in the database.
     #[doc = doc_database!()]
-    fn last(&self) -> Result<(T::Key, T::Value), RuntimeError>;
+    fn last(&self) -> DbResult<(T::Key, T::Value)>;
 
     /// Returns `true` if the database contains no `(key, value)` pairs.
     ///
     /// # Errors
     /// This can only return [`RuntimeError::Io`] on errors.
-    fn is_empty(&self) -> Result<bool, RuntimeError>;
+    fn is_empty(&self) -> DbResult<bool>;
 }
 
 //---------------------------------------------------------------------------------------------------- DatabaseRw
@@ -161,7 +159,7 @@ pub trait DatabaseRw<T: Table>: DatabaseRo<T> {
     #[doc = doc_database!()]
     ///
     /// This will never [`RuntimeError::KeyExists`].
-    fn put(&mut self, key: &T::Key, value: &T::Value) -> Result<(), RuntimeError>;
+    fn put(&mut self, key: &T::Key, value: &T::Value) -> DbResult<()>;
 
     /// Delete a key-value pair in the database.
     ///
@@ -170,7 +168,7 @@ pub trait DatabaseRw<T: Table>: DatabaseRo<T> {
     #[doc = doc_database!()]
     ///
     /// This will never [`RuntimeError::KeyExists`].
-    fn delete(&mut self, key: &T::Key) -> Result<(), RuntimeError>;
+    fn delete(&mut self, key: &T::Key) -> DbResult<()>;
 
     /// Delete and return a key-value pair in the database.
     ///
@@ -178,7 +176,7 @@ pub trait DatabaseRw<T: Table>: DatabaseRo<T> {
     /// it will serialize the `T::Value` and return it.
     ///
     #[doc = doc_database!()]
-    fn take(&mut self, key: &T::Key) -> Result<T::Value, RuntimeError>;
+    fn take(&mut self, key: &T::Key) -> DbResult<T::Value>;
 
     /// Fetch the value, and apply a function to it - or delete the entry.
     ///
@@ -192,7 +190,7 @@ pub trait DatabaseRw<T: Table>: DatabaseRo<T> {
     /// - If `f` returns `None`, the entry will be [`DatabaseRw::delete`]d
     ///
     #[doc = doc_database!()]
-    fn update<F>(&mut self, key: &T::Key, mut f: F) -> Result<(), RuntimeError>
+    fn update<F>(&mut self, key: &T::Key, mut f: F) -> DbResult<()>
     where
         F: FnMut(T::Value) -> Option<T::Value>,
     {
@@ -207,10 +205,10 @@ pub trait DatabaseRw<T: Table>: DatabaseRo<T> {
     /// Removes and returns the first `(key, value)` pair in the database.
     ///
     #[doc = doc_database!()]
-    fn pop_first(&mut self) -> Result<(T::Key, T::Value), RuntimeError>;
+    fn pop_first(&mut self) -> DbResult<(T::Key, T::Value)>;
 
     /// Removes and returns the last `(key, value)` pair in the database.
     ///
     #[doc = doc_database!()]
-    fn pop_last(&mut self) -> Result<(T::Key, T::Value), RuntimeError>;
+    fn pop_last(&mut self) -> DbResult<(T::Key, T::Value)>;
 }