@cogcoin/client 0.5.0

package/dist/cli/mutation-json.js

@@ -0,0 +1,311 @@
+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 buildSingleTxMutationData(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 buildFamilyMutationData(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 buildStateChangeData(options) {
+    return {
+        resultType: "state-change",
+        stateChange: {
+            kind: options.kind,
+            before: options.before ?? null,
+            after: options.after ?? null,
+        },
+        state: options.state,
+    };
+}
+export function buildOperationData(options) {
+    return {
+        resultType: "operation",
+        operation: {
+            kind: options.kind,
+            ...options.operation,
+        },
+        state: options.state ?? null,
+    };
+}
+export function buildRegisterMutationData(result, options) {
+    return {
+        ...buildSingleTxMutationData({
+            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 buildDomainMarketMutationData(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 = buildSingleTxMutationData({
+        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 buildCogMutationData(result, options) {
+    const data = buildSingleTxMutationData({
+        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 buildAnchorMutationData(result, options) {
+    return buildFamilyMutationData({
+        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 buildDomainAdminMutationData(result, options) {
+    const data = buildSingleTxMutationData({
+        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 buildFieldMutationData(result) {
+    if (result.family) {
+        return {
+            ...buildFamilyMutationData({
+                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,
+                    expectedFieldId: result.fieldId,
+                    permanent: result.permanent,
+                    format: result.format,
+                },
+            }),
+            resolved: buildFieldResolvedJson(result),
+        };
+    }
+    return {
+        ...buildSingleTxMutationData({
+            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 buildReputationMutationData(result) {
+    const data = buildSingleTxMutationData({
+        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 buildWalletLockMutationData(result) {
+    const after = {
+        walletRootId: result.walletRootId,
+        locked: true,
+    };
+    return buildStateChangeData({
+        kind: "wallet-lock",
+        state: after,
+        after,
+    });
+}
+export function buildInitMutationData(result) {
+    const after = {
+        walletRootId: result.walletRootId,
+        fundingAddress: result.fundingAddress,
+        unlockUntilUnixMs: result.unlockUntilUnixMs,
+        locked: false,
+    };
+    return buildStateChangeData({
+        kind: "init",
+        state: after,
+        before: null,
+        after,
+    });
+}
+export function buildUnlockMutationData(result) {
+    const after = {
+        walletRootId: result.state.walletRootId,
+        locked: false,
+        unlockUntilUnixMs: result.unlockUntilUnixMs,
+        fundingAddress: result.state.funding.address,
+        source: result.source,
+    };
+    return buildStateChangeData({
+        kind: "unlock",
+        state: after,
+        after,
+    });
+}
+export function buildWalletExportMutationData(result) {
+    const state = {
+        walletRootId: result.walletRootId,
+        archivePath: result.archivePath,
+    };
+    return buildOperationData({
+        kind: "wallet-export",
+        state,
+        operation: {
+            walletRootId: result.walletRootId,
+            archivePath: result.archivePath,
+            exportMode: "trusted-quiescent",
+        },
+    });
+}
+export function buildWalletImportMutationData(result) {
+    const after = {
+        walletRootId: result.walletRootId,
+        archivePath: result.archivePath,
+        fundingAddress: result.fundingAddress,
+        unlockUntilUnixMs: result.unlockUntilUnixMs,
+    };
+    return buildStateChangeData({
+        kind: "wallet-import",
+        state: after,
+        after,
+    });
+}
+export function buildRepairMutationData(result) {
+    const after = {
+        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,
+    };
+    return buildStateChangeData({
+        kind: "repair",
+        state: after,
+        after,
+    });
+}

package/dist/cli/mutation-resolved-json.d.ts

@@ -0,0 +1,124 @@
+import type { CogMutationResult, DomainAdminMutationResult, DomainMarketMutationResult, FieldMutationResult, RegisterDomainResult, ReputationMutationResult } from "../wallet/tx/index.js";
+export declare function decimalOrNull(value: bigint | null | undefined): string | null;
+export declare function buildRegisterResolvedJson(result: RegisterDomainResult): {
+    path: "root" | "subdomain";
+    parentDomainName: string | null;
+    sender: {
+        selector: string;
+        localIndex: number;
+        scriptPubKeyHex: string;
+        address: string;
+    };
+    economicEffect: {
+        kind: "treasury-payment" | "cog-burn";
+        amount: string | null;
+    };
+};
+export declare function buildDomainMarketResolvedJson(result: DomainMarketMutationResult, commandKind: "transfer" | "sell" | "unsell" | "buy"): {
+    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;
+export declare function buildCogResolvedJson(result: CogMutationResult, commandKind: "send" | "claim" | "reclaim" | "cog-lock"): {
+    claimPath?: import("../wallet/tx/cog.js").CogResolvedClaimPath | null | undefined;
+    sender: {
+        selector: string;
+        localIndex: number;
+        scriptPubKeyHex: string;
+        address: string;
+    };
+};
+export declare function buildDomainAdminResolvedJson(result: DomainAdminMutationResult): {
+    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;
+export declare function buildFieldResolvedJson(result: FieldMutationResult): {
+    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;
+export declare function buildReputationResolvedJson(result: ReputationMutationResult): {
+    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;

package/dist/cli/mutation-resolved-json.js

@@ -0,0 +1,129 @@
+export function decimalOrNull(value) {
+    return value === null || value === undefined ? null : value.toString();
+}
+function buildResolvedSenderJson(sender) {
+    return {
+        selector: sender.selector,
+        localIndex: sender.localIndex,
+        scriptPubKeyHex: sender.scriptPubKeyHex,
+        address: sender.address,
+    };
+}
+function buildScriptTargetJson(target) {
+    return target === null || target === undefined
+        ? null
+        : {
+            scriptPubKeyHex: target.scriptPubKeyHex,
+            address: target.address,
+            opaque: target.opaque,
+        };
+}
+export function buildRegisterResolvedJson(result) {
+    return {
+        path: result.resolved.path,
+        parentDomainName: result.resolved.parentDomainName,
+        sender: buildResolvedSenderJson(result.resolved.sender),
+        economicEffect: {
+            kind: result.resolved.economicEffect.kind,
+            amount: decimalOrNull(result.resolved.economicEffect.amount),
+        },
+    };
+}
+export function buildDomainMarketResolvedJson(result, commandKind) {
+    if (commandKind === "buy") {
+        return {
+            buyer: result.resolvedBuyer === null || result.resolvedBuyer === undefined
+                ? null
+                : buildResolvedSenderJson(result.resolvedBuyer),
+            seller: result.resolvedSeller === null || result.resolvedSeller === undefined
+                ? null
+                : {
+                    scriptPubKeyHex: result.resolvedSeller.scriptPubKeyHex,
+                    address: result.resolvedSeller.address,
+                },
+        };
+    }
+    if (result.resolved === null || result.resolved === undefined) {
+        return null;
+    }
+    return {
+        sender: buildResolvedSenderJson(result.resolved.sender),
+        recipient: buildScriptTargetJson(result.resolved.recipient),
+        economicEffect: result.resolved.economicEffect.kind === "ownership-transfer"
+            ? {
+                kind: result.resolved.economicEffect.kind,
+                clearsListing: result.resolved.economicEffect.clearsListing,
+            }
+            : {
+                kind: result.resolved.economicEffect.kind,
+                listedPriceCogtoshi: result.resolved.economicEffect.listedPriceCogtoshi,
+            },
+    };
+}
+export function buildCogResolvedJson(result, commandKind) {
+    return {
+        sender: buildResolvedSenderJson(result.resolved.sender),
+        ...(commandKind === "claim" || commandKind === "reclaim"
+            ? { claimPath: result.resolved.claimPath }
+            : {}),
+    };
+}
+export function buildDomainAdminResolvedJson(result) {
+    if (result.resolved === null || result.resolved === undefined) {
+        return null;
+    }
+    return {
+        sender: buildResolvedSenderJson(result.resolved.sender),
+        target: buildScriptTargetJson(result.resolved.target),
+        effect: result.resolved.effect.kind === "endpoint-set"
+            ? {
+                kind: result.resolved.effect.kind,
+                byteLength: result.resolved.effect.byteLength,
+            }
+            : {
+                kind: result.resolved.effect.kind,
+            },
+    };
+}
+export function buildFieldResolvedJson(result) {
+    if (result.resolved === null || result.resolved === undefined) {
+        return null;
+    }
+    return {
+        sender: buildResolvedSenderJson(result.resolved.sender),
+        path: result.resolved.path,
+        value: result.resolved.value === null
+            ? null
+            : {
+                format: result.resolved.value.format,
+                byteLength: result.resolved.value.byteLength,
+            },
+        effect: result.resolved.effect.kind === "create-and-initialize-field"
+            ? {
+                kind: result.resolved.effect.kind,
+                tx1BurnCogtoshi: result.resolved.effect.tx1BurnCogtoshi,
+                tx2AdditionalBurnCogtoshi: result.resolved.effect.tx2AdditionalBurnCogtoshi,
+            }
+            : {
+                kind: result.resolved.effect.kind,
+                burnCogtoshi: result.resolved.effect.burnCogtoshi,
+            },
+    };
+}
+export function buildReputationResolvedJson(result) {
+    if (result.resolved === null || result.resolved === undefined) {
+        return null;
+    }
+    return {
+        sender: buildResolvedSenderJson(result.resolved.sender),
+        effect: {
+            kind: result.resolved.effect.kind,
+            burnCogtoshi: result.resolved.effect.burnCogtoshi,
+        },
+        review: {
+            included: result.resolved.review.included,
+            byteLength: result.resolved.review.byteLength,
+        },
+        selfStake: result.resolved.selfStake,
+    };
+}

package/dist/cli/mutation-success.d.ts

@@ -0,0 +1,20 @@
+import { type MutationTextField } from "./mutation-text-write.js";
+import type { ParsedCliArgs, RequiredCliRunnerContext } from "./types.js";
+export interface MutationSuccessNextSteps {
+    json: string[];
+    text: string[];
+}
+export declare function commandMutationNextSteps(command: string): MutationSuccessNextSteps;
+export declare function workflowMutationNextSteps(nextSteps: readonly string[]): MutationSuccessNextSteps;
+export declare function writeMutationCommandSuccess(parsed: ParsedCliArgs, context: RequiredCliRunnerContext, options: {
+    data: unknown;
+    previewData?: unknown;
+    reusedExisting: boolean;
+    reusedMessage: string;
+    nextSteps: MutationSuccessNextSteps;
+    text: {
+        heading: string;
+        fields: MutationTextField[];
+    };
+    warnings?: string[];
+}): number;

package/dist/cli/mutation-success.js

@@ -0,0 +1,47 @@
+import { createPreviewSuccessEnvelope, createMutationSuccessEnvelope, describeCanonicalCommand, resolvePreviewJsonSchema, resolveStableMutationJsonSchema, writeJsonValue, } from "./output.js";
+import { writeMutationTextResult, } from "./mutation-text-write.js";
+import { formatNextStepLines } from "./workflow-hints.js";
+export function commandMutationNextSteps(command) {
+    return {
+        json: [`Run \`${command}\`.`],
+        text: [`Next step: ${command}`],
+    };
+}
+export function workflowMutationNextSteps(nextSteps) {
+    return {
+        json: [...nextSteps],
+        text: formatNextStepLines(nextSteps),
+    };
+}
+function mutationOutcome(reusedExisting) {
+    return reusedExisting ? "reconciled" : "submitted";
+}
+function reuseExplanation(reusedExisting, message) {
+    return reusedExisting ? [message] : [];
+}
+export function writeMutationCommandSuccess(parsed, context, options) {
+    if (parsed.outputMode === "preview-json") {
+        writeJsonValue(context.stdout, createPreviewSuccessEnvelope(resolvePreviewJsonSchema(parsed), describeCanonicalCommand(parsed), mutationOutcome(options.reusedExisting), options.previewData ?? options.data, {
+            explanations: reuseExplanation(options.reusedExisting, options.reusedMessage),
+            nextSteps: options.nextSteps.json,
+            warnings: options.warnings,
+        }));
+        return 0;
+    }
+    if (parsed.outputMode === "json") {
+        writeJsonValue(context.stdout, createMutationSuccessEnvelope(resolveStableMutationJsonSchema(parsed), describeCanonicalCommand(parsed), mutationOutcome(options.reusedExisting), options.data, {
+            explanations: reuseExplanation(options.reusedExisting, options.reusedMessage),
+            nextSteps: options.nextSteps.json,
+            warnings: options.warnings,
+        }));
+        return 0;
+    }
+    writeMutationTextResult(context.stdout, {
+        heading: options.text.heading,
+        fields: options.text.fields,
+        reusedExisting: options.reusedExisting,
+        reusedMessage: options.reusedMessage,
+        trailerLines: options.nextSteps.text,
+    });
+    return 0;
+}

package/dist/cli/mutation-text-format.d.ts

@@ -0,0 +1,22 @@
+import type { CogMutationResult, DomainAdminMutationResult, DomainMarketMutationResult, FieldMutationResult, ReputationMutationResult, RegisterDomainResult } from "../wallet/tx/index.js";
+export declare function formatRegisterSenderSummary(result: RegisterDomainResult): string;
+export declare function formatRegisterEconomicEffect(result: RegisterDomainResult): string;
+export declare function formatBuyBuyerSummary(result: DomainMarketMutationResult): string;
+export declare function formatBuySellerSummary(result: DomainMarketMutationResult): string;
+export declare function formatBuySettlementSummary(): string;
+export declare function formatDomainMarketSenderSummary(result: DomainMarketMutationResult): string;
+export declare function formatDomainMarketRecipientSummary(result: DomainMarketMutationResult): string;
+export declare function formatDomainMarketEconomicEffect(result: DomainMarketMutationResult): string;
+export declare function formatDomainAdminSenderSummary(result: DomainAdminMutationResult): string;
+export declare function formatDomainAdminTargetSummary(result: DomainAdminMutationResult): string;
+export declare function formatDomainAdminEffect(result: DomainAdminMutationResult): string;
+export declare function formatDomainAdminPayloadSummary(result: DomainAdminMutationResult): string;
+export declare function formatFieldSenderSummary(result: FieldMutationResult): string;
+export declare function formatFieldPath(result: FieldMutationResult): string;
+export declare function formatFieldValueSummary(result: FieldMutationResult): string;
+export declare function formatFieldEffect(result: FieldMutationResult): string;
+export declare function formatCogSenderSummary(result: CogMutationResult): string;
+export declare function formatCogClaimPath(result: CogMutationResult): string;
+export declare function formatReputationSenderSummary(result: ReputationMutationResult): string;
+export declare function formatReputationReviewSummary(result: ReputationMutationResult): string;
+export declare function formatReputationEffect(result: ReputationMutationResult): string;