@cogcoin/client 1.1.8 → 1.1.9

package/dist/cli/commands/wallet-mutation/field.js

@@ -0,0 +1,125 @@
+import { formatFieldEffect, formatFieldPath, formatFieldSenderSummary, formatFieldValueSummary, } from "../../mutation-text-format.js";
+import { commandMutationNextSteps, workflowMutationNextSteps, } from "../../mutation-success.js";
+function createFieldValueSource(endpointText, endpointJson, endpointBytes, fieldFormat, fieldValue) {
+    if (endpointText !== null) {
+        return { kind: "text", value: endpointText };
+    }
+    if (endpointJson !== null) {
+        return { kind: "json", value: endpointJson };
+    }
+    if (endpointBytes !== null) {
+        return { kind: "bytes", value: endpointBytes };
+    }
+    return {
+        kind: "raw",
+        format: fieldFormat,
+        value: fieldValue,
+    };
+}
+export const fieldMutationCommandSpec = {
+    id: "field",
+    async run(command) {
+        if (command.parsed.command === "field-create") {
+            const result = await command.context.createField({
+                domainName: command.parsed.args[0],
+                fieldName: command.parsed.args[1],
+                permanent: command.parsed.fieldPermanent,
+                feeRateSatVb: command.parsed.satvb,
+                dataDir: command.dataDir,
+                databasePath: command.dbPath,
+                provider: command.provider,
+                prompter: command.prompter,
+                assumeYes: command.parsed.assumeYes,
+                paths: command.runtimePaths,
+            });
+            return {
+                reusedExisting: result.reusedExisting,
+                reusedMessage: "The existing pending field creation was reconciled instead of creating a duplicate.",
+                fees: result.fees,
+                explorerTxid: result.txid,
+                nextSteps: workflowMutationNextSteps([
+                    `cogcoin field show ${result.domainName} ${result.fieldName}`,
+                    `cogcoin field set ${result.domainName} ${result.fieldName} --text <value>`,
+                ]),
+                text: {
+                    heading: "Field creation submitted.",
+                    fields: [
+                        { label: "Domain", value: result.domainName },
+                        { label: "Field", value: result.fieldName },
+                        { label: "Sender", value: formatFieldSenderSummary(result) },
+                        { label: "Path", value: formatFieldPath(result) },
+                        { label: "Value", value: formatFieldValueSummary(result), when: result.resolved?.value !== null && result.resolved?.value !== undefined },
+                        { label: "Effect", value: formatFieldEffect(result) },
+                        { label: "Status", value: result.status },
+                        { label: "Txid", value: result.txid },
+                    ],
+                },
+            };
+        }
+        if (command.parsed.command === "field-set") {
+            const result = await command.context.setField({
+                domainName: command.parsed.args[0],
+                fieldName: command.parsed.args[1],
+                source: createFieldValueSource(command.parsed.endpointText, command.parsed.endpointJson, command.parsed.endpointBytes, command.parsed.fieldFormat, command.parsed.fieldValue),
+                feeRateSatVb: command.parsed.satvb,
+                dataDir: command.dataDir,
+                databasePath: command.dbPath,
+                provider: command.provider,
+                prompter: command.prompter,
+                assumeYes: command.parsed.assumeYes,
+                paths: command.runtimePaths,
+            });
+            return {
+                reusedExisting: result.reusedExisting,
+                reusedMessage: "The existing pending field update was reconciled instead of creating a duplicate.",
+                fees: result.fees,
+                explorerTxid: result.txid,
+                nextSteps: commandMutationNextSteps(`cogcoin field show ${result.domainName} ${result.fieldName}`),
+                text: {
+                    heading: "Field update submitted.",
+                    fields: [
+                        { label: "Domain", value: result.domainName },
+                        { label: "Field", value: result.fieldName },
+                        { label: "Sender", value: formatFieldSenderSummary(result) },
+                        { label: "Value", value: formatFieldValueSummary(result) },
+                        { label: "Effect", value: formatFieldEffect(result) },
+                        { label: "Status", value: result.status },
+                        { label: "Txid", value: result.txid },
+                    ],
+                },
+            };
+        }
+        if (command.parsed.command === "field-clear") {
+            const result = await command.context.clearField({
+                domainName: command.parsed.args[0],
+                fieldName: command.parsed.args[1],
+                feeRateSatVb: command.parsed.satvb,
+                dataDir: command.dataDir,
+                databasePath: command.dbPath,
+                provider: command.provider,
+                prompter: command.prompter,
+                assumeYes: command.parsed.assumeYes,
+                paths: command.runtimePaths,
+            });
+            return {
+                reusedExisting: result.reusedExisting,
+                reusedMessage: "The existing pending field clear was reconciled instead of creating a duplicate.",
+                fees: result.fees,
+                explorerTxid: result.txid,
+                nextSteps: commandMutationNextSteps(`cogcoin field show ${result.domainName} ${result.fieldName}`),
+                text: {
+                    heading: "Field clear submitted.",
+                    fields: [
+                        { label: "Domain", value: result.domainName },
+                        { label: "Field", value: result.fieldName },
+                        { label: "Sender", value: formatFieldSenderSummary(result) },
+                        { label: "Effect", value: formatFieldEffect(result) },
+                        { label: "Status", value: result.status },
+                        { label: "Txid", value: result.txid },
+                    ],
+                },
+            };
+        }
+        throw new Error(`wallet mutation command not implemented: ${command.parsed.command}`);
+    },
+};

package/dist/cli/commands/wallet-mutation/register.d.ts

@@ -0,0 +1,2 @@
+import type { WalletMutationCommandSpec } from "./types.js";
+export declare const registerMutationCommandSpec: WalletMutationCommandSpec;

package/dist/cli/commands/wallet-mutation/register.js

@@ -0,0 +1,38 @@
+import { formatRegisterEconomicEffect, formatRegisterSenderSummary } from "../../mutation-text-format.js";
+import { workflowMutationNextSteps, } from "../../mutation-success.js";
+import { getRegisterNextSteps } from "../../workflow-hints.js";
+export const registerMutationCommandSpec = {
+    id: "register",
+    async run(command) {
+        const result = await command.context.registerDomain({
+            domainName: command.parsed.args[0],
+            feeRateSatVb: command.parsed.satvb,
+            dataDir: command.dataDir,
+            databasePath: command.dbPath,
+            forceRace: command.parsed.forceRace,
+            provider: command.provider,
+            prompter: command.prompter,
+            assumeYes: command.parsed.assumeYes,
+            paths: command.runtimePaths,
+        });
+        return {
+            reusedExisting: result.reusedExisting,
+            reusedMessage: "The existing pending registration was reconciled instead of creating a duplicate.",
+            fees: result.fees,
+            explorerTxid: result.txid,
+            nextSteps: workflowMutationNextSteps(getRegisterNextSteps(result.domainName, result.registerKind)),
+            text: {
+                heading: "Registration submitted.",
+                fields: [
+                    { label: "Domain", value: result.domainName },
+                    { label: "Path", value: result.resolved.path },
+                    { label: "Parent", value: result.resolved.parentDomainName ?? "", when: result.resolved.parentDomainName !== null },
+                    { label: "Sender", value: formatRegisterSenderSummary(result) },
+                    { label: "Economic effect", value: formatRegisterEconomicEffect(result) },
+                    { label: "Status", value: result.status },
+                    { label: "Txid", value: result.txid },
+                ],
+            },
+        };
+    },
+};

package/dist/cli/commands/wallet-mutation/registry.d.ts

@@ -0,0 +1,3 @@
+import type { ParsedCliArgs } from "../../types.js";
+import type { WalletMutationCommandSpec } from "./types.js";
+export declare function getWalletMutationCommandSpec(command: ParsedCliArgs["command"]): WalletMutationCommandSpec | null;

package/dist/cli/commands/wallet-mutation/registry.js

@@ -0,0 +1,39 @@
+import { anchorMutationCommandSpec } from "./anchor.js";
+import { bitcoinTransferCommandSpec } from "./bitcoin-transfer.js";
+import { cogMutationCommandSpec } from "./cog.js";
+import { domainAdminMutationCommandSpec } from "./domain-admin.js";
+import { domainMarketMutationCommandSpec } from "./domain-market.js";
+import { fieldMutationCommandSpec } from "./field.js";
+import { registerMutationCommandSpec } from "./register.js";
+import { reputationMutationCommandSpec } from "./reputation.js";
+const walletMutationCommandSpecs = new Map([
+    ["bitcoin-transfer", bitcoinTransferCommandSpec],
+    ["anchor", anchorMutationCommandSpec],
+    ["register", registerMutationCommandSpec],
+    ["transfer", domainMarketMutationCommandSpec],
+    ["sell", domainMarketMutationCommandSpec],
+    ["unsell", domainMarketMutationCommandSpec],
+    ["buy", domainMarketMutationCommandSpec],
+    ["domain-endpoint-set", domainAdminMutationCommandSpec],
+    ["domain-endpoint-clear", domainAdminMutationCommandSpec],
+    ["domain-delegate-set", domainAdminMutationCommandSpec],
+    ["domain-delegate-clear", domainAdminMutationCommandSpec],
+    ["domain-miner-set", domainAdminMutationCommandSpec],
+    ["domain-miner-clear", domainAdminMutationCommandSpec],
+    ["domain-canonical", domainAdminMutationCommandSpec],
+    ["field-create", fieldMutationCommandSpec],
+    ["field-set", fieldMutationCommandSpec],
+    ["field-clear", fieldMutationCommandSpec],
+    ["send", cogMutationCommandSpec],
+    ["cog-lock", cogMutationCommandSpec],
+    ["claim", cogMutationCommandSpec],
+    ["reclaim", cogMutationCommandSpec],
+    ["rep-give", reputationMutationCommandSpec],
+    ["rep-revoke", reputationMutationCommandSpec],
+]);
+export function getWalletMutationCommandSpec(command) {
+    if (command === null) {
+        return null;
+    }
+    return walletMutationCommandSpecs.get(command) ?? null;
+}

package/dist/cli/commands/wallet-mutation/reputation.d.ts

@@ -0,0 +1,2 @@
+import type { WalletMutationCommandSpec } from "./types.js";
+export declare const reputationMutationCommandSpec: WalletMutationCommandSpec;

package/dist/cli/commands/wallet-mutation/reputation.js

@@ -0,0 +1,57 @@
+import { parseCogAmountToCogtoshi } from "../../../wallet/tx/index.js";
+import { formatReputationEffect, formatReputationReviewSummary, formatReputationSenderSummary, } from "../../mutation-text-format.js";
+import { commandMutationNextSteps } from "../../mutation-success.js";
+export const reputationMutationCommandSpec = {
+    id: "reputation",
+    async run(command) {
+        const result = command.parsed.command === "rep-give"
+            ? await command.context.giveReputation({
+                sourceDomainName: command.parsed.args[0],
+                targetDomainName: command.parsed.args[1],
+                amountCogtoshi: parseCogAmountToCogtoshi(command.parsed.args[2]),
+                reviewText: command.parsed.reviewText,
+                feeRateSatVb: command.parsed.satvb,
+                dataDir: command.dataDir,
+                databasePath: command.dbPath,
+                provider: command.provider,
+                prompter: command.prompter,
+                assumeYes: command.parsed.assumeYes,
+                paths: command.runtimePaths,
+            })
+            : await command.context.revokeReputation({
+                sourceDomainName: command.parsed.args[0],
+                targetDomainName: command.parsed.args[1],
+                amountCogtoshi: parseCogAmountToCogtoshi(command.parsed.args[2]),
+                reviewText: command.parsed.reviewText,
+                feeRateSatVb: command.parsed.satvb,
+                dataDir: command.dataDir,
+                databasePath: command.dbPath,
+                provider: command.provider,
+                prompter: command.prompter,
+                assumeYes: command.parsed.assumeYes,
+                paths: command.runtimePaths,
+            });
+        return {
+            reusedExisting: result.reusedExisting,
+            reusedMessage: "The existing pending reputation mutation was reconciled instead of creating a duplicate.",
+            fees: result.fees,
+            explorerTxid: result.txid,
+            nextSteps: commandMutationNextSteps(`cogcoin show ${result.targetDomainName}`),
+            text: {
+                heading: command.parsed.command === "rep-give"
+                    ? "Reputation support submitted."
+                    : "Reputation revoke submitted.",
+                fields: [
+                    { label: "Source domain", value: result.sourceDomainName },
+                    { label: "Target domain", value: result.targetDomainName },
+                    { label: "Sender", value: formatReputationSenderSummary(result) },
+                    { label: "Amount", value: `${result.amountCogtoshi.toString()} cogtoshi` },
+                    { label: "Review", value: formatReputationReviewSummary(result) },
+                    { label: "Effect", value: formatReputationEffect(result) },
+                    { label: "Status", value: result.status },
+                    { label: "Txid", value: result.txid },
+                ],
+            },
+        };
+    },
+};

package/dist/cli/commands/wallet-mutation/types.d.ts

@@ -0,0 +1,32 @@
+import type { WalletRuntimePaths } from "../../../wallet/runtime.js";
+import type { WalletSecretProvider } from "../../../wallet/state/provider.js";
+import type { WalletPrompter } from "../../../wallet/lifecycle.js";
+import type { WalletMutationFeeSummary } from "../../../wallet/tx/index.js";
+import type { MutationSuccessNextSteps } from "../../mutation-success.js";
+import type { MutationTextField } from "../../mutation-text-write.js";
+import type { ParsedCliArgs, RequiredCliRunnerContext } from "../../types.js";
+export interface ResolvedWalletMutationCommandContext {
+    parsed: ParsedCliArgs;
+    context: RequiredCliRunnerContext;
+    runtimePaths: WalletRuntimePaths;
+    dataDir: string;
+    dbPath: string;
+    prompter: WalletPrompter;
+    provider: WalletSecretProvider;
+    interactive: boolean;
+}
+export interface WalletMutationCommandSuccessDescriptor {
+    reusedExisting: boolean;
+    reusedMessage: string;
+    fees?: WalletMutationFeeSummary | null;
+    explorerTxid?: string | null;
+    nextSteps: MutationSuccessNextSteps;
+    text: {
+        heading: string;
+        fields: MutationTextField[];
+    };
+}
+export interface WalletMutationCommandSpec {
+    id: string;
+    run(context: ResolvedWalletMutationCommandContext): Promise<WalletMutationCommandSuccessDescriptor>;
+}

package/dist/cli/commands/wallet-mutation/types.js

@@ -0,0 +1 @@
+export {};