@cogcoin/client 1.1.4 → 1.1.6

package/dist/wallet/reset.js

@@ -14,7 +14,6 @@ import { loadMiningRuntimeStatus } from "./mining/runtime-artifacts.js";
 import { clearLegacyWalletLockArtifacts, withUnlockedManagedCoreWallet } from "./managed-core-wallet.js";
 import { resolveWalletRuntimePathsForTesting } from "./runtime.js";
 import { createDefaultWalletSecretProvider, createWalletRootId, createWalletSecretReference, } from "./state/provider.js";
-import { loadWalletSeedIndex } from "./state/seed-index.js";
 import { extractWalletRootIdHintFromWalletStateEnvelope, loadRawWalletStateEnvelope, loadWalletState, saveWalletState, } from "./state/storage.js";
 import { confirmTypedAcknowledgement } from "./tx/confirm.js";
 function sanitizeWalletName(walletRootId) {
@@ -50,6 +49,36 @@ async function readJsonFileOrNull(path) {
         return null;
     }
 }
+async function collectLegacyImportedSeedSecretProviderKeyIds(paths) {
+    const seedsRoot = join(paths.stateRoot, "seeds");
+    const entries = await readdir(seedsRoot, { withFileTypes: true }).catch((error) => {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return [];
+        }
+        throw error;
+    });
+    const keyIds = new Set();
+    for (const entry of entries) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const seedRoot = join(seedsRoot, entry.name);
+        const candidatePaths = [
+            join(seedRoot, "wallet-state.enc"),
+            join(seedRoot, "wallet-state.enc.bak"),
+            join(seedRoot, "wallet-init-pending.enc"),
+            join(seedRoot, "wallet-init-pending.enc.bak"),
+        ];
+        for (const candidatePath of candidatePaths) {
+            const envelope = await readJsonFileOrNull(candidatePath);
+            const keyId = envelope?.secretProvider?.keyId?.trim() ?? "";
+            if (keyId.length > 0) {
+                keyIds.add(keyId);
+            }
+        }
+    }
+    return [...keyIds].sort((left, right) => left.localeCompare(right));
+}
 async function isProcessAlive(pid) {
     if (pid === null) {
         return false;
@@ -454,12 +483,7 @@ async function preflightReset(options) {
     }
     const tracked = await collectTrackedManagedProcesses(options.paths);
     const secretProviderKeyId = rawEnvelope?.envelope.secretProvider?.keyId ?? null;
-    const seedIndex = await loadWalletSeedIndex({
-        paths: options.paths,
-    }).catch(() => null);
-    const importedSeedSecretProviderKeyIds = [...new Set((seedIndex?.seeds ?? [])
-            .filter((seed) => seed.kind === "imported")
-            .map((seed) => createWalletSecretReference(seed.walletRootId).keyId))];
+    const importedSeedSecretProviderKeyIds = await collectLegacyImportedSeedSecretProviderKeyIds(options.paths);
     return {
         dataRoot: options.paths.dataRoot,
         removedRoots,
@@ -555,8 +579,8 @@ async function resolveResetExecutionDecision(options) {
     let walletChoice = "";
     let loadedWalletForEntropyReset = null;
     if (options.preflight.wallet.present) {
-        const answer = (await options.prompter.prompt("Wallet reset choice ([Enter] retain base entropy, \"skip\", or \"delete wallet\"): ")).trim();
-        if (answer !== "" && answer !== "skip" && answer !== "delete wallet") {
+        const answer = (await options.prompter.prompt("Wallet reset choice ([Enter] retain base entropy, \"skip\", or \"clear wallet entropy\"): ")).trim();
+        if (answer !== "" && answer !== "skip" && answer !== "clear wallet entropy") {
             throw new Error("reset_wallet_choice_invalid");
         }
         walletChoice = answer;
@@ -592,7 +616,7 @@ function determineWalletAction(walletPresent, walletChoice) {
     if (walletChoice === "skip") {
         return "kept-unchanged";
     }
-    if (walletChoice === "delete wallet") {
+    if (walletChoice === "clear wallet entropy") {
         return "deleted";
     }
     return "retain-mnemonic";
@@ -636,7 +660,7 @@ export async function previewResetWallet(options) {
         walletPrompt: preflight.wallet.present
             ? {
                 defaultAction: "retain-mnemonic",
-                acceptedInputs: ["", "skip", "delete wallet"],
+                acceptedInputs: ["", "skip", "clear wallet entropy"],
                 entropyRetainingResetAvailable: preflight.wallet.mode === "provider-backed",
                 envelopeSource: preflight.wallet.envelopeSource,
             }

package/dist/wallet/runtime.d.ts

@@ -1,7 +1,5 @@
 import type { CogcoinPathResolution } from "../app-paths.js";
-export type WalletSeedKind = "main" | "imported";
 export interface WalletRuntimePathResolution extends CogcoinPathResolution {
-    seedName?: string | null;
 }
 export interface WalletRuntimePaths {
     dataRoot: string;
@@ -11,9 +9,6 @@ export interface WalletRuntimePaths {
     walletRuntimeRoot: string;
     stateRoot: string;
     walletStateRoot: string;
-    seedRegistryPath: string;
-    selectedSeedName: string;
-    selectedSeedKind: WalletSeedKind;
     bitcoinDataDir: string;
     indexerRoot: string;
     walletStateDirectory: string;
@@ -31,5 +26,4 @@ export interface WalletRuntimePaths {
     miningEventsPath: string;
     miningControlLockPath: string;
 }
-export declare function deriveWalletRuntimePathsForSeed(basePaths: WalletRuntimePaths, seedName: string | null | undefined): WalletRuntimePaths;
 export declare function resolveWalletRuntimePathsForTesting(resolution?: WalletRuntimePathResolution): WalletRuntimePaths;

package/dist/wallet/runtime.js

@@ -1,41 +1,8 @@
 import { join } from "node:path";
 import { resolveCogcoinPathsForTesting } from "../app-paths.js";
-function resolveSeedLayout(sharedStateRoot, sharedRuntimeRoot, seedName) {
-    if (seedName === "main") {
-        return {
-            seedKind: "main",
-            walletStateRoot: sharedStateRoot,
-            walletRuntimeRoot: sharedRuntimeRoot,
-        };
-    }
-    return {
-        seedKind: "imported",
-        walletStateRoot: join(sharedStateRoot, "seeds", seedName),
-        walletRuntimeRoot: join(sharedRuntimeRoot, "seeds", seedName),
-    };
-}
-export function deriveWalletRuntimePathsForSeed(basePaths, seedName) {
-    const resolvedSeedName = seedName ?? "main";
-    const seedLayout = resolveSeedLayout(basePaths.stateRoot, basePaths.runtimeRoot, resolvedSeedName);
-    return {
-        ...basePaths,
-        walletRuntimeRoot: seedLayout.walletRuntimeRoot,
-        walletStateRoot: seedLayout.walletStateRoot,
-        selectedSeedName: resolvedSeedName,
-        selectedSeedKind: seedLayout.seedKind,
-        walletStateDirectory: seedLayout.walletStateRoot,
-        walletStatePath: join(seedLayout.walletStateRoot, "wallet-state.enc"),
-        walletStateBackupPath: join(seedLayout.walletStateRoot, "wallet-state.enc.bak"),
-        walletInitPendingPath: join(seedLayout.walletStateRoot, "wallet-init-pending.enc"),
-        walletInitPendingBackupPath: join(seedLayout.walletStateRoot, "wallet-init-pending.enc.bak"),
-        miningRoot: join(seedLayout.walletRuntimeRoot, "mining"),
-        miningStatusPath: join(seedLayout.walletRuntimeRoot, "mining", "status.json"),
-        miningEventsPath: join(seedLayout.walletRuntimeRoot, "mining", "events.jsonl"),
-    };
-}
 export function resolveWalletRuntimePathsForTesting(resolution = {}) {
     const paths = resolveCogcoinPathsForTesting(resolution);
-    return deriveWalletRuntimePathsForSeed({
+    return {
         dataRoot: paths.dataRoot,
         clientDataDir: paths.clientDataDir,
         clientConfigPath: paths.clientConfigPath,
@@ -43,9 +10,6 @@ export function resolveWalletRuntimePathsForTesting(resolution = {}) {
         walletRuntimeRoot: paths.runtimeRoot,
         stateRoot: paths.stateRoot,
         walletStateRoot: paths.stateRoot,
-        seedRegistryPath: join(paths.stateRoot, "seed-index.json"),
-        selectedSeedName: "main",
-        selectedSeedKind: "main",
         bitcoinDataDir: paths.bitcoinDataDir,
         indexerRoot: paths.indexerRoot,
         walletStateDirectory: paths.stateRoot,
@@ -62,5 +26,5 @@ export function resolveWalletRuntimePathsForTesting(resolution = {}) {
         miningStatusPath: join(paths.runtimeRoot, "mining", "status.json"),
         miningEventsPath: join(paths.runtimeRoot, "mining", "events.jsonl"),
         miningControlLockPath: paths.miningControlLockPath,
-    }, resolution.seedName);
+    };
 }

package/dist/wallet/tx/common.d.ts

@@ -168,6 +168,24 @@ export declare function buildWalletMutationTransaction<TPlan>(options: {
     availableFundingMinConf?: number;
     temporarilyUnlockedPolicyOutpoints?: readonly OutpointRecord[];
 }): Promise<BuiltWalletMutationTransaction>;
+export declare function fundAndValidateWalletMutationDraft<TPlan>(options: {
+    rpc: WalletMutationRpcClient;
+    walletName: string;
+    plan: TPlan & {
+        fixedInputs: FixedWalletInput[];
+        outputs: unknown[];
+        changeAddress: string;
+        changePosition?: number | null;
+        allowedFundingScriptPubKeyHex: string;
+        eligibleFundingOutpointKeys: Set<string>;
+    };
+    validateFundedDraft(decoded: RpcDecodedPsbt, funded: RpcWalletCreateFundedPsbtResult, plan: TPlan): void;
+    feeRate?: number;
+    availableFundingMinConf?: number;
+}): Promise<{
+    funded: RpcWalletCreateFundedPsbtResult;
+    decoded: RpcDecodedPsbt;
+}>;
 export declare function buildWalletMutationTransactionWithReserveFallback<TPlan>(options: {
     rpc: WalletMutationRpcClient;
     walletName: string;

package/dist/wallet/tx/common.js

@@ -416,35 +416,16 @@ export async function pauseMiningForWalletMutation(options) {
     });
 }
 export async function buildWalletMutationTransaction(options) {
-    const availableFundingMinConf = options.availableFundingMinConf ?? 1;
-    const availableFundingUtxos = (await options.rpc.listUnspent(options.walletName, availableFundingMinConf))
-        .filter((entry) => isSpendableFundingUtxo(entry, options.plan.allowedFundingScriptPubKeyHex, availableFundingMinConf));
-    const availableFundingValueByKey = new Map(availableFundingUtxos.map((entry) => [
-        outpointKey({ txid: entry.txid, vout: entry.vout }),
-        btcNumberToSats(entry.amount),
-    ]));
-    const validationPlan = {
-        ...options.plan,
-        eligibleFundingOutpointKeys: new Set([
-            ...options.plan.eligibleFundingOutpointKeys,
-            ...availableFundingUtxos.map((entry) => outpointKey({ txid: entry.txid, vout: entry.vout })),
-        ]),
-    };
     const temporaryBuilderLockedOutpoints = [];
     try {
-        const funded = await options.rpc.walletCreateFundedPsbt(options.walletName, options.plan.fixedInputs, options.plan.outputs, 0, {
-            add_inputs: true,
-            include_unsafe: false,
-            minconf: availableFundingMinConf,
-            changeAddress: options.plan.changeAddress,
-            ...(options.plan.changePosition == null ? {} : { changePosition: options.plan.changePosition }),
-            lockUnspents: false,
-            fee_rate: options.feeRate ?? DEFAULT_WALLET_MUTATION_FEE_RATE_SAT_VB,
-            replaceable: true,
-            subtractFeeFromOutputs: [],
+        const { funded, decoded } = await fundAndValidateWalletMutationDraft({
+            rpc: options.rpc,
+            walletName: options.walletName,
+            plan: options.plan,
+            validateFundedDraft: options.validateFundedDraft,
+            feeRate: options.feeRate,
+            availableFundingMinConf: options.availableFundingMinConf,
         });
-        const decoded = await options.rpc.decodePsbt(funded.psbt);
-        options.validateFundedDraft(decoded, funded, validationPlan);
         let signed;
         let finalized;
         let rawHex;
@@ -490,6 +471,39 @@ export async function buildWalletMutationTransaction(options) {
         throw error;
     }
 }
+export async function fundAndValidateWalletMutationDraft(options) {
+    const availableFundingMinConf = options.availableFundingMinConf ?? 1;
+    const availableFundingUtxos = (await options.rpc.listUnspent(options.walletName, availableFundingMinConf))
+        .filter((entry) => isSpendableFundingUtxo(entry, options.plan.allowedFundingScriptPubKeyHex, availableFundingMinConf));
+    const availableFundingValueByKey = new Map(availableFundingUtxos.map((entry) => [
+        outpointKey({ txid: entry.txid, vout: entry.vout }),
+        btcNumberToSats(entry.amount),
+    ]));
+    const validationPlan = {
+        ...options.plan,
+        eligibleFundingOutpointKeys: new Set([
+            ...options.plan.eligibleFundingOutpointKeys,
+            ...availableFundingUtxos.map((entry) => outpointKey({ txid: entry.txid, vout: entry.vout })),
+        ]),
+    };
+    const funded = await options.rpc.walletCreateFundedPsbt(options.walletName, options.plan.fixedInputs, options.plan.outputs, 0, {
+        add_inputs: true,
+        include_unsafe: false,
+        minconf: availableFundingMinConf,
+        changeAddress: options.plan.changeAddress,
+        ...(options.plan.changePosition == null ? {} : { changePosition: options.plan.changePosition }),
+        lockUnspents: false,
+        fee_rate: options.feeRate ?? DEFAULT_WALLET_MUTATION_FEE_RATE_SAT_VB,
+        replaceable: true,
+        subtractFeeFromOutputs: [],
+    });
+    const decoded = await options.rpc.decodePsbt(funded.psbt);
+    options.validateFundedDraft(decoded, funded, validationPlan);
+    return {
+        funded,
+        decoded,
+    };
+}
 export async function buildWalletMutationTransactionWithReserveFallback(options) {
     return buildWalletMutationTransaction({
         rpc: options.rpc,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cogcoin/client",
-  "version": "1.1.4",
+  "version": "1.1.6",
   "description": "Store-backed Cogcoin client with wallet flows, SQLite persistence, and managed Bitcoin Core integration.",
   "license": "MIT",
   "type": "module",

package/dist/wallet/state/seed-index.d.ts

@@ -1,43 +0,0 @@
-import type { WalletSeedKind, WalletRuntimePaths } from "../runtime.js";
-import { type RawWalletStateEnvelope } from "./storage.js";
-export interface WalletSeedRecord {
-    name: string;
-    kind: WalletSeedKind;
-    walletRootId: string;
-    createdAtUnixMs: number;
-    restoredAtUnixMs: number | null;
-}
-export interface WalletSeedIndexV1 {
-    schemaVersion: 1;
-    lastWrittenAtUnixMs: number;
-    seeds: WalletSeedRecord[];
-}
-export declare function normalizeWalletSeedName(name: string): string;
-export declare function isValidWalletSeedName(name: string): boolean;
-export declare function assertValidImportedWalletSeedName(name: string): string;
-export declare function findWalletSeedRecord(index: WalletSeedIndexV1, seedName: string): WalletSeedRecord | null;
-export declare function loadWalletSeedIndex(options: {
-    paths: Pick<WalletRuntimePaths, "seedRegistryPath" | "walletStatePath" | "walletStateBackupPath">;
-    nowUnixMs?: number;
-    loadRawWalletStateEnvelope?: (paths: {
-        primaryPath: string;
-        backupPath: string;
-    }) => Promise<RawWalletStateEnvelope | null>;
-}): Promise<WalletSeedIndexV1>;
-export declare function saveWalletSeedIndex(paths: Pick<WalletRuntimePaths, "seedRegistryPath">, index: WalletSeedIndexV1): Promise<void>;
-export declare function ensureMainWalletSeedIndexRecord(options: {
-    paths: Pick<WalletRuntimePaths, "seedRegistryPath" | "walletStatePath" | "walletStateBackupPath">;
-    walletRootId: string;
-    nowUnixMs?: number;
-}): Promise<WalletSeedIndexV1>;
-export declare function addImportedWalletSeedRecord(options: {
-    paths: Pick<WalletRuntimePaths, "seedRegistryPath" | "walletStatePath" | "walletStateBackupPath">;
-    seedName: string;
-    walletRootId: string;
-    nowUnixMs?: number;
-}): Promise<WalletSeedIndexV1>;
-export declare function removeWalletSeedRecord(options: {
-    paths: Pick<WalletRuntimePaths, "seedRegistryPath" | "walletStatePath" | "walletStateBackupPath">;
-    seedName: string;
-    nowUnixMs?: number;
-}): Promise<WalletSeedIndexV1>;

package/dist/wallet/state/seed-index.js

@@ -1,151 +0,0 @@
-import { mkdir, readFile } from "node:fs/promises";
-import { dirname } from "node:path";
-import { writeFileAtomic } from "../fs/atomic.js";
-import { extractWalletRootIdHintFromWalletStateEnvelope, loadRawWalletStateEnvelope, } from "./storage.js";
-function createEmptySeedIndex(nowUnixMs) {
-    return {
-        schemaVersion: 1,
-        lastWrittenAtUnixMs: nowUnixMs,
-        seeds: [],
-    };
-}
-function sortSeedRecords(seeds) {
-    return [...seeds].sort((left, right) => left.name.localeCompare(right.name));
-}
-async function readSeedIndexFile(path) {
-    try {
-        const parsed = JSON.parse(await readFile(path, "utf8"));
-        if (parsed?.schemaVersion !== 1 || !Array.isArray(parsed.seeds)) {
-            throw new Error("wallet_seed_index_invalid");
-        }
-        return {
-            schemaVersion: 1,
-            lastWrittenAtUnixMs: typeof parsed.lastWrittenAtUnixMs === "number" ? parsed.lastWrittenAtUnixMs : 0,
-            seeds: sortSeedRecords(parsed.seeds),
-        };
-    }
-    catch (error) {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-            return null;
-        }
-        throw new Error("wallet_seed_index_invalid");
-    }
-}
-export function normalizeWalletSeedName(name) {
-    return name.trim().toLowerCase();
-}
-export function isValidWalletSeedName(name) {
-    return /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(name);
-}
-export function assertValidImportedWalletSeedName(name) {
-    const normalized = normalizeWalletSeedName(name);
-    if (!isValidWalletSeedName(normalized)) {
-        throw new Error("wallet_seed_name_invalid");
-    }
-    if (normalized === "main") {
-        throw new Error("wallet_seed_name_reserved");
-    }
-    return normalized;
-}
-export function findWalletSeedRecord(index, seedName) {
-    const normalized = normalizeWalletSeedName(seedName);
-    return index.seeds.find((seed) => seed.name === normalized) ?? null;
-}
-export async function loadWalletSeedIndex(options) {
-    const nowUnixMs = options.nowUnixMs ?? Date.now();
-    const stored = await readSeedIndexFile(options.paths.seedRegistryPath);
-    if (stored !== null) {
-        return stored;
-    }
-    const rawEnvelope = await (options.loadRawWalletStateEnvelope ?? loadRawWalletStateEnvelope)({
-        primaryPath: options.paths.walletStatePath,
-        backupPath: options.paths.walletStateBackupPath,
-    }).catch(() => null);
-    const mainWalletRootId = extractWalletRootIdHintFromWalletStateEnvelope(rawEnvelope?.envelope ?? null);
-    if (mainWalletRootId === null) {
-        return createEmptySeedIndex(nowUnixMs);
-    }
-    return {
-        schemaVersion: 1,
-        lastWrittenAtUnixMs: nowUnixMs,
-        seeds: [{
-                name: "main",
-                kind: "main",
-                walletRootId: mainWalletRootId,
-                createdAtUnixMs: nowUnixMs,
-                restoredAtUnixMs: null,
-            }],
-    };
-}
-export async function saveWalletSeedIndex(paths, index) {
-    await mkdir(dirname(paths.seedRegistryPath), { recursive: true });
-    await writeFileAtomic(paths.seedRegistryPath, `${JSON.stringify({
-        ...index,
-        seeds: sortSeedRecords(index.seeds),
-    }, null, 2)}\n`, { mode: 0o600 });
-}
-export async function ensureMainWalletSeedIndexRecord(options) {
-    const nowUnixMs = options.nowUnixMs ?? Date.now();
-    const index = await loadWalletSeedIndex({
-        paths: options.paths,
-        nowUnixMs,
-    });
-    const existing = findWalletSeedRecord(index, "main");
-    const seeds = index.seeds.filter((seed) => seed.name !== "main");
-    seeds.push({
-        name: "main",
-        kind: "main",
-        walletRootId: options.walletRootId,
-        createdAtUnixMs: existing?.createdAtUnixMs ?? nowUnixMs,
-        restoredAtUnixMs: existing?.restoredAtUnixMs ?? null,
-    });
-    const nextIndex = {
-        schemaVersion: 1,
-        lastWrittenAtUnixMs: nowUnixMs,
-        seeds: sortSeedRecords(seeds),
-    };
-    await saveWalletSeedIndex(options.paths, nextIndex);
-    return nextIndex;
-}
-export async function addImportedWalletSeedRecord(options) {
-    const nowUnixMs = options.nowUnixMs ?? Date.now();
-    const seedName = assertValidImportedWalletSeedName(options.seedName);
-    const index = await loadWalletSeedIndex({
-        paths: options.paths,
-        nowUnixMs,
-    });
-    if (findWalletSeedRecord(index, seedName) !== null) {
-        throw new Error("wallet_seed_name_exists");
-    }
-    const nextIndex = {
-        schemaVersion: 1,
-        lastWrittenAtUnixMs: nowUnixMs,
-        seeds: sortSeedRecords([
-            ...index.seeds,
-            {
-                name: seedName,
-                kind: "imported",
-                walletRootId: options.walletRootId,
-                createdAtUnixMs: nowUnixMs,
-                restoredAtUnixMs: nowUnixMs,
-            },
-        ]),
-    };
-    await saveWalletSeedIndex(options.paths, nextIndex);
-    return nextIndex;
-}
-export async function removeWalletSeedRecord(options) {
-    const nowUnixMs = options.nowUnixMs ?? Date.now();
-    const seedName = normalizeWalletSeedName(options.seedName);
-    const index = await loadWalletSeedIndex({
-        paths: options.paths,
-        nowUnixMs,
-    });
-    const nextIndex = {
-        schemaVersion: 1,
-        lastWrittenAtUnixMs: nowUnixMs,
-        seeds: sortSeedRecords(index.seeds.filter((seed) => seed.name !== seedName)),
-    };
-    await saveWalletSeedIndex(options.paths, nextIndex);
-    return nextIndex;
-}