@cogcoin/client 1.1.7 → 1.1.9

package/dist/cli/pagination.d.ts

@@ -0,0 +1,15 @@
+export interface ListPage {
+    limit: number | null;
+    returned: number;
+    truncated: boolean;
+    moreAvailable: boolean | null;
+    totalKnown: number | null;
+}
+export declare function normalizeListPage<T>(items: readonly T[], options: {
+    limit: number | null;
+    all: boolean;
+    defaultLimit: number;
+}): {
+    items: T[];
+    page: ListPage;
+};

package/dist/cli/pagination.js

@@ -0,0 +1,16 @@
+export function normalizeListPage(items, options) {
+    const totalKnown = items.length;
+    const appliedLimit = options.all ? null : (options.limit ?? options.defaultLimit);
+    const pagedItems = appliedLimit === null ? [...items] : items.slice(0, appliedLimit);
+    const truncated = appliedLimit !== null && totalKnown > appliedLimit;
+    return {
+        items: pagedItems,
+        page: {
+            limit: appliedLimit,
+            returned: pagedItems.length,
+            truncated,
+            moreAvailable: truncated,
+            totalKnown,
+        },
+    };
+}

package/dist/cli/recommendations.d.ts

@@ -0,0 +1,4 @@
+import type { WalletReadContext } from "../wallet/read/index.js";
+export declare function getRepairRecommendation(context: WalletReadContext): string | null;
+export declare function getClientUnlockRecommendation(context: WalletReadContext): string | null;
+export declare function getMutationRecommendation(context: WalletReadContext): string | null;

package/dist/cli/recommendations.js

@@ -0,0 +1,108 @@
+export function getRepairRecommendation(context) {
+    if (context.localState.clientPasswordReadiness === "setup-required"
+        || context.localState.clientPasswordReadiness === "migration-required") {
+        return "Run `cogcoin init` to configure the client password and migrate local wallet secrets.";
+    }
+    if (context.localState.unlockRequired) {
+        return null;
+    }
+    if (context.localState.availability === "uninitialized") {
+        return "Run `cogcoin init` to create or restore a wallet.";
+    }
+    if (context.localState.availability === "local-state-corrupt") {
+        return "Run `cogcoin repair` to recover local wallet state.";
+    }
+    if (context.bitcoind.health === "service-version-mismatch"
+        || context.bitcoind.health === "wallet-root-mismatch"
+        || context.bitcoind.health === "runtime-mismatch"
+        || context.bitcoind.health === "replica-missing"
+        || context.bitcoind.health === "replica-mismatch"
+        || context.bitcoind.health === "failed") {
+        return "Run `cogcoin repair` to recover the managed bitcoind service and Core wallet replica.";
+    }
+    if (context.indexer.health === "failed"
+        || context.indexer.health === "schema-mismatch"
+        || context.indexer.health === "service-version-mismatch"
+        || context.indexer.health === "wallet-root-mismatch") {
+        return "Run `cogcoin repair` to recover the managed indexer daemon and local indexer artifacts.";
+    }
+    if (context.localState.state?.miningState.state === "repair-required"
+        || (context.localState.state?.pendingMutations ?? []).some((mutation) => mutation.status === "repair-required")) {
+        return "Run `cogcoin repair` before relying on local wallet state.";
+    }
+    return null;
+}
+export function getClientUnlockRecommendation(context) {
+    if (context.localState.unlockRequired) {
+        return "Rerun this command in an interactive terminal so Cogcoin can prompt for the client password.";
+    }
+    return null;
+}
+export function getMutationRecommendation(context) {
+    const pendingMutations = context.localState.state?.pendingMutations ?? [];
+    const unresolved = pendingMutations.find((mutation) => mutation.status === "broadcast-unknown" || mutation.status === "repair-required");
+    if (unresolved === undefined) {
+        return null;
+    }
+    if (unresolved.status === "repair-required") {
+        return "Run `cogcoin repair` before starting another mutation.";
+    }
+    if (unresolved.kind === "register") {
+        return `Rerun \`cogcoin register ${unresolved.domainName}\` to reconcile the pending registration, or run \`cogcoin repair\` if it remains unresolved.`;
+    }
+    if (unresolved.kind === "anchor") {
+        return `Rerun \`cogcoin anchor ${unresolved.domainName}\` to reconcile the pending anchor, or run \`cogcoin repair\` if it remains unresolved.`;
+    }
+    if (unresolved.kind === "transfer") {
+        return `Rerun \`cogcoin transfer ${unresolved.domainName}\` with the same target to reconcile the pending transfer, or run \`cogcoin repair\` if it remains unresolved.`;
+    }
+    if (unresolved.kind === "sell") {
+        const command = unresolved.priceCogtoshi === 0n ? "unsell" : "sell";
+        return `Rerun \`cogcoin ${command} ${unresolved.domainName}\` to reconcile the pending listing change, or run \`cogcoin repair\` if it remains unresolved.`;
+    }
+    if (unresolved.kind === "buy") {
+        return `Rerun \`cogcoin buy ${unresolved.domainName}\` to reconcile the pending purchase, or run \`cogcoin repair\` if it remains unresolved.`;
+    }
+    if (unresolved.kind === "endpoint") {
+        return unresolved.endpointValueHex === ""
+            ? `Rerun \`cogcoin domain endpoint clear ${unresolved.domainName}\` to reconcile the pending endpoint clear, or run \`cogcoin repair\` if it remains unresolved.`
+            : `Rerun \`cogcoin domain endpoint set ${unresolved.domainName} ...\` to reconcile the pending endpoint update, or run \`cogcoin repair\` if it remains unresolved.`;
+    }
+    if (unresolved.kind === "delegate") {
+        return unresolved.recipientScriptPubKeyHex === null
+            ? `Rerun \`cogcoin domain delegate clear ${unresolved.domainName}\` to reconcile the pending delegate clear, or run \`cogcoin repair\` if it remains unresolved.`
+            : `Rerun \`cogcoin domain delegate set ${unresolved.domainName} ...\` to reconcile the pending delegate update, or run \`cogcoin repair\` if it remains unresolved.`;
+    }
+    if (unresolved.kind === "miner") {
+        return unresolved.recipientScriptPubKeyHex === null
+            ? `Rerun \`cogcoin domain miner clear ${unresolved.domainName}\` to reconcile the pending miner clear, or run \`cogcoin repair\` if it remains unresolved.`
+            : `Rerun \`cogcoin domain miner set ${unresolved.domainName} ...\` to reconcile the pending miner update, or run \`cogcoin repair\` if it remains unresolved.`;
+    }
+    if (unresolved.kind === "canonical") {
+        return `Rerun \`cogcoin domain canonical ${unresolved.domainName}\` to reconcile the pending canonical update, or run \`cogcoin repair\` if it remains unresolved.`;
+    }
+    if (unresolved.kind === "field-create") {
+        return `Rerun \`cogcoin field create ${unresolved.domainName} ${unresolved.fieldName} ...\` to reconcile the pending field creation, or run \`cogcoin repair\` if it remains unresolved.`;
+    }
+    if (unresolved.kind === "field-set") {
+        return `Rerun \`cogcoin field set ${unresolved.domainName} ${unresolved.fieldName} ...\` to reconcile the pending field update, or run \`cogcoin repair\` if it remains unresolved.`;
+    }
+    if (unresolved.kind === "field-clear") {
+        return `Rerun \`cogcoin field clear ${unresolved.domainName} ${unresolved.fieldName}\` to reconcile the pending field clear, or run \`cogcoin repair\` if it remains unresolved.`;
+    }
+    if (unresolved.kind === "rep-give") {
+        return `Rerun \`cogcoin rep give ${unresolved.domainName} ${unresolved.recipientDomainName ?? "..."} ...\` to reconcile the pending reputation support, or run \`cogcoin repair\` if it remains unresolved.`;
+    }
+    if (unresolved.kind === "rep-revoke") {
+        return `Rerun \`cogcoin rep revoke ${unresolved.domainName} ${unresolved.recipientDomainName ?? "..."} ...\` to reconcile the pending reputation revoke, or run \`cogcoin repair\` if it remains unresolved.`;
+    }
+    if (unresolved.kind === "send") {
+        return "Rerun the same `cogcoin send ...` command to reconcile the pending transfer, or run `cogcoin repair` if it remains unresolved.";
+    }
+    if (unresolved.kind === "lock") {
+        return "Rerun the same `cogcoin cog lock ...` command to reconcile the pending lock, or run `cogcoin repair` if it remains unresolved.";
+    }
+    return unresolved.preimageHex === "0000000000000000000000000000000000000000000000000000000000000000"
+        ? "Rerun the same `cogcoin reclaim ...` command to reconcile the pending reclaim, or run `cogcoin repair` if it remains unresolved."
+        : "Rerun the same `cogcoin claim ...` command to reconcile the pending claim, or run `cogcoin repair` if it remains unresolved.";
+}

package/dist/cli/wallet-format/availability.d.ts

@@ -0,0 +1,5 @@
+import type { WalletReadContext } from "../../wallet/read/index.js";
+export declare function resolveWalletRootLabel(context: WalletReadContext): string;
+export declare function appendServiceSummary(lines: string[], context: WalletReadContext): void;
+export declare function appendWalletAvailability(lines: string[], context: WalletReadContext): void;
+export declare function getOverviewNextStep(context: WalletReadContext): string | null;

package/dist/cli/wallet-format/availability.js

@@ -0,0 +1,96 @@
+import { formatMiningSummaryLine } from "../mining-format.js";
+import { getClientUnlockRecommendation, getMutationRecommendation, getRepairRecommendation, } from "../recommendations.js";
+import { getBootstrapSyncNextStep } from "../workflow-hints.js";
+import { formatIndexerTruthSource, formatMaybe, formatServiceHealth, } from "./shared.js";
+export function resolveWalletRootLabel(context) {
+    return context.model?.walletRootId
+        ?? context.localState.walletRootId
+        ?? context.nodeStatus?.walletRootId
+        ?? "none";
+}
+export function appendServiceSummary(lines, context) {
+    lines.push(`Managed bitcoind: ${formatServiceHealth(context.bitcoind.health)}`);
+    if (context.bitcoind.message !== null) {
+        lines.push(`Managed bitcoind note: ${context.bitcoind.message}`);
+    }
+    lines.push(`Bitcoin service: ${formatServiceHealth(context.nodeHealth)}`);
+    if (context.nodeStatus !== null) {
+        lines.push(`Bitcoin best height: ${formatMaybe(context.nodeStatus.nodeBestHeight)}`);
+        lines.push(`Bitcoin headers: ${formatMaybe(context.nodeStatus.nodeHeaderHeight)}`);
+    }
+    if (context.nodeMessage !== null) {
+        lines.push(`Bitcoin note: ${context.nodeMessage}`);
+    }
+    lines.push(`Indexer service: ${formatServiceHealth(context.indexer.health)}`);
+    lines.push(`Indexer truth source: ${formatIndexerTruthSource(context.indexer.source)}`);
+    if (context.indexer.daemonInstanceId !== null) {
+        lines.push(`Indexer daemon instance: ${context.indexer.daemonInstanceId}`);
+    }
+    if (context.indexer.snapshotSeq !== null) {
+        lines.push(`Indexer snapshot sequence: ${context.indexer.snapshotSeq}`);
+    }
+    if (context.indexer.status?.reorgDepth !== null && context.indexer.status?.reorgDepth !== undefined) {
+        lines.push(`Indexer reorg depth: ${context.indexer.status.reorgDepth}`);
+    }
+    if (context.indexer.snapshotTip !== null) {
+        lines.push(`Indexer tip height: ${context.indexer.snapshotTip.height}`);
+    }
+    else {
+        lines.push("Indexer tip height: unavailable");
+    }
+    if (context.indexer.message !== null) {
+        lines.push(`Indexer note: ${context.indexer.message}`);
+    }
+    if (context.mining !== undefined) {
+        lines.push(`Mining: ${formatMiningSummaryLine(context.mining)}`);
+        if (context.mining.runtime.note !== null) {
+            lines.push(`Mining note: ${context.mining.runtime.note}`);
+        }
+    }
+}
+export function appendWalletAvailability(lines, context) {
+    lines.push(`Wallet state: ${context.localState.availability}`);
+    lines.push(`Wallet root: ${resolveWalletRootLabel(context)}`);
+    if (context.localState.message !== null) {
+        lines.push(`Wallet note: ${context.localState.message}`);
+    }
+    const nodeStatus = context.nodeStatus;
+    const replica = nodeStatus?.walletReplica ?? null;
+    if (replica !== null) {
+        lines.push(`Managed Core wallet: ${replica.proofStatus ?? "not-proven"}`);
+    }
+    if (nodeStatus?.walletReplicaMessage) {
+        lines.push(`Managed Core note: ${nodeStatus.walletReplicaMessage}`);
+    }
+    const repairRecommendation = getRepairRecommendation(context);
+    if (repairRecommendation !== null) {
+        lines.push(`Recommended next step: ${repairRecommendation}`);
+    }
+    else {
+        const clientUnlockRecommendation = getClientUnlockRecommendation(context);
+        if (clientUnlockRecommendation !== null) {
+            lines.push(`Recommended next step: ${clientUnlockRecommendation}`);
+        }
+        else if (getBootstrapSyncNextStep(context) !== null) {
+            lines.push("Recommended next step: Run `cogcoin sync` to bootstrap assumeutxo and the managed Bitcoin/indexer state.");
+        }
+    }
+    const mutationRecommendation = getMutationRecommendation(context);
+    if (mutationRecommendation !== null) {
+        lines.push(`Mutation note: ${mutationRecommendation}`);
+    }
+}
+export function getOverviewNextStep(context) {
+    const repairRecommendation = getRepairRecommendation(context);
+    if (repairRecommendation !== null) {
+        return repairRecommendation;
+    }
+    const clientUnlockRecommendation = getClientUnlockRecommendation(context);
+    if (clientUnlockRecommendation !== null) {
+        return clientUnlockRecommendation;
+    }
+    if (getBootstrapSyncNextStep(context) !== null) {
+        return "Run `cogcoin sync` to bootstrap assumeutxo and the managed Bitcoin/indexer state.";
+    }
+    return getMutationRecommendation(context);
+}

package/dist/cli/wallet-format/balance.d.ts

@@ -0,0 +1,2 @@
+import type { WalletReadContext } from "../../wallet/read/index.js";
+export declare function formatBalanceReport(context: WalletReadContext): string;

package/dist/cli/wallet-format/balance.js

@@ -0,0 +1,162 @@
+import { getBalance } from "@cogcoin/indexer/queries";
+import { isRootDomainName } from "../../wallet/read/index.js";
+import { loadBalanceArtText } from "../art.js";
+import { formatNextStepLines, getFundingQuickstartGuidance, } from "../workflow-hints.js";
+import { appendWalletAvailability } from "./availability.js";
+import { formatBitcoinAmount, formatCogAmount, formatServiceHealth, } from "./shared.js";
+const BALANCE_QUICKSTART_THRESHOLD_SATS = 150000n;
+const BALANCE_BUY_ROOT_THRESHOLD_SATS = 100000n;
+const BALANCE_MINING_THRESHOLD_SATS = 10000n;
+function renderBalanceArtLine(templateLine, label, value) {
+    const labelIndex = templateLine.indexOf(label);
+    if (labelIndex === -1) {
+        throw new Error(`balance_art_label_missing_${label}`);
+    }
+    const fieldStart = labelIndex + label.length;
+    const borderIndex = Math.max(templateLine.lastIndexOf("│"), templateLine.lastIndexOf("|"));
+    if (borderIndex <= fieldStart) {
+        throw new Error(`balance_art_field_invalid_${label}`);
+    }
+    const fieldWidth = borderIndex - fieldStart;
+    const fieldValue = value.slice(0, fieldWidth).padEnd(fieldWidth, " ");
+    const rendered = `${templateLine.slice(0, fieldStart)}${fieldValue}${templateLine.slice(borderIndex)}`;
+    if (rendered.length !== templateLine.length) {
+        throw new Error(`balance_art_render_width_invalid_${label}`);
+    }
+    return rendered;
+}
+function renderBalanceArtCard(context) {
+    const templateLines = loadBalanceArtText().split("\n");
+    const fundingAddress = context.model.walletAddress ?? "unavailable";
+    const spendableCog = getBalance(context.snapshot.state, new Uint8Array(Buffer.from(context.model.walletScriptPubKeyHex, "hex")));
+    return templateLines.map((line) => {
+        if (line.includes("Funding address:")) {
+            return renderBalanceArtLine(line, "Funding address:", ` ${fundingAddress}`);
+        }
+        if (line.includes("Bitcoin Balance:")) {
+            return renderBalanceArtLine(line, "Bitcoin Balance:", ` ${formatBitcoinAmount(context.fundingSpendableSats ?? null)}`);
+        }
+        if (line.includes("Cogcoin Balance:")) {
+            return renderBalanceArtLine(line, "Cogcoin Balance:", ` ${formatCogAmount(spendableCog)}`);
+        }
+        if (line.includes("mempool.space/address/")) {
+            return renderBalanceArtLine(line, "mempool.space/address/", fundingAddress);
+        }
+        return line;
+    });
+}
+function hasRegisteredOrAnchoredDomain(model) {
+    return model.domains.some((domain) => domain.localRelationship === "local"
+        && (domain.chainStatus === "registered-unanchored" || domain.chainStatus === "anchored"));
+}
+function listBalanceDomainsByStatus(model, status) {
+    return model.domains
+        .filter((domain) => domain.localRelationship === "local" && domain.chainStatus === status)
+        .sort((left, right) => left.name.localeCompare(right.name));
+}
+function shouldShowBalanceQuickstart(context) {
+    return context.fundingSpendableSats !== null
+        && context.fundingSpendableSats < BALANCE_QUICKSTART_THRESHOLD_SATS
+        && !hasRegisteredOrAnchoredDomain(context.model);
+}
+function formatBalanceDomainSection(title, icon, domains, emptyLabel) {
+    const domainItems = domains.map((domain) => `${icon} ${domain.name}`);
+    const wrappedDomainLines = [];
+    let currentLine = "";
+    for (const item of domainItems) {
+        const candidate = currentLine.length === 0 ? item : `${currentLine}, ${item}`;
+        if (candidate.length <= 80) {
+            currentLine = candidate;
+            continue;
+        }
+        if (currentLine.length > 0) {
+            wrappedDomainLines.push(currentLine);
+        }
+        currentLine = item;
+    }
+    if (currentLine.length > 0) {
+        wrappedDomainLines.push(currentLine);
+    }
+    return [
+        title,
+        ...(domains.length === 0
+            ? [emptyLabel]
+            : wrappedDomainLines),
+    ];
+}
+function getBalanceNextSteps(context) {
+    const anchoredDomains = listBalanceDomainsByStatus(context.model, "anchored");
+    const anchoredRootDomains = anchoredDomains.filter((domain) => isRootDomainName(domain.name));
+    const unanchoredDomains = listBalanceDomainsByStatus(context.model, "registered-unanchored");
+    if (anchoredRootDomains.length > 0) {
+        if (context.fundingSpendableSats !== null && context.fundingSpendableSats < BALANCE_MINING_THRESHOLD_SATS) {
+            return [`Transfer BTC to ${context.model.walletAddress ?? "this wallet address"} so your anchored root domain can keep mining.`];
+        }
+        if (context.fundingSpendableSats !== null && context.fundingSpendableSats > BALANCE_MINING_THRESHOLD_SATS) {
+            if (context.mining?.provider.status === "missing") {
+                return ["Run `cogcoin mine setup` to configure your mining provider."];
+            }
+            return ["Run `cogcoin mine` to start mining with your anchored root domain."];
+        }
+        return [];
+    }
+    if (unanchoredDomains.length > 0) {
+        return [`Run \`cogcoin anchor ${unanchoredDomains[0].name}\` to anchor your unanchored domain.`];
+    }
+    if (context.fundingSpendableSats !== null && context.fundingSpendableSats > BALANCE_BUY_ROOT_THRESHOLD_SATS) {
+        return ["Buy a 6+ character root domain with `cogcoin register <root>`."];
+    }
+    return [];
+}
+function listPendingBalanceLines(context) {
+    const lines = [];
+    for (const mutation of (context.localState.state?.pendingMutations ?? [])
+        .filter((entry) => (entry.kind === "send" || entry.kind === "lock" || entry.kind === "claim")
+        && entry.status !== "confirmed"
+        && entry.status !== "canceled")) {
+        const label = mutation.kind === "claim" && mutation.preimageHex === "0000000000000000000000000000000000000000000000000000000000000000"
+            ? "reclaim"
+            : mutation.kind;
+        lines.push(`Pending: ${label}  ${mutation.status}${mutation.amountCogtoshi === null || mutation.amountCogtoshi === undefined ? "" : `  ${formatCogAmount(mutation.amountCogtoshi)}`}`);
+    }
+    return lines;
+}
+function formatReadyBalanceReport(context) {
+    const anchoredDomains = listBalanceDomainsByStatus(context.model, "anchored");
+    const unanchoredDomains = listBalanceDomainsByStatus(context.model, "registered-unanchored");
+    const nextStepLines = formatNextStepLines(getBalanceNextSteps(context));
+    const lines = [
+        "",
+        ...renderBalanceArtCard(context),
+        "",
+        ...formatBalanceDomainSection("Anchored Domains", "⌂", anchoredDomains, "--- No anchored domains ---"),
+        "",
+        ...formatBalanceDomainSection("Unanchored Domains", "~", unanchoredDomains, "--- No unanchored domains ---"),
+    ];
+    if (shouldShowBalanceQuickstart(context)) {
+        lines.push("");
+        lines.push(`Quickstart: ${getFundingQuickstartGuidance()}`);
+    }
+    if (nextStepLines.length > 0) {
+        lines.push("");
+        lines.push(...nextStepLines);
+    }
+    const pendingLines = listPendingBalanceLines(context);
+    if (pendingLines.length > 0) {
+        lines.push("");
+        lines.push(...pendingLines);
+    }
+    return lines.join("\n");
+}
+export function formatBalanceReport(context) {
+    const lines = ["COG Balance"];
+    if (context.model === null) {
+        appendWalletAvailability(lines, context);
+        return lines.join("\n");
+    }
+    if (context.snapshot === null) {
+        lines.push(`Indexer-backed balances are unavailable while the indexer is ${formatServiceHealth(context.indexer.health)}.`);
+        return lines.join("\n");
+    }
+    return formatReadyBalanceReport(context);
+}

package/dist/cli/wallet-format/domains.d.ts

@@ -0,0 +1,8 @@
+import type { WalletDomainView, WalletReadContext } from "../../wallet/read/index.js";
+export declare function formatDomainsReport(context: WalletReadContext, options?: {
+    limit?: number | null;
+    all?: boolean;
+    domains?: WalletDomainView[] | null;
+    activeFilters?: string[];
+}): string;
+export declare function formatDomainReport(context: WalletReadContext, domainName: string): string;

package/dist/cli/wallet-format/domains.js

@@ -0,0 +1,84 @@
+import { findWalletDomain } from "../../wallet/read/index.js";
+import { appendWalletAvailability } from "./availability.js";
+import { formatCogAmount, formatMaybe, formatServiceHealth, } from "./shared.js";
+import { formatPendingMutationDomainLabel, listPendingDomainMutations, listPendingDomainShowMutations, listPendingFieldMutations, } from "./pending.js";
+export function formatDomainsReport(context, options = {}) {
+    const lines = ["Domains"];
+    if (context.model === null) {
+        appendWalletAvailability(lines, context);
+        return lines.join("\n");
+    }
+    const visibleDomains = options.domains ?? context.model.domains;
+    if (visibleDomains.length === 0) {
+        if ((options.activeFilters?.length ?? 0) > 0) {
+            lines.push(`No locally related domains matched the active filters (${options.activeFilters.join(", ")}).`);
+            return lines.join("\n");
+        }
+        lines.push("No locally related domains.");
+        return lines.join("\n");
+    }
+    const renderedDomains = options.all || options.limit === null || options.limit === undefined
+        ? visibleDomains
+        : visibleDomains.slice(0, options.limit);
+    for (const domain of renderedDomains) {
+        const pending = listPendingDomainMutations(context, domain.name);
+        const pendingFieldMutations = listPendingFieldMutations(context, domain.name);
+        const pendingText = pending.length === 0
+            ? ""
+            : `  pending ${pending.map((mutation) => mutation.kind === "sell" && mutation.priceCogtoshi === 0n
+                ? `unsell:${mutation.status}`
+                : mutation.kind === "endpoint" && mutation.endpointValueHex === ""
+                    ? `endpoint-clear:${mutation.status}`
+                    : mutation.kind === "delegate" && mutation.recipientScriptPubKeyHex === null
+                        ? `delegate-clear:${mutation.status}`
+                        : mutation.kind === "miner" && mutation.recipientScriptPubKeyHex === null
+                            ? `miner-clear:${mutation.status}`
+                            : `${mutation.kind}:${mutation.status}`).join(",")}`;
+        const pendingFieldsText = pendingFieldMutations.length === 0
+            ? ""
+            : `  field-pending ${pendingFieldMutations.map((mutation) => `${mutation.fieldName}:${mutation.kind}:${mutation.status}`).join(",")}`;
+        lines.push(`${domain.name}  ${domain.chainStatus}  ${domain.localRelationship}  owner ${domain.ownerAddress ?? domain.ownerScriptPubKeyHex ?? "unknown"}  fields ${formatMaybe(domain.fieldCount)}${pendingText}${pendingFieldsText}`);
+    }
+    if (!options.all && options.limit !== null && options.limit !== undefined && visibleDomains.length > options.limit) {
+        lines.push(`Showing first ${renderedDomains.length} of ${visibleDomains.length}. Use --limit <n> or --all for more.`);
+    }
+    return lines.join("\n");
+}
+export function formatDomainReport(context, domainName) {
+    const lines = [`Domain: ${domainName}`];
+    if (context.snapshot === null && context.model?.domains.find((domain) => domain.name === domainName) === undefined) {
+        lines.push(`Domain state is unavailable while the indexer is ${formatServiceHealth(context.indexer.health)}.`);
+        return lines.join("\n");
+    }
+    const view = findWalletDomain(context, domainName);
+    if (view === null) {
+        lines.push("Domain not found.");
+        return lines.join("\n");
+    }
+    lines.push(`Domain ID: ${formatMaybe(view.domain.domainId)}`);
+    lines.push(`Anchored: ${view.domain.anchored === null ? "unknown" : (view.domain.anchored ? "yes" : "no")}`);
+    lines.push(`Owner: ${view.domain.ownerAddress ?? view.domain.ownerScriptPubKeyHex ?? "unknown"}`);
+    lines.push(`Local relationship: ${view.localRelationship}`);
+    lines.push(`Listing price: ${view.domain.listingPriceCogtoshi === null ? "none" : formatCogAmount(view.domain.listingPriceCogtoshi)}`);
+    lines.push(`Field count: ${formatMaybe(view.domain.fieldCount)}`);
+    if (view.domain.selfStakeCogtoshi !== null
+        || view.domain.supportedStakeCogtoshi !== null
+        || view.domain.totalSupportedCogtoshi !== null
+        || view.domain.totalRevokedCogtoshi !== null) {
+        lines.push(`Reputation self-stake: ${view.domain.selfStakeCogtoshi === null ? "unavailable" : formatCogAmount(view.domain.selfStakeCogtoshi)}`);
+        lines.push(`Reputation supported stake: ${view.domain.supportedStakeCogtoshi === null ? "unavailable" : formatCogAmount(view.domain.supportedStakeCogtoshi)}`);
+        lines.push(`Reputation total supported: ${view.domain.totalSupportedCogtoshi === null ? "unavailable" : formatCogAmount(view.domain.totalSupportedCogtoshi)}`);
+        lines.push(`Reputation total revoked: ${view.domain.totalRevokedCogtoshi === null ? "unavailable" : formatCogAmount(view.domain.totalRevokedCogtoshi)}`);
+    }
+    lines.push(`Delegate: ${view.domain.delegateScriptPubKeyHex ?? "none"}`);
+    lines.push(`Designated miner: ${view.domain.minerScriptPubKeyHex ?? "none"}`);
+    lines.push(`Endpoint: ${view.domain.endpointText ?? "none"}`);
+    lines.push(`Founding message: ${view.domain.foundingMessageText ?? "none"}`);
+    for (const mutation of listPendingDomainShowMutations(context, domainName)) {
+        lines.push(`Pending mutation: ${formatPendingMutationDomainLabel(mutation)}  ${mutation.status}`);
+    }
+    for (const mutation of listPendingFieldMutations(context, domainName)) {
+        lines.push(`Pending field mutation: ${mutation.fieldName ?? "unknown"}  ${mutation.kind}  ${mutation.status}`);
+    }
+    return lines.join("\n");
+}

package/dist/cli/wallet-format/fields.d.ts

@@ -0,0 +1,6 @@
+import type { WalletReadContext } from "../../wallet/read/index.js";
+export declare function formatFieldsReport(context: WalletReadContext, domainName: string, options?: {
+    limit?: number | null;
+    all?: boolean;
+}): string;
+export declare function formatFieldReport(context: WalletReadContext, domainName: string, fieldName: string): string;

package/dist/cli/wallet-format/fields.js

@@ -0,0 +1,61 @@
+import { findDomainField, formatFieldFormat, listDomainFields, } from "../../wallet/read/index.js";
+import { formatServiceHealth } from "./shared.js";
+import { listPendingFieldMutations } from "./pending.js";
+function renderFieldLine(field) {
+    return `${field.name}  id ${field.fieldId}  ${field.permanent ? "permanent" : "mutable"}  ${field.hasValue ? formatFieldFormat(field.format) : "empty"}  ${field.preview ?? "(no value)"}`;
+}
+export function formatFieldsReport(context, domainName, options = {}) {
+    const lines = [`Fields: ${domainName}`];
+    if (context.snapshot === null) {
+        lines.push(`Field state is unavailable while the indexer is ${formatServiceHealth(context.indexer.health)}.`);
+        return lines.join("\n");
+    }
+    const fields = listDomainFields(context, domainName);
+    if (fields === null) {
+        lines.push("Domain not found.");
+        return lines.join("\n");
+    }
+    const renderedFields = options.all || options.limit === null || options.limit === undefined
+        ? fields
+        : fields.slice(0, options.limit);
+    if (renderedFields.length === 0) {
+        lines.push("No fields found.");
+    }
+    else {
+        for (const field of renderedFields) {
+            lines.push(renderFieldLine(field));
+        }
+    }
+    for (const mutation of listPendingFieldMutations(context, domainName)) {
+        lines.push(`Pending field mutation: ${mutation.fieldName ?? "unknown"}  ${mutation.kind}  ${mutation.status}`);
+    }
+    if (!options.all && options.limit !== null && options.limit !== undefined && fields.length > options.limit) {
+        lines.push(`Showing first ${renderedFields.length} of ${fields.length}. Use --limit <n> or --all for more.`);
+    }
+    return lines.join("\n");
+}
+export function formatFieldReport(context, domainName, fieldName) {
+    const lines = [`Field: ${domainName}.${fieldName}`];
+    if (context.snapshot === null) {
+        lines.push(`Field state is unavailable while the indexer is ${formatServiceHealth(context.indexer.health)}.`);
+        return lines.join("\n");
+    }
+    const field = findDomainField(context, domainName, fieldName);
+    const pendingMutations = listPendingFieldMutations(context, domainName, fieldName);
+    if (field === null) {
+        lines.push("Field not found.");
+    }
+    else {
+        lines.push(`Domain ID: ${field.domainId}`);
+        lines.push(`Field ID: ${field.fieldId}`);
+        lines.push(`Permanent: ${field.permanent ? "yes" : "no"}`);
+        lines.push(`Has value: ${field.hasValue ? "yes" : "no"}`);
+        lines.push(`Format: ${formatFieldFormat(field.format)}`);
+        lines.push(`Preview: ${field.preview ?? "(no value)"}`);
+        lines.push(`Raw value hex: ${field.rawValueHex ?? "none"}`);
+    }
+    for (const mutation of pendingMutations) {
+        lines.push(`Pending field mutation: ${mutation.kind}  ${mutation.status}`);
+    }
+    return lines.join("\n");
+}

package/dist/cli/wallet-format/identity.d.ts

@@ -0,0 +1,5 @@
+import type { WalletReadContext } from "../../wallet/read/index.js";
+export declare function formatIdentityListReport(context: WalletReadContext, _options?: {
+    limit?: number | null;
+    all?: boolean;
+}): string;

package/dist/cli/wallet-format/identity.js

@@ -0,0 +1,19 @@
+import { getBalance } from "@cogcoin/indexer/queries";
+import { appendWalletAvailability } from "./availability.js";
+import { formatCogAmount } from "./shared.js";
+export function formatIdentityListReport(context, _options = {}) {
+    const lines = ["Wallet Address"];
+    if (context.model === null) {
+        appendWalletAvailability(lines, context);
+        return lines.join("\n");
+    }
+    const domains = context.model.domains
+        .filter((domain) => domain.localRelationship === "local")
+        .map((domain) => domain.name)
+        .sort();
+    const balance = context.snapshot === null
+        ? null
+        : getBalance(context.snapshot.state, new Uint8Array(Buffer.from(context.model.walletScriptPubKeyHex, "hex")));
+    lines.push(`${context.model.walletAddress ?? `spk:${context.model.walletScriptPubKeyHex}`}  balance ${balance === null ? "unavailable" : formatCogAmount(balance)}  domains ${domains.length === 0 ? "none" : domains.join(", ")}`);
+    return lines.join("\n");
+}

package/dist/cli/wallet-format/locks.d.ts

@@ -0,0 +1,7 @@
+import type { WalletReadContext } from "../../wallet/read/index.js";
+export declare function formatLocksReport(context: WalletReadContext, options?: {
+    claimableOnly?: boolean;
+    reclaimableOnly?: boolean;
+    limit?: number | null;
+    all?: boolean;
+}): string;