@cogcoin/client 1.1.6 → 1.1.7

package/dist/wallet/read/context.js

@@ -1,15 +1,10 @@
 import { access, constants } from "node:fs/promises";
-import { deserializeIndexerState, loadBundledGenesisParameters } from "@cogcoin/indexer";
 import { readPackageVersionFromDisk } from "../../package-version.js";
-import { attachOrStartIndexerDaemon, INDEXER_DAEMON_BACKGROUND_FOLLOW_RECOVERY_FAILED, probeIndexerDaemon, readObservedIndexerDaemonStatus, readSnapshotWithRetry, } from "../../bitcoind/indexer-daemon.js";
-import { deriveManagedBitcoindWalletStatus, resolveManagedBitcoindProbeDecision, } from "../../bitcoind/managed-runtime/bitcoind-policy.js";
-import { deriveManagedIndexerWalletStatus, resolveIndexerDaemonProbeDecision, } from "../../bitcoind/managed-runtime/indexer-policy.js";
+import { readSnapshotWithRetry, } from "../../bitcoind/indexer-daemon.js";
 import { createRpcClient } from "../../bitcoind/node.js";
 import { UNINITIALIZED_WALLET_ROOT_ID } from "../../bitcoind/service-paths.js";
-import { attachOrStartManagedBitcoindService, probeManagedBitcoindService, } from "../../bitcoind/service.js";
-import { resolveCogcoinProcessingStartHeight } from "../../bitcoind/processing-start-height.js";
+import { attachOrStartManagedBitcoindService } from "../../bitcoind/service.js";
 import {} from "../../bitcoind/types.js";
-import { verifyManagedCoreWalletReplica, } from "../lifecycle.js";
 import { normalizeWalletStateRecord, persistWalletCoinControlStateIfNeeded } from "../coin-control.js";
 import { persistNormalizedWalletDescriptorStateIfNeeded } from "../descriptor-normalization.js";
 import { inspectMiningControlPlane } from "../mining/index.js";
@@ -19,11 +14,9 @@ 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";
+import { openManagedWalletReadServiceBundle } from "./managed-services.js";
 import { createWalletReadModel } from "./project.js";
 const DEFAULT_SERVICE_START_TIMEOUT_MS = 10_000;
-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.";
 function btcAmountToSats(value) {
     return BigInt(Math.round(value * 100_000_000));
 }
@@ -223,99 +216,6 @@ async function inspectWalletLocalState(options = {}) {
         };
     }
 }
-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) {
-    try {
-        const probe = await 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 loadBundledGenesisParameters();
-        const handle = await attachOrStartManagedBitcoindService({
-            dataDir: options.dataDir,
-            chain: "main",
-            startHeight: resolveCogcoinProcessingStartHeight(genesis),
-            walletRootId: options.walletRootId,
-            startupTimeoutMs: options.startupTimeoutMs,
-        });
-        const rpc = 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),
-        };
-    }
-}
 async function readFundingSpendableSats(options) {
     if (options.state === null || options.rpc === null) {
         return null;
@@ -345,109 +245,26 @@ export async function openWalletReadContext(options) {
         paths: options.paths,
     });
     const walletRootId = localState.walletRootId ?? UNINITIALIZED_WALLET_ROOT_ID;
-    const node = await attachNodeStatus({
+    const managedServices = await openManagedWalletReadServiceBundle({
         dataDir: options.dataDir,
+        databasePath: options.databasePath,
         walletRootId,
+        localState,
         startupTimeoutMs,
-    });
-    if (localState.state !== null && node.status !== null) {
-        const verifiedReplica = await verifyManagedCoreWalletReplica(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);
-    let daemonClient = null;
-    let daemonStatus = null;
-    let observedDaemonStatus = null;
-    let snapshot = null;
-    let indexerSource = "none";
-    let daemonError = null;
-    try {
-        const probe = await probeIndexerDaemon({
-            dataDir: options.dataDir,
-            walletRootId,
-        });
-        const probeDecision = resolveIndexerDaemonProbeDecision({
-            probe,
-            expectedBinaryVersion: expectedIndexerBinaryVersion,
-        });
-        if (probeDecision.action !== "reject") {
-            await probe.client?.close().catch(() => undefined);
-            daemonClient = await attachOrStartIndexerDaemon({
-                dataDir: options.dataDir,
-                databasePath: options.databasePath,
-                walletRootId,
-                startupTimeoutMs,
-                ensureBackgroundFollow: true,
-                expectedBinaryVersion: expectedIndexerBinaryVersion,
-            });
-        }
-        else {
-            observedDaemonStatus = probe.status;
-            indexerSource = probe.status === null ? "none" : "probe";
-            daemonError = probeDecision.error;
-        }
-        if (daemonClient !== null) {
-            const lease = await readSnapshotWithRetry(daemonClient, 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 node.handle?.stop().catch(() => undefined);
-            throw error;
-        }
-        if (observedDaemonStatus === null) {
-            observedDaemonStatus = await readObservedIndexerDaemonStatus({
-                dataDir: options.dataDir,
-                walletRootId,
-            }).catch(() => null);
-            if (observedDaemonStatus !== null) {
-                indexerSource = "status-file";
-            }
-        }
-    }
-    const indexer = deriveManagedIndexerWalletStatus({
-        daemonStatus,
-        observedStatus: observedDaemonStatus,
-        snapshot,
-        source: indexerSource,
+        expectedIndexerBinaryVersion,
         now,
-        startupError: daemonError,
     });
     const fundingSpendableSats = await readFundingSpendableSats({
         state: localState.state,
-        rpc: node.rpc,
+        rpc: managedServices.node.rpc,
     });
     const mining = await inspectMiningControlPlane({
         provider: options.secretProvider,
         localState,
-        bitcoind,
-        nodeStatus: node.status,
-        nodeHealth: nodeDerived.health,
-        indexer,
+        bitcoind: managedServices.bitcoind,
+        nodeStatus: managedServices.node.status,
+        nodeHealth: managedServices.nodeHealth,
+        indexer: managedServices.indexer,
         nowUnixMs: now,
         paths: options.paths,
     });
@@ -455,20 +272,19 @@ export async function openWalletReadContext(options) {
         dataDir: options.dataDir,
         databasePath: options.databasePath,
         localState,
-        bitcoind,
-        nodeStatus: node.status,
-        nodeHealth: nodeDerived.health,
-        nodeMessage: nodeDerived.message,
-        indexer,
-        snapshot,
+        bitcoind: managedServices.bitcoind,
+        nodeStatus: managedServices.node.status,
+        nodeHealth: managedServices.nodeHealth,
+        nodeMessage: managedServices.nodeMessage,
+        indexer: managedServices.indexer,
+        snapshot: managedServices.snapshot,
         model: localState.state === null
             ? null
-            : createWalletReadModel(localState.state, snapshot),
+            : createWalletReadModel(localState.state, managedServices.snapshot),
         fundingSpendableSats,
         mining,
         async close() {
-            await daemonClient?.close().catch(() => undefined);
-            await node.handle?.stop().catch(() => undefined);
+            await managedServices.close();
         },
     };
 }

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

@@ -0,0 +1,33 @@
+import { loadBundledGenesisParameters } from "@cogcoin/indexer";
+import { attachOrStartIndexerDaemon, probeIndexerDaemon, readObservedIndexerDaemonStatus, readSnapshotWithRetry, 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;
+};
+export declare function openManagedWalletReadServiceBundle(options: {
+    dataDir: string;
+    databasePath: string;
+    walletRootId: string;
+    localState: WalletLocalStateStatus;
+    startupTimeoutMs: number;
+    expectedIndexerBinaryVersion: string | null;
+    now: number;
+}, dependencies?: ManagedWalletReadServiceDeps): Promise<ManagedWalletReadServiceBundle<ManagedBitcoindNodeHandle, ReturnType<typeof createRpcClient>, IndexerDaemonClient>>;
+export {};

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

@@ -0,0 +1,222 @@
+import { deserializeIndexerState, loadBundledGenesisParameters } from "@cogcoin/indexer";
+import { attachOrStartIndexerDaemon, INDEXER_DAEMON_BACKGROUND_FOLLOW_RECOVERY_FAILED, probeIndexerDaemon, readObservedIndexerDaemonStatus, readSnapshotWithRetry, } from "../../bitcoind/indexer-daemon.js";
+import { deriveManagedBitcoindWalletStatus, resolveManagedBitcoindProbeDecision, } from "../../bitcoind/managed-runtime/bitcoind-policy.js";
+import { deriveManagedIndexerWalletStatus, resolveIndexerDaemonProbeDecision, } from "../../bitcoind/managed-runtime/indexer-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 defaultManagedWalletReadServiceDeps = {
+    loadBundledGenesisParameters,
+    probeManagedBitcoindService,
+    attachOrStartManagedBitcoindService,
+    createRpcClient,
+    verifyManagedCoreWalletReplica,
+    probeIndexerDaemon,
+    attachOrStartIndexerDaemon,
+    readSnapshotWithRetry,
+    readObservedIndexerDaemonStatus,
+};
+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 openManagedWalletReadServiceBundle(options, dependencies = defaultManagedWalletReadServiceDeps) {
+    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);
+    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 node.handle?.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 {
+        node,
+        bitcoind,
+        nodeHealth: nodeDerived.health,
+        nodeMessage: nodeDerived.message,
+        daemonClient,
+        indexer,
+        snapshot,
+        async close() {
+            await daemonClient?.close().catch(() => undefined);
+            await node.handle?.stop().catch(() => undefined);
+        },
+    };
+}

package/dist/wallet/state/client-password/bootstrap.d.ts

@@ -0,0 +1,2 @@
+import type { ClientPasswordAgentBootstrapState } from "./types.js";
+export declare function createAgentBootstrapState(state: ClientPasswordAgentBootstrapState): ClientPasswordAgentBootstrapState;

package/dist/wallet/state/client-password/bootstrap.js

@@ -0,0 +1,3 @@
+export function createAgentBootstrapState(state) {
+    return state;
+}

package/dist/wallet/state/client-password/context.d.ts

@@ -0,0 +1,10 @@
+import type { WalletRuntimePaths } from "../../runtime.js";
+import type { ClientPasswordResolvedContext, ClientPasswordStorageOptions } from "./types.js";
+export declare function resolveLocalSecretFilePath(directoryPath: string, keyId: string): string;
+export declare function resolveClientPasswordStatePath(directoryPath: string): string;
+export declare function resolveClientPasswordRotationJournalPath(directoryPath: string): string;
+export declare function isMissingFileError(error: unknown): boolean;
+export declare function createRuntimeError(code: string, cause?: unknown): Error;
+export declare function resolveClientPasswordContext(options: ClientPasswordStorageOptions): ClientPasswordResolvedContext;
+export declare function resolveClientPasswordStorageOptionsForWalletPaths(paths: Pick<WalletRuntimePaths, "stateRoot" | "runtimeRoot">, platform?: NodeJS.Platform): ClientPasswordStorageOptions;
+export declare function createLegacyKeychainServiceName(): string;

package/dist/wallet/state/client-password/context.js

@@ -0,0 +1,46 @@
+import { join } from "node:path";
+function sanitizeSecretKeyId(keyId) {
+    return keyId.replace(/[^a-zA-Z0-9._-]+/g, "-");
+}
+export function resolveLocalSecretFilePath(directoryPath, keyId) {
+    return join(directoryPath, `${sanitizeSecretKeyId(keyId)}.secret`);
+}
+export function resolveClientPasswordStatePath(directoryPath) {
+    return join(directoryPath, "client-password.json");
+}
+export function resolveClientPasswordRotationJournalPath(directoryPath) {
+    return join(directoryPath, "client-password-rotation.json");
+}
+export function isMissingFileError(error) {
+    return error instanceof Error
+        && "code" in error
+        && error.code === "ENOENT";
+}
+export function createRuntimeError(code, cause) {
+    return cause === undefined ? new Error(code) : new Error(code, { cause });
+}
+export function resolveClientPasswordContext(options) {
+    return {
+        ...options,
+        legacyMacKeychainReader: options.legacyMacKeychainReader ?? null,
+        passwordStatePath: resolveClientPasswordStatePath(options.directoryPath),
+        rotationJournalPath: resolveClientPasswordRotationJournalPath(options.directoryPath),
+    };
+}
+export function resolveClientPasswordStorageOptionsForWalletPaths(paths, platform = process.platform) {
+    return {
+        platform,
+        stateRoot: paths.stateRoot,
+        runtimeRoot: paths.runtimeRoot,
+        directoryPath: join(paths.stateRoot, "secrets"),
+        runtimeErrorCode: platform === "win32"
+            ? "wallet_secret_provider_windows_runtime_error"
+            : platform === "darwin"
+                ? "wallet_secret_provider_macos_runtime_error"
+                : "wallet_secret_provider_linux_runtime_error",
+        legacyMacKeychainReader: null,
+    };
+}
+export function createLegacyKeychainServiceName() {
+    return "org.cogcoin.wallet";
+}

package/dist/wallet/state/client-password/crypto.d.ts

@@ -0,0 +1,34 @@
+import type { ClientPasswordStateV1, WrappedSecretEnvelopeV1 } from "./types.js";
+export declare const CLIENT_PASSWORD_DEFAULT_UNLOCK_SECONDS = 3600;
+export declare const CLIENT_PASSWORD_SETUP_AUTO_UNLOCK_SECONDS = 86400;
+export declare function zeroizeBuffer(buffer: Uint8Array | null | undefined): void;
+export declare function derivePasswordKey(passwordBytes: Uint8Array, saltBytes: Uint8Array): Promise<Buffer>;
+export declare function createClientPasswordState(options: {
+    passwordBytes: Uint8Array;
+    passwordHint: string;
+}): Promise<{
+    state: ClientPasswordStateV1;
+    derivedKey: Buffer;
+}>;
+export declare function createWrappedSecretEnvelope(secret: Uint8Array, derivedKey: Uint8Array): WrappedSecretEnvelopeV1;
+export declare function verifyPassword(options: {
+    state: ClientPasswordStateV1;
+    passwordBytes: Uint8Array;
+}): Promise<Buffer | null>;
+export declare function decryptWrappedSecretEnvelope(envelope: WrappedSecretEnvelopeV1, derivedKey: Uint8Array): Uint8Array;
+export declare function encryptSessionSecretBase64(options: {
+    key: Uint8Array;
+    secretBase64: string;
+}): {
+    nonce: string;
+    tag: string;
+    ciphertext: string;
+};
+export declare function decryptSessionSecretBase64(options: {
+    key: Uint8Array;
+    envelope: {
+        nonce: string;
+        tag: string;
+        ciphertext: string;
+    };
+}): string;