lints

crate-template/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "artemis-crate-template"
+version = "0.1.0"
+edition = "2021"
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/paradigmxyz/artemis"
+readme = "README.md"
+
+[dependencies]

crate-template/src/lib.rs

@@ -0,0 +1,8 @@
+#![warn(missing_docs, unreachable_pub)]
+#![deny(unused_must_use, rust_2018_idioms)]
+#![doc(test(
+    no_crate_inject,
+    attr(deny(warnings, rust_2018_idioms), allow(dead_code, unused_variables))
+))]
+
+//! artemis crate template

crates/clients/matchmaker/src/client.rs

@@ -15,6 +15,7 @@ use crate::{
 
 /// Matchmaker client to interact with MEV-share
 pub struct Client<S> {
+    /// Underlying HTTP client
     pub http_client: HttpClient<FlashbotsSigner<S, HttpBackend>>,
 }
 

crates/clients/matchmaker/src/flashbots_signer.rs

@@ -17,12 +17,12 @@ use tower::{Layer, Service};
 
 /// Layer that applies [`FlashbotsSigner`] which adds a request header with a signed payload.
 #[derive(Clone)]
-pub struct FlashbotsSignerLayer<S> {
+pub(crate) struct FlashbotsSignerLayer<S> {
     signer: Arc<S>,
 }
 
 impl<S> FlashbotsSignerLayer<S> {
-    pub fn new(signer: Arc<S>) -> Self {
+    pub(crate) fn new(signer: Arc<S>) -> Self {
         FlashbotsSignerLayer { signer }
     }
 }

crates/clients/matchmaker/src/lib.rs

@@ -1,3 +1,15 @@
+#![warn(missing_docs, unreachable_pub)]
+#![deny(unused_must_use, rust_2018_idioms)]
+#![doc(test(
+    no_crate_inject,
+    attr(deny(warnings, rust_2018_idioms), allow(dead_code, unused_variables))
+))]
+
+//! Client library for Flashbots MEV-share Matchmaker, fulfilling the
+//! [MEV-share spec](https://github.com/flashbots/mev-share).
+
+/// Core client implementation
 pub mod client;
 mod flashbots_signer;
+/// Core type definitions for the client
 pub mod types;

crates/clients/matchmaker/src/types.rs

@@ -1,53 +1,71 @@
 use ethers::types::{Bytes, H256, U64};
 use serde::{Deserialize, Serialize};
 
+/// A bundle of transactions to send to the matchmaker.
 #[derive(Clone, Debug, Default, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct BundleRequest {
+    /// The version of the MEV-share API to use.
     pub version: ProtocolVersion,
+    /// Data used by block builders to check if the bundle should be considered for inclusion.
     pub inclusion: Inclusion,
+    /// The transactions to include in the bundle.
     pub body: Vec<BundleTx>,
 }
 
+/// Data used by block builders to check if the bundle should be considered for inclusion.
 #[derive(Clone, Debug, Default, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Inclusion {
+    /// The first block the bundle is valid for.
     pub block: U64,
+    /// The last block the bundle is valid for.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub max_block: Option<U64>,
 }
 
-/// A bundle tx, which can either be a transaction hash, or a full tx
+/// A bundle tx, which can either be a transaction hash, or a full tx.
 #[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(untagged)]
 #[serde(rename_all = "camelCase")]
 pub enum BundleTx {
+    /// The hash of the transaction we are trying to backrun.
     TxHash {
+        /// Tx hash.
         hash: H256,
     },
+    /// A new signed transaction.
     #[serde(rename_all = "camelCase")]
     Tx {
+        /// Bytes of the signed transaction.
         tx: Bytes,
+        /// If true, the transaction can revert without the bundle being considered invalid.
         can_revert: bool,
     },
 }
 
+/// Response from the matchmaker after sending a bundle.
 #[derive(Deserialize, Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct SendBundleResponse {
+    /// Hash of the bundle bodies.
     bundle_hash: H256,
 }
 
+/// The version of the MEV-share API to use.
 #[derive(Deserialize, Debug, Serialize, Clone, Default)]
 pub enum ProtocolVersion {
     #[default]
     #[serde(rename = "beta-1")]
+    /// The beta-1 version of the API.
     Beta1,
+    /// The 0.1 version of the API.
     #[serde(rename = "v0.1")]
     V0_1,
 }
 
 impl BundleRequest {
+    /// Create a new bundle request.
     pub fn new(
         block_num: U64,
         max_block: Option<U64>,
@@ -64,6 +82,7 @@ impl BundleRequest {
         }
     }
 
+    /// Helper function to create a simple bundle request with sensible defaults.
     pub fn make_simple(block_num: U64, transactions: Vec<BundleTx>) -> Self {
         // bundle is valid for 5 blocks
         let max_block = block_num.saturating_add(U64::from(5));