diff --git a/Cargo.lock b/Cargo.lock
index bc7f6ce..f6f9e2c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -939,7 +939,7 @@ checksum = "2a2330da5de22e8a3cb63252ce2abb30116bf5265e89c0e01bc17015ce30a476"
 
 [[package]]
 name = "ddk"
-version = "1.0.8"
+version = "1.0.9"
 dependencies = [
  "async-trait",
  "base64 0.13.1",
@@ -979,7 +979,7 @@ dependencies = [
 
 [[package]]
 name = "ddk-dlc"
-version = "1.0.8"
+version = "1.0.9"
 dependencies = [
  "bitcoin",
  "miniscript",
@@ -991,7 +991,7 @@ dependencies = [
 
 [[package]]
 name = "ddk-manager"
-version = "1.0.8"
+version = "1.0.9"
 dependencies = [
  "async-trait",
  "bitcoin",
@@ -1018,7 +1018,7 @@ dependencies = [
 
 [[package]]
 name = "ddk-messages"
-version = "1.0.8"
+version = "1.0.9"
 dependencies = [
  "bitcoin",
  "ddk-dlc",
@@ -1031,7 +1031,7 @@ dependencies = [
 
 [[package]]
 name = "ddk-node"
-version = "1.0.8"
+version = "1.0.9"
 dependencies = [
  "anyhow",
  "bitcoin",
@@ -1058,7 +1058,7 @@ dependencies = [
 
 [[package]]
 name = "ddk-payouts"
-version = "1.0.8"
+version = "1.0.9"
 dependencies = [
  "anyhow",
  "bitcoin",
@@ -1073,7 +1073,7 @@ dependencies = [
 
 [[package]]
 name = "ddk-trie"
-version = "1.0.8"
+version = "1.0.9"
 dependencies = [
  "bitcoin",
  "ddk-dlc",
@@ -2124,7 +2124,7 @@ dependencies = [
 
 [[package]]
 name = "kormir"
-version = "1.0.8"
+version = "1.0.9"
 dependencies = [
  "base64 0.13.1",
  "bitcoin",
diff --git a/ddk-manager/Cargo.toml b/ddk-manager/Cargo.toml
index 6237045..0336c5b 100644
--- a/ddk-manager/Cargo.toml
+++ b/ddk-manager/Cargo.toml
@@ -6,7 +6,7 @@ homepage = "https://github.com/bennyhodl/rust-dlc"
 license-file = "../LICENSE"
 name = "ddk-manager"
 repository = "https://github.com/bennyhodl/rust-dlc/tree/master/dlc-manager"
-version = "1.0.8"
+version = "1.0.9"
 
 [features]
 default= ["std"]
@@ -19,9 +19,9 @@ use-serde = ["serde", "ddk-dlc/use-serde", "ddk-messages/use-serde", "ddk-trie/u
 async-trait = "0.1.50"
 bitcoin = { version = "0.32.6", default-features = false }
 
-ddk-dlc = { version = "1.0.8", path = "../dlc", features = ["use-serde"] }
-ddk-messages = { version = "1.0.8", path = "../dlc-messages", features = [ "use-serde"] }
-ddk-trie = { version = "1.0.8", path = "../dlc-trie", features = ["use-serde"] }
+ddk-dlc = { version = "1.0.9", path = "../dlc", features = ["use-serde"] }
+ddk-messages = { version = "1.0.9", path = "../dlc-messages", features = [ "use-serde"] }
+ddk-trie = { version = "1.0.9", path = "../dlc-trie", features = ["use-serde"] }
 
 futures = "0.3.31"
 hex = { package = "hex-conservative", version = "0.1" }
diff --git a/ddk-node/Cargo.toml b/ddk-node/Cargo.toml
index 818057a..dd21b8b 100644
--- a/ddk-node/Cargo.toml
+++ b/ddk-node/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ddk-node"
-version = "1.0.8"
+version = "1.0.9"
 authors = ["benny b <ben@bitcoinbay.foundation>"]
 description = "DDK node to facilitate DLC contracts."
 license = "MIT"
@@ -8,11 +8,11 @@ repository = "https://github.com/bennyhodl/dlcdevkit"
 edition = "2021"
 
 [dependencies]
-ddk = { version = "1.0.8", path = "../ddk", features = ["postgres", "kormir", "nostr"] }
-ddk-manager = { version = "1.0.8", path = "../ddk-manager", features = ["use-serde"] }
-ddk-payouts = { version = "1.0.8", path = "../payouts" }
-ddk-dlc = { version = "1.0.8", path = "../dlc", features = ["use-serde"] }
-ddk-messages = { version = "1.0.8", path = "../dlc-messages", features = [ "use-serde"] }
+ddk = { version = "1.0.9", path = "../ddk", features = ["postgres", "kormir", "nostr"] }
+ddk-manager = { version = "1.0.9", path = "../ddk-manager", features = ["use-serde"] }
+ddk-payouts = { version = "1.0.9", path = "../payouts" }
+ddk-dlc = { version = "1.0.9", path = "../dlc", features = ["use-serde"] }
+ddk-messages = { version = "1.0.9", path = "../dlc-messages", features = [ "use-serde"] }
 
 bitcoin = { version = "0.32.6", features = ["rand", "serde"] }
 
diff --git a/ddk-node/src/ddkrpc.rs b/ddk-node/src/ddkrpc.rs
index 7073f79..ad25d1d 100644
--- a/ddk-node/src/ddkrpc.rs
+++ b/ddk-node/src/ddkrpc.rs
@@ -255,6 +255,7 @@ pub struct SignRequest {
     #[prost(oneof = "sign_request::Outcome", tags = "2, 3")]
     pub outcome: ::core::option::Option<sign_request::Outcome>,
 }
+/// Nested message and enum types in `SignRequest`.
 pub mod sign_request {
     #[derive(serde::Serialize, serde::Deserialize)]
     #[allow(clippy::derive_partial_eq_without_eq)]
@@ -276,8 +277,8 @@ pub struct SignResponse {
 /// Generated client implementations.
 pub mod ddk_rpc_client {
     #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
-    use tonic::codegen::http::Uri;
     use tonic::codegen::*;
+    use tonic::codegen::http::Uri;
     #[derive(Debug, Clone)]
     pub struct DdkRpcClient<T> {
         inner: tonic::client::Grpc<T>,
@@ -321,8 +322,9 @@ pub mod ddk_rpc_client {
                     <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                 >,
             >,
-            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
-                Into<StdError> + Send + Sync,
+            <T as tonic::codegen::Service<
+                http::Request<tonic::body::BoxBody>,
+            >>::Error: Into<StdError> + Send + Sync,
         {
             DdkRpcClient::new(InterceptedService::new(inner, interceptor))
         }
@@ -361,103 +363,131 @@ pub mod ddk_rpc_client {
             &mut self,
             request: impl tonic::IntoRequest<super::InfoRequest>,
         ) -> std::result::Result<tonic::Response<super::InfoResponse>, tonic::Status> {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::new(
+                        tonic::Code::Unknown,
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static("/ddkrpc.DdkRpc/Info");
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(GrpcMethod::new("ddkrpc.DdkRpc", "Info"));
+            req.extensions_mut().insert(GrpcMethod::new("ddkrpc.DdkRpc", "Info"));
             self.inner.unary(req, path, codec).await
         }
         pub async fn send_offer(
             &mut self,
             request: impl tonic::IntoRequest<super::SendOfferRequest>,
-        ) -> std::result::Result<tonic::Response<super::SendOfferResponse>, tonic::Status> {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
+        ) -> std::result::Result<
+            tonic::Response<super::SendOfferResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::new(
+                        tonic::Code::Unknown,
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static("/ddkrpc.DdkRpc/SendOffer");
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(GrpcMethod::new("ddkrpc.DdkRpc", "SendOffer"));
+            req.extensions_mut().insert(GrpcMethod::new("ddkrpc.DdkRpc", "SendOffer"));
             self.inner.unary(req, path, codec).await
         }
         pub async fn accept_offer(
             &mut self,
             request: impl tonic::IntoRequest<super::AcceptOfferRequest>,
-        ) -> std::result::Result<tonic::Response<super::AcceptOfferResponse>, tonic::Status>
-        {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
+        ) -> std::result::Result<
+            tonic::Response<super::AcceptOfferResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::new(
+                        tonic::Code::Unknown,
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static("/ddkrpc.DdkRpc/AcceptOffer");
+            let path = http::uri::PathAndQuery::from_static(
+                "/ddkrpc.DdkRpc/AcceptOffer",
+            );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(GrpcMethod::new("ddkrpc.DdkRpc", "AcceptOffer"));
+            req.extensions_mut().insert(GrpcMethod::new("ddkrpc.DdkRpc", "AcceptOffer"));
             self.inner.unary(req, path, codec).await
         }
         pub async fn list_offers(
             &mut self,
             request: impl tonic::IntoRequest<super::ListOffersRequest>,
-        ) -> std::result::Result<tonic::Response<super::ListOffersResponse>, tonic::Status>
-        {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
+        ) -> std::result::Result<
+            tonic::Response<super::ListOffersResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::new(
+                        tonic::Code::Unknown,
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static("/ddkrpc.DdkRpc/ListOffers");
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(GrpcMethod::new("ddkrpc.DdkRpc", "ListOffers"));
+            req.extensions_mut().insert(GrpcMethod::new("ddkrpc.DdkRpc", "ListOffers"));
             self.inner.unary(req, path, codec).await
         }
         pub async fn new_address(
             &mut self,
             request: impl tonic::IntoRequest<super::NewAddressRequest>,
-        ) -> std::result::Result<tonic::Response<super::NewAddressResponse>, tonic::Status>
-        {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
+        ) -> std::result::Result<
+            tonic::Response<super::NewAddressResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::new(
+                        tonic::Code::Unknown,
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static("/ddkrpc.DdkRpc/NewAddress");
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(GrpcMethod::new("ddkrpc.DdkRpc", "NewAddress"));
+            req.extensions_mut().insert(GrpcMethod::new("ddkrpc.DdkRpc", "NewAddress"));
             self.inner.unary(req, path, codec).await
         }
         pub async fn wallet_balance(
             &mut self,
             request: impl tonic::IntoRequest<super::WalletBalanceRequest>,
-        ) -> std::result::Result<tonic::Response<super::WalletBalanceResponse>, tonic::Status>
-        {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
+        ) -> std::result::Result<
+            tonic::Response<super::WalletBalanceResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::new(
+                        tonic::Code::Unknown,
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static("/ddkrpc.DdkRpc/WalletBalance");
+            let path = http::uri::PathAndQuery::from_static(
+                "/ddkrpc.DdkRpc/WalletBalance",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("ddkrpc.DdkRpc", "WalletBalance"));
@@ -466,51 +496,64 @@ pub mod ddk_rpc_client {
         pub async fn wallet_sync(
             &mut self,
             request: impl tonic::IntoRequest<super::WalletSyncRequest>,
-        ) -> std::result::Result<tonic::Response<super::WalletSyncResponse>, tonic::Status>
-        {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
+        ) -> std::result::Result<
+            tonic::Response<super::WalletSyncResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::new(
+                        tonic::Code::Unknown,
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static("/ddkrpc.DdkRpc/WalletSync");
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(GrpcMethod::new("ddkrpc.DdkRpc", "WalletSync"));
+            req.extensions_mut().insert(GrpcMethod::new("ddkrpc.DdkRpc", "WalletSync"));
             self.inner.unary(req, path, codec).await
         }
         pub async fn sync(
             &mut self,
             request: impl tonic::IntoRequest<super::SyncRequest>,
         ) -> std::result::Result<tonic::Response<super::SyncResponse>, tonic::Status> {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::new(
+                        tonic::Code::Unknown,
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static("/ddkrpc.DdkRpc/Sync");
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(GrpcMethod::new("ddkrpc.DdkRpc", "Sync"));
+            req.extensions_mut().insert(GrpcMethod::new("ddkrpc.DdkRpc", "Sync"));
             self.inner.unary(req, path, codec).await
         }
         pub async fn get_wallet_transactions(
             &mut self,
             request: impl tonic::IntoRequest<super::GetWalletTransactionsRequest>,
-        ) -> std::result::Result<tonic::Response<super::GetWalletTransactionsResponse>, tonic::Status>
-        {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
+        ) -> std::result::Result<
+            tonic::Response<super::GetWalletTransactionsResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::new(
+                        tonic::Code::Unknown,
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static("/ddkrpc.DdkRpc/GetWalletTransactions");
+            let path = http::uri::PathAndQuery::from_static(
+                "/ddkrpc.DdkRpc/GetWalletTransactions",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("ddkrpc.DdkRpc", "GetWalletTransactions"));
@@ -519,85 +562,115 @@ pub mod ddk_rpc_client {
         pub async fn list_utxos(
             &mut self,
             request: impl tonic::IntoRequest<super::ListUtxosRequest>,
-        ) -> std::result::Result<tonic::Response<super::ListUtxosResponse>, tonic::Status> {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
+        ) -> std::result::Result<
+            tonic::Response<super::ListUtxosResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::new(
+                        tonic::Code::Unknown,
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static("/ddkrpc.DdkRpc/ListUtxos");
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(GrpcMethod::new("ddkrpc.DdkRpc", "ListUtxos"));
+            req.extensions_mut().insert(GrpcMethod::new("ddkrpc.DdkRpc", "ListUtxos"));
             self.inner.unary(req, path, codec).await
         }
         pub async fn list_peers(
             &mut self,
             request: impl tonic::IntoRequest<super::ListPeersRequest>,
-        ) -> std::result::Result<tonic::Response<super::ListPeersResponse>, tonic::Status> {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
+        ) -> std::result::Result<
+            tonic::Response<super::ListPeersResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::new(
+                        tonic::Code::Unknown,
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static("/ddkrpc.DdkRpc/ListPeers");
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(GrpcMethod::new("ddkrpc.DdkRpc", "ListPeers"));
+            req.extensions_mut().insert(GrpcMethod::new("ddkrpc.DdkRpc", "ListPeers"));
             self.inner.unary(req, path, codec).await
         }
         pub async fn connect_peer(
             &mut self,
             request: impl tonic::IntoRequest<super::ConnectRequest>,
-        ) -> std::result::Result<tonic::Response<super::ConnectResponse>, tonic::Status> {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
+        ) -> std::result::Result<
+            tonic::Response<super::ConnectResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::new(
+                        tonic::Code::Unknown,
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static("/ddkrpc.DdkRpc/ConnectPeer");
+            let path = http::uri::PathAndQuery::from_static(
+                "/ddkrpc.DdkRpc/ConnectPeer",
+            );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(GrpcMethod::new("ddkrpc.DdkRpc", "ConnectPeer"));
+            req.extensions_mut().insert(GrpcMethod::new("ddkrpc.DdkRpc", "ConnectPeer"));
             self.inner.unary(req, path, codec).await
         }
         pub async fn list_oracles(
             &mut self,
             request: impl tonic::IntoRequest<super::ListOraclesRequest>,
-        ) -> std::result::Result<tonic::Response<super::ListOraclesResponse>, tonic::Status>
-        {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
+        ) -> std::result::Result<
+            tonic::Response<super::ListOraclesResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::new(
+                        tonic::Code::Unknown,
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static("/ddkrpc.DdkRpc/ListOracles");
+            let path = http::uri::PathAndQuery::from_static(
+                "/ddkrpc.DdkRpc/ListOracles",
+            );
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(GrpcMethod::new("ddkrpc.DdkRpc", "ListOracles"));
+            req.extensions_mut().insert(GrpcMethod::new("ddkrpc.DdkRpc", "ListOracles"));
             self.inner.unary(req, path, codec).await
         }
         pub async fn list_contracts(
             &mut self,
             request: impl tonic::IntoRequest<super::ListContractsRequest>,
-        ) -> std::result::Result<tonic::Response<super::ListContractsResponse>, tonic::Status>
-        {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
+        ) -> std::result::Result<
+            tonic::Response<super::ListContractsResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::new(
+                        tonic::Code::Unknown,
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static("/ddkrpc.DdkRpc/ListContracts");
+            let path = http::uri::PathAndQuery::from_static(
+                "/ddkrpc.DdkRpc/ListContracts",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("ddkrpc.DdkRpc", "ListContracts"));
@@ -607,32 +680,41 @@ pub mod ddk_rpc_client {
             &mut self,
             request: impl tonic::IntoRequest<super::SendRequest>,
         ) -> std::result::Result<tonic::Response<super::SendResponse>, tonic::Status> {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::new(
+                        tonic::Code::Unknown,
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static("/ddkrpc.DdkRpc/Send");
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(GrpcMethod::new("ddkrpc.DdkRpc", "Send"));
+            req.extensions_mut().insert(GrpcMethod::new("ddkrpc.DdkRpc", "Send"));
             self.inner.unary(req, path, codec).await
         }
         pub async fn oracle_announcements(
             &mut self,
             request: impl tonic::IntoRequest<super::OracleAnnouncementsRequest>,
-        ) -> std::result::Result<tonic::Response<super::OracleAnnouncementsResponse>, tonic::Status>
-        {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
+        ) -> std::result::Result<
+            tonic::Response<super::OracleAnnouncementsResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::new(
+                        tonic::Code::Unknown,
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static("/ddkrpc.DdkRpc/OracleAnnouncements");
+            let path = http::uri::PathAndQuery::from_static(
+                "/ddkrpc.DdkRpc/OracleAnnouncements",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("ddkrpc.DdkRpc", "OracleAnnouncements"));
@@ -641,34 +723,45 @@ pub mod ddk_rpc_client {
         pub async fn create_enum(
             &mut self,
             request: impl tonic::IntoRequest<super::CreateEnumRequest>,
-        ) -> std::result::Result<tonic::Response<super::CreateEnumResponse>, tonic::Status>
-        {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
+        ) -> std::result::Result<
+            tonic::Response<super::CreateEnumResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::new(
+                        tonic::Code::Unknown,
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static("/ddkrpc.DdkRpc/CreateEnum");
             let mut req = request.into_request();
-            req.extensions_mut()
-                .insert(GrpcMethod::new("ddkrpc.DdkRpc", "CreateEnum"));
+            req.extensions_mut().insert(GrpcMethod::new("ddkrpc.DdkRpc", "CreateEnum"));
             self.inner.unary(req, path, codec).await
         }
         pub async fn create_numeric(
             &mut self,
             request: impl tonic::IntoRequest<super::CreateNumericRequest>,
-        ) -> std::result::Result<tonic::Response<super::CreateNumericResponse>, tonic::Status>
-        {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
+        ) -> std::result::Result<
+            tonic::Response<super::CreateNumericResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::new(
+                        tonic::Code::Unknown,
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static("/ddkrpc.DdkRpc/CreateNumeric");
+            let path = http::uri::PathAndQuery::from_static(
+                "/ddkrpc.DdkRpc/CreateNumeric",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("ddkrpc.DdkRpc", "CreateNumeric"));
@@ -678,14 +771,19 @@ pub mod ddk_rpc_client {
             &mut self,
             request: impl tonic::IntoRequest<super::SignRequest>,
         ) -> std::result::Result<tonic::Response<super::SignResponse>, tonic::Status> {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::new(
+                        tonic::Code::Unknown,
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static("/ddkrpc.DdkRpc/SignAnnouncement");
+            let path = http::uri::PathAndQuery::from_static(
+                "/ddkrpc.DdkRpc/SignAnnouncement",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("ddkrpc.DdkRpc", "SignAnnouncement"));
@@ -707,27 +805,45 @@ pub mod ddk_rpc_server {
         async fn send_offer(
             &self,
             request: tonic::Request<super::SendOfferRequest>,
-        ) -> std::result::Result<tonic::Response<super::SendOfferResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::SendOfferResponse>,
+            tonic::Status,
+        >;
         async fn accept_offer(
             &self,
             request: tonic::Request<super::AcceptOfferRequest>,
-        ) -> std::result::Result<tonic::Response<super::AcceptOfferResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::AcceptOfferResponse>,
+            tonic::Status,
+        >;
         async fn list_offers(
             &self,
             request: tonic::Request<super::ListOffersRequest>,
-        ) -> std::result::Result<tonic::Response<super::ListOffersResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::ListOffersResponse>,
+            tonic::Status,
+        >;
         async fn new_address(
             &self,
             request: tonic::Request<super::NewAddressRequest>,
-        ) -> std::result::Result<tonic::Response<super::NewAddressResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::NewAddressResponse>,
+            tonic::Status,
+        >;
         async fn wallet_balance(
             &self,
             request: tonic::Request<super::WalletBalanceRequest>,
-        ) -> std::result::Result<tonic::Response<super::WalletBalanceResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::WalletBalanceResponse>,
+            tonic::Status,
+        >;
         async fn wallet_sync(
             &self,
             request: tonic::Request<super::WalletSyncRequest>,
-        ) -> std::result::Result<tonic::Response<super::WalletSyncResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::WalletSyncResponse>,
+            tonic::Status,
+        >;
         async fn sync(
             &self,
             request: tonic::Request<super::SyncRequest>,
@@ -735,15 +851,24 @@ pub mod ddk_rpc_server {
         async fn get_wallet_transactions(
             &self,
             request: tonic::Request<super::GetWalletTransactionsRequest>,
-        ) -> std::result::Result<tonic::Response<super::GetWalletTransactionsResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::GetWalletTransactionsResponse>,
+            tonic::Status,
+        >;
         async fn list_utxos(
             &self,
             request: tonic::Request<super::ListUtxosRequest>,
-        ) -> std::result::Result<tonic::Response<super::ListUtxosResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::ListUtxosResponse>,
+            tonic::Status,
+        >;
         async fn list_peers(
             &self,
             request: tonic::Request<super::ListPeersRequest>,
-        ) -> std::result::Result<tonic::Response<super::ListPeersResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::ListPeersResponse>,
+            tonic::Status,
+        >;
         async fn connect_peer(
             &self,
             request: tonic::Request<super::ConnectRequest>,
@@ -751,11 +876,17 @@ pub mod ddk_rpc_server {
         async fn list_oracles(
             &self,
             request: tonic::Request<super::ListOraclesRequest>,
-        ) -> std::result::Result<tonic::Response<super::ListOraclesResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::ListOraclesResponse>,
+            tonic::Status,
+        >;
         async fn list_contracts(
             &self,
             request: tonic::Request<super::ListContractsRequest>,
-        ) -> std::result::Result<tonic::Response<super::ListContractsResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::ListContractsResponse>,
+            tonic::Status,
+        >;
         async fn send(
             &self,
             request: tonic::Request<super::SendRequest>,
@@ -763,15 +894,24 @@ pub mod ddk_rpc_server {
         async fn oracle_announcements(
             &self,
             request: tonic::Request<super::OracleAnnouncementsRequest>,
-        ) -> std::result::Result<tonic::Response<super::OracleAnnouncementsResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::OracleAnnouncementsResponse>,
+            tonic::Status,
+        >;
         async fn create_enum(
             &self,
             request: tonic::Request<super::CreateEnumRequest>,
-        ) -> std::result::Result<tonic::Response<super::CreateEnumResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::CreateEnumResponse>,
+            tonic::Status,
+        >;
         async fn create_numeric(
             &self,
             request: tonic::Request<super::CreateNumericRequest>,
-        ) -> std::result::Result<tonic::Response<super::CreateNumericResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::CreateNumericResponse>,
+            tonic::Status,
+        >;
         async fn sign_announcement(
             &self,
             request: tonic::Request<super::SignRequest>,
@@ -800,7 +940,10 @@ pub mod ddk_rpc_server {
                 max_encoding_message_size: None,
             }
         }
-        pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
+        pub fn with_interceptor<F>(
+            inner: T,
+            interceptor: F,
+        ) -> InterceptedService<Self, F>
         where
             F: tonic::service::Interceptor,
         {
@@ -856,15 +999,21 @@ pub mod ddk_rpc_server {
                 "/ddkrpc.DdkRpc/Info" => {
                     #[allow(non_camel_case_types)]
                     struct InfoSvc<T: DdkRpc>(pub Arc<T>);
-                    impl<T: DdkRpc> tonic::server::UnaryService<super::InfoRequest> for InfoSvc<T> {
+                    impl<T: DdkRpc> tonic::server::UnaryService<super::InfoRequest>
+                    for InfoSvc<T> {
                         type Response = super::InfoResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::InfoRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as DdkRpc>::info(&inner, request).await };
+                            let fut = async move {
+                                <T as DdkRpc>::info(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -894,16 +1043,21 @@ pub mod ddk_rpc_server {
                 "/ddkrpc.DdkRpc/SendOffer" => {
                     #[allow(non_camel_case_types)]
                     struct SendOfferSvc<T: DdkRpc>(pub Arc<T>);
-                    impl<T: DdkRpc> tonic::server::UnaryService<super::SendOfferRequest> for SendOfferSvc<T> {
+                    impl<T: DdkRpc> tonic::server::UnaryService<super::SendOfferRequest>
+                    for SendOfferSvc<T> {
                         type Response = super::SendOfferResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::SendOfferRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut =
-                                async move { <T as DdkRpc>::send_offer(&inner, request).await };
+                            let fut = async move {
+                                <T as DdkRpc>::send_offer(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -933,16 +1087,23 @@ pub mod ddk_rpc_server {
                 "/ddkrpc.DdkRpc/AcceptOffer" => {
                     #[allow(non_camel_case_types)]
                     struct AcceptOfferSvc<T: DdkRpc>(pub Arc<T>);
-                    impl<T: DdkRpc> tonic::server::UnaryService<super::AcceptOfferRequest> for AcceptOfferSvc<T> {
+                    impl<
+                        T: DdkRpc,
+                    > tonic::server::UnaryService<super::AcceptOfferRequest>
+                    for AcceptOfferSvc<T> {
                         type Response = super::AcceptOfferResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::AcceptOfferRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut =
-                                async move { <T as DdkRpc>::accept_offer(&inner, request).await };
+                            let fut = async move {
+                                <T as DdkRpc>::accept_offer(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -972,16 +1133,21 @@ pub mod ddk_rpc_server {
                 "/ddkrpc.DdkRpc/ListOffers" => {
                     #[allow(non_camel_case_types)]
                     struct ListOffersSvc<T: DdkRpc>(pub Arc<T>);
-                    impl<T: DdkRpc> tonic::server::UnaryService<super::ListOffersRequest> for ListOffersSvc<T> {
+                    impl<T: DdkRpc> tonic::server::UnaryService<super::ListOffersRequest>
+                    for ListOffersSvc<T> {
                         type Response = super::ListOffersResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::ListOffersRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut =
-                                async move { <T as DdkRpc>::list_offers(&inner, request).await };
+                            let fut = async move {
+                                <T as DdkRpc>::list_offers(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -1011,16 +1177,21 @@ pub mod ddk_rpc_server {
                 "/ddkrpc.DdkRpc/NewAddress" => {
                     #[allow(non_camel_case_types)]
                     struct NewAddressSvc<T: DdkRpc>(pub Arc<T>);
-                    impl<T: DdkRpc> tonic::server::UnaryService<super::NewAddressRequest> for NewAddressSvc<T> {
+                    impl<T: DdkRpc> tonic::server::UnaryService<super::NewAddressRequest>
+                    for NewAddressSvc<T> {
                         type Response = super::NewAddressResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::NewAddressRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut =
-                                async move { <T as DdkRpc>::new_address(&inner, request).await };
+                            let fut = async move {
+                                <T as DdkRpc>::new_address(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -1050,16 +1221,23 @@ pub mod ddk_rpc_server {
                 "/ddkrpc.DdkRpc/WalletBalance" => {
                     #[allow(non_camel_case_types)]
                     struct WalletBalanceSvc<T: DdkRpc>(pub Arc<T>);
-                    impl<T: DdkRpc> tonic::server::UnaryService<super::WalletBalanceRequest> for WalletBalanceSvc<T> {
+                    impl<
+                        T: DdkRpc,
+                    > tonic::server::UnaryService<super::WalletBalanceRequest>
+                    for WalletBalanceSvc<T> {
                         type Response = super::WalletBalanceResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::WalletBalanceRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut =
-                                async move { <T as DdkRpc>::wallet_balance(&inner, request).await };
+                            let fut = async move {
+                                <T as DdkRpc>::wallet_balance(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -1089,16 +1267,21 @@ pub mod ddk_rpc_server {
                 "/ddkrpc.DdkRpc/WalletSync" => {
                     #[allow(non_camel_case_types)]
                     struct WalletSyncSvc<T: DdkRpc>(pub Arc<T>);
-                    impl<T: DdkRpc> tonic::server::UnaryService<super::WalletSyncRequest> for WalletSyncSvc<T> {
+                    impl<T: DdkRpc> tonic::server::UnaryService<super::WalletSyncRequest>
+                    for WalletSyncSvc<T> {
                         type Response = super::WalletSyncResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::WalletSyncRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut =
-                                async move { <T as DdkRpc>::wallet_sync(&inner, request).await };
+                            let fut = async move {
+                                <T as DdkRpc>::wallet_sync(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -1128,15 +1311,21 @@ pub mod ddk_rpc_server {
                 "/ddkrpc.DdkRpc/Sync" => {
                     #[allow(non_camel_case_types)]
                     struct SyncSvc<T: DdkRpc>(pub Arc<T>);
-                    impl<T: DdkRpc> tonic::server::UnaryService<super::SyncRequest> for SyncSvc<T> {
+                    impl<T: DdkRpc> tonic::server::UnaryService<super::SyncRequest>
+                    for SyncSvc<T> {
                         type Response = super::SyncResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::SyncRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as DdkRpc>::sync(&inner, request).await };
+                            let fut = async move {
+                                <T as DdkRpc>::sync(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -1166,18 +1355,23 @@ pub mod ddk_rpc_server {
                 "/ddkrpc.DdkRpc/GetWalletTransactions" => {
                     #[allow(non_camel_case_types)]
                     struct GetWalletTransactionsSvc<T: DdkRpc>(pub Arc<T>);
-                    impl<T: DdkRpc> tonic::server::UnaryService<super::GetWalletTransactionsRequest>
-                        for GetWalletTransactionsSvc<T>
-                    {
+                    impl<
+                        T: DdkRpc,
+                    > tonic::server::UnaryService<super::GetWalletTransactionsRequest>
+                    for GetWalletTransactionsSvc<T> {
                         type Response = super::GetWalletTransactionsResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::GetWalletTransactionsRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as DdkRpc>::get_wallet_transactions(&inner, request).await
+                                <T as DdkRpc>::get_wallet_transactions(&inner, request)
+                                    .await
                             };
                             Box::pin(fut)
                         }
@@ -1208,16 +1402,21 @@ pub mod ddk_rpc_server {
                 "/ddkrpc.DdkRpc/ListUtxos" => {
                     #[allow(non_camel_case_types)]
                     struct ListUtxosSvc<T: DdkRpc>(pub Arc<T>);
-                    impl<T: DdkRpc> tonic::server::UnaryService<super::ListUtxosRequest> for ListUtxosSvc<T> {
+                    impl<T: DdkRpc> tonic::server::UnaryService<super::ListUtxosRequest>
+                    for ListUtxosSvc<T> {
                         type Response = super::ListUtxosResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::ListUtxosRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut =
-                                async move { <T as DdkRpc>::list_utxos(&inner, request).await };
+                            let fut = async move {
+                                <T as DdkRpc>::list_utxos(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -1247,16 +1446,21 @@ pub mod ddk_rpc_server {
                 "/ddkrpc.DdkRpc/ListPeers" => {
                     #[allow(non_camel_case_types)]
                     struct ListPeersSvc<T: DdkRpc>(pub Arc<T>);
-                    impl<T: DdkRpc> tonic::server::UnaryService<super::ListPeersRequest> for ListPeersSvc<T> {
+                    impl<T: DdkRpc> tonic::server::UnaryService<super::ListPeersRequest>
+                    for ListPeersSvc<T> {
                         type Response = super::ListPeersResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::ListPeersRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut =
-                                async move { <T as DdkRpc>::list_peers(&inner, request).await };
+                            let fut = async move {
+                                <T as DdkRpc>::list_peers(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -1286,16 +1490,21 @@ pub mod ddk_rpc_server {
                 "/ddkrpc.DdkRpc/ConnectPeer" => {
                     #[allow(non_camel_case_types)]
                     struct ConnectPeerSvc<T: DdkRpc>(pub Arc<T>);
-                    impl<T: DdkRpc> tonic::server::UnaryService<super::ConnectRequest> for ConnectPeerSvc<T> {
+                    impl<T: DdkRpc> tonic::server::UnaryService<super::ConnectRequest>
+                    for ConnectPeerSvc<T> {
                         type Response = super::ConnectResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::ConnectRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut =
-                                async move { <T as DdkRpc>::connect_peer(&inner, request).await };
+                            let fut = async move {
+                                <T as DdkRpc>::connect_peer(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -1325,16 +1534,23 @@ pub mod ddk_rpc_server {
                 "/ddkrpc.DdkRpc/ListOracles" => {
                     #[allow(non_camel_case_types)]
                     struct ListOraclesSvc<T: DdkRpc>(pub Arc<T>);
-                    impl<T: DdkRpc> tonic::server::UnaryService<super::ListOraclesRequest> for ListOraclesSvc<T> {
+                    impl<
+                        T: DdkRpc,
+                    > tonic::server::UnaryService<super::ListOraclesRequest>
+                    for ListOraclesSvc<T> {
                         type Response = super::ListOraclesResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::ListOraclesRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut =
-                                async move { <T as DdkRpc>::list_oracles(&inner, request).await };
+                            let fut = async move {
+                                <T as DdkRpc>::list_oracles(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -1364,16 +1580,23 @@ pub mod ddk_rpc_server {
                 "/ddkrpc.DdkRpc/ListContracts" => {
                     #[allow(non_camel_case_types)]
                     struct ListContractsSvc<T: DdkRpc>(pub Arc<T>);
-                    impl<T: DdkRpc> tonic::server::UnaryService<super::ListContractsRequest> for ListContractsSvc<T> {
+                    impl<
+                        T: DdkRpc,
+                    > tonic::server::UnaryService<super::ListContractsRequest>
+                    for ListContractsSvc<T> {
                         type Response = super::ListContractsResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::ListContractsRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut =
-                                async move { <T as DdkRpc>::list_contracts(&inner, request).await };
+                            let fut = async move {
+                                <T as DdkRpc>::list_contracts(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -1403,15 +1626,21 @@ pub mod ddk_rpc_server {
                 "/ddkrpc.DdkRpc/Send" => {
                     #[allow(non_camel_case_types)]
                     struct SendSvc<T: DdkRpc>(pub Arc<T>);
-                    impl<T: DdkRpc> tonic::server::UnaryService<super::SendRequest> for SendSvc<T> {
+                    impl<T: DdkRpc> tonic::server::UnaryService<super::SendRequest>
+                    for SendSvc<T> {
                         type Response = super::SendResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::SendRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut = async move { <T as DdkRpc>::send(&inner, request).await };
+                            let fut = async move {
+                                <T as DdkRpc>::send(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -1441,11 +1670,15 @@ pub mod ddk_rpc_server {
                 "/ddkrpc.DdkRpc/OracleAnnouncements" => {
                     #[allow(non_camel_case_types)]
                     struct OracleAnnouncementsSvc<T: DdkRpc>(pub Arc<T>);
-                    impl<T: DdkRpc> tonic::server::UnaryService<super::OracleAnnouncementsRequest>
-                        for OracleAnnouncementsSvc<T>
-                    {
+                    impl<
+                        T: DdkRpc,
+                    > tonic::server::UnaryService<super::OracleAnnouncementsRequest>
+                    for OracleAnnouncementsSvc<T> {
                         type Response = super::OracleAnnouncementsResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::OracleAnnouncementsRequest>,
@@ -1483,16 +1716,21 @@ pub mod ddk_rpc_server {
                 "/ddkrpc.DdkRpc/CreateEnum" => {
                     #[allow(non_camel_case_types)]
                     struct CreateEnumSvc<T: DdkRpc>(pub Arc<T>);
-                    impl<T: DdkRpc> tonic::server::UnaryService<super::CreateEnumRequest> for CreateEnumSvc<T> {
+                    impl<T: DdkRpc> tonic::server::UnaryService<super::CreateEnumRequest>
+                    for CreateEnumSvc<T> {
                         type Response = super::CreateEnumResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::CreateEnumRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut =
-                                async move { <T as DdkRpc>::create_enum(&inner, request).await };
+                            let fut = async move {
+                                <T as DdkRpc>::create_enum(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -1522,16 +1760,23 @@ pub mod ddk_rpc_server {
                 "/ddkrpc.DdkRpc/CreateNumeric" => {
                     #[allow(non_camel_case_types)]
                     struct CreateNumericSvc<T: DdkRpc>(pub Arc<T>);
-                    impl<T: DdkRpc> tonic::server::UnaryService<super::CreateNumericRequest> for CreateNumericSvc<T> {
+                    impl<
+                        T: DdkRpc,
+                    > tonic::server::UnaryService<super::CreateNumericRequest>
+                    for CreateNumericSvc<T> {
                         type Response = super::CreateNumericResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::CreateNumericRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut =
-                                async move { <T as DdkRpc>::create_numeric(&inner, request).await };
+                            let fut = async move {
+                                <T as DdkRpc>::create_numeric(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -1561,9 +1806,13 @@ pub mod ddk_rpc_server {
                 "/ddkrpc.DdkRpc/SignAnnouncement" => {
                     #[allow(non_camel_case_types)]
                     struct SignAnnouncementSvc<T: DdkRpc>(pub Arc<T>);
-                    impl<T: DdkRpc> tonic::server::UnaryService<super::SignRequest> for SignAnnouncementSvc<T> {
+                    impl<T: DdkRpc> tonic::server::UnaryService<super::SignRequest>
+                    for SignAnnouncementSvc<T> {
                         type Response = super::SignResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::SignRequest>,
@@ -1598,14 +1847,18 @@ pub mod ddk_rpc_server {
                     };
                     Box::pin(fut)
                 }
-                _ => Box::pin(async move {
-                    Ok(http::Response::builder()
-                        .status(200)
-                        .header("grpc-status", "12")
-                        .header("content-type", "application/grpc")
-                        .body(empty_body())
-                        .unwrap())
-                }),
+                _ => {
+                    Box::pin(async move {
+                        Ok(
+                            http::Response::builder()
+                                .status(200)
+                                .header("grpc-status", "12")
+                                .header("content-type", "application/grpc")
+                                .body(empty_body())
+                                .unwrap(),
+                        )
+                    })
+                }
             }
         }
     }
diff --git a/ddk/Cargo.toml b/ddk/Cargo.toml
index 399fd86..10c9fed 100644
--- a/ddk/Cargo.toml
+++ b/ddk/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ddk"
-version = "1.0.8"
+version = "1.0.9"
 edition = "2021"
 license = "MIT"
 description = "application tooling for DLCs 🌊"
@@ -24,10 +24,10 @@ sled = ["dep:sled"]
 postgres = ["dep:sqlx", "sqlx/postgres"]
 
 [dependencies]
-ddk-manager = { version = "1.0.8", path = "../ddk-manager", features = ["use-serde"] }
-ddk-dlc = { version = "1.0.8", path = "../dlc", features = ["use-serde"] }
-ddk-messages = { version = "1.0.8", path = "../dlc-messages", features = [ "use-serde"] }
-ddk-trie = { version = "1.0.8", path = "../dlc-trie", features = ["use-serde"] }
+ddk-manager = { version = "1.0.9", path = "../ddk-manager", features = ["use-serde"] }
+ddk-dlc = { version = "1.0.9", path = "../dlc", features = ["use-serde"] }
+ddk-messages = { version = "1.0.9", path = "../dlc-messages", features = [ "use-serde"] }
+ddk-trie = { version = "1.0.9", path = "../dlc-trie", features = ["use-serde"] }
 
 bitcoin = { version = "0.32.6", features = ["rand", "serde"] }
 bdk_esplora = { version = "0.22.0", features = ["blocking-https", "async-https", "tokio"] }
@@ -58,7 +58,7 @@ lightning-net-tokio = { version = "0.1.0", optional = true }
 
 # oracle feature
 reqwest = { version = "0.12.9", features = ["json"], optional = true }
-kormir = { version = "1.0.8", path = "../kormir" }
+kormir = { version = "1.0.9", path = "../kormir" }
 hmac = "0.12.1"
 sha2 = "0.10"
 nostr-database = { version = "0.40.0", optional = true }
diff --git a/dlc-messages/Cargo.toml b/dlc-messages/Cargo.toml
index 9787deb..4912cc0 100644
--- a/dlc-messages/Cargo.toml
+++ b/dlc-messages/Cargo.toml
@@ -5,7 +5,7 @@ homepage = "https://github.com/bennyhodl/dlcdevkit"
 license-file = "../LICENSE"
 name = "ddk-messages"
 repository = "https://github.com/bennyhodl/dlcdevkit/tree/master/dlc-messages"
-version = "1.0.8"
+version = "1.0.9"
 edition = "2015"
 
 [features]
@@ -16,7 +16,7 @@ use-serde = ["serde", "secp256k1-zkp/serde", "bitcoin/serde"]
 
 [dependencies]
 bitcoin = { version = "0.32.6", default-features = false }
-ddk-dlc = { version = "1.0.8", path = "../dlc", default-features = false }
+ddk-dlc = { version = "1.0.9", path = "../dlc", default-features = false }
 lightning = { version = "0.1.5", default-features = false }
 secp256k1-zkp = { version = "0.11.0" }
 serde = {version = "1.0", features = ["derive"], optional = true}
diff --git a/dlc-trie/Cargo.toml b/dlc-trie/Cargo.toml
index 6f08414..1111ffb 100644
--- a/dlc-trie/Cargo.toml
+++ b/dlc-trie/Cargo.toml
@@ -5,7 +5,7 @@ homepage = "https://github.com/bennyhodl/dlcdevkit"
 license-file = "../LICENSE"
 name = "ddk-trie"
 repository = "https://github.com/bennyhodl/dlcdevkit/tree/master/dlc-trie"
-version = "1.0.8"
+version = "1.0.9"
 edition = "2015"
 
 [features]
@@ -17,7 +17,7 @@ use-serde = ["serde", "ddk-dlc/use-serde"]
 
 [dependencies]
 bitcoin = { version = "0.32.6", default-features = false }
-ddk-dlc = { version = "1.0.8", path = "../dlc", default-features = false }
+ddk-dlc = { version = "1.0.9", path = "../dlc", default-features = false }
 rayon = {version = "1.5", optional = true}
 secp256k1-zkp = {version = "0.11.0" }
 serde = {version = "1.0", optional = true, default-features = false, features = ["derive"]}
diff --git a/dlc/Cargo.toml b/dlc/Cargo.toml
index 87a24e0..bf089f1 100644
--- a/dlc/Cargo.toml
+++ b/dlc/Cargo.toml
@@ -5,7 +5,7 @@ homepage = "https://github.com/bennyhodl/dlcdevkit"
 license-file = "../LICENSE"
 name = "ddk-dlc"
 repository = "https://github.com/bennyhodl/dlcdevkit/tree/master/dlc"
-version = "1.0.8"
+version = "1.0.9"
 edition = "2015"
 
 [dependencies]
diff --git a/kormir/Cargo.toml b/kormir/Cargo.toml
index 8cb12be..8a1bc4f 100644
--- a/kormir/Cargo.toml
+++ b/kormir/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "kormir"
-version = "1.0.8"
+version = "1.0.9"
 edition = "2021"
 authors = ["benthecarman <ben@mutinywallet.com>", "benny b <ben@bitcoinbay.foundation>"]
 description = "Oracle implementation for DLCs"
@@ -15,8 +15,8 @@ nostr = ["dep:nostr", "dep:base64"]
 
 [dependencies]
 bitcoin = { version = "0.32.6", features = ["serde"] }
-ddk-dlc = { version = "1.0.8", path = "../dlc", features = ["use-serde"] }
-ddk-messages = { version = "1.0.8", path = "../dlc-messages", features = [ "use-serde"] }
+ddk-dlc = { version = "1.0.9", path = "../dlc", features = ["use-serde"] }
+ddk-messages = { version = "1.0.9", path = "../dlc-messages", features = [ "use-serde"] }
 lightning = "0.1.5"
 log = "0.4.22"
 nostr = { version = "0.40.0", optional = true }
diff --git a/payouts/Cargo.toml b/payouts/Cargo.toml
index 9230f05..7083af0 100644
--- a/payouts/Cargo.toml
+++ b/payouts/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ddk-payouts"
-version = "1.0.8"
+version = "1.0.9"
 authors = ["benny b <ben@bitcoinbay.foundation>"]
 description = "Library to build payout functions for DLC contracts."
 license = "MIT"
@@ -8,10 +8,10 @@ repository = "https://github.com/bennyhodl/dlcdevkit"
 edition = "2021"
 
 [dependencies]
-ddk-manager = { version = "1.0.8", path = "../ddk-manager", features = ["use-serde"] }
-ddk-dlc = { version = "1.0.8", path = "../dlc", features = ["use-serde"] }
-ddk-messages = { version = "1.0.8", path = "../dlc-messages", features = ["use-serde"] }
-ddk-trie = { version = "1.0.8", path = "../dlc-trie", features = ["use-serde"] }
+ddk-manager = { version = "1.0.9", path = "../ddk-manager", features = ["use-serde"] }
+ddk-dlc = { version = "1.0.9", path = "../dlc", features = ["use-serde"] }
+ddk-messages = { version = "1.0.9", path = "../dlc-messages", features = ["use-serde"] }
+ddk-trie = { version = "1.0.9", path = "../dlc-trie", features = ["use-serde"] }
 
 bitcoin = "0.32.6"
 serde = { version = "1.0.209", features = ["derive"] }