diff --git a/firewood/src/lib.rs b/firewood/src/lib.rs
index 2007dfcde..24682eda7 100644
--- a/firewood/src/lib.rs
+++ b/firewood/src/lib.rs
@@ -194,6 +194,5 @@ pub mod storage;
 pub mod api;
 pub(crate) mod config;
 pub mod nibbles;
-pub mod service;
 
 pub mod v2;
diff --git a/firewood/src/service/client.rs b/firewood/src/service/client.rs
deleted file mode 100644
index b1d7b38ac..000000000
--- a/firewood/src/service/client.rs
+++ /dev/null
@@ -1,201 +0,0 @@
-// Copyright (C) 2023, Ava Labs, Inc. All rights reserved.
-// See the file LICENSE.md for licensing terms.
-
-/// Client side connection structure
-///
-/// A connection is used to send messages to the firewood thread.
-use std::fmt::Debug;
-use std::mem::take;
-use std::thread::JoinHandle;
-use std::{path::Path, thread};
-
-use tokio::sync::{mpsc, oneshot};
-
-use crate::api::Revision;
-
-use crate::merkle::MerkleError;
-use crate::v2::api::Proof;
-use crate::{
-    db::{DbConfig, DbError},
-    merkle::TrieHash,
-};
-use async_trait::async_trait;
-
-use super::server::FirewoodService;
-use super::{Request, RevRequest, RevisionHandle};
-
-/// A `Connection` represents a connection to the thread running firewood
-/// The type specified is how you want to refer to your key values; this is
-/// something like `Vec<u8>` or `&[u8]`
-#[derive(Debug)]
-pub struct Connection<N: Send> {
-    sender: Option<mpsc::Sender<Request<N>>>,
-    handle: Option<JoinHandle<FirewoodService>>,
-}
-
-impl<N: Send> Drop for Connection<N> {
-    fn drop(&mut self) {
-        drop(take(&mut self.sender));
-        take(&mut self.handle)
-            .unwrap()
-            .join()
-            .expect("Couldn't join with the firewood thread");
-    }
-}
-
-impl<N: Send + 'static> Connection<N> {
-    #[allow(dead_code)]
-    fn new<P: AsRef<Path>>(path: P, cfg: DbConfig) -> Self {
-        let (sender, receiver) = mpsc::channel(1_000)
-            as (
-                tokio::sync::mpsc::Sender<Request<N>>,
-                tokio::sync::mpsc::Receiver<Request<N>>,
-            );
-        let owned_path = path.as_ref().to_path_buf();
-        let handle = thread::Builder::new()
-            .name("firewood-receiver".to_owned())
-            .spawn(move || FirewoodService::new(receiver, owned_path, cfg))
-            .expect("thread creation failed");
-        Self {
-            sender: Some(sender),
-            handle: Some(handle),
-        }
-    }
-}
-
-impl<N: Send> super::RevisionHandle<N> {
-    pub async fn close(self) {
-        let _ = self
-            .sender
-            .send(Request::RevRequest(RevRequest::Drop { handle: self.id }))
-            .await;
-    }
-}
-
-#[async_trait]
-impl<N: Send> Revision<N> for super::RevisionHandle<N> {
-    async fn kv_root_hash(&self) -> Result<TrieHash, DbError> {
-        let (send, recv) = oneshot::channel();
-        let msg = Request::RevRequest(RevRequest::RootHash {
-            handle: self.id,
-            respond_to: send,
-        });
-        let _ = self.sender.send(msg).await;
-        recv.await.expect("Actor task has been killed")
-    }
-
-    async fn kv_get<K: AsRef<[u8]> + Send + Sync>(&self, key: K) -> Result<Vec<u8>, DbError> {
-        let (send, recv) = oneshot::channel();
-        let _ = Request::RevRequest::<N>(RevRequest::Get {
-            handle: self.id,
-            key: key.as_ref().to_vec(),
-            respond_to: send,
-        });
-        recv.await.expect("Actor task has been killed")
-    }
-
-    async fn prove<K: AsRef<[u8]> + Send + Sync>(&self, key: K) -> Result<Proof<N>, MerkleError> {
-        let (send, recv) = oneshot::channel();
-        let msg = Request::RevRequest(RevRequest::Prove {
-            handle: self.id,
-            key: key.as_ref().to_vec(),
-            respond_to: send,
-        });
-        self.sender.send(msg).await.expect("channel failed");
-        recv.await.expect("channel failed")
-    }
-
-    async fn verify_range_proof<K: AsRef<[u8]> + Send + Sync>(
-        &self,
-        _proof: Proof<N>,
-        _first_key: K,
-        _last_key: K,
-        _keys: Vec<K>,
-        _values: Vec<K>,
-    ) {
-        todo!()
-    }
-    async fn root_hash(&self) -> Result<TrieHash, DbError> {
-        let (send, recv) = oneshot::channel();
-        let msg = Request::RevRequest(RevRequest::RootHash {
-            handle: self.id,
-            respond_to: send,
-        });
-        self.sender.send(msg).await.expect("channel failed");
-        recv.await.expect("channel failed")
-    }
-
-    async fn dump<W: std::io::Write + Send + Sync>(&self, _writer: W) -> Result<(), DbError> {
-        todo!()
-    }
-
-    #[cfg(feature = "eth")]
-    async fn dump_account<W: std::io::Write + Send + Sync, K: AsRef<[u8]> + Send + Sync>(
-        &self,
-        _key: K,
-        _writer: W,
-    ) -> Result<(), DbError> {
-        todo!()
-    }
-
-    async fn kv_dump<W: std::io::Write + Send + Sync>(&self, _writer: W) -> Result<(), DbError> {
-        unimplemented!();
-    }
-
-    #[cfg(feature = "eth")]
-    async fn get_balance<K: AsRef<[u8]> + Send + Sync>(
-        &self,
-        _key: K,
-    ) -> Result<primitive_types::U256, DbError> {
-        todo!()
-    }
-
-    #[cfg(feature = "eth")]
-    async fn get_code<K: AsRef<[u8]> + Send + Sync>(&self, _key: K) -> Result<Vec<u8>, DbError> {
-        todo!()
-    }
-
-    #[cfg(feature = "eth")]
-    async fn get_nonce<K: AsRef<[u8]> + Send + Sync>(
-        &self,
-        _key: K,
-    ) -> Result<crate::api::Nonce, DbError> {
-        todo!()
-    }
-
-    #[cfg(feature = "eth")]
-    async fn get_state<K: AsRef<[u8]> + Send + Sync>(
-        &self,
-        _key: K,
-        _sub_key: K,
-    ) -> Result<Vec<u8>, DbError> {
-        todo!()
-    }
-}
-
-#[async_trait]
-impl<N: Send> crate::api::Db<RevisionHandle<N>, N> for Connection<N>
-where
-    tokio::sync::mpsc::Sender<Request<N>>: From<tokio::sync::mpsc::Sender<Request<N>>>,
-{
-    async fn get_revision(&self, root_hash: TrieHash) -> Option<RevisionHandle<N>> {
-        let (send, recv) = oneshot::channel();
-        let msg = Request::NewRevision {
-            root_hash,
-            respond_to: send,
-        };
-        self.sender
-            .as_ref()
-            .unwrap()
-            .send(msg)
-            .await
-            .expect("channel failed");
-        let id = recv.await.unwrap();
-        id.map(|id| RevisionHandle {
-            sender: self.sender.as_ref().unwrap().clone(),
-            id,
-        })
-    }
-}
-
-// TODO: add a meaningful test with `Proposal` and `Revisions`.
diff --git a/firewood/src/service/mod.rs b/firewood/src/service/mod.rs
deleted file mode 100644
index 77587d744..000000000
--- a/firewood/src/service/mod.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-// Copyright (C) 2023, Ava Labs, Inc. All rights reserved.
-// See the file LICENSE.md for licensing terms.
-
-use tokio::sync::{mpsc, oneshot};
-
-use crate::{
-    db::DbError,
-    merkle::{MerkleError, TrieHash},
-    v2::api::Proof,
-};
-
-mod client;
-mod server;
-
-pub type BatchId = u32;
-pub type RevId = u32;
-
-#[derive(Debug)]
-pub struct RevisionHandle<N: Send> {
-    sender: mpsc::Sender<Request<N>>,
-    id: u32,
-}
-
-/// Client side request object
-#[derive(Debug)]
-pub enum Request<N: Send> {
-    NewRevision {
-        root_hash: TrieHash,
-        respond_to: oneshot::Sender<Option<RevId>>,
-    },
-
-    RevRequest(RevRequest<N>),
-}
-
-type OwnedKey = Vec<u8>;
-#[allow(dead_code)]
-type OwnedVal = Vec<u8>;
-
-#[derive(Debug)]
-pub enum RevRequest<N: Send> {
-    Get {
-        handle: RevId,
-        key: OwnedKey,
-        respond_to: oneshot::Sender<Result<Vec<u8>, DbError>>,
-    },
-    Prove {
-        handle: RevId,
-        key: OwnedKey,
-        respond_to: oneshot::Sender<Result<Proof<N>, MerkleError>>,
-    },
-    RootHash {
-        handle: RevId,
-        respond_to: oneshot::Sender<Result<TrieHash, DbError>>,
-    },
-    Drop {
-        handle: RevId,
-    },
-}
diff --git a/firewood/src/service/server.rs b/firewood/src/service/server.rs
deleted file mode 100644
index 043f0d76b..000000000
--- a/firewood/src/service/server.rs
+++ /dev/null
@@ -1,89 +0,0 @@
-// Copyright (C) 2023, Ava Labs, Inc. All rights reserved.
-// See the file LICENSE.md for licensing terms.
-
-use std::{
-    collections::HashMap,
-    path::PathBuf,
-    sync::atomic::{AtomicU32, Ordering},
-};
-use tokio::sync::mpsc::Receiver;
-
-use crate::db::{Db, DbConfig, DbError};
-
-use super::{Request, RevId};
-
-macro_rules! get_rev {
-    ($rev: ident, $handle: ident, $out: expr) => {
-        match $rev.get(&$handle) {
-            None => {
-                let _ = $out.send(Err(DbError::InvalidParams));
-                continue;
-            }
-            Some(x) => x,
-        }
-    };
-}
-#[derive(Copy, Debug, Clone)]
-pub struct FirewoodService {}
-
-impl FirewoodService {
-    pub fn new<N: Send>(
-        mut receiver: Receiver<Request<N>>,
-        owned_path: PathBuf,
-        cfg: DbConfig,
-    ) -> Self {
-        let db = Db::new(owned_path, &cfg).unwrap();
-        let mut revs = HashMap::new();
-        let lastid = AtomicU32::new(0);
-        loop {
-            let msg = match receiver.blocking_recv() {
-                Some(msg) => msg,
-                None => break,
-            };
-            match msg {
-                Request::NewRevision {
-                    root_hash,
-                    respond_to,
-                } => {
-                    let id: RevId = lastid.fetch_add(1, Ordering::Relaxed);
-                    let msg = match db.get_revision(&root_hash) {
-                        Some(rev) => {
-                            revs.insert(id, rev);
-                            Some(id)
-                        }
-                        None => None,
-                    };
-                    let _ = respond_to.send(msg);
-                }
-
-                Request::RevRequest(req) => match req {
-                    super::RevRequest::Get {
-                        handle,
-                        key,
-                        respond_to,
-                    } => {
-                        let rev = get_rev!(revs, handle, respond_to);
-                        let msg = rev.kv_get(key);
-                        let _ = respond_to.send(msg.map_or(Err(DbError::KeyNotFound), Ok));
-                    }
-                    super::RevRequest::Prove {
-                        handle: _handle,
-                        key: _key,
-                        respond_to: _respond_to,
-                    } => {
-                        todo!()
-                    }
-                    super::RevRequest::RootHash { handle, respond_to } => {
-                        let rev = get_rev!(revs, handle, respond_to);
-                        let msg = rev.kv_root_hash();
-                        let _ = respond_to.send(msg);
-                    }
-                    super::RevRequest::Drop { handle } => {
-                        revs.remove(&handle);
-                    }
-                },
-            }
-        }
-        FirewoodService {}
-    }
-}
diff --git a/firewood/src/v2/db.rs b/firewood/src/v2/db.rs
index 89853eb86..a210d1302 100644
--- a/firewood/src/v2/db.rs
+++ b/firewood/src/v2/db.rs
@@ -82,33 +82,3 @@ where
         Ok(proposal)
     }
 }
-
-#[derive(Debug, Default)]
-pub struct DbView;
-
-#[async_trait]
-impl api::DbView for DbView {
-    async fn root_hash(&self) -> Result<api::HashKey, api::Error> {
-        todo!()
-    }
-
-    async fn val<K: KeyType>(&self, _key: K) -> Result<Option<Vec<u8>>, api::Error> {
-        todo!()
-    }
-
-    async fn single_key_proof<K: KeyType>(
-        &self,
-        _key: K,
-    ) -> Result<Option<api::Proof<Vec<u8>>>, api::Error> {
-        todo!()
-    }
-
-    async fn range_proof<K: KeyType, V, N>(
-        &self,
-        _first_key: Option<K>,
-        _last_key: Option<K>,
-        _limit: usize,
-    ) -> Result<Option<api::RangeProof<K, V, N>>, api::Error> {
-        todo!()
-    }
-}