@dignetwork/chia-block-listener 0.1.18 → 0.1.19

package/.github/workflows/ci.yml

@@ -0,0 +1,74 @@
+name: CI
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  rust-checks:
+    name: Rust checks (fmt, clippy)
+    runs-on: ubuntu-22.04
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Cache cargo
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+
+      - name: Format check
+        run: cargo fmt --all -- --check
+
+      - name: Clippy
+        run: cargo clippy --workspace --all-targets -- -D warnings
+
+  build:
+    name: Build (${{ matrix.os }})
+    needs: rust-checks
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-22.04, macos-14, windows-latest]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 22
+
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Cache cargo
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+
+      - name: Install yarn
+        run: corepack enable && corepack prepare yarn@1.22.22 --activate
+
+      - name: Install @napi-rs/cli
+        run: yarn global add @napi-rs/cli@^2.18.4
+
+      - name: Install deps
+        run: yarn install --frozen-lockfile
+
+      - name: Build NAPI addon
+        run: yarn build

package/.github/workflows/release.yml

@@ -0,0 +1,227 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  publish-crates:
+    name: Publish crates to crates.io
+    runs-on: ubuntu-22.04
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          components: rustfmt, clippy
+
+      - name: Cache cargo
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+
+      - name: Install curl + python3
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y curl python3
+
+      # Enforce the same quality gates as CI for the crates you publish.
+      - name: Rust fmt check (published crates)
+        run: cargo fmt --all -- --check
+
+      - name: Rust clippy (published crates)
+        run: |
+          cargo clippy \
+            -p dig-dns-discovery \
+            -p chia-generator-parser \
+            -p chia-block-listener \
+            --all-targets \
+            -- -D warnings
+
+      - name: Cargo login
+        env:
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
+        run: cargo login "$CARGO_REGISTRY_TOKEN"
+
+      - name: Publish dig-dns-discovery (dry-run + if needed)
+        env:
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
+        working-directory: ./crate/dig-dns-discovery
+        shell: bash
+        run: |
+          set -euo pipefail
+          CRATE="dig-dns-discovery"
+          VER="$(cargo metadata --no-deps --format-version 1 | python3 -c 'import sys, json; print(json.load(sys.stdin)["packages"][0]["version"])')"
+          echo "Crate: ${CRATE}  Version: ${VER}"
+
+          # Validate publish packaging/build without uploading
+          cargo publish --dry-run
+
+          CODE="$(curl -s -o /dev/null -w "%{http_code}" "https://crates.io/api/v1/crates/${CRATE}/${VER}" || true)"
+          if [ "$CODE" = "200" ]; then
+            echo "Already published: ${CRATE} ${VER} (skipping upload)."
+            exit 0
+          fi
+
+          cargo publish --no-verify
+
+      - name: Publish chia-generator-parser (dry-run + if needed)
+        env:
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
+        working-directory: ./crate/chia-generator-parser
+        shell: bash
+        run: |
+          set -euo pipefail
+          CRATE="chia-generator-parser"
+          VER="$(cargo metadata --no-deps --format-version 1 | python3 -c 'import sys, json; print(json.load(sys.stdin)["packages"][0]["version"])')"
+          echo "Crate: ${CRATE}  Version: ${VER}"
+
+          cargo publish --dry-run
+
+          CODE="$(curl -s -o /dev/null -w "%{http_code}" "https://crates.io/api/v1/crates/${CRATE}/${VER}" || true)"
+          if [ "$CODE" = "200" ]; then
+            echo "Already published: ${CRATE} ${VER} (skipping upload)."
+            exit 0
+          fi
+
+          cargo publish --no-verify
+
+      # Reduce flakiness: ensure the dependency versions are visible before publishing chia-block-listener.
+      - name: Wait for crates.io visibility (dig-dns-discovery + chia-generator-parser)
+        shell: bash
+        run: |
+          set -euo pipefail
+          DIG_VER="$(cargo metadata --no-deps --format-version 1 | python3 -c 'import sys, json; print(json.load(sys.stdin)["packages"][0]["version"])')"
+          PAR_VER="$(cargo metadata --no-deps --format-version 1 | python3 -c 'import sys, json; print(json.load(sys.stdin)["packages"][0]["version"])')"
+
+          check() {
+            local crate="$1" ver="$2"
+            curl -s -o /dev/null -w "%{http_code}" "https://crates.io/api/v1/crates/${crate}/${ver}" || true
+          }
+
+          for i in {1..24}; do
+            A="$(check dig-dns-discovery "$DIG_VER")"
+            B="$(check chia-generator-parser "$PAR_VER")"
+            if [ "$A" = "200" ] && [ "$B" = "200" ]; then
+              echo "Deps visible on crates.io."
+              exit 0
+            fi
+            echo "Waiting for crates.io visibility... (${i}/24)"
+            sleep 5
+          done
+
+          echo "Timed out waiting for dependency crates to be visible on crates.io."
+          exit 1
+
+      - name: Publish chia-block-listener (dry-run + if needed)
+        env:
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
+        working-directory: .
+        shell: bash
+        run: |
+          set -euo pipefail
+          CRATE="chia-block-listener"
+          VER="$(cargo metadata --no-deps --format-version 1 | python3 -c 'import sys, json; print(json.load(sys.stdin)["packages"][0]["version"])')"
+          echo "Crate: ${CRATE}  Version: ${VER}"
+
+          cargo publish --dry-run
+
+          CODE="$(curl -s -o /dev/null -w "%{http_code}" "https://crates.io/api/v1/crates/${CRATE}/${VER}" || true)"
+          if [ "$CODE" = "200" ]; then
+            echo "Already published: ${CRATE} ${VER} (skipping upload)."
+            exit 0
+          fi
+
+          cargo publish --no-verify
+
+  build:
+    name: Build binaries (${{ matrix.os }})
+    needs: publish-crates
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-22.04, macos-14, windows-latest]
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 22
+
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Cache cargo
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+
+      - name: Install yarn
+        run: corepack enable && corepack prepare yarn@1.22.22 --activate
+
+      - name: Install @napi-rs/cli
+        run: yarn global add @napi-rs/cli@^2.18.4
+
+      - name: Install deps
+        run: yarn install --frozen-lockfile
+
+      - name: Build artifacts
+        run: yarn build
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: artifacts-${{ runner.os }}
+          path: |
+            ./*.node
+            npm/**/package.json
+            npm/**/*.node
+
+  publish:
+    name: Publish to npm
+    needs: [ publish-crates, build ]
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          registry-url: "https://registry.npmjs.org"
+
+      - name: Install yarn
+        run: corepack enable && corepack prepare yarn@1.22.22 --activate
+
+      - name: Install deps
+        run: yarn install --frozen-lockfile
+
+      - name: Download artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: artifacts
+          merge-multiple: true
+
+      - name: Install yarn
+        run: corepack enable && corepack prepare yarn@1.22.22 --activate
+
+      - name: Install deps
+        run: yarn install --frozen-lockfile
+
+      - name: Publish main npm package
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+        run: npm publish --access public

package/Cargo.toml

@@ -1,19 +1,16 @@
 [package]
 name = "chia-block-listener"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
-
-[lib]
-crate-type = ["cdylib"]
+description = "Event driven listener and messaging interface for Chia blockchain peers"
+license = "Apache-2.0" # or "MIT" / "MIT OR Apache-2.0" etc.
 
 [dependencies]
-# NAPI-rs for Node.js bindings
-napi = { version = "2", features = ["napi9", "tokio_rt", "async"] }
-napi-derive = "2"
 
 # Async runtime
 tokio = { version = "1", features = ["full"] }
 futures-util = "0.3"
+tokio-util = "0.7"
 
 # Chia-related dependencies
 chia-protocol = "0.26"
@@ -34,13 +31,20 @@ tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 sha2 = "0.10"
 dirs = "5"
-
-# Local crates
-chia-generator-parser = { path = "./crate/chia-generator-parser" }
-dns-discovery = { path = "./crate/dns-discovery" }
-
-[build-dependencies]
-napi-build = "2"
+dig-dns-discovery = { workspace = true }
+chia-generator-parser = { workspace = true}
 
 [profile.release]
 lto = true
+
+[workspace]
+members = [
+    ".",
+    "crate/chia-generator-parser",
+    "crate/dig-dns-discovery",
+    "crate/chia-block-listener-napi",
+]
+
+[workspace.dependencies]
+dig-dns-discovery = { path = "crate/dig-dns-discovery", version = "0.2.0" }
+chia-generator-parser = { path = "crate/chia-generator-parser", version = "0.2.0" }

package/README.md

@@ -68,6 +68,123 @@ process.on('SIGINT', () => {
   process.exit(0)
 })
 ```
+
+## Rust usage (canonical, Rust-first interface)
+
+This repository now provides a pure Rust API suitable for use in Tokio-based applications, while the N-API adapter remains a thin layer for Node.js. The Rust-facing entry point is `BlockListener` (previously named `Listener`).
+
+Key points of the Rust API:
+- Your application owns the policy/event loop. The library only manages networking, peers, and event emission.
+- Subscribe to events via a bounded broadcast channel. Delivery is best-effort; slow consumers may miss messages, which is appropriate for catch-up/skip logic.
+- Structured shutdown: signal cancellation quickly and optionally wait for all internal tasks to complete.
+
+Example:
+
+```rust
+use chia_block_listener::{init_tracing, BlockListener, ListenerConfig};
+use chia_block_listener::types::Event;
+use tokio_stream::wrappers::BroadcastStream;
+use tokio_stream::StreamExt;
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    // Optional: enable logging
+    init_tracing();
+
+    // Configure and create the block listener (buffer defaults to 1024)
+    let block_listener = BlockListener::new(ListenerConfig::default())?;
+
+    // Subscribe to events (bounded, best-effort delivery)
+    let rx = block_listener.subscribe();
+    let mut events = BroadcastStream::new(rx);
+
+    // Connect a peer
+    let _peer_id = block_listener.add_peer("localhost".into(), 8444, "mainnet".into()).await?;
+
+    // Application-owned policy loop: read events and act
+    let policy = tokio::spawn(async move {
+        while let Some(item) = events.next().await {
+            match item {
+                Ok(Event::PeerConnected(e)) => {
+                    println!("connected: {} ({}:{})", e.peer_id, e.host, e.port);
+                }
+                Ok(Event::PeerDisconnected(e)) => {
+                    println!("disconnected: {} reason={:?}", e.peer_id, e.message);
+                }
+                Ok(Event::NewPeakHeight(e)) => {
+                    println!("new peak: old={:?} new={} from {}", e.old_peak, e.new_peak, e.peer_id);
+                }
+                Ok(Event::BlockReceived(b)) => {
+                    println!("block {} {}", b.height, b.header_hash);
+                }
+                Err(_lagged) => {
+                    // One or more messages were missed (slow consumer). Best-effort model: recompute current state if needed.
+                    // For catch-up use cases, you generally only need latest peak or most recent block.
+                }
+            }
+        }
+    });
+
+    // Shutdown example (e.g., on SIGINT/SIGTERM):
+    // Signal fast
+    block_listener.shutdown().await?;
+    // Wait for all internal tasks to end deterministically
+    block_listener.shutdown_and_wait().await?;
+
+    policy.await?;
+    Ok(())
+}
+```
+
+### Backpressure and delivery guarantees
+- The core guarantees that parsed blocks are submitted into the internal event pipeline (no pre-broadcast drop). Blocks are enqueued with backpressure inside the pool and forwarded to the broadcast dispatcher.
+- Event broadcast to subscribers uses a bounded buffer (default 1024). If a subscriber is slow, it may receive `Lagged(n)` from the stream wrapper, meaning it missed `n` events. This affects slow subscribers only and does not cause block events to be dropped before entering the broadcast.
+- Informational events (peerConnected, peerDisconnected, newPeakHeight) are best-effort before broadcast and may be dropped under overload to avoid stalling networking.
+- Recommended approach for “catch-up” logic: maintain your own application state keyed by height/epoch and cancel/work-skip as newer events arrive. If you need every block for historical processing, use explicit queries like `get_block_by_height`/ranges in addition to the live stream.
+
+### Passive WebSocket listening and multi-peer behavior
+- **Listener, not poller:** Each `add_peer` establishes a dedicated streaming WebSocket reader (per peer) that passively consumes protocol messages and drives events. `NewPeakWallet` triggers a `RequestBlock` immediately; `RespondBlock` is parsed and emitted as `Event::BlockReceived` via the core event pipeline.
+- **Unified event pipeline:** All live events (`PeerConnected`, `PeerDisconnected`, `NewPeakHeight`, `BlockReceived`) flow through a single core mpsc sink and are forwarded to all subscribers via `broadcast`. Blocks use `send().await` into the sink (no pre-broadcast drop); informational events are best-effort `try_send` to avoid stalling I/O.
+- **Multiple peers:** You can call `add_peer` multiple times. The pool tracks each peer independently with its own streaming reader and request worker. On-demand requests (`get_block_by_height`) use round-robin with cooldown and remove unhealthy peers based on repeated failures/timeouts/protocol errors.
+- **Consumption pattern:** Your app owns the policy loop—subscribe once, then react to events as they arrive. Slow subscribers may receive `Lagged(n)` from the broadcast wrapper; recompute state as needed. For guaranteed historical coverage, pair live listening with explicit `get_block_by_height` / range queries.
+- **Shutdown:** `shutdown()` signals cancellation; `shutdown_and_wait()` awaits the dispatcher and all tracked peer/request tasks for deterministic teardown. `Drop` on `Listener` signals cancel without awaiting (non-blocking drop safety).
+
+### Auto-reconnect (DNS-driven, Rust API)
+- **Opt-in via config:** Set `BlockListenerConfig { auto_reconnect: true, network_id, default_port, max_auto_reconnect_retries, .. }` when constructing `BlockListener`.
+- **When it runs:** The auto-reconnect task starts on the first `subscribe()` call. It keeps one active peer for you; manual `add_peer` calls still work and can coexist.
+- **How it works:**
+  - Uses the core DNS introducers for the configured `network_id` (default `mainnet`) and `default_port` (default `8444`).
+  - On startup (if no peers connected) or when all peers disconnect, it runs discovery, shuffles the results, and tries each peer in the batch until one connects.
+  - If a peer disconnects and none remain, discovery is rerun and peers are retried in batches up to `max_auto_reconnect_retries` (default 10 batches). Failure after all retries surfaces a best-effort `PeerDisconnected` event with an explanatory message.
+- **Backpressure & events:** Once connected, live events still flow through the same sink → broadcast pipeline; block delivery guarantees and backpressure semantics remain unchanged.
+- **Example:**
+```rust
+use chia_block_listener::{BlockListener, BlockListenerConfig};
+
+let config = BlockListenerConfig {
+    auto_reconnect: true,
+    network_id: "mainnet".into(),
+    default_port: 8444,
+    max_auto_reconnect_retries: 10,
+    buffer: 1024,
+};
+
+let listener = BlockListener::new(config)?;
+let mut rx = listener.subscribe(); // kicks off auto-reconnect
+```
+
+### Shutdown semantics
+- `shutdown()` signals cancellation and returns quickly.
+- `shutdown_and_wait()` cancels and then awaits all internal tasks to finish (peer workers, request processor, dispatchers), providing deterministic shutdown.
+
+### Configuration
+- `BlockListenerConfig` exposes:
+  - `buffer` (event buffer per subscriber, default 1024)
+  - `auto_reconnect` (enable DNS-based single-peer maintenance)
+  - `network_id` (e.g., `mainnet`, `testnet11`; used for DNS discovery)
+  - `default_port` (port used for discovered peers, default 8444)
+  - `max_auto_reconnect_retries` (discovery batches to attempt before surfacing an error event, default 10)
+- Additional knobs (timeouts, rate limits, etc.) are centralized in the core with sensible defaults and named constants.
 ## API Reference
 
 ### ChiaBlockListener Class

package/crate/chia-block-listener-napi/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "chia-block-listener-napi"
+version = "0.2.0"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+napi = { version = "2", features = ["napi9", "tokio_rt", "async"] }
+napi-derive = "2"
+tokio = { version = "1", features = ["full"] }
+futures-util = "0.3"
+hex = "0.4"
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+chia-block-listener = { path = "../.." }
+chia-generator-parser = { path = "../chia-generator-parser" }
+chia-protocol = "0.26"
+chia-traits = "0.26"
+
+[build-dependencies]
+napi-build = "2"

package/{src → crate/chia-block-listener-napi/src}/block_parser_napi.rs

@@ -124,7 +124,6 @@ impl From<&GeneratorBlockInfo> for GeneratorBlockInfoJS {
 
 // Export BlockHeightInfo for TypeScript
 #[napi(object)]
-#[derive(Clone)]
 pub struct BlockHeightInfoJS {
     pub height: u32,
     #[napi(js_name = "isTransactionBlock")]
@@ -145,15 +144,10 @@ pub struct ChiaBlockParser {
     parser: RustBlockParser,
 }
 
-impl Default for ChiaBlockParser {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
 #[napi]
 impl ChiaBlockParser {
     /// Create a new block parser
+    #[allow(clippy::new_without_default)]
     #[napi(constructor)]
     pub fn new() -> Self {
         info!("Creating new ChiaBlockParser");

package/{src → crate/chia-block-listener-napi/src}/dns_discovery_napi.rs

@@ -1,4 +1,5 @@
-use dns_discovery::{DiscoveryResult, DnsDiscovery, DnsDiscoveryError, PeerAddress};
+use chia_block_listener::dns_discovery::{DiscoveryResult, DnsDiscoveryError, PeerAddress};
+use chia_block_listener::DnsDiscoveryClient as CoreDnsDiscoveryClient;
 use napi::bindgen_prelude::*;
 use napi_derive::napi;
 use tracing::{debug, info};
@@ -82,7 +83,7 @@ pub struct AddressResult {
 
 #[napi]
 pub struct DnsDiscoveryClient {
-    discovery: DnsDiscovery,
+    core: CoreDnsDiscoveryClient,
 }
 
 #[napi]
@@ -93,14 +94,14 @@ impl DnsDiscoveryClient {
         info!("Creating new DnsDiscoveryClient");
 
         let rt = tokio::runtime::Handle::current();
-        let discovery = rt
-            .block_on(async { DnsDiscovery::new().await })
+        let core = rt
+            .block_on(async { CoreDnsDiscoveryClient::new().await })
             .map_err(|e| {
                 let error_info = DnsDiscoveryErrorInfo::from(e);
                 Error::new(Status::GenericFailure, error_info.message)
             })?;
 
-        Ok(Self { discovery })
+        Ok(Self { core })
     }
 
     /// Discover peers for Chia mainnet
@@ -108,7 +109,7 @@ impl DnsDiscoveryClient {
     pub async fn discover_mainnet_peers(&self) -> Result<DiscoveryResultJS> {
         debug!("Discovering mainnet peers via DNS");
 
-        self.discovery
+        self.core
             .discover_mainnet_peers()
             .await
             .map(|result| DiscoveryResultJS::from(&result))
@@ -123,7 +124,7 @@ impl DnsDiscoveryClient {
     pub async fn discover_testnet11_peers(&self) -> Result<DiscoveryResultJS> {
         debug!("Discovering testnet11 peers via DNS");
 
-        self.discovery
+        self.core
             .discover_testnet11_peers()
             .await
             .map(|result| DiscoveryResultJS::from(&result))
@@ -145,10 +146,8 @@ impl DnsDiscoveryClient {
             introducers.len()
         );
 
-        let introducer_refs: Vec<&str> = introducers.iter().map(|s| s.as_str()).collect();
-
-        self.discovery
-            .discover_peers(&introducer_refs, default_port)
+        self.core
+            .discover_peers(&introducers, default_port)
             .await
             .map(|result| DiscoveryResultJS::from(&result))
             .map_err(|e| {
@@ -162,8 +161,8 @@ impl DnsDiscoveryClient {
     pub async fn resolve_ipv4(&self, hostname: String) -> Result<AddressResult> {
         debug!("Resolving IPv4 addresses for {}", hostname);
 
-        self.discovery
-            .resolve_ipv4(&hostname)
+        self.core
+            .resolve_ipv4(hostname.as_str())
             .await
             .map(|addrs| AddressResult {
                 addresses: addrs.iter().map(|addr| addr.to_string()).collect(),
@@ -180,8 +179,8 @@ impl DnsDiscoveryClient {
     pub async fn resolve_ipv6(&self, hostname: String) -> Result<AddressResult> {
         debug!("Resolving IPv6 addresses for {}", hostname);
 
-        self.discovery
-            .resolve_ipv6(&hostname)
+        self.core
+            .resolve_ipv6(hostname.as_str())
             .await
             .map(|addrs| AddressResult {
                 addresses: addrs.iter().map(|addr| addr.to_string()).collect(),
@@ -198,30 +197,10 @@ impl DnsDiscoveryClient {
     pub async fn resolve_both(&self, hostname: String, port: u16) -> Result<DiscoveryResultJS> {
         debug!("Resolving both IPv4 and IPv6 addresses for {}", hostname);
 
-        self.discovery
-            .resolve_both(&hostname, port)
+        self.core
+            .resolve_both(hostname.as_str(), port)
             .await
             .map(|result| DiscoveryResultJS::from(&result))
-            .map_err(|e| {
-                let error_info = DnsDiscoveryErrorInfo::from(e);
-                Error::new(Status::GenericFailure, error_info.message)
-            })
-    }
-}
-
-impl Default for DnsDiscoveryClient {
-    fn default() -> Self {
-        Self::new().unwrap()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[tokio::test]
-    async fn test_client_creation() {
-        let client = DnsDiscoveryClient::new();
-        assert!(client.is_ok());
+            .map_err(|e| Error::new(Status::GenericFailure, e.to_string()))
     }
 }