@cogcoin/client 0.5.4 → 0.5.6

package/dist/wallet/runtime.d.ts

@@ -1,6 +1,7 @@
 import type { CogcoinPathResolution } from "../app-paths.js";
 export interface WalletRuntimePaths {
     dataRoot: string;
+    clientDataDir: string;
     clientConfigPath: string;
     runtimeRoot: string;
     hooksRoot: string;
@@ -9,6 +10,8 @@ export interface WalletRuntimePaths {
     indexerRoot: string;
     walletStatePath: string;
     walletStateBackupPath: string;
+    walletInitPendingPath: string;
+    walletInitPendingBackupPath: string;
     walletUnlockSessionPath: string;
     walletExplicitLockPath: string;
     walletControlLockPath: string;

package/dist/wallet/runtime.js

@@ -3,6 +3,7 @@ export function resolveWalletRuntimePathsForTesting(resolution = {}) {
     const paths = resolveCogcoinPathsForTesting(resolution);
     return {
         dataRoot: paths.dataRoot,
+        clientDataDir: paths.clientDataDir,
         clientConfigPath: paths.clientConfigPath,
         runtimeRoot: paths.runtimeRoot,
         hooksRoot: paths.hooksRoot,
@@ -11,6 +12,8 @@ export function resolveWalletRuntimePathsForTesting(resolution = {}) {
         indexerRoot: paths.indexerRoot,
         walletStatePath: paths.walletStatePath,
         walletStateBackupPath: paths.walletStateBackupPath,
+        walletInitPendingPath: paths.walletInitPendingPath,
+        walletInitPendingBackupPath: paths.walletInitPendingBackupPath,
         walletUnlockSessionPath: paths.walletUnlockSessionPath,
         walletExplicitLockPath: paths.walletExplicitLockPath,
         walletControlLockPath: paths.walletControlLockPath,

package/dist/wallet/state/crypto.d.ts

@@ -15,6 +15,7 @@ export declare function rederiveKeyFromEnvelope(passphrase: Uint8Array | string,
 export declare function encryptBytesWithKey(plaintext: Uint8Array, key: Uint8Array, metadata: {
     format: string;
     wrappedBy: string;
+    walletRootIdHint?: string | null;
     argon2id?: Argon2EnvelopeParams | null;
     secretProvider?: WalletSecretReference | null;
 }): EncryptedEnvelopeV1;
@@ -22,10 +23,12 @@ export declare function decryptBytesWithKey(envelope: EncryptedEnvelopeV1, key:
 export declare function encryptJsonWithPassphrase<T>(value: T, passphrase: Uint8Array | string, metadata: {
     format: string;
     wrappedBy?: string;
+    walletRootIdHint?: string | null;
 }): Promise<EncryptedEnvelopeV1>;
 export declare function encryptJsonWithSecretProvider<T>(value: T, provider: WalletSecretProvider, secretReference: WalletSecretReference, metadata: {
     format: string;
     wrappedBy?: string;
+    walletRootIdHint?: string | null;
 }): Promise<EncryptedEnvelopeV1>;
 export declare function decryptJsonWithPassphrase<T>(envelope: EncryptedEnvelopeV1, passphrase: Uint8Array | string): Promise<T>;
 export declare function decryptJsonWithSecretProvider<T>(envelope: EncryptedEnvelopeV1, provider: WalletSecretProvider): Promise<T>;

package/dist/wallet/state/crypto.js

@@ -76,6 +76,7 @@ export function encryptBytesWithKey(plaintext, key, metadata) {
         version: 1,
         cipher: "aes-256-gcm",
         wrappedBy: metadata.wrappedBy,
+        walletRootIdHint: metadata.walletRootIdHint ?? null,
         argon2id: metadata.argon2id ?? null,
         secretProvider: metadata.secretProvider ?? null,
         nonce: nonce.toString("base64"),
@@ -96,6 +97,7 @@ export async function encryptJsonWithPassphrase(value, passphrase, metadata) {
     return encryptBytesWithKey(Buffer.from(JSON.stringify(value, jsonReplacer)), derived.key, {
         format: metadata.format,
         wrappedBy: metadata.wrappedBy ?? "passphrase",
+        walletRootIdHint: metadata.walletRootIdHint ?? null,
         argon2id: derived.params,
     });
 }
@@ -104,6 +106,7 @@ export async function encryptJsonWithSecretProvider(value, provider, secretRefer
     return encryptBytesWithKey(Buffer.from(JSON.stringify(value, jsonReplacer)), key, {
         format: metadata.format,
         wrappedBy: metadata.wrappedBy ?? "secret-provider",
+        walletRootIdHint: metadata.walletRootIdHint ?? null,
         secretProvider: secretReference,
     });
 }

package/dist/wallet/state/pending-init.d.ts

@@ -0,0 +1,24 @@
+import type { WalletPendingInitializationStateV1 } from "../types.js";
+import type { WalletSecretProvider, WalletSecretReference } from "./provider.js";
+export interface WalletPendingInitializationStoragePaths {
+    primaryPath: string;
+    backupPath: string;
+}
+export interface LoadedWalletPendingInitializationState {
+    source: "primary" | "backup";
+    state: WalletPendingInitializationStateV1;
+}
+export declare function saveWalletPendingInitializationState(paths: WalletPendingInitializationStoragePaths, state: WalletPendingInitializationStateV1, access: {
+    provider: WalletSecretProvider;
+    secretReference: WalletSecretReference;
+}): Promise<void>;
+export declare function loadWalletPendingInitializationState(paths: WalletPendingInitializationStoragePaths, access: {
+    provider: WalletSecretProvider;
+}): Promise<LoadedWalletPendingInitializationState>;
+export declare function loadWalletPendingInitializationStateOrNull(paths: WalletPendingInitializationStoragePaths, access: {
+    provider: WalletSecretProvider;
+}): Promise<LoadedWalletPendingInitializationState | null>;
+export declare function clearWalletPendingInitializationState(paths: WalletPendingInitializationStoragePaths, access?: {
+    provider?: WalletSecretProvider;
+    secretReference?: WalletSecretReference;
+}): Promise<void>;

package/dist/wallet/state/pending-init.js

@@ -0,0 +1,59 @@
+import { readFile, rm } from "node:fs/promises";
+import { writeJsonFileAtomic } from "../fs/atomic.js";
+import { decryptJsonWithSecretProvider, encryptJsonWithSecretProvider, } from "./crypto.js";
+function isMissingFileError(error) {
+    return error instanceof Error
+        && "code" in error
+        && error.code === "ENOENT";
+}
+async function readEnvelope(path) {
+    const raw = await readFile(path, "utf8");
+    return JSON.parse(raw);
+}
+async function loadFromPath(path, source, provider) {
+    return {
+        source,
+        state: await decryptJsonWithSecretProvider(await readEnvelope(path), provider),
+    };
+}
+export async function saveWalletPendingInitializationState(paths, state, access) {
+    const envelope = await encryptJsonWithSecretProvider(state, access.provider, access.secretReference, {
+        format: "cogcoin-wallet-init-pending-state",
+    });
+    await writeJsonFileAtomic(paths.primaryPath, envelope, { mode: 0o600 });
+    await writeJsonFileAtomic(paths.backupPath, envelope, { mode: 0o600 });
+}
+export async function loadWalletPendingInitializationState(paths, access) {
+    try {
+        return await loadFromPath(paths.primaryPath, "primary", access.provider);
+    }
+    catch (primaryError) {
+        try {
+            return await loadFromPath(paths.backupPath, "backup", access.provider);
+        }
+        catch (backupError) {
+            if (isMissingFileError(primaryError)) {
+                throw backupError;
+            }
+            throw primaryError;
+        }
+    }
+}
+export async function loadWalletPendingInitializationStateOrNull(paths, access) {
+    try {
+        return await loadWalletPendingInitializationState(paths, access);
+    }
+    catch (error) {
+        if (isMissingFileError(error)) {
+            return null;
+        }
+        throw error;
+    }
+}
+export async function clearWalletPendingInitializationState(paths, access) {
+    await rm(paths.primaryPath, { force: true }).catch(() => undefined);
+    await rm(paths.backupPath, { force: true }).catch(() => undefined);
+    if (access?.provider != null && access.secretReference != null) {
+        await access.provider.deleteSecret(access.secretReference.keyId).catch(() => undefined);
+    }
+}

package/dist/wallet/state/provider.d.ts

@@ -23,6 +23,7 @@ export interface WalletSecretProvider {
     deleteSecret(keyId: string): Promise<void>;
 }
 export declare function createWalletSecretReference(walletRootId: string): WalletSecretReference;
+export declare function createWalletPendingInitSecretReference(stateRoot: string): WalletSecretReference;
 export declare class MemoryWalletSecretProvider implements WalletSecretProvider {
     #private;
     readonly kind = "memory-test";

package/dist/wallet/state/provider.js

@@ -1,4 +1,4 @@
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { execFile, spawn } from "node:child_process";
 import { mkdir, readFile, rm } from "node:fs/promises";
 import { dirname, join } from "node:path";
@@ -17,6 +17,12 @@ export function createWalletSecretReference(walletRootId) {
         keyId: `wallet-state:${walletRootId}`,
     };
 }
+export function createWalletPendingInitSecretReference(stateRoot) {
+    return {
+        kind: "wallet-init-pending-key",
+        keyId: `wallet-init-pending:${createHash("sha256").update(stateRoot).digest("hex")}`,
+    };
+}
 function bytesToBase64(secret) {
     return Buffer.from(secret).toString("base64");
 }

package/dist/wallet/state/storage.d.ts

@@ -1,4 +1,4 @@
-import type { WalletStateV1 } from "../types.js";
+import type { EncryptedEnvelopeV1, WalletStateV1 } from "../types.js";
 import type { WalletSecretProvider, WalletSecretReference } from "./provider.js";
 export interface WalletStateStoragePaths {
     primaryPath: string;
@@ -8,6 +8,10 @@ export interface LoadedWalletState {
     source: "primary" | "backup";
     state: WalletStateV1;
 }
+export interface RawWalletStateEnvelope {
+    source: "primary" | "backup";
+    envelope: EncryptedEnvelopeV1;
+}
 export type WalletStateSaveAccess = Uint8Array | string | {
     provider: WalletSecretProvider;
     secretReference: WalletSecretReference;
@@ -15,5 +19,7 @@ export type WalletStateSaveAccess = Uint8Array | string | {
 export type WalletStateLoadAccess = Uint8Array | string | {
     provider: WalletSecretProvider;
 };
+export declare function loadRawWalletStateEnvelope(paths: WalletStateStoragePaths): Promise<RawWalletStateEnvelope | null>;
+export declare function extractWalletRootIdHintFromWalletStateEnvelope(envelope: EncryptedEnvelopeV1 | null): string | null;
 export declare function saveWalletState(paths: WalletStateStoragePaths, state: WalletStateV1, access: WalletStateSaveAccess): Promise<void>;
 export declare function loadWalletState(paths: WalletStateStoragePaths, access: WalletStateLoadAccess): Promise<LoadedWalletState>;

package/dist/wallet/state/storage.js

@@ -5,6 +5,43 @@ async function readEnvelope(path) {
     const raw = await readFile(path, "utf8");
     return JSON.parse(raw);
 }
+export async function loadRawWalletStateEnvelope(paths) {
+    try {
+        return {
+            source: "primary",
+            envelope: await readEnvelope(paths.primaryPath),
+        };
+    }
+    catch (primaryError) {
+        try {
+            return {
+                source: "backup",
+                envelope: await readEnvelope(paths.backupPath),
+            };
+        }
+        catch {
+            if (primaryError instanceof SyntaxError
+                || !(primaryError instanceof Error)
+                || !("code" in primaryError)
+                || primaryError.code !== "ENOENT") {
+                throw primaryError;
+            }
+            return null;
+        }
+    }
+}
+export function extractWalletRootIdHintFromWalletStateEnvelope(envelope) {
+    const hint = envelope?.walletRootIdHint?.trim() ?? "";
+    if (hint.length > 0) {
+        return hint;
+    }
+    const keyId = envelope?.secretProvider?.keyId ?? null;
+    const prefix = "wallet-state:";
+    if (keyId === null || !keyId.startsWith(prefix)) {
+        return null;
+    }
+    return keyId.slice(prefix.length);
+}
 export async function saveWalletState(paths, state, access) {
     let previousPrimary = null;
     try {
@@ -21,9 +58,11 @@ export async function saveWalletState(paths, state, access) {
     const envelope = typeof access === "string" || access instanceof Uint8Array
         ? await encryptJsonWithPassphrase(state, access, {
             format: "cogcoin-local-wallet-state",
+            walletRootIdHint: state.walletRootId,
         })
         : await encryptJsonWithSecretProvider(state, access.provider, access.secretReference, {
             format: "cogcoin-local-wallet-state",
+            walletRootIdHint: state.walletRootId,
         });
     await writeJsonFileAtomic(paths.primaryPath, envelope, { mode: 0o600 });
     if (previousPrimary !== null) {

package/dist/wallet/types.d.ts

@@ -229,6 +229,7 @@ export interface EncryptedEnvelopeV1 {
     version: 1;
     cipher: "aes-256-gcm";
     wrappedBy: string;
+    walletRootIdHint?: string | null;
     argon2id?: Argon2EnvelopeParams | null;
     secretProvider?: {
         kind: string;
@@ -252,3 +253,11 @@ export interface WalletExplicitLockStateV1 {
     walletRootId: string;
     lockedAtUnixMs: number;
 }
+export interface WalletPendingInitializationStateV1 {
+    schemaVersion: 1;
+    createdAtUnixMs: number;
+    mnemonic: {
+        phrase: string;
+        language: WalletMnemonicLanguage;
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cogcoin/client",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "description": "Store-backed Cogcoin client with wallet flows, SQLite persistence, and managed Bitcoin Core integration.",
   "license": "MIT",
   "type": "module",
@@ -53,10 +53,12 @@
   "files": [
     "LICENSE",
     "README.md",
-    "dist/**/*"
+    "dist"
   ],
   "scripts": {
     "build": "rm -rf dist && node ./node_modules/typescript/bin/tsc -p tsconfig.json && node -e \"import('node:fs/promises').then(async (fs) => { await fs.mkdir('dist/art', { recursive: true }); await Promise.all([fs.copyFile('src/writing_quotes.json', 'dist/writing_quotes.json'), fs.copyFile('src/art/banner.txt', 'dist/art/banner.txt'), fs.copyFile('src/art/scroll.txt', 'dist/art/scroll.txt'), fs.copyFile('src/art/train-smoke.txt', 'dist/art/train-smoke.txt'), fs.copyFile('src/art/train.txt', 'dist/art/train.txt'), fs.copyFile('src/art/train-car.txt', 'dist/art/train-car.txt'), fs.copyFile('src/art/wallet.txt', 'dist/art/wallet.txt')]); })\"",
+    "generate:default-snapshot-chunk-manifest": "node scripts/generate-default-snapshot-chunk-manifest.mjs",
+    "verify:default-snapshot-chunk-manifest": "node scripts/generate-default-snapshot-chunk-manifest.mjs --check",
     "test": "rm -rf .test-dist && node ./node_modules/typescript/bin/tsc -p tsconfig.test.json && node -e \"import('node:fs/promises').then(async (fs) => { await fs.mkdir('.test-dist/src/art', { recursive: true }); await Promise.all([fs.copyFile('src/writing_quotes.json', '.test-dist/src/writing_quotes.json'), fs.copyFile('src/art/banner.txt', '.test-dist/src/art/banner.txt'), fs.copyFile('src/art/scroll.txt', '.test-dist/src/art/scroll.txt'), fs.copyFile('src/art/train-smoke.txt', '.test-dist/src/art/train-smoke.txt'), fs.copyFile('src/art/train.txt', '.test-dist/src/art/train.txt'), fs.copyFile('src/art/train-car.txt', '.test-dist/src/art/train-car.txt'), fs.copyFile('src/art/wallet.txt', '.test-dist/src/art/wallet.txt')]); })\" && node --test .test-dist/test/*.test.js"
   },
   "dependencies": {