@cogcoin/client 1.0.2 → 1.1.0

package/dist/wallet/mining/sentence-protocol.d.ts

@@ -16,6 +16,7 @@ export interface MiningSentenceGenerationRequestV1 {
         domainId: number;
         domainName: string;
         requiredWords: [string, string, string, string, string];
+        extraPrompt: string | null;
     }>;
 }
 export interface MiningSentenceCandidateV1 {

package/dist/wallet/mining/sentences.js

@@ -25,9 +25,13 @@ function buildSystemPrompt(extraPrompt) {
         "Every sentence must be a single natural-language sentence.",
         "Do not add commentary, markdown, or code fences.",
         "Do not invent domain IDs or request IDs.",
+        "Each rootDomains entry may include an extraPrompt that applies only to that domain.",
+        "If rootDomains[i].extraPrompt is present, use it only for candidates for that domainId.",
+        "If rootDomains[i].extraPrompt is null, fall back to the request-level extraPrompt when it is present.",
+        "Never apply one domain's prompt to another domain's candidates.",
     ];
     if (extraPrompt !== null && extraPrompt.trim().length > 0) {
-        lines.push(`Extra instruction: ${extraPrompt.trim()}`);
+        lines.push(`Request-level fallback instruction: ${extraPrompt.trim()}`);
     }
     return lines.join("\n");
 }
@@ -86,7 +90,7 @@ async function requestBuiltInSentences(options) {
                     input: [
                         {
                             role: "system",
-                            content: buildSystemPrompt(options.extraPrompt),
+                            content: buildSystemPrompt(options.request.extraPrompt),
                         },
                         {
                             role: "user",
@@ -133,7 +137,7 @@ async function requestBuiltInSentences(options) {
             body: JSON.stringify({
                 model,
                 max_tokens: 1_200,
-                system: buildSystemPrompt(options.extraPrompt),
+                system: buildSystemPrompt(options.request.extraPrompt),
                 messages: [
                     {
                         role: "user",
@@ -245,7 +249,6 @@ export async function generateMiningSentences(request, options) {
             provider: builtIn.provider,
             apiKey: builtIn.apiKey,
             modelOverride: builtIn.modelOverride,
-            extraPrompt: builtIn.extraPrompt ?? request.extraPrompt,
             request,
             fetchImpl: options.fetchImpl,
             signal: options.signal,

package/dist/wallet/mining/types.d.ts

@@ -10,12 +10,38 @@ export interface MiningProviderConfigRecord {
     modelSelectionSource: MiningModelSelectionSource;
     updatedAtUnixMs: number;
 }
+export type MiningProviderConfigByProvider = Partial<Record<MiningProviderKind, MiningProviderConfigRecord>>;
 export interface ClientConfigV1 {
     schemaVersion: 1;
     mining: {
         builtIn: MiningProviderConfigRecord | null;
+        builtInByProvider?: MiningProviderConfigByProvider;
+        domainExtraPrompts: Record<string, string>;
     };
 }
+export interface MiningDomainPromptEntry {
+    domain: {
+        name: string;
+        domainId: number | null;
+    };
+    mineable: boolean;
+    prompt: string | null;
+    effectivePromptSource: "domain" | "global-fallback" | "none";
+}
+export interface MiningDomainPromptListResult {
+    fallbackPromptConfigured: boolean;
+    prompts: MiningDomainPromptEntry[];
+}
+export interface MiningDomainPromptMutationResult {
+    domain: {
+        name: string;
+        domainId: number | null;
+    };
+    previousPrompt: string | null;
+    prompt: string | null;
+    status: "updated" | "cleared";
+    fallbackPromptConfigured: boolean;
+}
 export interface MiningEventRecord {
     schemaVersion: 1;
     timestampUnixMs: number;

package/dist/wallet/mining/visualizer.d.ts

@@ -11,6 +11,7 @@ export interface MiningSentenceBoardEntry {
     rank: number;
     domainName: string;
     sentence: string;
+    requiredWords: readonly string[];
 }
 export interface MiningProvisionalSentenceEntry {
     domainName: string | null;
@@ -44,6 +45,8 @@ export declare class MiningFollowVisualizer {
         platform?: NodeJS.Platform;
         env?: NodeJS.ProcessEnv;
         clock?: RenderClock;
+        clientVersion?: string | null;
+        updateAvailable?: boolean;
         rendererFactory?: (stream: TtyRenderStream) => VisualizerRendererLike;
     });
     update(snapshot: MiningRuntimeStatusV1, uiState?: MiningFollowVisualizerState): void;

package/dist/wallet/mining/visualizer.js

@@ -1,9 +1,11 @@
 import { createBootstrapProgress } from "../../bitcoind/progress/formatting.js";
+import { normalizeInlineText, truncateLine } from "../../bitcoind/progress/formatting.js";
 import { advanceFollowSceneState, createFollowSceneState, replaceFollowBlockTimes, syncFollowSceneState, } from "../../bitcoind/progress/follow-scene.js";
 import { DEFAULT_RENDER_CLOCK, resolveTtyRenderPolicy, TtyRenderThrottle, } from "../../bitcoind/progress/render-policy.js";
 import { TtyProgressRenderer } from "../../bitcoind/progress/tty-renderer.js";
 const MINING_ARTWORK_COG_WIDTH = 22;
 const MINING_SENTENCE_BOARD_SIZE = 5;
+const MINING_SENTENCE_BOARD_WRAP_WIDTH = 80;
 function formatCogAmountWithDecimals(value, { maxFractionDigits, minFractionDigits, }) {
     const sign = value < 0n ? "-" : "";
     const absolute = value < 0n ? -value : value;
@@ -44,14 +46,86 @@ function formatCompactCogBalanceText(balanceCogtoshi) {
 function formatCompactSatBalanceText(balanceSats) {
     return balanceSats === null ? null : `${balanceSats.toString()} SAT`;
 }
+function formatArtworkVersionText(clientVersion) {
+    if (typeof clientVersion !== "string") {
+        return null;
+    }
+    const normalizedVersion = normalizeInlineText(clientVersion);
+    if (normalizedVersion.length === 0) {
+        return null;
+    }
+    return normalizedVersion.startsWith("v")
+        ? normalizedVersion
+        : `v${normalizedVersion}`;
+}
 function formatRewardCogAmount(value) {
     return `${formatCogAmountWithDecimals(value, {
         maxFractionDigits: 8,
         minFractionDigits: 1,
     })} COG`;
 }
-function formatSentenceRow(rank, domainName, sentence) {
-    return `${rank}. @${domainName}: ${sentence}`;
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function consumeWrappedLine(text, capacity) {
+    const remaining = text.trimStart();
+    if (remaining.length <= capacity) {
+        return {
+            line: remaining,
+            remaining: "",
+        };
+    }
+    const candidate = remaining.slice(0, capacity + 1);
+    const breakIndex = candidate.lastIndexOf(" ");
+    if (breakIndex > 0) {
+        return {
+            line: remaining.slice(0, breakIndex).trimEnd(),
+            remaining: remaining.slice(breakIndex + 1).trimStart(),
+        };
+    }
+    return {
+        line: remaining.slice(0, capacity),
+        remaining: remaining.slice(capacity).trimStart(),
+    };
+}
+function highlightRequiredWords(sentence, requiredWords) {
+    const uniqueWords = [...new Set(requiredWords
+            .map((word) => word.trim().toLowerCase())
+            .filter((word) => word.length > 0))].sort((left, right) => right.length - left.length);
+    if (uniqueWords.length === 0) {
+        return sentence;
+    }
+    const pattern = new RegExp(`\\b(?:${uniqueWords.map(escapeRegExp).join("|")})\\b`, "gi");
+    return sentence.replace(pattern, (match) => match.toUpperCase());
+}
+function formatSentenceSlot(prefix, sentence, requiredWords, lineCount) {
+    if (sentence === null) {
+        return [
+            prefix.trimEnd(),
+            ...Array.from({ length: Math.max(0, lineCount - 1) }, () => ""),
+        ];
+    }
+    const normalizedSentence = highlightRequiredWords(normalizeInlineText(sentence), requiredWords);
+    const continuationPrefix = " ".repeat(prefix.length);
+    const lines = [];
+    let remaining = normalizedSentence;
+    for (let lineIndex = 0; lineIndex < lineCount; lineIndex += 1) {
+        const linePrefix = lineIndex === 0 ? prefix : continuationPrefix;
+        const capacity = Math.max(0, MINING_SENTENCE_BOARD_WRAP_WIDTH - linePrefix.length);
+        const wrapped = consumeWrappedLine(remaining, capacity);
+        const isLastLine = lineIndex === lineCount - 1;
+        const lineContent = isLastLine && wrapped.remaining.length > 0
+            ? truncateLine(`${wrapped.line}\u2026`, capacity)
+            : wrapped.line;
+        lines.push(lineContent.length === 0
+            ? ""
+            : `${linePrefix}${lineContent}`);
+        remaining = wrapped.remaining;
+    }
+    return lines;
+}
+function formatSentenceRow(entry) {
+    return formatSentenceSlot(`${entry.rank}. @${entry.domainName}: `, entry.sentence, entry.requiredWords, 2);
 }
 function formatRequiredWordsLine(words) {
     if (words.length === 0) {
@@ -59,11 +133,11 @@ function formatRequiredWordsLine(words) {
     }
     return `Required words: ${words.map((word) => word.toUpperCase()).join(", ")}`;
 }
-function formatProvisionalSentenceRow(entry) {
+function formatProvisionalSentenceRow(entry, requiredWords) {
     if (entry.domainName === null || entry.sentence === null) {
-        return "";
+        return ["", "", ""];
     }
-    return `@${entry.domainName}: ${entry.sentence}`;
+    return formatSentenceSlot(`@${entry.domainName}: `, entry.sentence, requiredWords, 3);
 }
 export function createEmptyMiningFollowVisualizerState() {
     return {
@@ -93,6 +167,7 @@ function cloneMiningFollowVisualizerState(state) {
         visibleBlockTimesByHeight: { ...state.visibleBlockTimesByHeight },
         settledBoardEntries: state.settledBoardEntries.map((entry) => ({
             ...entry,
+            requiredWords: [...entry.requiredWords],
         })),
         provisionalRequiredWords: [...state.provisionalRequiredWords],
         provisionalEntry: {
@@ -105,6 +180,10 @@ function cloneMiningFollowVisualizerState(state) {
             },
     };
 }
+function miningFollowSceneShouldSettle(snapshot, nowUnixMs) {
+    return ((snapshot.tipSettledUntilUnixMs ?? 0) > nowUnixMs
+        || (snapshot.reconnectSettledUntilUnixMs ?? 0) > nowUnixMs);
+}
 const VISUALIZER_PROGRESS_SNAPSHOT = {
     url: "",
     filename: "mining-follow-visualizer",
@@ -195,6 +274,8 @@ export function describeMiningVisualizerProgress(snapshot) {
 }
 export class MiningFollowVisualizer {
     #renderer;
+    #artworkStatusLeftText;
+    #artworkStatusRightText;
     #clock;
     #renderThrottle;
     #progress = createBootstrapProgress("follow_tip", VISUALIZER_PROGRESS_SNAPSHOT);
@@ -210,6 +291,9 @@ export class MiningFollowVisualizer {
             env: options.env,
         });
         this.#clock = options.clock ?? DEFAULT_RENDER_CLOCK;
+        const artworkVersionText = formatArtworkVersionText(options.clientVersion);
+        this.#artworkStatusLeftText = options.updateAvailable === true ? "UPDATE" : null;
+        this.#artworkStatusRightText = artworkVersionText;
         this.#renderer = renderPolicy.enabled
             ? options.rendererFactory?.(stream) ?? new TtyProgressRenderer(stream)
             : null;
@@ -238,10 +322,13 @@ export class MiningFollowVisualizer {
         replaceFollowBlockTimes(this.#scene, this.#latestUiState.visibleBlockTimesByHeight);
         const indexedHeight = this.#latestSnapshot.indexerTipHeight ?? this.#latestSnapshot.coreBestHeight ?? null;
         const nodeHeight = this.#latestSnapshot.coreBestHeight ?? indexedHeight;
+        const settleLatest = miningFollowSceneShouldSettle(this.#latestSnapshot, this.#clock.now());
         syncFollowSceneState(this.#scene, {
             indexedHeight,
             nodeHeight,
             liveActivated: true,
+            authoritativeTip: true,
+            settleLatest,
         });
         this.#renderThrottle.request();
     }
@@ -275,22 +362,29 @@ export class MiningFollowVisualizer {
         this.#progress.targetHeight = nodeHeight;
         this.#progress.etaSeconds = null;
         this.#progress.lastError = snapshot.lastError;
-        this.#renderer.renderFollowScene(this.#progress, indexedHeight, nodeHeight, this.#scene, describeMiningVisualizerStatus(snapshot, uiState), {
+        const renderOptions = {
             artworkCogText: formatCompactCogBalanceText(uiState.balanceCogtoshi),
             artworkSatText: formatCompactSatBalanceText(uiState.balanceSats),
             extraLines: [
-                `✎ Indexed Block #${uiState.settledBlockHeight ?? "-----"} Sentences ✎`,
+                `✎ Block #${uiState.settledBlockHeight ?? "-----"} Sentences ✎`,
                 "",
                 ...Array.from({ length: MINING_SENTENCE_BOARD_SIZE }, (_value, index) => {
                     const entry = uiState.settledBoardEntries[index];
                     return entry === undefined
-                        ? `${index + 1}.`
-                        : formatSentenceRow(entry.rank, entry.domainName, entry.sentence);
-                }),
+                        ? [`${index + 1}.`, ""]
+                        : formatSentenceRow(entry);
+                }).flat(),
                 "----------",
                 formatRequiredWordsLine(uiState.provisionalRequiredWords),
-                formatProvisionalSentenceRow(uiState.provisionalEntry),
+                ...formatProvisionalSentenceRow(uiState.provisionalEntry, uiState.provisionalRequiredWords),
             ],
-        });
+        };
+        if (this.#artworkStatusLeftText !== null) {
+            renderOptions.artworkStatusLeftText = this.#artworkStatusLeftText;
+        }
+        if (this.#artworkStatusRightText !== null) {
+            renderOptions.artworkStatusRightText = this.#artworkStatusRightText;
+        }
+        this.#renderer.renderFollowScene(this.#progress, indexedHeight, nodeHeight, this.#scene, describeMiningVisualizerStatus(snapshot, uiState), renderOptions);
     }
 }

package/dist/wallet/read/context.d.ts

@@ -15,6 +15,7 @@ export declare function openWalletReadContext(options: {
     secretProvider?: WalletSecretProvider;
     walletControlLockHeld?: boolean;
     startupTimeoutMs?: number;
+    expectedIndexerBinaryVersion?: string | null;
     now?: number;
     paths?: WalletRuntimePaths;
 }): Promise<WalletReadContext>;

package/dist/wallet/read/context.js

@@ -1,6 +1,6 @@
 import { access, constants } from "node:fs/promises";
 import { deserializeIndexerState, loadBundledGenesisParameters } from "@cogcoin/indexer";
-import { attachOrStartIndexerDaemon, probeIndexerDaemon, readObservedIndexerDaemonStatus, readSnapshotWithRetry, } from "../../bitcoind/indexer-daemon.js";
+import { attachOrStartIndexerDaemon, INDEXER_DAEMON_BACKGROUND_FOLLOW_RECOVERY_FAILED, probeIndexerDaemon, readObservedIndexerDaemonStatus, 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";
@@ -76,7 +76,6 @@ async function normalizeLoadedWalletStateForRead(options) {
         dataDir: options.dataDir,
         chain: "main",
         startHeight: 0,
-        serviceLifetime: "ephemeral",
         walletRootId: options.loaded.state.walletRootId,
     });
     try {
@@ -246,6 +245,11 @@ function mapIndexerStartupError(message) {
                 health: "unavailable",
                 message: "The live indexer daemon socket responded with an invalid or incomplete protocol exchange.",
             };
+        case INDEXER_DAEMON_BACKGROUND_FOLLOW_RECOVERY_FAILED:
+            return {
+                health: "failed",
+                message: "The managed indexer daemon could not recover automatic background follow.",
+            };
         default:
             return {
                 health: "unavailable",
@@ -436,7 +440,6 @@ async function attachNodeStatus(options) {
             dataDir: options.dataDir,
             chain: "main",
             startHeight: resolveCogcoinProcessingStartHeight(genesis),
-            serviceLifetime: "ephemeral",
             walletRootId: options.walletRootId,
             startupTimeoutMs: options.startupTimeoutMs,
         });
@@ -534,18 +537,15 @@ export async function openWalletReadContext(options) {
             dataDir: options.dataDir,
             walletRootId,
         });
-        if (probe.compatibility === "compatible") {
-            daemonClient = probe.client;
-            observedDaemonStatus = probe.status;
-            indexerSource = "probe";
-        }
-        else if (probe.compatibility === "unreachable") {
+        if (probe.compatibility === "compatible" || probe.compatibility === "unreachable") {
+            await probe.client?.close().catch(() => undefined);
             daemonClient = await attachOrStartIndexerDaemon({
                 dataDir: options.dataDir,
                 databasePath: options.databasePath,
-                serviceLifetime: "ephemeral",
                 walletRootId,
                 startupTimeoutMs,
+                ensureBackgroundFollow: true,
+                expectedBinaryVersion: options.expectedIndexerBinaryVersion,
             });
         }
         else {
@@ -570,6 +570,11 @@ export async function openWalletReadContext(options) {
     }
     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,

package/dist/wallet/reset.js

@@ -232,7 +232,6 @@ async function recreateManagedCoreWalletReplicaForReset(options) {
         dataDir: options.dataDir,
         chain: "main",
         startHeight: 0,
-        serviceLifetime: "ephemeral",
         walletRootId: options.state.walletRootId,
         managedWalletPassphrase: options.state.managedCoreWallet.internalPassphrase,
     });

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

@@ -1,6 +1,9 @@
 import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
 import net from "node:net";
 import { rm } from "node:fs/promises";
+function shouldRemoveAgentEndpointPath(endpoint) {
+    return !endpoint.startsWith("\\\\.\\pipe\\");
+}
 function zeroizeBuffer(buffer) {
     if (buffer != null) {
         buffer.fill(0);
@@ -67,7 +70,7 @@ async function main() {
         }
         zeroizeBuffer(key);
         key = Buffer.alloc(0);
-        if (!bootstrap.endpoint.startsWith("\\\\.\\")) {
+        if (shouldRemoveAgentEndpointPath(bootstrap.endpoint)) {
             await rm(bootstrap.endpoint, { force: true }).catch(() => undefined);
         }
         process.exit(0);

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

@@ -33,13 +33,18 @@ function resolveClientPasswordStatePath(directoryPath) {
 function resolveClientPasswordRotationJournalPath(directoryPath) {
     return join(directoryPath, "client-password-rotation.json");
 }
-function resolveAgentEndpoint(platform, stateRoot) {
+function resolveAgentEndpoint(stateRoot) {
     const hash = createHash("sha256").update(stateRoot).digest("hex").slice(0, 24);
-    if (platform === "win32") {
+    // Wallet provider tests simulate foreign platforms, but the local agent transport
+    // still has to follow the real host runtime.
+    if (process.platform === "win32") {
         return `\\\\.\\pipe\\cogcoin-client-password-${hash}`;
     }
     return join(tmpdir(), `cogcoin-client-password-${hash}.sock`);
 }
+function shouldRemoveAgentEndpointPath(endpoint) {
+    return !endpoint.startsWith("\\\\.\\pipe\\");
+}
 function isMissingFileError(error) {
     return error instanceof Error
         && "code" in error
@@ -352,7 +357,7 @@ async function openAgentConnection(endpoint) {
     });
 }
 async function requestAgent(options, request) {
-    const endpoint = resolveAgentEndpoint(options.platform, options.stateRoot);
+    const endpoint = resolveAgentEndpoint(options.stateRoot);
     const socket = await openAgentConnection(endpoint);
     return await new Promise((resolve, reject) => {
         let received = "";
@@ -418,8 +423,9 @@ async function requestAgentOrNull(options, request) {
             ? String(error.code ?? "")
             : "";
         if (code === "ENOENT" || code === "ECONNREFUSED" || code === "ECONNRESET" || code === "EPIPE") {
-            if (options.platform !== "win32") {
-                await rm(resolveAgentEndpoint(options.platform, options.stateRoot), { force: true }).catch(() => undefined);
+            const endpoint = resolveAgentEndpoint(options.stateRoot);
+            if (shouldRemoveAgentEndpointPath(endpoint)) {
+                await rm(endpoint, { force: true }).catch(() => undefined);
             }
             return null;
         }
@@ -441,8 +447,9 @@ export async function readClientPasswordSessionStatus(options) {
 }
 export async function lockClientPasswordSession(options) {
     await requestAgentOrNull(options, { command: "lock" }).catch(() => null);
-    if (options.platform !== "win32") {
-        await rm(resolveAgentEndpoint(options.platform, options.stateRoot), { force: true }).catch(() => undefined);
+    const endpoint = resolveAgentEndpoint(options.stateRoot);
+    if (shouldRemoveAgentEndpointPath(endpoint)) {
+        await rm(endpoint, { force: true }).catch(() => undefined);
     }
     return {
         unlocked: false,
@@ -499,7 +506,7 @@ async function startClientPasswordSession(options) {
 }
 async function startClientPasswordSessionWithExpiry(options) {
     const unlockUntilUnixMs = options.unlockUntilUnixMs;
-    const endpoint = resolveAgentEndpoint(options.platform, options.stateRoot);
+    const endpoint = resolveAgentEndpoint(options.stateRoot);
     await lockClientPasswordSession(options).catch(() => undefined);
     await mkdir(options.runtimeRoot, { recursive: true }).catch(() => undefined);
     const child = spawn(process.execPath, [fileURLToPath(new URL("./client-password-agent.js", import.meta.url)), endpoint, String(unlockUntilUnixMs)], {

package/dist/wallet/tx/anchor.js

@@ -394,7 +394,6 @@ export async function anchorDomain(options) {
                 dataDir: options.dataDir,
                 chain: "main",
                 startHeight: 0,
-                serviceLifetime: "ephemeral",
                 walletRootId: state.walletRootId,
             });
             const rpc = (options.rpcFactory ?? createRpcClient)(node.rpc);

package/dist/wallet/tx/bitcoin-transfer.js

@@ -131,7 +131,6 @@ export async function transferBitcoin(options) {
                 dataDir: options.dataDir,
                 chain: "main",
                 startHeight: 0,
-                serviceLifetime: "ephemeral",
                 walletRootId: state.walletRootId,
             });
             const rpc = (options.rpcFactory ?? createRpcClient)(node.rpc);

package/dist/wallet/tx/cog.js

@@ -534,7 +534,6 @@ export async function sendCog(options) {
                 dataDir: options.dataDir,
                 chain: "main",
                 startHeight: 0,
-                serviceLifetime: "ephemeral",
                 walletRootId: operation.state.walletRootId,
             });
             const rpc = (options.rpcFactory ?? createRpcClient)(node.rpc);
@@ -717,7 +716,6 @@ export async function lockCogToDomain(options) {
                 dataDir: options.dataDir,
                 chain: "main",
                 startHeight: 0,
-                serviceLifetime: "ephemeral",
                 walletRootId: operation.state.walletRootId,
             });
             const rpc = (options.rpcFactory ?? createRpcClient)(node.rpc);
@@ -877,7 +875,6 @@ async function runClaimLikeMutation(options, reclaim) {
                 dataDir: options.dataDir,
                 chain: "main",
                 startHeight: 0,
-                serviceLifetime: "ephemeral",
                 walletRootId: operation.state.walletRootId,
             });
             const rpc = (options.rpcFactory ?? createRpcClient)(node.rpc);

package/dist/wallet/tx/common.js

@@ -435,7 +435,7 @@ export async function buildWalletMutationTransaction(options) {
         const funded = await options.rpc.walletCreateFundedPsbt(options.walletName, options.plan.fixedInputs, options.plan.outputs, 0, {
             add_inputs: true,
             include_unsafe: false,
-            minconf: 1,
+            minconf: availableFundingMinConf,
             changeAddress: options.plan.changeAddress,
             ...(options.plan.changePosition == null ? {} : { changePosition: options.plan.changePosition }),
             lockUnspents: false,

package/dist/wallet/tx/domain-admin.js

@@ -518,7 +518,6 @@ async function submitDomainAdminMutation(options) {
                 dataDir: options.dataDir,
                 chain: "main",
                 startHeight: 0,
-                serviceLifetime: "ephemeral",
                 walletRootId: operation.state.walletRootId,
             });
             const rpc = (options.rpcFactory ?? createRpcClient)(node.rpc);

package/dist/wallet/tx/domain-market.js

@@ -609,7 +609,6 @@ export async function transferDomain(options) {
                 dataDir: options.dataDir,
                 chain: "main",
                 startHeight: 0,
-                serviceLifetime: "ephemeral",
                 walletRootId: operation.state.walletRootId,
             });
             const rpc = (options.rpcFactory ?? createRpcClient)(node.rpc);
@@ -868,7 +867,6 @@ async function runSellMutation(options) {
                 dataDir: options.dataDir,
                 chain: "main",
                 startHeight: 0,
-                serviceLifetime: "ephemeral",
                 walletRootId: operation.state.walletRootId,
             });
             const rpc = (options.rpcFactory ?? createRpcClient)(node.rpc);
@@ -1138,7 +1136,6 @@ export async function buyDomain(options) {
                 dataDir: options.dataDir,
                 chain: "main",
                 startHeight: 0,
-                serviceLifetime: "ephemeral",
                 walletRootId: operation.state.walletRootId,
             });
             const rpc = (options.rpcFactory ?? createRpcClient)(node.rpc);

package/dist/wallet/tx/field.js

@@ -686,7 +686,6 @@ async function submitStandaloneFieldMutation(options) {
                 dataDir: options.dataDir,
                 chain: "main",
                 startHeight: 0,
-                serviceLifetime: "ephemeral",
                 walletRootId: operation.state.walletRootId,
             });
             const rpc = (options.rpcFactory ?? createRpcClient)(node.rpc);

package/dist/wallet/tx/register.js

@@ -532,7 +532,6 @@ export async function registerDomain(options) {
                 dataDir: options.dataDir,
                 chain: "main",
                 startHeight: 0,
-                serviceLifetime: "ephemeral",
                 walletRootId: state.walletRootId,
             });
             const rpc = (options.rpcFactory ?? createRpcClient)(node.rpc);

package/dist/wallet/tx/reputation.js

@@ -513,7 +513,6 @@ async function submitReputationMutation(options) {
                 dataDir: options.dataDir,
                 chain: "main",
                 startHeight: 0,
-                serviceLifetime: "ephemeral",
                 walletRootId: operation.state.walletRootId,
             });
             const rpc = (options.rpcFactory ?? createRpcClient)(node.rpc);

package/package.json

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