@toon-protocol/hub 0.34.3

package/dist/index.d.ts

@@ -0,0 +1,1342 @@
+import { E as EncryptedWallet, T as TownhouseConfig, N as NodeType$1, a as ConnectorRuntimeConfig, D as DockerOrchestrator, W as WalletManager, b as ConnectorAdminClient, c as ChainProviderEntry, R as RecentClaim } from './orchestrator-dGq7CeaO.js';
+export { A as ApiConfig, B as BandwidthStats, d as ChainType, e as ComposeLoaderError, C as ComposeLoaderOptions, f as ComposeProfile, g as ConnectorConfig, h as ContainerSpec, i as DerivedNodeKeys, j as DvmNodeConfig, k as EvmChainProvider, H as HealthCheckOptions, l as HealthResponse, m as HsHostnameResponse, L as LoggingConfig, M as MetricsPeerEntry, n as MetricsResponse, o as MillNodeConfig, p as MinaChainProvider, q as NodeKeyInfo, r as NodeKeys, s as NodesConfig, O as OrchestratorError, t as OrchestratorEvents, P as PacketLogEntry, u as PacketLogFilter, v as PeerEntry, w as PeerStatus, x as PeersResponse, S as SolanaChainProvider, y as TownNodeConfig, z as TransportConfig, F as WalletConfig, G as WalletManagerConfig, I as WalletState, J as loadComposeTemplate, K as materializeComposeTemplate } from './orchestrator-dGq7CeaO.js';
+import { FastifyBaseLogger, FastifyInstance } from 'fastify';
+import Docker from 'dockerode';
+import { z } from 'zod';
+export { NetworkMode } from '@toon-protocol/core';
+import 'node:events';
+
+/**
+ * Wallet encryption/decryption for Townhouse (Story 21.4, Task 2).
+ *
+ * Uses Node.js crypto: scrypt for KDF, AES-256-GCM for authenticated encryption.
+ * The mnemonic is the plaintext being encrypted.
+ */
+
+/**
+ * Encrypt a mnemonic with a password using scrypt + AES-256-GCM.
+ */
+declare function encryptWallet(mnemonic: string, password: string): EncryptedWallet;
+/**
+ * Decrypt an encrypted wallet with a password.
+ * Throws on wrong password (GCM auth tag verification failure).
+ */
+declare function decryptWallet(encrypted: EncryptedWallet, password: string): string;
+
+/**
+ * Wallet file I/O for Townhouse (Story 21.4, Task 2.2).
+ *
+ * Persists encrypted wallet to disk with 0o600 permissions (owner-only).
+ * Warns if existing file has world-readable permissions.
+ */
+
+/**
+ * Save encrypted wallet to disk with restrictive permissions.
+ * Creates parent directory if missing.
+ */
+declare function saveWallet(path: string, encrypted: EncryptedWallet): Promise<void>;
+/**
+ * Load encrypted wallet from disk.
+ * Returns null if file does not exist.
+ * Warns (via returned flag) if file permissions are too open.
+ */
+declare function loadWallet(path: string): Promise<{
+    wallet: EncryptedWallet;
+    permissionsWarning?: string;
+} | null>;
+
+/**
+ * Sensible default configuration. All nodes disabled by default —
+ * operator must explicitly enable what they want to run.
+ */
+declare function getDefaultConfig(): TownhouseConfig;
+
+/**
+ * Config file loader — reads YAML, validates, writes.
+ */
+
+/**
+ * Load and validate a Townhouse config from a YAML file.
+ * Environment variables override YAML values for key settings:
+ *   - TOWNHOUSE_API_PORT
+ *   - TOWNHOUSE_TRANSPORT_MODE
+ *   - TOWNHOUSE_LOG_LEVEL
+ */
+declare function loadConfig(configPath: string): TownhouseConfig;
+/**
+ * Save a config to a YAML file atomically.
+ * Writes to a temp file first, then renames to the target (atomic on POSIX).
+ */
+declare function saveConfig(configPath: string, config: TownhouseConfig): void;
+
+/**
+ * Runtime validation for Townhouse configuration.
+ * Validates shape, narrows types, returns typed config or throws.
+ */
+
+declare class ConfigValidationError extends Error {
+    constructor(message: string);
+}
+/**
+ * Validate raw input and return a typed TownhouseConfig.
+ * Throws ConfigValidationError with descriptive messages on invalid input.
+ */
+declare function validateConfig(raw: unknown): TownhouseConfig;
+
+/**
+ * Connector Config Generator for Townhouse (Story 21.3).
+ *
+ * Generates runtime configuration for the standalone ILP connector
+ * based on the Townhouse config and currently active nodes.
+ */
+
+/** Default ATOR SOCKS proxy address */
+declare const DEFAULT_ATOR_PROXY = "socks5h://proxy.ator.io:9050";
+/**
+ * ConnectorConfigGenerator produces runtime configuration for the standalone
+ * ILP connector based on Townhouse config and active node list.
+ *
+ * Key design: peer BTP URLs are deterministic Docker DNS names, so nodes
+ * don't need to be running for config generation to work.
+ */
+declare class ConnectorConfigGenerator {
+    private readonly config;
+    constructor(config: TownhouseConfig);
+    /**
+     * Generate a ConnectorRuntimeConfig for the given set of active nodes.
+     *
+     * @param activeNodes - Node types currently running or about to start
+     * @returns Typed configuration object (not serialized)
+     */
+    generate(activeNodes: NodeType$1[]): ConnectorRuntimeConfig;
+    /**
+     * Serialize a ConnectorRuntimeConfig into environment variable key-value pairs.
+     *
+     * @returns Record of env var name to string value
+     */
+    toEnvVars(runtimeConfig: ConnectorRuntimeConfig): Record<string, string>;
+    /**
+     * Convert a ConnectorRuntimeConfig into the string[] format expected by
+     * dockerode's container create API (Env option: ['KEY=VALUE', ...]).
+     *
+     * @returns Array of 'KEY=VALUE' strings
+     */
+    toEnvArray(runtimeConfig: ConnectorRuntimeConfig): string[];
+    /**
+     * Render a connector YAML config string the connector image at 3.3.x can
+     * load via its `CONFIG_FILE` env var (default `./config.yaml`).
+     *
+     * The shape mirrors `docker/configs/townhouse-dev-connector.yaml` (the
+     * working dev fixture) — peers list is empty because child nodes dial
+     * INTO the connector at startup; the connector accepts BTP connections
+     * (no-auth in dev) without needing pre-configured peer entries.
+     *
+     * Added in the orchestrator-bug-fix: env vars set on the container were
+     * silently ignored by the connector image, which only reads from this
+     * YAML file. Caller writes the returned string to disk and mounts it
+     * at `/config/connector.yaml` in the container.
+     */
+    toYaml(runtimeConfig: ConnectorRuntimeConfig): string;
+    /**
+     * Translate the runtime config's transport block into the discriminated-
+     * union shape the connector expects. See toYaml's note for why this was
+     * silently broken before.
+     */
+    private buildConnectorTransportBlock;
+    /**
+     * Generate PeerEntry list for each active node type.
+     * BTP URLs use Docker DNS: btp+ws://townhouse-{type}:3000 // nosemgrep: javascript.lang.security.detect-insecure-websocket.detect-insecure-websocket
+     */
+    private generatePeerList;
+    /**
+     * Generate transport config from Townhouse config.
+     * When mode is 'hs', includes SOCKS proxy (uses default if not configured).
+     * Carries forward externalUrl + hiddenService when set; downstream
+     * buildConnectorTransportBlock handles translation to the connector's
+     * wire shape.
+     */
+    private generateTransportConfig;
+}
+
+/**
+ * ATOR transport probe — periodically TCP-connects to the configured SOCKS5
+ * proxy host:port and measures direct HTTPS latency for comparison.
+ *
+ * The probe answers a single operator question: "is my configured ATOR proxy
+ * contactable from this host?" TCP connect is the right granularity — if the
+ * TCP listener is up, the connector's real BTP traffic will succeed.
+ *
+ * The probe NEVER makes a real SOCKS5 handshake or proxied request — only a
+ * plain TCP connect to the proxy host:port.
+ */
+interface TransportProbeOptions {
+    proxyUrl: string;
+    intervalMs?: number;
+    /** Override the direct-latency probe URL (for tests — avoids real network). */
+    directProbeUrl?: string;
+}
+interface TransportProbeStatus {
+    reachable: boolean;
+    latencyProxyMs: number | null;
+    latencyDirectMs: number | null;
+    lastProbedAt: number;
+    probeError: string | null;
+}
+declare class TransportProbe {
+    private proxyUrl;
+    private readonly intervalMs;
+    private readonly directProbeUrl;
+    private running;
+    private timer;
+    private status;
+    constructor(opts: TransportProbeOptions);
+    /** Start the probe loop. Idempotent — calling twice while running is a no-op. */
+    start(): void;
+    /** Stop the probe loop. Idempotent. */
+    stop(): void;
+    /** Returns the latest probe snapshot synchronously. Never blocks. */
+    getStatus(): TransportProbeStatus;
+    /**
+     * Update the target proxy URL.
+     * The next tick will use the new URL; the current tick may complete against the old URL.
+     */
+    setProxyUrl(url: string): void;
+    private tick;
+    private probeTcp;
+    private probeDirectLatency;
+    private logTransition;
+}
+
+/**
+ * Townhouse API — type definitions.
+ */
+
+/** Per-kind job count for jobsRecent.byKind */
+interface DvmJobsByKindEntry {
+    kind: number;
+    count: number;
+}
+/** Per-status job counts for the sliding window */
+interface DvmJobsByStatus {
+    processing: number;
+    success: number;
+    error: number;
+    partial: number;
+}
+/** Windowed recent-jobs telemetry (default window: 5 min) */
+interface DvmJobsRecent {
+    total: number;
+    byKind: DvmJobsByKindEntry[];
+    byStatus: DvmJobsByStatus;
+}
+/** Response shape for GET /health on the DVM BLS server (port 3400). */
+interface DvmHealthResponse {
+    status: 'starting' | 'ok' | 'stopping' | 'stopped' | 'error';
+    version: string;
+    nodePubkey: string;
+    uptimeSec: number;
+    /** Registered handler event kinds (e.g. [5094]). */
+    handlerKinds: number[];
+    /** Per-kind pricing in string-encoded bigint (e.g. { "5094": "10" }). */
+    kindPricing: Record<string, string>;
+    basePricePerByte: string;
+    jobsRecent: DvmJobsRecent;
+}
+/** Chains a Mill node can settle on. Inlined from packages/mill/src/wallet.ts. */
+type MillChainKind = 'evm' | 'mina' | 'solana';
+/** A configured swap pair, inlined from packages/core/src/types.ts (SwapPair). */
+interface MillSwapPair {
+    from: {
+        assetCode: string;
+        assetScale: number;
+        chain: string;
+    };
+    to: {
+        assetCode: string;
+        assetScale: number;
+        chain: string;
+    };
+    rate: string;
+    minAmount?: string;
+    maxAmount?: string;
+}
+/**
+ * Response shape for GET /health on the Mill BLS server. Inlined from
+ * packages/mill/src/mill.ts (MillHealthResponse) — keep in sync.
+ */
+interface MillHealthResponse {
+    status: 'ok' | 'starting' | 'stopping' | 'stopped';
+    version: string;
+    nodePubkey: string;
+    swapPairsCount: number;
+    chains: readonly MillChainKind[];
+    uptimeSec: number;
+    inventory: Record<string, string>;
+    /** Configured swap pairs — operator-config, no secrets. */
+    swapPairs: MillSwapPair[];
+    /** Per-asset available reserves, parallel to `inventory` (which is total). */
+    inventoryAvailable: Record<string, string>;
+}
+/** Node types supported by Townhouse */
+type NodeType = 'town' | 'mill' | 'dvm';
+/** Runtime state of a node container */
+type NodeState = 'running' | 'stopped' | 'error' | 'not-created';
+/** Response shape for GET /nodes */
+interface NodeInfo {
+    /**
+     * Unique instance identifier — equals `type` for single-instance deployments.
+     * Required in responses from this API; undefined in legacy test fixtures.
+     */
+    id: string;
+    type: NodeType;
+    enabled: boolean;
+    state: NodeState;
+    uptimeSeconds: number | null;
+    image: string;
+}
+/** Detailed response shape for GET /nodes/:type */
+interface NodeDetail extends NodeInfo {
+    config: {
+        feePerEvent?: number;
+        feeBasisPoints?: number;
+        feePerJob?: number;
+        kindPricing?: Record<string, number>;
+        enabled: boolean;
+    };
+    metrics: MetricsPayload | null;
+}
+/** Metrics payload from connector admin — narrowed per connector-team agreement 2026-04-21 */
+interface MetricsPayload {
+    packetsForwarded: number;
+    packetsRejected: number;
+    bytesSent: number;
+    attribution: 'aggregate' | 'per-peer';
+    available: boolean;
+}
+/** Nostr event shape forwarded in relayEvents messages */
+interface NostrEventPayload {
+    id: string;
+    kind: number;
+    pubkey: string;
+    content: string;
+    tags: string[][];
+    sig: string;
+    created_at: number;
+}
+/** WebSocket message shapes */
+interface WsMetricsMessage {
+    type: 'metrics';
+    payload: MetricsPayload;
+    ts: number;
+}
+interface WsNodeStateMessage {
+    type: 'nodeState';
+    payload: NodeStatePayload;
+    ts: number;
+}
+interface WsHeartbeatMessage {
+    type: 'heartbeat';
+    ts: number;
+}
+interface WsBatchMessage {
+    type: 'batch';
+    messages: WsMessage[];
+    ts: number;
+}
+/** Forwarded Nostr event from a Town relay subscription */
+interface WsRelayEventsMessage {
+    type: 'relayEvents';
+    nodeId: string;
+    payload: NostrEventPayload;
+    ts: number;
+}
+/** Connector restart notifications (emitted around fee-config PATCH) */
+interface WsConnectorRestartingMessage {
+    type: 'connectorRestarting';
+    ts: number;
+}
+interface WsConnectorRestartedMessage {
+    type: 'connectorRestarted';
+    ts: number;
+}
+interface NodeStatePayload {
+    name: string;
+    state: string;
+}
+/** Server notification when the upstream relay WebSocket for a nodeId disconnects */
+interface WsRelayEventsStatusMessage {
+    type: 'relayEventsStatus';
+    nodeId: string;
+    connected: boolean;
+    ts: number;
+}
+type WsMessage = WsMetricsMessage | WsNodeStateMessage | WsHeartbeatMessage | WsBatchMessage | WsRelayEventsMessage | WsConnectorRestartingMessage | WsConnectorRestartedMessage | WsRelayEventsStatusMessage;
+/** Response shape for GET /nodes/:type/bandwidth */
+interface BandwidthPayload {
+    bytesIn: number;
+    bytesOut: number;
+    sampleAt: number;
+}
+/** Packet log time-series bucket */
+interface TimeseriesBucket {
+    ts: number;
+    count: number;
+}
+/** Response shape for GET /nodes/:type/packets/timeseries */
+interface PacketTimeseriesPayload {
+    buckets: TimeseriesBucket[];
+}
+/** Minimal common health shape; superset emitted by Town containers. */
+interface TownHealthPayload {
+    status: 'ok' | 'starting' | 'stopping' | 'stopped' | 'error';
+    version?: string;
+    uptimeSec?: number;
+    nodePubkey?: string;
+}
+/** Union of all node health response shapes. */
+type NodeHealthPayload = MillHealthResponse | TownHealthPayload | DvmHealthResponse;
+/** Per-kind job activity bucket for GET /nodes/:nodeId/jobs/recent */
+interface JobsByKindEntry {
+    kind: number;
+    count: number;
+    volume: string;
+}
+/** Response shape for GET /nodes/:nodeId/jobs/recent */
+interface JobsRecentPayload {
+    count: number;
+    volume: string;
+    byKind: JobsByKindEntry[];
+    byStatus: {
+        processing: number;
+        success: number;
+        error: number;
+        partial: number;
+    };
+}
+/** Per-pair swap activity bucket */
+interface SwapByPairEntry {
+    pair: string;
+    count: number;
+    volume: string;
+}
+/** Response shape for GET /nodes/mill/swaps/recent */
+interface MillSwapsRecentPayload {
+    count: number;
+    volume: string;
+    byPair: SwapByPairEntry[];
+}
+/** Per-chain deposit address entry */
+interface DepositAddressEntry {
+    family: 'evm' | 'solana' | 'mina';
+    address: string;
+}
+/** Response shape for GET /nodes/:type/deposit-addresses */
+interface DepositAddressesPayload {
+    chains: DepositAddressEntry[];
+}
+/** Per-chain balance entry returned by GET /api/wallet/balances */
+interface WalletBalanceEntry {
+    nodeType: 'town' | 'mill' | 'dvm';
+    family: 'evm' | 'solana' | 'mina';
+    token: 'ETH' | 'USDC' | 'SOL' | 'MINA';
+    address: string;
+    /** Decimal string in raw units (wei, lamports, etc.) */
+    balance: string;
+    /** Decimal places — 18 for ETH, 6 for USDC, 9 for SOL, 9 for MINA */
+    scale: number;
+    available: boolean;
+    /** Populated when available === false */
+    reason?: string;
+}
+/** Response shape for GET /api/wallet/balances */
+interface WalletBalancesPayload {
+    entries: WalletBalanceEntry[];
+    ts: number;
+}
+/** Request body for POST /api/wallet/withdraw.
+ *  `chainFamily` lists all values the route accepts at the wire level — the
+ *  handler returns 501 for solana/mina with a structured payload pointing the
+ *  caller at the deposit-address copy flow. */
+interface WithdrawRequest {
+    nodeType: 'town' | 'mill' | 'dvm';
+    chainFamily: 'evm' | 'solana' | 'mina';
+    token: 'native' | 'USDC';
+    recipient: string;
+    /** Decimal string in raw units */
+    amount: string;
+    /** When true: returns gas estimate without broadcasting */
+    dryRun?: boolean;
+}
+/** Successful broadcast response (dryRun !== true). */
+interface WithdrawSuccessResponse {
+    txHash: `0x${string}`;
+    chainId: number;
+}
+/** Successful dryRun response (no broadcast performed). */
+interface WithdrawDryRunResponse {
+    estimatedGas: string;
+    estimatedFee: string;
+}
+/** Discriminated union — callers narrow by presence of `txHash`. */
+type WithdrawResponse = WithdrawSuccessResponse | WithdrawDryRunResponse;
+/** Request body for POST /api/wallet/reveal */
+interface RevealRequest {
+    password: string;
+}
+/** Response shape for POST /api/wallet/reveal */
+type RevealResponse = {
+    mnemonic: string;
+} | {
+    error: 'invalid_password' | 'wallet_not_initialized' | 'wallet_corrupted';
+    message?: string;
+};
+/** Response shape for GET /api/wallet/transaction/:txHash */
+interface TransactionReceiptPayload {
+    status: 'pending' | 'success' | 'reverted';
+    blockNumber?: number;
+    txHash: string;
+}
+/** Response shape for GET /api/wizard/state */
+interface WizardStatePayload {
+    config_exists: boolean;
+    wallet_exists: boolean;
+    containers_running: boolean;
+    mode: 'wizard' | 'normal';
+    ts: number;
+}
+/** Request body for POST /api/wizard/init.
+ *  `mnemonic` is required in BOTH modes — `mnemonic_mode` is purely a UX hint
+ *  for the SPA, the server is stateless WRT the mnemonic and validates it on
+ *  every init regardless of mode (see story 21.14 Dev Notes). */
+interface WizardInitRequest {
+    password: string;
+    password_confirm: string;
+    mnemonic_mode: 'generate' | 'import';
+    mnemonic: string;
+    backup_ack: boolean;
+    nodes: {
+        town: {
+            enabled: boolean;
+            feePerEvent?: number;
+        };
+        mill: {
+            enabled: boolean;
+            feeBasisPoints?: number;
+        };
+        dvm: {
+            enabled: boolean;
+            feePerJob?: number;
+        };
+    };
+    transport: {
+        mode: 'direct' | 'hs';
+    };
+    /**
+     * Optional settlement chains (connector chainProviders) to configure during
+     * first-run setup. Omitted/empty → the connector uses the dev-Anvil default.
+     * Validated deeply when the resulting config is saved.
+     */
+    chainProviders?: ChainProviderEntry[];
+}
+/** Progress messages streamed over WS /api/wizard/progress */
+type WizardProgressMessage = {
+    type: 'pull_progress';
+    image: string;
+    status: string;
+    progress?: string;
+    ts: number;
+} | {
+    type: 'container_starting';
+    name: string;
+    ts: number;
+} | {
+    type: 'container_healthy';
+    name: string;
+    ts: number;
+} | {
+    type: 'container_failed';
+    name: string;
+    reason: string;
+    ts: number;
+} | {
+    type: 'launch_complete';
+    ts: number;
+} | {
+    type: 'error';
+    message: string;
+    ts: number;
+};
+/** Response shape for GET /api/transport */
+interface TransportStatusPayload {
+    mode: 'direct' | 'hs';
+    /** Present only when mode === 'hs' */
+    socksProxy?: string;
+    reachable: boolean;
+    latencyProxyMs: number | null;
+    latencyDirectMs: number | null;
+    /** ms epoch; 0 if probe never ran */
+    lastProbedAt: number;
+    probeError: string | null;
+    /** Server timestamp at response build time */
+    ts: number;
+}
+/** Request body for PATCH /api/transport */
+interface TransportPatchRequest {
+    mode: 'direct' | 'hs';
+    socksProxy?: string;
+}
+/** Response body for PATCH /api/transport */
+interface TransportPatchResponse {
+    mode: 'direct' | 'hs';
+    socksProxy?: string;
+    restartTriggered: boolean;
+    /** ms epoch of connector restart; present when restartTriggered === true */
+    restartedAt?: number;
+}
+/** API server returned by createApiServer */
+interface ApiServer {
+    app: FastifyInstance;
+    close: () => Promise<void>;
+}
+/** Dependencies required to create the API server */
+interface ApiDeps {
+    configPath: string;
+    config: TownhouseConfig;
+    orchestrator: DockerOrchestrator;
+    wallet: WalletManager;
+    connectorAdmin: ConnectorAdminClient;
+    /**
+     * Probe instance. Required: callers (createApiServer, createWizardApiServer,
+     * cli, dev API server) construct it from the config and pass it explicitly.
+     */
+    transportProbe: TransportProbe;
+    logger?: FastifyBaseLogger;
+}
+
+/**
+ * API Server Factory.
+ *
+ * SECURITY: Only binds to loopback address by default (localhost-only for v1).
+ * Set TOWNHOUSE_API_ALLOW_REMOTE=1 to override this security boundary.
+ */
+
+/**
+ * Create the Fastify API server. Caller MUST supply a `transportProbe` in
+ * `deps` (constructed from the config and started if mode === 'hs').
+ */
+declare function createApiServer(deps: ApiDeps): Promise<ApiServer>;
+
+/**
+ * Wizard API Server Factory.
+ *
+ * Starts in wizard mode (only wizard routes), transitions to normal mode
+ * after POST /wizard/init completes and containers are healthy.
+ * SECURITY: Wizard mode hard-rejects non-loopback bind regardless of env var.
+ */
+
+interface WizardInitialDeps {
+    /** Directory where ~/.townhouse/ (or override) lives */
+    configDir: string;
+    /** Full path to config.yaml */
+    configPath: string;
+    /** Full path to wallet.enc */
+    walletPath: string;
+    /** Port to bind the API */
+    port: number;
+    /** Bind host — must be a loopback address; defaults to 127.0.0.1 */
+    bindHost?: string;
+    docker: Docker;
+    logger?: FastifyBaseLogger | boolean;
+}
+/**
+ * Create the wizard API server. Starts in wizard-only mode.
+ * After POST /wizard/init + orchestrator launch, transitions to normal mode.
+ */
+declare function createWizardApiServer(initialDeps: WizardInitialDeps): Promise<ApiServer>;
+
+/**
+ * Hourly earnings snapshot writer (Story 47.3).
+ *
+ * Persists `claimsReceivedTotal` per (peerId × assetCode) — plus apex
+ * `connectorFees[]` rows under `peerId: '__apex__'` — to
+ * `${dirname(configPath)}/earnings-snapshots.jsonl` once per hour. Consumed
+ * by `snapshot-reader.ts`'s `DeltaComputer` factory. Failure mode: any
+ * per-tick error is logged via `logger.warn` and swallowed (the writer NEVER
+ * throws into the apex event loop) — the next tick retries cleanly. Pruning
+ * runs after each successful append (entries older than 13 months are
+ * rewritten atomically). File mode is `0o600` on every write.
+ *
+ * @module
+ * @since 47.3
+ */
+
+/**
+ * One JSONL row in `earnings-snapshots.jsonl`.
+ *
+ * NOTE: apex routing-fee rows use `peerId: '__apex__'`. The field name
+ * `claimsReceivedTotal` is technically a misnomer for apex rows — those
+ * are connector routing fees, not received claims — but the uniform column
+ * name keeps the JSONL schema simple and the reader doesn't need a special
+ * case.
+ */
+interface SnapshotEntry {
+    /** ISO-8601 UTC timestamp of the tick boundary (e.g. '2026-05-12T15:00:00.000Z'). */
+    ts: string;
+    /** Connector peerId, OR the literal `'__apex__'` for apex routing-fee rows. */
+    peerId: string;
+    assetCode: string;
+    /** Decimal-string cumulative (claims received for peers, routing-fee total for apex). */
+    claimsReceivedTotal: string;
+}
+interface SnapshotWriterOptions {
+    connectorAdmin: ConnectorAdminClient;
+    /** Absolute path to `earnings-snapshots.jsonl`. */
+    snapshotPath: string;
+    /** Tick interval (ms). Default 3_600_000 (1 hour). */
+    tickIntervalMs?: number;
+    /** Injected clock for tests. Default `() => new Date()`. */
+    now?: () => Date;
+    /** Retention window in months. Default 13. */
+    retentionMonths?: number;
+    /** pino/Fastify-compatible logger; warn-only. */
+    logger?: {
+        warn(obj: object, msg?: string): void;
+    };
+    /**
+     * Fire one tick immediately on `start()` instead of waiting for the first
+     * interval. Default `false` (production). Tests set this to `true` to
+     * assert append behavior without advancing fake timers.
+     */
+    fireOnStart?: boolean;
+}
+declare class SnapshotWriter {
+    private readonly opts;
+    private timer;
+    private tickPending;
+    constructor(opts: SnapshotWriterOptions);
+    start(): void;
+    stop(): void;
+    /** Exposed for test ergonomics — runs one full append+prune cycle. */
+    tick(): Promise<void>;
+    private runTick;
+    private appendEntries;
+    private pruneIfNeeded;
+}
+
+/**
+ * `nodes.yaml` schema + read/write helpers (Story 46.1).
+ *
+ * `~/.townhouse/nodes.yaml` is the operator-managed source of truth for
+ * enabled child nodes. The reconciler (see `../reconciler.ts`) converges
+ * connector peer state to this file on every `townhouse hs up`.
+ *
+ * Architectural rule (Epic 46.2 dependency): yaml writes happen BEFORE
+ * connector registration. The drift window resolves in the safe direction —
+ * a yaml entry without a connector peer is re-registered on next boot; a
+ * connector peer without a yaml entry is treated as `'external'` and left
+ * alone.
+ */
+
+declare const NodesYamlEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<["town", "mill", "dvm"]>;
+    peerId: z.ZodString;
+    ilpAddress: z.ZodString;
+    derivationIndex: z.ZodNumber;
+    nostrPubkey: z.ZodOptional<z.ZodString>;
+    enabledAt: z.ZodString;
+    lastSeenAt: z.ZodNullable<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    type: "town" | "mill" | "dvm";
+    id: string;
+    peerId: string;
+    ilpAddress: string;
+    derivationIndex: number;
+    enabledAt: string;
+    lastSeenAt: string | null;
+    nostrPubkey?: string | undefined;
+}, {
+    type: "town" | "mill" | "dvm";
+    id: string;
+    peerId: string;
+    ilpAddress: string;
+    derivationIndex: number;
+    enabledAt: string;
+    lastSeenAt: string | null;
+    nostrPubkey?: string | undefined;
+}>;
+declare const NodesYamlSchema: z.ZodEffects<z.ZodObject<{
+    entries: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<["town", "mill", "dvm"]>;
+        peerId: z.ZodString;
+        ilpAddress: z.ZodString;
+        derivationIndex: z.ZodNumber;
+        nostrPubkey: z.ZodOptional<z.ZodString>;
+        enabledAt: z.ZodString;
+        lastSeenAt: z.ZodNullable<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        type: "town" | "mill" | "dvm";
+        id: string;
+        peerId: string;
+        ilpAddress: string;
+        derivationIndex: number;
+        enabledAt: string;
+        lastSeenAt: string | null;
+        nostrPubkey?: string | undefined;
+    }, {
+        type: "town" | "mill" | "dvm";
+        id: string;
+        peerId: string;
+        ilpAddress: string;
+        derivationIndex: number;
+        enabledAt: string;
+        lastSeenAt: string | null;
+        nostrPubkey?: string | undefined;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    entries: {
+        type: "town" | "mill" | "dvm";
+        id: string;
+        peerId: string;
+        ilpAddress: string;
+        derivationIndex: number;
+        enabledAt: string;
+        lastSeenAt: string | null;
+        nostrPubkey?: string | undefined;
+    }[];
+}, {
+    entries: {
+        type: "town" | "mill" | "dvm";
+        id: string;
+        peerId: string;
+        ilpAddress: string;
+        derivationIndex: number;
+        enabledAt: string;
+        lastSeenAt: string | null;
+        nostrPubkey?: string | undefined;
+    }[];
+}>, {
+    entries: {
+        type: "town" | "mill" | "dvm";
+        id: string;
+        peerId: string;
+        ilpAddress: string;
+        derivationIndex: number;
+        enabledAt: string;
+        lastSeenAt: string | null;
+        nostrPubkey?: string | undefined;
+    }[];
+}, {
+    entries: {
+        type: "town" | "mill" | "dvm";
+        id: string;
+        peerId: string;
+        ilpAddress: string;
+        derivationIndex: number;
+        enabledAt: string;
+        lastSeenAt: string | null;
+        nostrPubkey?: string | undefined;
+    }[];
+}>;
+type NodesYamlEntry = z.infer<typeof NodesYamlEntrySchema>;
+type NodesYaml = z.infer<typeof NodesYamlSchema>;
+/**
+ * Read and validate `nodes.yaml` at the given path.
+ *
+ * Returns `{ entries: [] }` if the file does not exist (graceful first-run).
+ * Throws a `ZodError` with a useful path if the file is present but invalid.
+ */
+declare function readNodesYaml(path: string): Promise<NodesYaml>;
+/**
+ * Write `nodes.yaml` atomically with file mode `0o600`.
+ *
+ * Atomic = write to `<path>.tmp` then `fs.rename`. On POSIX, rename is
+ * atomic when source + destination live on the same filesystem (always true
+ * for `~/.townhouse/nodes.yaml`). Prevents partial-write corruption if the
+ * process is killed mid-write.
+ */
+declare function writeNodesYaml(path: string, data: NodesYaml): Promise<void>;
+
+/**
+ * `PeerTypeResolver` (Story 46.1).
+ *
+ * The connector is a generic ILP router — it has no concept of
+ * `'town' | 'mill' | 'dvm'`. Townhouse owns the type concept entirely
+ * via this resolver, which is the single translation layer between
+ * connector `peerId` values and operator-meaningful node types.
+ *
+ * Architectural rule (Epic 46 planning §Architectural Layering):
+ * downstream consumers (Epic 47 aggregator, Epic 48 TUI, Epic 49 telemetry)
+ * MUST call through this resolver — they never hardcode peer-to-type
+ * mappings.
+ *
+ * The resolver is rebuilt from a `NodesYaml` snapshot — prefer immutable
+ * rebuild (re-instantiate) over mutable update for testability.
+ */
+
+/**
+ * Minimal shape of a peer entry from the connector's `GET /admin/peers`
+ * response (mirrors `PeerStatus` in `../connector/types.ts`). Only the fields
+ * the type-inference heuristic reads are required, so callers can pass the
+ * connector response verbatim.
+ */
+interface ConnectorPeerLike {
+    /** Connector `peerId` (the value the peer authenticates as on its BTP session). */
+    id: string;
+    /** ILP route prefixes registered against this peer as nextHop. */
+    ilpAddresses?: string[];
+}
+declare class PeerTypeResolver {
+    private readonly map;
+    constructor(yaml: NodesYaml);
+    /**
+     * Build a resolver from the connector's `GET /admin/peers` roster instead of
+     * `nodes.yaml`. This is the resolution path for compose-rendered deployments
+     * (`townhouse hs up`), where the connector knows its child peers but no
+     * `nodes.yaml` was ever written (only the `townhouse node add` provisioning
+     * path writes one). The node type is inferred from each peer's `id` /
+     * `ilpAddresses` (see `inferTypeFromConnectorPeer`); peers whose type cannot
+     * be inferred are simply omitted from the map and therefore resolve to
+     * `'external'`.
+     */
+    static fromConnectorPeers(peers: ConnectorPeerLike[]): PeerTypeResolver;
+    /**
+     * Resolve a connector `peerId` to its operator-declared node type.
+     * Returns `'external'` for unknown peerIds (legitimate non-Townhouse
+     * peers running through the same connector).
+     */
+    resolvePeerType(peerId: string): NodeType$1 | 'external';
+}
+
+/**
+ * Earnings aggregator (Story 47.2).
+ *
+ * Aggregates connector-reported earnings into the canonical
+ * `{ status, apex, peers }` shape consumed by the host-API
+ * `/api/earnings` endpoint.
+ *
+ * Source of truth: `connectorAdmin.getEarnings()` (Story 47.1).
+ * Peer-type attribution via `PeerTypeResolver` (Story 46.1); the resolver
+ * buckets unmatched peerIds as `'external'` (enforcement lives in the
+ * resolver, not here — we trust its contract).
+ *
+ * Failure mode: if `getEarnings()` throws (network, 503-when-disabled,
+ * shape drift), returns the empty payload with
+ * `status: 'connector_unavailable'`. The route returns 200 either way;
+ * operators see zeros plus a UI banner rather than a 5xx. An injected
+ * `logger.warn` (Fastify / pino-compatible) is called on failure so ops
+ * can distinguish "connector outage" from "no earnings yet."
+ *
+ * @module
+ * @since 47.2
+ */
+
+/**
+ * Per-asset cumulative + delta breakdown. `lifetime` is the connector's
+ * cumulative `claimsReceivedTotal` (decimal-string bigint at `assetScale`
+ * decimals). `today` / `month` / `year` are deltas computed by Story 47.3's
+ * snapshot-reader; until the `deltaComputer` dep is provided, they stub
+ * to '0'. Asset-scale interpretation (USD: 6, ETH: 18, sats: 0) is the
+ * dashboard's job — the aggregator never collapses to a unit.
+ */
+interface PerAsset {
+    lifetime: string;
+    today: string;
+    month: string;
+    year: string;
+}
+/** Per-peer earnings entry in the aggregator output. */
+interface NodeEarnings {
+    id: string;
+    type: NodeType$1 | 'external';
+    byAsset: Record<string, PerAsset>;
+    /** Max `lastClaimAt` across this peer's assets, or `null` if none. Added in 47.4. */
+    lastClaimAt: string | null;
+}
+/**
+ * Wire-level status for the aggregator response.
+ *
+ * `'ok'` — `getEarnings()` succeeded; payload reflects connector state.
+ * `'connector_unavailable'` — `getEarnings()` threw (network, 503, shape
+ * drift); apex + peers are empty. The dashboard renders a banner.
+ */
+type AggregatedEarningsStatus = 'ok' | 'connector_unavailable';
+/** Top-level aggregator output. Extended in 47.4 with dashboard fields. */
+interface AggregatedEarnings {
+    status: AggregatedEarningsStatus;
+    apex: {
+        routingFees: Record<string, PerAsset>;
+    };
+    peers: NodeEarnings[];
+    /** Pass-through from connector `recentClaims`. Empty array on connector outage. */
+    recentClaims: RecentClaim[];
+    /** Sum of `getMetrics().peers[].packetsForwarded` PLUS `packetsLocallyDelivered`
+     *  (connector v3.7.0+, toon-protocol/connector#73 — counts events that landed
+     *  via the self-delivery route, where the connector's in-process relay accepts
+     *  the event locally rather than forwarding to a remote peer). 0 on connector
+     *  outage or metrics failure. */
+    eventsRelayed: number;
+    /** From `getMetrics().uptimeSeconds`. 0 on connector outage or metrics failure. */
+    uptimeSeconds: number;
+}
+/** Resolves TODAY / MONTH / YEAR deltas for a (scope, assetCode) tuple. */
+type DeltaComputer = (params: {
+    /** Either a connector peerId or the literal `'__apex__'` for routing-fee rows. */
+    scope: string;
+    assetCode: string;
+    /** Current cumulative (matches the lifetime value in the response). */
+    currentLifetime: string;
+}) => Promise<{
+    today: string;
+    month: string;
+    year: string;
+}>;
+/**
+ * Minimal logger contract; Fastify `request.log` and pino satisfy it.
+ * Kept narrow so tests can pass a `{ warn: vi.fn() }` stub.
+ */
+interface AggregatorLogger {
+    warn(obj: object, msg?: string): void;
+}
+interface AggregateEarningsInput {
+    connectorAdmin: ConnectorAdminClient;
+    peerTypeResolver: PeerTypeResolver;
+    /**
+     * Optional delta computer (Story 47.3). When omitted, all PerAsset
+     * `today` / `month` / `year` fields stub to '0'. The route layer (47.4)
+     * wires the snapshot-backed implementation. A rejection on a single
+     * asset stubs that asset's deltas to '0' and emits `logger.warn`; one
+     * bad asset never breaks the aggregate.
+     */
+    deltaComputer?: DeltaComputer;
+    /**
+     * Optional logger. When provided, `getEarnings()` failures and
+     * `deltaComputer` rejections are surfaced via `logger.warn` so ops can
+     * distinguish a connector outage from "no earnings yet."
+     */
+    logger?: AggregatorLogger;
+}
+
+/**
+ * Snapshot reader + `DeltaComputer` factory (Story 47.3).
+ *
+ * Reads `earnings-snapshots.jsonl` and computes TODAY/MONTH/YEAR deltas vs.
+ * UTC boundaries (midnight, 1st-of-month, 1st-of-year). Tolerates malformed
+ * lines (skip) and clock-skewed snapshots (filter `ts > now`). Returns `'0'`
+ * when no boundary snapshot exists yet.
+ *
+ * @module
+ * @since 47.3
+ */
+
+/** ISO of the most recent UTC midnight <= ref. */
+declare function utcDayBoundary(ref: Date): string;
+/** ISO of the first instant of the current calendar month in UTC. */
+declare function utcMonthBoundary(ref: Date): string;
+/** ISO of the first instant of the current calendar year in UTC. */
+declare function utcYearBoundary(ref: Date): string;
+/**
+ * Construct a `DeltaComputer` (Story 47.2's type) backed by the snapshot
+ * file at `snapshotPath`. The returned function is the one wired into
+ * `aggregateEarnings({ ..., deltaComputer })` by Story 47.4's route.
+ *
+ * Reads the snapshot file once per DeltaComputer call (single-pass), then
+ * resolves all three boundaries (today/month/year) in-memory from the parsed
+ * map. No cross-call cache in v1 — see Open Question 6 in story notes.
+ */
+declare function createDeltaComputer(opts: {
+    snapshotPath: string;
+    /** Optional clock injection for tests. Default `() => new Date()`. */
+    now?: () => Date;
+}): DeltaComputer;
+
+/**
+ * Image manifest reader for Townhouse (Story 46.2).
+ *
+ * `~/.townhouse/image-manifest.json` is materialized by `compose-loader.ts`
+ * during `townhouse hs up`. It maps node types to their digest-pinned image
+ * refs, consumed by `POST /api/nodes` step 2 (pull image).
+ */
+
+declare const ImageManifestSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    townhouseVersion: z.ZodString;
+    builtAt: z.ZodString;
+    images: z.ZodObject<{
+        'townhouse-api': z.ZodObject<{
+            name: z.ZodString;
+            tag: z.ZodString;
+            digest: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            name: string;
+            tag: string;
+            digest: string;
+        }, {
+            name: string;
+            tag: string;
+            digest: string;
+        }>;
+        town: z.ZodObject<{
+            name: z.ZodString;
+            tag: z.ZodString;
+            digest: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            name: string;
+            tag: string;
+            digest: string;
+        }, {
+            name: string;
+            tag: string;
+            digest: string;
+        }>;
+        mill: z.ZodObject<{
+            name: z.ZodString;
+            tag: z.ZodString;
+            digest: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            name: string;
+            tag: string;
+            digest: string;
+        }, {
+            name: string;
+            tag: string;
+            digest: string;
+        }>;
+        dvm: z.ZodObject<{
+            name: z.ZodString;
+            tag: z.ZodString;
+            digest: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            name: string;
+            tag: string;
+            digest: string;
+        }, {
+            name: string;
+            tag: string;
+            digest: string;
+        }>;
+        connector: z.ZodObject<{
+            name: z.ZodString;
+            tag: z.ZodString;
+            digest: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            name: string;
+            tag: string;
+            digest: string;
+        }, {
+            name: string;
+            tag: string;
+            digest: string;
+        }>;
+    }, "strict", z.ZodTypeAny, {
+        town: {
+            name: string;
+            tag: string;
+            digest: string;
+        };
+        mill: {
+            name: string;
+            tag: string;
+            digest: string;
+        };
+        dvm: {
+            name: string;
+            tag: string;
+            digest: string;
+        };
+        connector: {
+            name: string;
+            tag: string;
+            digest: string;
+        };
+        'townhouse-api': {
+            name: string;
+            tag: string;
+            digest: string;
+        };
+    }, {
+        town: {
+            name: string;
+            tag: string;
+            digest: string;
+        };
+        mill: {
+            name: string;
+            tag: string;
+            digest: string;
+        };
+        dvm: {
+            name: string;
+            tag: string;
+            digest: string;
+        };
+        connector: {
+            name: string;
+            tag: string;
+            digest: string;
+        };
+        'townhouse-api': {
+            name: string;
+            tag: string;
+            digest: string;
+        };
+    }>;
+}, "strict", z.ZodTypeAny, {
+    schemaVersion: 1;
+    townhouseVersion: string;
+    builtAt: string;
+    images: {
+        town: {
+            name: string;
+            tag: string;
+            digest: string;
+        };
+        mill: {
+            name: string;
+            tag: string;
+            digest: string;
+        };
+        dvm: {
+            name: string;
+            tag: string;
+            digest: string;
+        };
+        connector: {
+            name: string;
+            tag: string;
+            digest: string;
+        };
+        'townhouse-api': {
+            name: string;
+            tag: string;
+            digest: string;
+        };
+    };
+}, {
+    schemaVersion: 1;
+    townhouseVersion: string;
+    builtAt: string;
+    images: {
+        town: {
+            name: string;
+            tag: string;
+            digest: string;
+        };
+        mill: {
+            name: string;
+            tag: string;
+            digest: string;
+        };
+        dvm: {
+            name: string;
+            tag: string;
+            digest: string;
+        };
+        connector: {
+            name: string;
+            tag: string;
+            digest: string;
+        };
+        'townhouse-api': {
+            name: string;
+            tag: string;
+            digest: string;
+        };
+    };
+}>;
+type ImageManifest = z.infer<typeof ImageManifestSchema>;
+/**
+ * Read and validate `image-manifest.json` at the given path.
+ *
+ * Throws ENOENT if the file is missing — there is no graceful fallback for a
+ * missing manifest; it means `townhouse hs up` was not run first.
+ * Throws `ZodError` with a useful path if the file is present but invalid.
+ */
+declare function readImageManifest(path: string): Promise<ImageManifest>;
+
+/**
+ * Boot reconciler (Story 46.1).
+ *
+ * Converges connector peer state to `~/.townhouse/nodes.yaml` (truth) on
+ * every `townhouse hs up`. Reads yaml + connector peers, diffs them,
+ * re-registers any yaml entries missing from the connector, and logs
+ * connector peers without yaml entries as `'external'` (left alone).
+ *
+ * Container lifecycle is OUT of scope — that lives in Epic 46.2.
+ */
+
+/** Action recorded for a single divergence. */
+type DivergenceAction = 'reregistered' | 'reregister-failed' | 'external';
+/** A single divergence record for the reconciler log. */
+interface DivergenceLog {
+    timestamp: string;
+    peerId: string;
+    action: DivergenceAction;
+    detail?: string;
+}
+/** Summary returned by `reconcile()` so callers can surface partial-failure counts. */
+interface ReconcileSummary {
+    reregistered: number;
+    failed: number;
+    external: number;
+}
+declare class BootReconciler {
+    private readonly adminClient;
+    private readonly nodesYamlPath;
+    private readonly reconcilerLogPath;
+    private logDirEnsured;
+    private logFileChmodEnsured;
+    constructor(adminClient: Pick<ConnectorAdminClient, 'getPeers' | 'registerPeer'>, nodesYamlPath: string, reconcilerLogPath: string);
+    /**
+     * Diff `nodes.yaml` (truth) against `GET /admin/peers` (derived state)
+     * and converge.
+     *
+     * Ordering rule (Epic 46.2 dependency — load-bearing):
+     *   `nodes.yaml` write happens BEFORE connector registration
+     *   (`POST /admin/peers`).
+     *
+     * The drift window resolves in the safe direction:
+     *   - yaml entry without a connector peer = harmless. The reconciler
+     *     re-registers it on next `hs up` (this method does that).
+     *   - connector peer without a yaml entry = treated as `'external'` and
+     *     left alone (operators may legitimately route non-Townhouse peers
+     *     through the same connector).
+     *
+     * The unsafe direction (register first, then write yaml) creates a
+     * window where the connector routes to a peer Townhouse cannot clean
+     * up. Epic 46.2's provisioning pipeline MUST honor the yaml-first rule.
+     *
+     * Failures fetching `getPeers()` are surfaced (not swallowed) so the
+     * caller in `handleHsUp` can decide whether to treat reconciler
+     * divergence as fatal. (Today: non-fatal — see cli.ts wire point.)
+     *
+     * Per-divergence appendLog failures are caught so a single log-write
+     * failure does not abort the rest of the reconciliation pass.
+     */
+    reconcile(): Promise<ReconcileSummary>;
+    /**
+     * Compute divergences without mutating the connector. Exposed for
+     * testability — production callers use `reconcile()`.
+     */
+    private diff;
+    /**
+     * Append one divergence record without aborting the whole reconciliation
+     * pass on a single log-write failure (disk full, EACCES, etc.). Failures
+     * are themselves logged to stderr — not silently swallowed — so the
+     * operator can see them in the same `hs up` session.
+     */
+    private tryAppendLog;
+    /**
+     * Append one divergence record to the reconciler log as a single line of
+     * JSON (jsonl-style — easy to grep, easy to parse).
+     *
+     * `mkdir` runs once per reconciler instance. `chmod 0o600` on the log file
+     * also runs once — `fs.appendFile`'s `mode` option only applies on
+     * creation, so without a post-create chmod a pre-existing log file with
+     * permissive mode would never be tightened.
+     */
+    private appendLog;
+}
+
+export { type AggregateEarningsInput, type AggregatedEarnings, type AggregatedEarningsStatus, type AggregatorLogger, type ApiDeps, type ApiServer, type BandwidthPayload, BootReconciler, ChainProviderEntry, ConfigValidationError, ConnectorAdminClient, ConnectorConfigGenerator, ConnectorRuntimeConfig, DEFAULT_ATOR_PROXY, type DeltaComputer, type DepositAddressEntry, type DepositAddressesPayload, type DivergenceAction, type DivergenceLog, DockerOrchestrator, type DvmHealthResponse, EncryptedWallet, type ImageManifest, ImageManifestSchema, type JobsByKindEntry, type JobsRecentPayload, type MetricsPayload, type MillHealthResponse, type MillSwapsRecentPayload, type NodeDetail, type NodeEarnings, type NodeHealthPayload, type NodeInfo, type NodeState, NodeType$1 as NodeType, type NodesYaml, type NodesYamlEntry, NodesYamlEntrySchema, NodesYamlSchema, type NostrEventPayload, type PacketTimeseriesPayload, PeerTypeResolver, type PerAsset, type ReconcileSummary, type RevealRequest, type RevealResponse, type SnapshotEntry, SnapshotWriter, type SnapshotWriterOptions, type SwapByPairEntry, type TimeseriesBucket, type TownHealthPayload, TownhouseConfig, type TransactionReceiptPayload, type TransportPatchRequest, type TransportPatchResponse, TransportProbe, type TransportStatusPayload, type WalletBalanceEntry, type WalletBalancesPayload, WalletManager, type WithdrawDryRunResponse, type WithdrawRequest, type WithdrawResponse, type WithdrawSuccessResponse, type WizardInitRequest, type WizardProgressMessage, type WizardStatePayload, type WsBatchMessage, type WsConnectorRestartedMessage, type WsConnectorRestartingMessage, type WsHeartbeatMessage, type WsMessage, type WsMetricsMessage, type WsNodeStateMessage, type WsRelayEventsMessage, createApiServer, createDeltaComputer, createWizardApiServer, decryptWallet, encryptWallet, getDefaultConfig, loadConfig, loadWallet, readImageManifest, readNodesYaml, saveConfig, saveWallet, utcDayBoundary, utcMonthBoundary, utcYearBoundary, validateConfig, writeNodesYaml };