@cogcoin/client 1.1.8 → 1.1.10

package/dist/wallet/read/local-state.js

@@ -0,0 +1,233 @@
+import { access, constants } from "node:fs/promises";
+import { normalizeWalletStateRecord, persistWalletCoinControlStateIfNeeded } from "../coin-control.js";
+import { persistNormalizedWalletDescriptorStateIfNeeded } from "../descriptor-normalization.js";
+import { attachOrStartManagedBitcoindService } from "../../bitcoind/service.js";
+import { createRpcClient } from "../../bitcoind/node.js";
+import { normalizeMiningStateRecord } from "../mining/state.js";
+import { resolveWalletRootIdFromLocalArtifacts } from "../root-resolution.js";
+import { resolveWalletRuntimePathsForTesting } from "../runtime.js";
+import { extractWalletRootIdHintFromWalletStateEnvelope, loadRawWalletStateEnvelope, loadWalletState, } from "../state/storage.js";
+import { createDefaultWalletSecretProvider, createWalletSecretReference, inspectClientPasswordSetupReadiness, } from "../state/provider.js";
+import { describeClientPasswordLockedMessage, describeClientPasswordMigrationMessage, describeClientPasswordSetupMessage, } from "../state/client-password.js";
+const defaultWalletLocalStateDeps = {
+    attachOrStartManagedBitcoindService,
+    createRpcClient,
+};
+function btcAmountToSats(value) {
+    return BigInt(Math.round(value * 100_000_000));
+}
+function isSpendableFundingUtxo(entry, fundingScriptPubKeyHex) {
+    return entry.scriptPubKey === fundingScriptPubKeyHex
+        && entry.confirmations >= 1
+        && entry.spendable !== false
+        && entry.safe !== false;
+}
+async function pathExists(path) {
+    try {
+        await access(path, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isWalletAccessError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.startsWith("wallet_secret_missing_")
+        || message.startsWith("wallet_secret_provider_")
+        || message.startsWith("wallet_client_password_")
+        || message === "wallet_state_legacy_envelope_unsupported";
+}
+function describeWalletAccessMessage(options) {
+    const message = options.accessError instanceof Error ? options.accessError.message : String(options.accessError ?? "");
+    if (message === "wallet_state_legacy_envelope_unsupported") {
+        return "Wallet state exists but was created by an older Cogcoin wallet format that this version no longer loads directly.";
+    }
+    if (message === "wallet_client_password_setup_required") {
+        return describeClientPasswordSetupMessage();
+    }
+    if (message === "wallet_client_password_migration_required") {
+        return describeClientPasswordMigrationMessage();
+    }
+    if (message === "wallet_client_password_locked") {
+        return describeClientPasswordLockedMessage();
+    }
+    if (message.startsWith("wallet_secret_provider_")) {
+        return "Wallet state exists but the local secret provider is unavailable.";
+    }
+    if (message.startsWith("wallet_secret_missing_")) {
+        return "Wallet state exists but its local secret-provider material is unavailable.";
+    }
+    return message.length > 0
+        ? message
+        : "Wallet state exists but could not be loaded from the local secret provider.";
+}
+async function normalizeLoadedWalletStateForRead(options) {
+    if (options.dataDir === undefined) {
+        return options.loaded;
+    }
+    const node = await options.dependencies.attachOrStartManagedBitcoindService({
+        dataDir: options.dataDir,
+        chain: "main",
+        startHeight: 0,
+        walletRootId: options.loaded.state.walletRootId,
+    });
+    try {
+        const access = {
+            provider: options.access.provider,
+            secretReference: createWalletSecretReference(options.loaded.state.walletRootId),
+        };
+        const normalized = await persistNormalizedWalletDescriptorStateIfNeeded({
+            state: options.loaded.state,
+            access,
+            paths: options.paths,
+            nowUnixMs: options.now,
+            replacePrimary: options.loaded.source === "backup",
+            rpc: options.dependencies.createRpcClient(node.rpc),
+        });
+        const coinControl = await persistWalletCoinControlStateIfNeeded({
+            state: normalized.state,
+            access,
+            paths: options.paths,
+            nowUnixMs: options.now,
+            replacePrimary: (normalized.changed ? "primary" : options.loaded.source) === "backup",
+            rpc: options.dependencies.createRpcClient(node.rpc),
+        });
+        return {
+            source: coinControl.changed ? "primary" : normalized.changed ? "primary" : options.loaded.source,
+            state: coinControl.state,
+        };
+    }
+    finally {
+        await node.stop?.().catch(() => undefined);
+    }
+}
+export async function inspectWalletLocalStateWithDependencies(options = {}, dependencies = defaultWalletLocalStateDeps) {
+    const paths = options.paths ?? resolveWalletRuntimePathsForTesting();
+    const now = options.now ?? Date.now();
+    const provider = options.secretProvider ?? createDefaultWalletSecretProvider();
+    const [hasPrimaryStateFile, hasBackupStateFile] = await Promise.all([
+        pathExists(paths.walletStatePath),
+        pathExists(paths.walletStateBackupPath),
+    ]);
+    const clientPasswordReadiness = await inspectClientPasswordSetupReadiness(provider).catch(() => "ready");
+    if (!hasPrimaryStateFile && !hasBackupStateFile) {
+        return {
+            availability: "uninitialized",
+            clientPasswordReadiness,
+            unlockRequired: false,
+            walletRootId: null,
+            state: null,
+            source: null,
+            hasPrimaryStateFile,
+            hasBackupStateFile,
+            message: "Wallet state has not been initialized yet.",
+        };
+    }
+    if (clientPasswordReadiness !== "ready") {
+        const rawEnvelope = await loadRawWalletStateEnvelope({
+            primaryPath: paths.walletStatePath,
+            backupPath: paths.walletStateBackupPath,
+        }).catch(() => null);
+        if (rawEnvelope?.envelope.secretProvider == null) {
+            return {
+                availability: "local-state-corrupt",
+                clientPasswordReadiness: "ready",
+                unlockRequired: false,
+                walletRootId: extractWalletRootIdHintFromWalletStateEnvelope(rawEnvelope?.envelope ?? null),
+                state: null,
+                source: null,
+                hasPrimaryStateFile,
+                hasBackupStateFile,
+                message: "Wallet state exists but was created by an older Cogcoin wallet format that this version no longer loads directly.",
+            };
+        }
+        const resolvedRoot = await resolveWalletRootIdFromLocalArtifacts({
+            paths,
+            provider,
+        }).catch(() => null);
+        return {
+            availability: "local-state-corrupt",
+            clientPasswordReadiness,
+            unlockRequired: false,
+            walletRootId: resolvedRoot?.walletRootId ?? null,
+            state: null,
+            source: null,
+            hasPrimaryStateFile,
+            hasBackupStateFile,
+            message: clientPasswordReadiness === "migration-required"
+                ? describeClientPasswordMigrationMessage()
+                : describeClientPasswordSetupMessage(),
+        };
+    }
+    try {
+        const loaded = await loadWalletState({
+            primaryPath: paths.walletStatePath,
+            backupPath: paths.walletStateBackupPath,
+        }, {
+            provider,
+        });
+        const normalized = await normalizeLoadedWalletStateForRead({
+            loaded,
+            access: { provider },
+            dataDir: options.dataDir,
+            now,
+            paths,
+            dependencies,
+        });
+        return {
+            availability: "ready",
+            clientPasswordReadiness,
+            unlockRequired: false,
+            walletRootId: normalized.state.walletRootId,
+            state: normalizeWalletStateRecord({
+                ...normalized.state,
+                miningState: normalizeMiningStateRecord(normalized.state.miningState),
+            }),
+            source: normalized.source,
+            hasPrimaryStateFile,
+            hasBackupStateFile,
+            message: null,
+        };
+    }
+    catch (error) {
+        const resolvedRoot = await resolveWalletRootIdFromLocalArtifacts({
+            paths,
+            provider,
+        }).catch(() => null);
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            availability: "local-state-corrupt",
+            clientPasswordReadiness,
+            unlockRequired: message === "wallet_client_password_locked",
+            walletRootId: resolvedRoot?.walletRootId ?? null,
+            state: null,
+            source: null,
+            hasPrimaryStateFile,
+            hasBackupStateFile,
+            message: isWalletAccessError(error)
+                ? describeWalletAccessMessage({ accessError: error })
+                : error instanceof Error
+                    ? error.message
+                    : String(error),
+        };
+    }
+}
+export async function inspectWalletLocalState(options = {}) {
+    return inspectWalletLocalStateWithDependencies(options);
+}
+export async function readFundingSpendableSats(options) {
+    if (options.state === null || options.rpc === null) {
+        return null;
+    }
+    const state = options.state;
+    try {
+        const utxos = await options.rpc.listUnspent(state.managedCoreWallet.walletName, 1);
+        return utxos.reduce((sum, entry) => isSpendableFundingUtxo(entry, state.funding.scriptPubKeyHex)
+            ? sum + btcAmountToSats(entry.amount)
+            : sum, 0n);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/wallet/read/managed-bitcoind.d.ts

@@ -0,0 +1,30 @@
+import { loadBundledGenesisParameters } from "@cogcoin/indexer";
+import type { ManagedWalletNodeConnection } from "../../bitcoind/managed-runtime/types.js";
+import { createRpcClient } from "../../bitcoind/node.js";
+import { attachOrStartManagedBitcoindService, probeManagedBitcoindService } from "../../bitcoind/service.js";
+import type { ManagedBitcoindNodeHandle } from "../../bitcoind/types.js";
+import { verifyManagedCoreWalletReplica } from "../lifecycle.js";
+import type { WalletBitcoindStatus, WalletLocalStateStatus, WalletNodeStatus, WalletServiceHealth } from "./types.js";
+export type ManagedWalletBitcoindReadDeps = {
+    loadBundledGenesisParameters: typeof loadBundledGenesisParameters;
+    probeManagedBitcoindService: typeof probeManagedBitcoindService;
+    attachOrStartManagedBitcoindService: typeof attachOrStartManagedBitcoindService;
+    createRpcClient: typeof createRpcClient;
+    verifyManagedCoreWalletReplica: typeof verifyManagedCoreWalletReplica;
+};
+export interface ManagedWalletBitcoindReadState {
+    node: ManagedWalletNodeConnection<ManagedBitcoindNodeHandle, ReturnType<typeof createRpcClient>>;
+    bitcoind: WalletBitcoindStatus;
+    nodeHealth: WalletServiceHealth;
+    nodeMessage: string | null;
+}
+export declare function deriveNodeHealthForTesting(status: WalletNodeStatus | null, bitcoindHealth: WalletBitcoindStatus["health"]): {
+    health: WalletServiceHealth;
+    message: string | null;
+};
+export declare function openManagedWalletBitcoindReadState(options: {
+    dataDir: string;
+    walletRootId: string;
+    localState: WalletLocalStateStatus;
+    startupTimeoutMs: number;
+}, dependencies?: ManagedWalletBitcoindReadDeps): Promise<ManagedWalletBitcoindReadState>;

package/dist/wallet/read/managed-bitcoind.js

@@ -0,0 +1,138 @@
+import { loadBundledGenesisParameters } from "@cogcoin/indexer";
+import { deriveManagedBitcoindWalletStatus, resolveManagedBitcoindProbeDecision, } from "../../bitcoind/managed-runtime/bitcoind-policy.js";
+import { createRpcClient } from "../../bitcoind/node.js";
+import { resolveCogcoinProcessingStartHeight } from "../../bitcoind/processing-start-height.js";
+import { attachOrStartManagedBitcoindService, probeManagedBitcoindService, } from "../../bitcoind/service.js";
+import { verifyManagedCoreWalletReplica } from "../lifecycle.js";
+const TOLERATED_NODE_HEADER_LEAD_BLOCKS = 2;
+const TOLERATED_NODE_HEADER_LEAD_MESSAGE = "Bitcoin headers can briefly lead validated blocks; a short 1-2 block lead is normal and is being tolerated.";
+const NODE_CATCHING_UP_MESSAGE = "Bitcoin Core is still catching up to headers.";
+const defaultManagedWalletBitcoindReadDeps = {
+    loadBundledGenesisParameters,
+    probeManagedBitcoindService,
+    attachOrStartManagedBitcoindService,
+    createRpcClient,
+    verifyManagedCoreWalletReplica,
+};
+function deriveNodeHealth(status, bitcoindHealth) {
+    if (bitcoindHealth !== "ready" || status === null || !status.ready) {
+        return {
+            health: "catching-up",
+            message: NODE_CATCHING_UP_MESSAGE,
+        };
+    }
+    const headerLead = status.nodeBestHeight !== null && status.nodeHeaderHeight !== null
+        ? status.nodeHeaderHeight - status.nodeBestHeight
+        : null;
+    if (headerLead !== null && headerLead > 0) {
+        if (headerLead <= TOLERATED_NODE_HEADER_LEAD_BLOCKS) {
+            return {
+                health: "synced",
+                message: TOLERATED_NODE_HEADER_LEAD_MESSAGE,
+            };
+        }
+        return {
+            health: "catching-up",
+            message: NODE_CATCHING_UP_MESSAGE,
+        };
+    }
+    return {
+        health: "synced",
+        message: null,
+    };
+}
+export function deriveNodeHealthForTesting(status, bitcoindHealth) {
+    return deriveNodeHealth(status, bitcoindHealth);
+}
+async function attachNodeStatus(options, dependencies) {
+    try {
+        const probe = await dependencies.probeManagedBitcoindService({
+            dataDir: options.dataDir,
+            chain: "main",
+            startHeight: 0,
+            walletRootId: options.walletRootId,
+            startupTimeoutMs: options.startupTimeoutMs,
+        });
+        const decision = resolveManagedBitcoindProbeDecision(probe);
+        if (decision.action === "reject") {
+            return {
+                handle: null,
+                rpc: null,
+                status: null,
+                observedStatus: probe.status,
+                error: decision.error,
+            };
+        }
+        const genesis = await dependencies.loadBundledGenesisParameters();
+        const handle = await dependencies.attachOrStartManagedBitcoindService({
+            dataDir: options.dataDir,
+            chain: "main",
+            startHeight: resolveCogcoinProcessingStartHeight(genesis),
+            walletRootId: options.walletRootId,
+            startupTimeoutMs: options.startupTimeoutMs,
+        });
+        const rpc = dependencies.createRpcClient(handle.rpc);
+        const [chainInfo, serviceStatus] = await Promise.all([
+            rpc.getBlockchainInfo(),
+            handle.refreshServiceStatus?.(),
+        ]);
+        const status = {
+            ready: true,
+            chain: chainInfo.chain,
+            pid: handle.pid,
+            walletRootId: handle.walletRootId ?? null,
+            nodeBestHeight: chainInfo.blocks,
+            nodeBestHashHex: chainInfo.bestblockhash,
+            nodeHeaderHeight: chainInfo.headers,
+            serviceUpdatedAtUnixMs: serviceStatus?.updatedAtUnixMs ?? null,
+            serviceStatus: serviceStatus ?? null,
+            walletReplica: serviceStatus?.walletReplica ?? null,
+            walletReplicaMessage: serviceStatus?.walletReplica?.message ?? null,
+        };
+        return {
+            handle,
+            rpc,
+            status,
+            observedStatus: serviceStatus ?? null,
+            error: null,
+        };
+    }
+    catch (error) {
+        return {
+            handle: null,
+            rpc: null,
+            status: null,
+            observedStatus: null,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+export async function openManagedWalletBitcoindReadState(options, dependencies = defaultManagedWalletBitcoindReadDeps) {
+    const node = await attachNodeStatus({
+        dataDir: options.dataDir,
+        walletRootId: options.walletRootId,
+        startupTimeoutMs: options.startupTimeoutMs,
+    }, dependencies);
+    if (options.localState.state !== null && node.status !== null) {
+        const verifiedReplica = await dependencies.verifyManagedCoreWalletReplica(options.localState.state, options.dataDir, {
+            nodeHandle: node.handle ?? undefined,
+        });
+        node.status = {
+            ...node.status,
+            walletReplica: verifiedReplica,
+            walletReplicaMessage: verifiedReplica.message ?? null,
+        };
+    }
+    const bitcoind = deriveManagedBitcoindWalletStatus({
+        status: node.observedStatus,
+        nodeStatus: node.status,
+        startupError: node.error,
+    });
+    const nodeDerived = deriveNodeHealth(node.status, bitcoind.health);
+    return {
+        node,
+        bitcoind,
+        nodeHealth: nodeDerived.health,
+        nodeMessage: nodeDerived.message,
+    };
+}

package/dist/wallet/read/managed-indexer.d.ts

@@ -0,0 +1,23 @@
+import { attachOrStartIndexerDaemon, probeIndexerDaemon, readObservedIndexerDaemonStatus, readSnapshotWithRetry, type IndexerDaemonClient } from "../../bitcoind/indexer-daemon.js";
+import type { ManagedBitcoindNodeHandle } from "../../bitcoind/types.js";
+import type { WalletIndexerStatus, WalletSnapshotView } from "./types.js";
+export type ManagedWalletIndexerReadDeps = {
+    probeIndexerDaemon: typeof probeIndexerDaemon;
+    attachOrStartIndexerDaemon: typeof attachOrStartIndexerDaemon;
+    readSnapshotWithRetry: typeof readSnapshotWithRetry;
+    readObservedIndexerDaemonStatus: typeof readObservedIndexerDaemonStatus;
+};
+export interface ManagedWalletIndexerReadState {
+    daemonClient: IndexerDaemonClient | null;
+    indexer: WalletIndexerStatus;
+    snapshot: WalletSnapshotView | null;
+}
+export declare function openManagedWalletIndexerReadState(options: {
+    dataDir: string;
+    databasePath: string;
+    walletRootId: string;
+    startupTimeoutMs: number;
+    expectedIndexerBinaryVersion: string | null;
+    now: number;
+    nodeHandle: ManagedBitcoindNodeHandle | null;
+}, dependencies?: ManagedWalletIndexerReadDeps): Promise<ManagedWalletIndexerReadState>;

package/dist/wallet/read/managed-indexer.js

@@ -0,0 +1,87 @@
+import { deserializeIndexerState } from "@cogcoin/indexer";
+import { attachOrStartIndexerDaemon, INDEXER_DAEMON_BACKGROUND_FOLLOW_RECOVERY_FAILED, probeIndexerDaemon, readObservedIndexerDaemonStatus, readSnapshotWithRetry, } from "../../bitcoind/indexer-daemon.js";
+import { deriveManagedIndexerWalletStatus, resolveIndexerDaemonProbeDecision, } from "../../bitcoind/managed-runtime/indexer-policy.js";
+const defaultManagedWalletIndexerReadDeps = {
+    probeIndexerDaemon,
+    attachOrStartIndexerDaemon,
+    readSnapshotWithRetry,
+    readObservedIndexerDaemonStatus,
+};
+export async function openManagedWalletIndexerReadState(options, dependencies = defaultManagedWalletIndexerReadDeps) {
+    let daemonClient = null;
+    let daemonStatus = null;
+    let observedDaemonStatus = null;
+    let snapshot = null;
+    let indexerSource = "none";
+    let daemonError = null;
+    try {
+        const probe = await dependencies.probeIndexerDaemon({
+            dataDir: options.dataDir,
+            walletRootId: options.walletRootId,
+        });
+        const probeDecision = resolveIndexerDaemonProbeDecision({
+            probe,
+            expectedBinaryVersion: options.expectedIndexerBinaryVersion,
+        });
+        if (probeDecision.action !== "reject") {
+            await probe.client?.close().catch(() => undefined);
+            daemonClient = await dependencies.attachOrStartIndexerDaemon({
+                dataDir: options.dataDir,
+                databasePath: options.databasePath,
+                walletRootId: options.walletRootId,
+                startupTimeoutMs: options.startupTimeoutMs,
+                ensureBackgroundFollow: true,
+                expectedBinaryVersion: options.expectedIndexerBinaryVersion,
+            });
+        }
+        else {
+            observedDaemonStatus = probe.status;
+            indexerSource = probe.status === null ? "none" : "probe";
+            daemonError = probeDecision.error;
+        }
+        if (daemonClient !== null) {
+            const lease = await dependencies.readSnapshotWithRetry(daemonClient, options.walletRootId);
+            daemonStatus = lease.status;
+            observedDaemonStatus = lease.status;
+            snapshot = {
+                tip: lease.payload.tip,
+                state: deserializeIndexerState(Buffer.from(lease.payload.stateBase64, "base64")),
+                source: "lease",
+                daemonInstanceId: lease.payload.daemonInstanceId,
+                snapshotSeq: lease.payload.snapshotSeq,
+                openedAtUnixMs: lease.payload.openedAtUnixMs,
+            };
+            indexerSource = "lease";
+        }
+    }
+    catch (error) {
+        daemonError = error instanceof Error ? error.message : String(error);
+        if (daemonError === INDEXER_DAEMON_BACKGROUND_FOLLOW_RECOVERY_FAILED) {
+            await daemonClient?.close().catch(() => undefined);
+            await options.nodeHandle?.stop().catch(() => undefined);
+            throw error;
+        }
+        if (observedDaemonStatus === null) {
+            observedDaemonStatus = await dependencies.readObservedIndexerDaemonStatus({
+                dataDir: options.dataDir,
+                walletRootId: options.walletRootId,
+            }).catch(() => null);
+            if (observedDaemonStatus !== null) {
+                indexerSource = "status-file";
+            }
+        }
+    }
+    const indexer = deriveManagedIndexerWalletStatus({
+        daemonStatus,
+        observedStatus: observedDaemonStatus,
+        snapshot,
+        source: indexerSource,
+        now: options.now,
+        startupError: daemonError,
+    });
+    return {
+        daemonClient,
+        indexer,
+        snapshot,
+    };
+}

package/dist/wallet/read/managed-services.d.ts

@@ -1,26 +1,11 @@
-import { loadBundledGenesisParameters } from "@cogcoin/indexer";
-import { attachOrStartIndexerDaemon, probeIndexerDaemon, readObservedIndexerDaemonStatus, readSnapshotWithRetry, type IndexerDaemonClient } from "../../bitcoind/indexer-daemon.js";
+import { type IndexerDaemonClient } from "../../bitcoind/indexer-daemon.js";
 import type { ManagedWalletReadServiceBundle } from "../../bitcoind/managed-runtime/types.js";
 import { createRpcClient } from "../../bitcoind/node.js";
-import { attachOrStartManagedBitcoindService, probeManagedBitcoindService } from "../../bitcoind/service.js";
 import type { ManagedBitcoindNodeHandle } from "../../bitcoind/types.js";
-import { verifyManagedCoreWalletReplica } from "../lifecycle.js";
-import type { WalletBitcoindStatus, WalletLocalStateStatus, WalletNodeStatus, WalletServiceHealth } from "./types.js";
-type ManagedWalletReadServiceDeps = {
-    loadBundledGenesisParameters: typeof loadBundledGenesisParameters;
-    probeManagedBitcoindService: typeof probeManagedBitcoindService;
-    attachOrStartManagedBitcoindService: typeof attachOrStartManagedBitcoindService;
-    createRpcClient: typeof createRpcClient;
-    verifyManagedCoreWalletReplica: typeof verifyManagedCoreWalletReplica;
-    probeIndexerDaemon: typeof probeIndexerDaemon;
-    attachOrStartIndexerDaemon: typeof attachOrStartIndexerDaemon;
-    readSnapshotWithRetry: typeof readSnapshotWithRetry;
-    readObservedIndexerDaemonStatus: typeof readObservedIndexerDaemonStatus;
-};
-export declare function deriveNodeHealthForTesting(status: WalletNodeStatus | null, bitcoindHealth: WalletBitcoindStatus["health"]): {
-    health: WalletServiceHealth;
-    message: string | null;
-};
+import type { WalletLocalStateStatus } from "./types.js";
+import { deriveNodeHealthForTesting, type ManagedWalletBitcoindReadDeps } from "./managed-bitcoind.js";
+import { type ManagedWalletIndexerReadDeps } from "./managed-indexer.js";
+type ManagedWalletReadServiceDeps = ManagedWalletBitcoindReadDeps & ManagedWalletIndexerReadDeps;
 export declare function openManagedWalletReadServiceBundle(options: {
     dataDir: string;
     databasePath: string;
@@ -30,4 +15,4 @@ export declare function openManagedWalletReadServiceBundle(options: {
     expectedIndexerBinaryVersion: string | null;
     now: number;
 }, dependencies?: ManagedWalletReadServiceDeps): Promise<ManagedWalletReadServiceBundle<ManagedBitcoindNodeHandle, ReturnType<typeof createRpcClient>, IndexerDaemonClient>>;
-export {};
+export { deriveNodeHealthForTesting };