Cannot get middleware working due to Service trait impl

[thomasmost]

I'm writing middleware to load application state into a grpc handler, and I cannot get my app to serve with the middleware layer

I've double-checked the types and looked at many examples and I can't tell what I've gotten wrong in my implementation, nor can I really make sense of the "help" message in the error.

Any help you can give me will be deeply appreciated!

Full error on compilation:

error[E0277]: the trait bound `RegistryApplicationStateMiddleware<Routes>: Service<http::request::Request<tonic::transport::Body>>` is not satisfied
  --> registry/src/main.rs:39:6
   |
39 |     .serve(addr)
   |      ^^^^^ the trait `Service<http::request::Request<tonic::transport::Body>>` is not implemented for `RegistryApplicationStateMiddleware<Routes>`
   |
   = help: the trait `Service<http::Request<tonic::transport::Body>>` is implemented for `RegistryApplicationStateMiddleware<S>`

For more information about this error, try `rustc --explain E0277`.
error: could not compile `registry` (bin "registry") due to 1 previous error

Note the help message indicates the trait is implemented for a generic version of the middleware?? but is somehow not matching Routes...

middleware.rs

use std::{convert::Infallible, task::{Context, Poll}};

use data_access::db::ConnectionPool;
use http::Response;
use tonic::{body::BoxBody, server::NamedService};
use tower_service::Service;

#[derive(Debug, Clone, Default)]
pub struct RegistryApplicationState {
    pub pool: ConnectionPool,
}


#[derive(Debug, Clone, Default)]
pub struct RegistryApplicationStateLayer {
    pub pool: ConnectionPool,
}

impl<S> tower_layer::Layer<S> for RegistryApplicationStateLayer {
    type Service = RegistryApplicationStateMiddleware<S>;

    fn layer(&self, service: S) -> Self::Service {
        RegistryApplicationStateMiddleware {
            inner: service,
            pool: self.pool.clone(),
        }
    }
}

#[derive(Debug, Clone)]
pub struct RegistryApplicationStateMiddleware<S> {
    inner: S,
    pub pool: ConnectionPool,
}


impl<S> Service<http::request::Request<tonic::transport::Body>> for RegistryApplicationStateMiddleware<S>
where
S: Service<http::request::Request<tonic::transport::Body>, Response = Response<BoxBody>, Error = Infallible>
    + NamedService 
    + Clone
    + Send + 'static,
    S::Future: Send + 'static,
    S::Error: Into<Box<dyn std::error::Error + Send + Sync>> + Send,
{
    type Response = S::Response;
    type Error = S::Error;
    type Future = futures::future::BoxFuture<'static, Result<Self::Response, Self::Error>>;

    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
        self.inner.poll_ready(cx)
    }

    fn call(&mut self, mut req: http::request::Request<tonic::transport::Body>) -> Self::Future {
        // This is necessary because tonic internally uses `tower::buffer::Buffer`.
        // See https://github.com/tower-rs/tower/issues/547#issuecomment-767629149
        // for details on why this is necessary
        let clone = self.inner.clone();
        let mut inner = std::mem::replace(&mut self.inner, clone);

        req.extensions_mut().insert(RegistryApplicationState {
            pool: self.pool.clone(),
        });

        Box::pin(async move {
            // Do extra async work here...
            let response = inner.call(req).await?;

            Ok(response)
        })
    }
}

main.rs

use middleware::RegistryApplicationStateLayer;
use tonic::transport::Server;

use client::registry_service_server::RegistryServiceServer;
use server::DemoClient;


use data_access::db::ConnectionPool;

pub mod client;
mod middleware;
pub mod server;

mod store_proto {
  include!("client.rs");

  pub(crate) const FILE_DESCRIPTOR_SET: &[u8] =
    tonic::include_file_descriptor_set!("store_descriptor");
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
  dotenv::dotenv().ok();
  let addr = "127.0.0.1:9001".parse()?;
  let demo_registry_service = DemoClient::default();

  let reflection_service = tonic_reflection::server::Builder::configure()
    .register_encoded_file_descriptor_set(store_proto::FILE_DESCRIPTOR_SET)
    .build()
    .unwrap();

    let pool = ConnectionPool::default();


  Server::builder()
    .layer(RegistryApplicationStateLayer { pool })
    .add_service(RegistryServiceServer::new(demo_registry_service))
    .add_service(reflection_service)
    .serve(addr)
    .await?;
  Ok(())
}