@cogcoin/client 0.5.0

package/dist/cli/preview-json.d.ts

@@ -0,0 +1,416 @@
+import type { AnchorDomainResult, CogMutationResult, DomainAdminMutationResult, DomainMarketMutationResult, FieldMutationResult, RegisterDomainResult, ReputationMutationResult } from "../wallet/tx/index.js";
+import type { WalletRepairResult } from "../wallet/lifecycle.js";
+import type { MiningControlPlaneView, MiningRuntimeStatusV1 } from "../wallet/mining/index.js";
+export declare function buildSingleTxMutationPreviewData(options: {
+    kind: string;
+    localStatus: string;
+    txid: string | null | undefined;
+    wtxid?: string | null | undefined;
+    reusedExisting: boolean;
+    intent: Record<string, unknown>;
+    journalKind?: string | null;
+    intentFingerprintHex?: string | null;
+}): {
+    resultType: "single-tx-mutation";
+    mutation: {
+        kind: string;
+        journalKind: string;
+        localStatus: string;
+        reusedExisting: boolean;
+        intentFingerprintHex: string | null;
+    };
+    transaction: {
+        txid: string | null;
+        wtxid: string | null;
+    };
+    intent: Record<string, unknown>;
+};
+export declare function buildFamilyMutationPreviewData(options: {
+    familyKind: string;
+    familyStatus: string;
+    reusedExisting: boolean;
+    intent: Record<string, unknown>;
+    currentStep?: string | null;
+    tx1Txid?: string | null | undefined;
+    tx1Wtxid?: string | null | undefined;
+    tx2Txid?: string | null | undefined;
+    tx2Wtxid?: string | null | undefined;
+    intentFingerprintHex?: string | null;
+}): {
+    resultType: "family-mutation";
+    family: {
+        kind: string;
+        localStatus: string;
+        reusedExisting: boolean;
+        currentStep: string | null;
+        intentFingerprintHex: string | null;
+    };
+    transactions: {
+        tx1: {
+            txid: string | null;
+            wtxid: string | null;
+        };
+        tx2: {
+            txid: string | null;
+            wtxid: string | null;
+        };
+    };
+    intent: Record<string, unknown>;
+};
+export declare function buildStateChangePreviewData(options: {
+    kind: string;
+    state: Record<string, unknown>;
+    before?: Record<string, unknown> | null;
+    after?: Record<string, unknown> | null;
+}): {
+    resultType: "state-change";
+    stateChange: {
+        kind: string;
+        before: Record<string, unknown> | null;
+        after: Record<string, unknown> | null;
+    };
+    state: Record<string, unknown>;
+};
+export declare function buildRegisterPreviewData(result: RegisterDomainResult, options: {
+    forceRace: boolean;
+    fromIdentity: string | null;
+}): {
+    resolved: {
+        path: "root" | "subdomain";
+        parentDomainName: string | null;
+        sender: {
+            selector: string;
+            localIndex: number;
+            scriptPubKeyHex: string;
+            address: string;
+        };
+        economicEffect: {
+            kind: "treasury-payment" | "cog-burn";
+            amount: string | null;
+        };
+    };
+    resultType: "single-tx-mutation";
+    mutation: {
+        kind: string;
+        journalKind: string;
+        localStatus: string;
+        reusedExisting: boolean;
+        intentFingerprintHex: string | null;
+    };
+    transaction: {
+        txid: string | null;
+        wtxid: string | null;
+    };
+    intent: Record<string, unknown>;
+};
+export declare function buildDomainMarketPreviewData(result: DomainMarketMutationResult, options: {
+    commandKind: "transfer" | "sell" | "unsell" | "buy";
+    fromIdentity?: string | null;
+}): {
+    resolved: {
+        buyer: {
+            selector: string;
+            localIndex: number;
+            scriptPubKeyHex: string;
+            address: string;
+        } | null;
+        seller: {
+            scriptPubKeyHex: string;
+            address: string | null;
+        } | null;
+        sender?: undefined;
+        recipient?: undefined;
+        economicEffect?: undefined;
+    } | {
+        sender: {
+            selector: string;
+            localIndex: number;
+            scriptPubKeyHex: string;
+            address: string;
+        };
+        recipient: {
+            scriptPubKeyHex: string;
+            address: string | null;
+            opaque: boolean;
+        } | null;
+        economicEffect: {
+            kind: "ownership-transfer";
+            clearsListing: boolean;
+            listedPriceCogtoshi?: undefined;
+        } | {
+            kind: "listing-set" | "listing-clear";
+            listedPriceCogtoshi: string;
+            clearsListing?: undefined;
+        };
+        buyer?: undefined;
+        seller?: undefined;
+    } | null;
+    resultType: "single-tx-mutation";
+    mutation: {
+        kind: string;
+        journalKind: string;
+        localStatus: string;
+        reusedExisting: boolean;
+        intentFingerprintHex: string | null;
+    };
+    transaction: {
+        txid: string | null;
+        wtxid: string | null;
+    };
+    intent: Record<string, unknown>;
+};
+export declare function buildCogPreviewData(result: CogMutationResult, options: {
+    commandKind: "send" | "claim" | "reclaim" | "cog-lock";
+    fromIdentity: string | null;
+    timeoutBlocksOrDuration?: string | null;
+    timeoutHeight?: string | null;
+    conditionHex?: string | null;
+}): {
+    resolved: {
+        claimPath?: import("../wallet/tx/cog.js").CogResolvedClaimPath | null | undefined;
+        sender: {
+            selector: string;
+            localIndex: number;
+            scriptPubKeyHex: string;
+            address: string;
+        };
+    };
+    resultType: "single-tx-mutation";
+    mutation: {
+        kind: string;
+        journalKind: string;
+        localStatus: string;
+        reusedExisting: boolean;
+        intentFingerprintHex: string | null;
+    };
+    transaction: {
+        txid: string | null;
+        wtxid: string | null;
+    };
+    intent: Record<string, unknown>;
+};
+export declare function buildAnchorPreviewData(result: AnchorDomainResult, options: {
+    foundingMessageText: string | null;
+}): {
+    resultType: "family-mutation";
+    family: {
+        kind: string;
+        localStatus: string;
+        reusedExisting: boolean;
+        currentStep: string | null;
+        intentFingerprintHex: string | null;
+    };
+    transactions: {
+        tx1: {
+            txid: string | null;
+            wtxid: string | null;
+        };
+        tx2: {
+            txid: string | null;
+            wtxid: string | null;
+        };
+    };
+    intent: Record<string, unknown>;
+};
+export declare function buildDomainAdminPreviewData(result: DomainAdminMutationResult, options: {
+    commandKind: "domain-endpoint-set" | "domain-endpoint-clear" | "domain-delegate-set" | "domain-delegate-clear" | "domain-miner-set" | "domain-miner-clear" | "domain-canonical";
+}): {
+    resolved: {
+        sender: {
+            selector: string;
+            localIndex: number;
+            scriptPubKeyHex: string;
+            address: string;
+        };
+        target: {
+            scriptPubKeyHex: string;
+            address: string | null;
+            opaque: boolean;
+        } | null;
+        effect: {
+            kind: "endpoint-set";
+            byteLength: number;
+        } | {
+            kind: "endpoint-clear" | "delegate-set" | "delegate-clear" | "miner-set" | "miner-clear" | "canonicalize-owner";
+            byteLength?: undefined;
+        };
+    } | null;
+    resultType: "single-tx-mutation";
+    mutation: {
+        kind: string;
+        journalKind: string;
+        localStatus: string;
+        reusedExisting: boolean;
+        intentFingerprintHex: string | null;
+    };
+    transaction: {
+        txid: string | null;
+        wtxid: string | null;
+    };
+    intent: Record<string, unknown>;
+};
+export declare function buildFieldPreviewData(result: FieldMutationResult): {
+    resolved: {
+        sender: {
+            selector: string;
+            localIndex: number;
+            scriptPubKeyHex: string;
+            address: string;
+        };
+        path: import("../wallet/tx/field.js").FieldResolvedPath;
+        value: {
+            format: number;
+            byteLength: number;
+        } | null;
+        effect: {
+            kind: "create-and-initialize-field";
+            tx1BurnCogtoshi: "100";
+            tx2AdditionalBurnCogtoshi: "1";
+            burnCogtoshi?: undefined;
+        } | {
+            kind: "create-empty-field" | "write-field-value" | "clear-field-value";
+            burnCogtoshi: "0" | "1" | "100";
+            tx1BurnCogtoshi?: undefined;
+            tx2AdditionalBurnCogtoshi?: undefined;
+        };
+    } | null;
+    resultType: "family-mutation";
+    family: {
+        kind: string;
+        localStatus: string;
+        reusedExisting: boolean;
+        currentStep: string | null;
+        intentFingerprintHex: string | null;
+    };
+    transactions: {
+        tx1: {
+            txid: string | null;
+            wtxid: string | null;
+        };
+        tx2: {
+            txid: string | null;
+            wtxid: string | null;
+        };
+    };
+    intent: Record<string, unknown>;
+} | {
+    resolved: {
+        sender: {
+            selector: string;
+            localIndex: number;
+            scriptPubKeyHex: string;
+            address: string;
+        };
+        path: import("../wallet/tx/field.js").FieldResolvedPath;
+        value: {
+            format: number;
+            byteLength: number;
+        } | null;
+        effect: {
+            kind: "create-and-initialize-field";
+            tx1BurnCogtoshi: "100";
+            tx2AdditionalBurnCogtoshi: "1";
+            burnCogtoshi?: undefined;
+        } | {
+            kind: "create-empty-field" | "write-field-value" | "clear-field-value";
+            burnCogtoshi: "0" | "1" | "100";
+            tx1BurnCogtoshi?: undefined;
+            tx2AdditionalBurnCogtoshi?: undefined;
+        };
+    } | null;
+    resultType: "single-tx-mutation";
+    mutation: {
+        kind: string;
+        journalKind: string;
+        localStatus: string;
+        reusedExisting: boolean;
+        intentFingerprintHex: string | null;
+    };
+    transaction: {
+        txid: string | null;
+        wtxid: string | null;
+    };
+    intent: Record<string, unknown>;
+};
+export declare function buildReputationPreviewData(result: ReputationMutationResult): {
+    resolved: {
+        sender: {
+            selector: string;
+            localIndex: number;
+            scriptPubKeyHex: string;
+            address: string;
+        };
+        effect: {
+            kind: "give-support" | "revoke-support";
+            burnCogtoshi: string;
+        };
+        review: {
+            included: boolean;
+            byteLength: number | null;
+        };
+        selfStake: boolean;
+    } | null;
+    resultType: "single-tx-mutation";
+    mutation: {
+        kind: string;
+        journalKind: string;
+        localStatus: string;
+        reusedExisting: boolean;
+        intentFingerprintHex: string | null;
+    };
+    transaction: {
+        txid: string | null;
+        wtxid: string | null;
+    };
+    intent: Record<string, unknown>;
+};
+export declare function buildWalletLockPreviewData(result: {
+    walletRootId: string | null;
+}): {
+    resultType: "state-change";
+    stateChange: {
+        kind: string;
+        before: Record<string, unknown> | null;
+        after: Record<string, unknown> | null;
+    };
+    state: Record<string, unknown>;
+};
+export declare function buildRepairPreviewData(result: WalletRepairResult): {
+    resultType: "state-change";
+    stateChange: {
+        kind: string;
+        before: Record<string, unknown> | null;
+        after: Record<string, unknown> | null;
+    };
+    state: Record<string, unknown>;
+};
+export declare function buildHooksPreviewData(kind: "hooks-enable-mining" | "hooks-disable-mining" | "mine-setup", view: MiningControlPlaneView): {
+    resultType: "state-change";
+    stateChange: {
+        kind: string;
+        before: Record<string, unknown> | null;
+        after: Record<string, unknown> | null;
+    };
+    state: Record<string, unknown>;
+};
+export declare function buildMineStartPreviewData(result: {
+    started: boolean;
+    snapshot: MiningRuntimeStatusV1 | null;
+}): {
+    resultType: "state-change";
+    stateChange: {
+        kind: string;
+        before: Record<string, unknown> | null;
+        after: Record<string, unknown> | null;
+    };
+    state: Record<string, unknown>;
+};
+export declare function buildMineStopPreviewData(snapshot: MiningRuntimeStatusV1 | null): {
+    resultType: "state-change";
+    stateChange: {
+        kind: string;
+        before: Record<string, unknown> | null;
+        after: Record<string, unknown> | null;
+    };
+    state: Record<string, unknown>;
+};

package/dist/cli/preview-json.js

@@ -0,0 +1,293 @@
+import { buildCogResolvedJson, buildDomainAdminResolvedJson, buildDomainMarketResolvedJson, buildFieldResolvedJson, buildRegisterResolvedJson, buildReputationResolvedJson, decimalOrNull, } from "./mutation-resolved-json.js";
+function normalizeTxSummary(txid, wtxid) {
+    return {
+        txid: txid ?? null,
+        wtxid: wtxid ?? null,
+    };
+}
+export function buildSingleTxMutationPreviewData(options) {
+    return {
+        resultType: "single-tx-mutation",
+        mutation: {
+            kind: options.kind,
+            journalKind: options.journalKind ?? options.kind,
+            localStatus: options.localStatus,
+            reusedExisting: options.reusedExisting,
+            intentFingerprintHex: options.intentFingerprintHex ?? null,
+        },
+        transaction: normalizeTxSummary(options.txid, options.wtxid),
+        intent: options.intent,
+    };
+}
+export function buildFamilyMutationPreviewData(options) {
+    return {
+        resultType: "family-mutation",
+        family: {
+            kind: options.familyKind,
+            localStatus: options.familyStatus,
+            reusedExisting: options.reusedExisting,
+            currentStep: options.currentStep ?? null,
+            intentFingerprintHex: options.intentFingerprintHex ?? null,
+        },
+        transactions: {
+            tx1: normalizeTxSummary(options.tx1Txid, options.tx1Wtxid),
+            tx2: normalizeTxSummary(options.tx2Txid, options.tx2Wtxid),
+        },
+        intent: options.intent,
+    };
+}
+export function buildStateChangePreviewData(options) {
+    return {
+        resultType: "state-change",
+        stateChange: {
+            kind: options.kind,
+            before: options.before ?? null,
+            after: options.after ?? null,
+        },
+        state: options.state,
+    };
+}
+export function buildRegisterPreviewData(result, options) {
+    return {
+        ...buildSingleTxMutationPreviewData({
+            kind: "register",
+            localStatus: result.status,
+            txid: result.txid,
+            reusedExisting: result.reusedExisting,
+            intent: {
+                domainName: result.domainName,
+                registerKind: result.registerKind,
+                forceRace: options.forceRace,
+                fromIdentitySelector: options.fromIdentity,
+            },
+        }),
+        resolved: buildRegisterResolvedJson(result),
+    };
+}
+export function buildDomainMarketPreviewData(result, options) {
+    const intent = {
+        domainName: result.domainName,
+        listedPriceCogtoshi: decimalOrNull(result.listedPriceCogtoshi),
+        recipientScriptPubKeyHex: result.recipientScriptPubKeyHex ?? null,
+    };
+    if (options.commandKind === "buy") {
+        intent.fromIdentitySelector = options.fromIdentity ?? null;
+    }
+    const data = buildSingleTxMutationPreviewData({
+        kind: options.commandKind,
+        localStatus: result.status,
+        txid: result.txid,
+        reusedExisting: result.reusedExisting,
+        intent,
+        journalKind: result.kind,
+    });
+    if (options.commandKind !== "buy") {
+        return {
+            ...data,
+            resolved: buildDomainMarketResolvedJson(result, options.commandKind),
+        };
+    }
+    return {
+        ...data,
+        resolved: buildDomainMarketResolvedJson(result, options.commandKind),
+    };
+}
+export function buildCogPreviewData(result, options) {
+    const data = buildSingleTxMutationPreviewData({
+        kind: options.commandKind,
+        localStatus: result.status,
+        txid: result.txid,
+        reusedExisting: result.reusedExisting,
+        intent: {
+            amountCogtoshi: decimalOrNull(result.amountCogtoshi),
+            recipientScriptPubKeyHex: result.recipientScriptPubKeyHex ?? null,
+            recipientDomainName: result.recipientDomainName ?? null,
+            lockId: result.lockId ?? null,
+            fromIdentitySelector: options.fromIdentity,
+            timeoutBlocksOrDuration: options.timeoutBlocksOrDuration ?? null,
+            timeoutHeight: options.timeoutHeight ?? null,
+            conditionHex: options.conditionHex ?? null,
+        },
+        journalKind: result.kind,
+    });
+    return {
+        ...data,
+        resolved: buildCogResolvedJson(result, options.commandKind),
+    };
+}
+export function buildAnchorPreviewData(result, options) {
+    return buildFamilyMutationPreviewData({
+        familyKind: "anchor",
+        familyStatus: result.status,
+        reusedExisting: result.reusedExisting,
+        currentStep: result.status === "confirmed" ? "confirmed" : "submitted",
+        tx1Txid: result.tx1Txid,
+        tx2Txid: result.tx2Txid,
+        intent: {
+            domainName: result.domainName,
+            dedicatedIndex: result.dedicatedIndex,
+            foundingMessageIncluded: options.foundingMessageText !== null,
+        },
+    });
+}
+export function buildDomainAdminPreviewData(result, options) {
+    const data = buildSingleTxMutationPreviewData({
+        kind: options.commandKind,
+        localStatus: result.status,
+        txid: result.txid,
+        reusedExisting: result.reusedExisting,
+        intent: {
+            domainName: result.domainName,
+            recipientScriptPubKeyHex: result.recipientScriptPubKeyHex ?? null,
+            endpointValueHex: result.endpointValueHex ?? null,
+            endpointByteLength: result.endpointValueHex === null || result.endpointValueHex === undefined
+                ? null
+                : result.endpointValueHex.length / 2,
+        },
+        journalKind: result.kind,
+    });
+    return {
+        ...data,
+        resolved: buildDomainAdminResolvedJson(result),
+    };
+}
+export function buildFieldPreviewData(result) {
+    if (result.family) {
+        return {
+            ...buildFamilyMutationPreviewData({
+                familyKind: "field",
+                familyStatus: result.status,
+                reusedExisting: result.reusedExisting,
+                currentStep: result.status === "confirmed" ? "confirmed" : "submitted",
+                tx1Txid: result.tx1Txid ?? null,
+                tx2Txid: result.tx2Txid ?? null,
+                intent: {
+                    domainName: result.domainName,
+                    fieldName: result.fieldName,
+                    fieldId: result.fieldId,
+                    permanent: result.permanent,
+                    format: result.format,
+                },
+            }),
+            resolved: buildFieldResolvedJson(result),
+        };
+    }
+    return {
+        ...buildSingleTxMutationPreviewData({
+            kind: result.kind,
+            localStatus: result.status,
+            txid: result.txid,
+            reusedExisting: result.reusedExisting,
+            intent: {
+                domainName: result.domainName,
+                fieldName: result.fieldName,
+                fieldId: result.fieldId,
+                permanent: result.permanent,
+                format: result.format,
+            },
+        }),
+        resolved: buildFieldResolvedJson(result),
+    };
+}
+export function buildReputationPreviewData(result) {
+    const data = buildSingleTxMutationPreviewData({
+        kind: result.kind === "give" ? "rep-give" : "rep-revoke",
+        localStatus: result.status,
+        txid: result.txid,
+        reusedExisting: result.reusedExisting,
+        intent: {
+            sourceDomainName: result.sourceDomainName,
+            targetDomainName: result.targetDomainName,
+            amountCogtoshi: result.amountCogtoshi.toString(),
+            reviewIncluded: result.reviewIncluded,
+        },
+    });
+    return {
+        ...data,
+        resolved: buildReputationResolvedJson(result),
+    };
+}
+export function buildWalletLockPreviewData(result) {
+    return buildStateChangePreviewData({
+        kind: "wallet-lock",
+        state: {
+            walletRootId: result.walletRootId,
+            locked: true,
+        },
+    });
+}
+export function buildRepairPreviewData(result) {
+    return buildStateChangePreviewData({
+        kind: "repair",
+        state: {
+            walletRootId: result.walletRootId,
+            recoveredFromBackup: result.recoveredFromBackup,
+            recreatedManagedCoreWallet: result.recreatedManagedCoreWallet,
+            bitcoindServiceAction: result.bitcoindServiceAction,
+            bitcoindCompatibilityIssue: result.bitcoindCompatibilityIssue,
+            managedCoreReplicaAction: result.managedCoreReplicaAction,
+            bitcoindPostRepairHealth: result.bitcoindPostRepairHealth,
+            resetIndexerDatabase: result.resetIndexerDatabase,
+            indexerDaemonAction: result.indexerDaemonAction,
+            indexerCompatibilityIssue: result.indexerCompatibilityIssue,
+            indexerPostRepairHealth: result.indexerPostRepairHealth,
+            miningPreRepairRunMode: result.miningPreRepairRunMode,
+            miningResumeAction: result.miningResumeAction,
+            miningPostRepairRunMode: result.miningPostRepairRunMode,
+            miningResumeError: result.miningResumeError,
+            note: result.note,
+        },
+    });
+}
+function summarizeRuntime(snapshot) {
+    if (snapshot === null) {
+        return null;
+    }
+    return {
+        runMode: snapshot.runMode,
+        miningState: snapshot.miningState,
+        currentPhase: snapshot.currentPhase,
+        backgroundWorkerPid: snapshot.backgroundWorkerPid,
+        backgroundWorkerRunId: snapshot.backgroundWorkerRunId,
+        note: snapshot.note,
+    };
+}
+export function buildHooksPreviewData(kind, view) {
+    return buildStateChangePreviewData({
+        kind,
+        state: {
+            hook: {
+                mode: view.hook.mode,
+                validationState: view.hook.validationState,
+                operatorValidationState: view.hook.operatorValidationState,
+                validationError: view.hook.validationError,
+                cooldownActive: view.hook.cooldownActive,
+            },
+            provider: {
+                configured: view.provider.configured,
+                provider: view.provider.provider,
+                status: view.provider.status,
+            },
+            runtime: summarizeRuntime(view.runtime),
+        },
+    });
+}
+export function buildMineStartPreviewData(result) {
+    return buildStateChangePreviewData({
+        kind: "mine-start",
+        state: {
+            started: result.started,
+            runtime: summarizeRuntime(result.snapshot),
+        },
+    });
+}
+export function buildMineStopPreviewData(snapshot) {
+    return buildStateChangePreviewData({
+        kind: "mine-stop",
+        state: {
+            stopped: snapshot !== null,
+            runtime: summarizeRuntime(snapshot),
+            note: snapshot?.note ?? "Background mining was not active.",
+        },
+    });
+}

package/dist/cli/prompt.d.ts

@@ -0,0 +1,3 @@
+import type { WalletPrompter } from "../wallet/lifecycle.js";
+import type { ReadableLike, WritableLike } from "./types.js";
+export declare function createTerminalPrompter(input: NodeJS.ReadStream | ReadableLike, output: NodeJS.WriteStream | WritableLike): WalletPrompter;