@cogcoin/client 0.5.3 → 0.5.5

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

@@ -8,6 +8,7 @@ import { formatBuyBuyerSummary, formatBuySellerSummary, formatBuySettlementSumma
 import { createTerminalPrompter } from "../prompt.js";
 import { writeHandledCliError } from "../output.js";
 import { getAnchorNextSteps, getRegisterNextSteps, } from "../workflow-hints.js";
+import { createOwnedLockCleanupSignalWatcher, waitForCompletionOrStop, } from "../signals.js";
 function createFieldValueSource(parsed) {
     if (parsed.endpointText !== null) {
         return { kind: "text", value: parsed.endpointText };
@@ -30,645 +31,658 @@ function createCommandPrompter(parsed, context) {
         : context.createPrompter();
 }
 export async function runWalletMutationCommand(parsed, context) {
+    const runtimePaths = context.resolveWalletRuntimePaths();
+    const stopWatcher = createOwnedLockCleanupSignalWatcher(context.signalSource, context.forceExit, [
+        runtimePaths.walletControlLockPath,
+        runtimePaths.miningControlLockPath,
+        runtimePaths.bitcoindLockPath,
+        runtimePaths.indexerDaemonLockPath,
+    ]);
     try {
-        if (!isWalletMutationCommand(parsed.command)) {
-            writeLine(context.stderr, `wallet mutation command not implemented: ${parsed.command}`);
-            return 1;
-        }
-        const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
-        const dbPath = parsed.dbPath ?? context.resolveDefaultClientDatabasePath();
-        const prompter = createCommandPrompter(parsed, context);
-        if (isAnchorMutationCommand(parsed.command)) {
-            const result = await context.anchorDomain({
-                domainName: parsed.args[0],
-                foundingMessageText: parsed.anchorMessage,
-                dataDir,
-                databasePath: dbPath,
-                provider: context.walletSecretProvider,
-                prompter,
-            });
-            const nextSteps = getAnchorNextSteps(result.domainName);
-            return writeMutationCommandSuccess(parsed, context, {
-                data: buildAnchorMutationData(result, {
-                    foundingMessageText: parsed.anchorMessage,
-                }),
-                previewData: buildAnchorPreviewData(result, {
+        const outcome = await waitForCompletionOrStop((async () => {
+            if (!isWalletMutationCommand(parsed.command)) {
+                writeLine(context.stderr, `wallet mutation command not implemented: ${parsed.command}`);
+                return 1;
+            }
+            const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
+            const dbPath = parsed.dbPath ?? context.resolveDefaultClientDatabasePath();
+            const prompter = createCommandPrompter(parsed, context);
+            if (isAnchorMutationCommand(parsed.command)) {
+                const result = await context.anchorDomain({
+                    domainName: parsed.args[0],
                     foundingMessageText: parsed.anchorMessage,
-                }),
-                reusedExisting: result.reusedExisting,
-                reusedMessage: "The existing anchor family was reconciled instead of creating a duplicate.",
-                nextSteps: workflowMutationNextSteps(nextSteps),
-                text: {
-                    heading: "Anchor family submitted.",
-                    fields: [
-                        { label: "Domain", value: result.domainName },
-                        { label: "Dedicated index", value: String(result.dedicatedIndex) },
-                        { label: "Status", value: result.status },
-                        { label: "Tx1", value: result.tx1Txid },
-                        { label: "Tx2", value: result.tx2Txid },
-                    ],
-                },
-            });
-        }
-        if (isRegisterMutationCommand(parsed.command)) {
-            const result = await context.registerDomain({
-                domainName: parsed.args[0],
-                dataDir,
-                databasePath: dbPath,
-                forceRace: parsed.forceRace,
-                fromIdentity: parsed.fromIdentity,
-                provider: context.walletSecretProvider,
-                prompter,
-                assumeYes: parsed.assumeYes,
-            });
-            const nextSteps = getRegisterNextSteps(result.domainName, result.registerKind);
-            return writeMutationCommandSuccess(parsed, context, {
-                data: buildRegisterMutationData(result, {
-                    forceRace: parsed.forceRace,
-                    fromIdentity: parsed.fromIdentity,
-                }),
-                previewData: buildRegisterPreviewData(result, {
+                    dataDir,
+                    databasePath: dbPath,
+                    provider: context.walletSecretProvider,
+                    prompter,
+                });
+                const nextSteps = getAnchorNextSteps(result.domainName);
+                return writeMutationCommandSuccess(parsed, context, {
+                    data: buildAnchorMutationData(result, {
+                        foundingMessageText: parsed.anchorMessage,
+                    }),
+                    previewData: buildAnchorPreviewData(result, {
+                        foundingMessageText: parsed.anchorMessage,
+                    }),
+                    reusedExisting: result.reusedExisting,
+                    reusedMessage: "The existing anchor family was reconciled instead of creating a duplicate.",
+                    nextSteps: workflowMutationNextSteps(nextSteps),
+                    text: {
+                        heading: "Anchor family submitted.",
+                        fields: [
+                            { label: "Domain", value: result.domainName },
+                            { label: "Dedicated index", value: String(result.dedicatedIndex) },
+                            { label: "Status", value: result.status },
+                            { label: "Tx1", value: result.tx1Txid },
+                            { label: "Tx2", value: result.tx2Txid },
+                        ],
+                    },
+                });
+            }
+            if (isRegisterMutationCommand(parsed.command)) {
+                const result = await context.registerDomain({
+                    domainName: parsed.args[0],
+                    dataDir,
+                    databasePath: dbPath,
                     forceRace: parsed.forceRace,
                     fromIdentity: parsed.fromIdentity,
-                }),
-                reusedExisting: result.reusedExisting,
-                reusedMessage: "The existing pending registration was reconciled instead of creating a duplicate.",
-                nextSteps: workflowMutationNextSteps(nextSteps),
-                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 },
-                    ],
-                },
-            });
-        }
-        if (isTransferMutationCommand(parsed.command)) {
-            const result = await context.transferDomain({
-                domainName: parsed.args[0],
-                target: parsed.transferTarget,
-                dataDir,
-                databasePath: dbPath,
-                provider: context.walletSecretProvider,
-                prompter,
-                assumeYes: parsed.assumeYes,
-            });
-            return writeMutationCommandSuccess(parsed, context, {
-                data: buildDomainMarketMutationData(result, {
-                    commandKind: "transfer",
-                }),
-                previewData: buildDomainMarketPreviewData(result, {
-                    commandKind: "transfer",
-                }),
-                reusedExisting: result.reusedExisting,
-                reusedMessage: "The existing pending transfer was reconciled instead of creating a duplicate.",
-                nextSteps: commandMutationNextSteps(`cogcoin show ${result.domainName}`),
-                text: {
-                    heading: "Transfer submitted.",
-                    fields: [
-                        { label: "Domain", value: result.domainName },
-                        { label: "Sender", value: formatDomainMarketSenderSummary(result) },
-                        { label: "Recipient", value: formatDomainMarketRecipientSummary(result) },
-                        { label: "Economic effect", value: formatDomainMarketEconomicEffect(result) },
-                        { label: "Status", value: result.status },
-                        { label: "Txid", value: result.txid },
-                    ],
-                },
-            });
-        }
-        if (isSellOrUnsellMutationCommand(parsed.command)) {
-            const listedPriceCogtoshi = isUnsellMutationCommand(parsed.command)
-                ? 0n
-                : parseCogAmountToCogtoshi(parsed.args[1]);
-            const result = await context.sellDomain({
-                domainName: parsed.args[0],
-                listedPriceCogtoshi,
-                dataDir,
-                databasePath: dbPath,
-                provider: context.walletSecretProvider,
-                prompter,
-                assumeYes: parsed.assumeYes,
-            });
-            return writeMutationCommandSuccess(parsed, context, {
-                data: buildDomainMarketMutationData(result, {
-                    commandKind: result.listedPriceCogtoshi === 0n ? "unsell" : "sell",
-                }),
-                previewData: buildDomainMarketPreviewData(result, {
-                    commandKind: result.listedPriceCogtoshi === 0n ? "unsell" : "sell",
-                }),
-                reusedExisting: result.reusedExisting,
-                reusedMessage: "The existing pending listing mutation was reconciled instead of creating a duplicate.",
-                nextSteps: commandMutationNextSteps(`cogcoin show ${result.domainName}`),
-                text: {
-                    heading: result.listedPriceCogtoshi === 0n ? "Listing cancellation submitted." : "Listing submitted.",
-                    fields: [
-                        { label: "Domain", value: result.domainName },
-                        { label: "Sender", value: formatDomainMarketSenderSummary(result) },
-                        { label: "Price", value: `${result.listedPriceCogtoshi?.toString() ?? "0"} cogtoshi` },
-                        { label: "Economic effect", value: formatDomainMarketEconomicEffect(result) },
-                        { label: "Status", value: result.status },
-                        { label: "Txid", value: result.txid },
-                    ],
-                },
-            });
-        }
-        if (parsed.command === "domain-endpoint-set" || parsed.command === "domain-endpoint-clear") {
-            const result = parsed.command === "domain-endpoint-set"
-                ? await context.setDomainEndpoint({
+                    provider: context.walletSecretProvider,
+                    prompter,
+                    assumeYes: parsed.assumeYes,
+                });
+                const nextSteps = getRegisterNextSteps(result.domainName, result.registerKind);
+                return writeMutationCommandSuccess(parsed, context, {
+                    data: buildRegisterMutationData(result, {
+                        forceRace: parsed.forceRace,
+                        fromIdentity: parsed.fromIdentity,
+                    }),
+                    previewData: buildRegisterPreviewData(result, {
+                        forceRace: parsed.forceRace,
+                        fromIdentity: parsed.fromIdentity,
+                    }),
+                    reusedExisting: result.reusedExisting,
+                    reusedMessage: "The existing pending registration was reconciled instead of creating a duplicate.",
+                    nextSteps: workflowMutationNextSteps(nextSteps),
+                    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 },
+                        ],
+                    },
+                });
+            }
+            if (isTransferMutationCommand(parsed.command)) {
+                const result = await context.transferDomain({
                     domainName: parsed.args[0],
-                    source: parsed.endpointText !== null
-                        ? { kind: "text", value: parsed.endpointText }
-                        : parsed.endpointJson !== null
-                            ? { kind: "json", value: parsed.endpointJson }
-                            : { kind: "bytes", value: parsed.endpointBytes },
+                    target: parsed.transferTarget,
                     dataDir,
                     databasePath: dbPath,
                     provider: context.walletSecretProvider,
                     prompter,
                     assumeYes: parsed.assumeYes,
-                })
-                : await context.clearDomainEndpoint({
+                });
+                return writeMutationCommandSuccess(parsed, context, {
+                    data: buildDomainMarketMutationData(result, {
+                        commandKind: "transfer",
+                    }),
+                    previewData: buildDomainMarketPreviewData(result, {
+                        commandKind: "transfer",
+                    }),
+                    reusedExisting: result.reusedExisting,
+                    reusedMessage: "The existing pending transfer was reconciled instead of creating a duplicate.",
+                    nextSteps: commandMutationNextSteps(`cogcoin show ${result.domainName}`),
+                    text: {
+                        heading: "Transfer submitted.",
+                        fields: [
+                            { label: "Domain", value: result.domainName },
+                            { label: "Sender", value: formatDomainMarketSenderSummary(result) },
+                            { label: "Recipient", value: formatDomainMarketRecipientSummary(result) },
+                            { label: "Economic effect", value: formatDomainMarketEconomicEffect(result) },
+                            { label: "Status", value: result.status },
+                            { label: "Txid", value: result.txid },
+                        ],
+                    },
+                });
+            }
+            if (isSellOrUnsellMutationCommand(parsed.command)) {
+                const listedPriceCogtoshi = isUnsellMutationCommand(parsed.command)
+                    ? 0n
+                    : parseCogAmountToCogtoshi(parsed.args[1]);
+                const result = await context.sellDomain({
                     domainName: parsed.args[0],
+                    listedPriceCogtoshi,
                     dataDir,
                     databasePath: dbPath,
                     provider: context.walletSecretProvider,
                     prompter,
                     assumeYes: parsed.assumeYes,
                 });
-            return writeMutationCommandSuccess(parsed, context, {
-                data: buildDomainAdminMutationData(result, {
-                    commandKind: parsed.command,
-                }),
-                previewData: buildDomainAdminPreviewData(result, {
-                    commandKind: parsed.command,
-                }),
-                reusedExisting: result.reusedExisting,
-                reusedMessage: "The existing pending endpoint mutation was reconciled instead of creating a duplicate.",
-                nextSteps: commandMutationNextSteps(`cogcoin show ${result.domainName}`),
-                text: {
-                    heading: parsed.command === "domain-endpoint-set" ? "Endpoint update submitted." : "Endpoint clear submitted.",
-                    fields: [
-                        { label: "Domain", value: result.domainName },
-                        { label: "Sender", value: formatDomainAdminSenderSummary(result) },
-                        { label: "Payload", value: formatDomainAdminPayloadSummary(result) },
-                        { label: "Effect", value: formatDomainAdminEffect(result) },
-                        { label: "Status", value: result.status },
-                        { label: "Txid", value: result.txid },
-                    ],
-                },
-            });
-        }
-        if (parsed.command === "domain-delegate-set" || parsed.command === "domain-delegate-clear") {
-            const result = parsed.command === "domain-delegate-set"
-                ? await context.setDomainDelegate({
+                return writeMutationCommandSuccess(parsed, context, {
+                    data: buildDomainMarketMutationData(result, {
+                        commandKind: result.listedPriceCogtoshi === 0n ? "unsell" : "sell",
+                    }),
+                    previewData: buildDomainMarketPreviewData(result, {
+                        commandKind: result.listedPriceCogtoshi === 0n ? "unsell" : "sell",
+                    }),
+                    reusedExisting: result.reusedExisting,
+                    reusedMessage: "The existing pending listing mutation was reconciled instead of creating a duplicate.",
+                    nextSteps: commandMutationNextSteps(`cogcoin show ${result.domainName}`),
+                    text: {
+                        heading: result.listedPriceCogtoshi === 0n ? "Listing cancellation submitted." : "Listing submitted.",
+                        fields: [
+                            { label: "Domain", value: result.domainName },
+                            { label: "Sender", value: formatDomainMarketSenderSummary(result) },
+                            { label: "Price", value: `${result.listedPriceCogtoshi?.toString() ?? "0"} cogtoshi` },
+                            { label: "Economic effect", value: formatDomainMarketEconomicEffect(result) },
+                            { label: "Status", value: result.status },
+                            { label: "Txid", value: result.txid },
+                        ],
+                    },
+                });
+            }
+            if (parsed.command === "domain-endpoint-set" || parsed.command === "domain-endpoint-clear") {
+                const result = parsed.command === "domain-endpoint-set"
+                    ? await context.setDomainEndpoint({
+                        domainName: parsed.args[0],
+                        source: parsed.endpointText !== null
+                            ? { kind: "text", value: parsed.endpointText }
+                            : parsed.endpointJson !== null
+                                ? { kind: "json", value: parsed.endpointJson }
+                                : { kind: "bytes", value: parsed.endpointBytes },
+                        dataDir,
+                        databasePath: dbPath,
+                        provider: context.walletSecretProvider,
+                        prompter,
+                        assumeYes: parsed.assumeYes,
+                    })
+                    : await context.clearDomainEndpoint({
+                        domainName: parsed.args[0],
+                        dataDir,
+                        databasePath: dbPath,
+                        provider: context.walletSecretProvider,
+                        prompter,
+                        assumeYes: parsed.assumeYes,
+                    });
+                return writeMutationCommandSuccess(parsed, context, {
+                    data: buildDomainAdminMutationData(result, {
+                        commandKind: parsed.command,
+                    }),
+                    previewData: buildDomainAdminPreviewData(result, {
+                        commandKind: parsed.command,
+                    }),
+                    reusedExisting: result.reusedExisting,
+                    reusedMessage: "The existing pending endpoint mutation was reconciled instead of creating a duplicate.",
+                    nextSteps: commandMutationNextSteps(`cogcoin show ${result.domainName}`),
+                    text: {
+                        heading: parsed.command === "domain-endpoint-set" ? "Endpoint update submitted." : "Endpoint clear submitted.",
+                        fields: [
+                            { label: "Domain", value: result.domainName },
+                            { label: "Sender", value: formatDomainAdminSenderSummary(result) },
+                            { label: "Payload", value: formatDomainAdminPayloadSummary(result) },
+                            { label: "Effect", value: formatDomainAdminEffect(result) },
+                            { label: "Status", value: result.status },
+                            { label: "Txid", value: result.txid },
+                        ],
+                    },
+                });
+            }
+            if (parsed.command === "domain-delegate-set" || parsed.command === "domain-delegate-clear") {
+                const result = parsed.command === "domain-delegate-set"
+                    ? await context.setDomainDelegate({
+                        domainName: parsed.args[0],
+                        target: parsed.args[1],
+                        dataDir,
+                        databasePath: dbPath,
+                        provider: context.walletSecretProvider,
+                        prompter,
+                        assumeYes: parsed.assumeYes,
+                    })
+                    : await context.clearDomainDelegate({
+                        domainName: parsed.args[0],
+                        dataDir,
+                        databasePath: dbPath,
+                        provider: context.walletSecretProvider,
+                        prompter,
+                        assumeYes: parsed.assumeYes,
+                    });
+                return writeMutationCommandSuccess(parsed, context, {
+                    data: buildDomainAdminMutationData(result, {
+                        commandKind: parsed.command,
+                    }),
+                    previewData: buildDomainAdminPreviewData(result, {
+                        commandKind: parsed.command,
+                    }),
+                    reusedExisting: result.reusedExisting,
+                    reusedMessage: "The existing pending delegate mutation was reconciled instead of creating a duplicate.",
+                    nextSteps: commandMutationNextSteps(`cogcoin show ${result.domainName}`),
+                    text: {
+                        heading: parsed.command === "domain-delegate-set" ? "Delegate update submitted." : "Delegate clear submitted.",
+                        fields: [
+                            { label: "Domain", value: result.domainName },
+                            { label: "Sender", value: formatDomainAdminSenderSummary(result) },
+                            { label: "Target", value: formatDomainAdminTargetSummary(result) },
+                            { label: "Effect", value: formatDomainAdminEffect(result) },
+                            { label: "Status", value: result.status },
+                            { label: "Txid", value: result.txid },
+                        ],
+                    },
+                });
+            }
+            if (parsed.command === "domain-miner-set" || parsed.command === "domain-miner-clear") {
+                const result = parsed.command === "domain-miner-set"
+                    ? await context.setDomainMiner({
+                        domainName: parsed.args[0],
+                        target: parsed.args[1],
+                        dataDir,
+                        databasePath: dbPath,
+                        provider: context.walletSecretProvider,
+                        prompter,
+                        assumeYes: parsed.assumeYes,
+                    })
+                    : await context.clearDomainMiner({
+                        domainName: parsed.args[0],
+                        dataDir,
+                        databasePath: dbPath,
+                        provider: context.walletSecretProvider,
+                        prompter,
+                        assumeYes: parsed.assumeYes,
+                    });
+                return writeMutationCommandSuccess(parsed, context, {
+                    data: buildDomainAdminMutationData(result, {
+                        commandKind: parsed.command,
+                    }),
+                    previewData: buildDomainAdminPreviewData(result, {
+                        commandKind: parsed.command,
+                    }),
+                    reusedExisting: result.reusedExisting,
+                    reusedMessage: "The existing pending miner mutation was reconciled instead of creating a duplicate.",
+                    nextSteps: commandMutationNextSteps(`cogcoin show ${result.domainName}`),
+                    text: {
+                        heading: parsed.command === "domain-miner-set" ? "Miner update submitted." : "Miner clear submitted.",
+                        fields: [
+                            { label: "Domain", value: result.domainName },
+                            { label: "Sender", value: formatDomainAdminSenderSummary(result) },
+                            { label: "Target", value: formatDomainAdminTargetSummary(result) },
+                            { label: "Effect", value: formatDomainAdminEffect(result) },
+                            { label: "Status", value: result.status },
+                            { label: "Txid", value: result.txid },
+                        ],
+                    },
+                });
+            }
+            if (parsed.command === "domain-canonical") {
+                const result = await context.setDomainCanonical({
                     domainName: parsed.args[0],
-                    target: parsed.args[1],
                     dataDir,
                     databasePath: dbPath,
                     provider: context.walletSecretProvider,
                     prompter,
                     assumeYes: parsed.assumeYes,
-                })
-                : await context.clearDomainDelegate({
+                });
+                return writeMutationCommandSuccess(parsed, context, {
+                    data: buildDomainAdminMutationData(result, {
+                        commandKind: "domain-canonical",
+                    }),
+                    previewData: buildDomainAdminPreviewData(result, {
+                        commandKind: "domain-canonical",
+                    }),
+                    reusedExisting: result.reusedExisting,
+                    reusedMessage: "The existing pending canonical mutation was reconciled instead of creating a duplicate.",
+                    nextSteps: commandMutationNextSteps(`cogcoin show ${result.domainName}`),
+                    text: {
+                        heading: "Canonical update submitted.",
+                        fields: [
+                            { label: "Domain", value: result.domainName },
+                            { label: "Sender", value: formatDomainAdminSenderSummary(result) },
+                            { label: "Effect", value: formatDomainAdminEffect(result) },
+                            { label: "Status", value: result.status },
+                            { label: "Txid", value: result.txid },
+                        ],
+                    },
+                });
+            }
+            if (parsed.command === "field-create") {
+                const result = await context.createField({
                     domainName: parsed.args[0],
+                    fieldName: parsed.args[1],
+                    permanent: parsed.fieldPermanent,
+                    source: (parsed.endpointText !== null
+                        || parsed.endpointJson !== null
+                        || parsed.endpointBytes !== null
+                        || parsed.fieldFormat !== null)
+                        ? createFieldValueSource(parsed)
+                        : null,
                     dataDir,
                     databasePath: dbPath,
                     provider: context.walletSecretProvider,
                     prompter,
                     assumeYes: parsed.assumeYes,
                 });
-            return writeMutationCommandSuccess(parsed, context, {
-                data: buildDomainAdminMutationData(result, {
-                    commandKind: parsed.command,
-                }),
-                previewData: buildDomainAdminPreviewData(result, {
-                    commandKind: parsed.command,
-                }),
-                reusedExisting: result.reusedExisting,
-                reusedMessage: "The existing pending delegate mutation was reconciled instead of creating a duplicate.",
-                nextSteps: commandMutationNextSteps(`cogcoin show ${result.domainName}`),
-                text: {
-                    heading: parsed.command === "domain-delegate-set" ? "Delegate update submitted." : "Delegate clear submitted.",
-                    fields: [
-                        { label: "Domain", value: result.domainName },
-                        { label: "Sender", value: formatDomainAdminSenderSummary(result) },
-                        { label: "Target", value: formatDomainAdminTargetSummary(result) },
-                        { label: "Effect", value: formatDomainAdminEffect(result) },
-                        { label: "Status", value: result.status },
-                        { label: "Txid", value: result.txid },
-                    ],
-                },
-            });
-        }
-        if (parsed.command === "domain-miner-set" || parsed.command === "domain-miner-clear") {
-            const result = parsed.command === "domain-miner-set"
-                ? await context.setDomainMiner({
+                return writeMutationCommandSuccess(parsed, context, {
+                    data: buildFieldMutationData(result),
+                    previewData: buildFieldPreviewData(result),
+                    reusedExisting: result.reusedExisting,
+                    reusedMessage: result.family
+                        ? "The existing pending field family was reconciled instead of creating a duplicate."
+                        : "The existing pending field creation was reconciled instead of creating a duplicate.",
+                    nextSteps: commandMutationNextSteps(`cogcoin field show ${result.domainName} ${result.fieldName}`),
+                    text: {
+                        heading: result.family ? "Field create+write family submitted." : "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: "Tx1", value: result.tx1Txid ?? "unknown", when: result.family },
+                            { label: "Tx2", value: result.tx2Txid ?? "unknown", when: result.family },
+                            { label: "Txid", value: result.txid, when: !result.family },
+                        ],
+                    },
+                });
+            }
+            if (parsed.command === "field-set") {
+                const result = await context.setField({
                     domainName: parsed.args[0],
-                    target: parsed.args[1],
+                    fieldName: parsed.args[1],
+                    source: createFieldValueSource(parsed),
                     dataDir,
                     databasePath: dbPath,
                     provider: context.walletSecretProvider,
                     prompter,
                     assumeYes: parsed.assumeYes,
-                })
-                : await context.clearDomainMiner({
+                });
+                return writeMutationCommandSuccess(parsed, context, {
+                    data: buildFieldMutationData(result),
+                    previewData: buildFieldPreviewData(result),
+                    reusedExisting: result.reusedExisting,
+                    reusedMessage: "The existing pending field update was reconciled instead of creating a duplicate.",
+                    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 (parsed.command === "field-clear") {
+                const result = await context.clearField({
                     domainName: parsed.args[0],
+                    fieldName: parsed.args[1],
                     dataDir,
                     databasePath: dbPath,
                     provider: context.walletSecretProvider,
                     prompter,
                     assumeYes: parsed.assumeYes,
                 });
-            return writeMutationCommandSuccess(parsed, context, {
-                data: buildDomainAdminMutationData(result, {
-                    commandKind: parsed.command,
-                }),
-                previewData: buildDomainAdminPreviewData(result, {
-                    commandKind: parsed.command,
-                }),
-                reusedExisting: result.reusedExisting,
-                reusedMessage: "The existing pending miner mutation was reconciled instead of creating a duplicate.",
-                nextSteps: commandMutationNextSteps(`cogcoin show ${result.domainName}`),
-                text: {
-                    heading: parsed.command === "domain-miner-set" ? "Miner update submitted." : "Miner clear submitted.",
-                    fields: [
-                        { label: "Domain", value: result.domainName },
-                        { label: "Sender", value: formatDomainAdminSenderSummary(result) },
-                        { label: "Target", value: formatDomainAdminTargetSummary(result) },
-                        { label: "Effect", value: formatDomainAdminEffect(result) },
-                        { label: "Status", value: result.status },
-                        { label: "Txid", value: result.txid },
-                    ],
-                },
-            });
-        }
-        if (parsed.command === "domain-canonical") {
-            const result = await context.setDomainCanonical({
-                domainName: parsed.args[0],
-                dataDir,
-                databasePath: dbPath,
-                provider: context.walletSecretProvider,
-                prompter,
-                assumeYes: parsed.assumeYes,
-            });
-            return writeMutationCommandSuccess(parsed, context, {
-                data: buildDomainAdminMutationData(result, {
-                    commandKind: "domain-canonical",
-                }),
-                previewData: buildDomainAdminPreviewData(result, {
-                    commandKind: "domain-canonical",
-                }),
-                reusedExisting: result.reusedExisting,
-                reusedMessage: "The existing pending canonical mutation was reconciled instead of creating a duplicate.",
-                nextSteps: commandMutationNextSteps(`cogcoin show ${result.domainName}`),
-                text: {
-                    heading: "Canonical update submitted.",
-                    fields: [
-                        { label: "Domain", value: result.domainName },
-                        { label: "Sender", value: formatDomainAdminSenderSummary(result) },
-                        { label: "Effect", value: formatDomainAdminEffect(result) },
-                        { label: "Status", value: result.status },
-                        { label: "Txid", value: result.txid },
-                    ],
-                },
-            });
-        }
-        if (parsed.command === "field-create") {
-            const result = await context.createField({
-                domainName: parsed.args[0],
-                fieldName: parsed.args[1],
-                permanent: parsed.fieldPermanent,
-                source: (parsed.endpointText !== null
-                    || parsed.endpointJson !== null
-                    || parsed.endpointBytes !== null
-                    || parsed.fieldFormat !== null)
-                    ? createFieldValueSource(parsed)
-                    : null,
-                dataDir,
-                databasePath: dbPath,
-                provider: context.walletSecretProvider,
-                prompter,
-                assumeYes: parsed.assumeYes,
-            });
-            return writeMutationCommandSuccess(parsed, context, {
-                data: buildFieldMutationData(result),
-                previewData: buildFieldPreviewData(result),
-                reusedExisting: result.reusedExisting,
-                reusedMessage: result.family
-                    ? "The existing pending field family was reconciled instead of creating a duplicate."
-                    : "The existing pending field creation was reconciled instead of creating a duplicate.",
-                nextSteps: commandMutationNextSteps(`cogcoin field show ${result.domainName} ${result.fieldName}`),
-                text: {
-                    heading: result.family ? "Field create+write family submitted." : "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: "Tx1", value: result.tx1Txid ?? "unknown", when: result.family },
-                        { label: "Tx2", value: result.tx2Txid ?? "unknown", when: result.family },
-                        { label: "Txid", value: result.txid, when: !result.family },
-                    ],
-                },
-            });
-        }
-        if (parsed.command === "field-set") {
-            const result = await context.setField({
-                domainName: parsed.args[0],
-                fieldName: parsed.args[1],
-                source: createFieldValueSource(parsed),
-                dataDir,
-                databasePath: dbPath,
-                provider: context.walletSecretProvider,
-                prompter,
-                assumeYes: parsed.assumeYes,
-            });
-            return writeMutationCommandSuccess(parsed, context, {
-                data: buildFieldMutationData(result),
-                previewData: buildFieldPreviewData(result),
-                reusedExisting: result.reusedExisting,
-                reusedMessage: "The existing pending field update was reconciled instead of creating a duplicate.",
-                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 (parsed.command === "field-clear") {
-            const result = await context.clearField({
-                domainName: parsed.args[0],
-                fieldName: parsed.args[1],
-                dataDir,
-                databasePath: dbPath,
-                provider: context.walletSecretProvider,
-                prompter,
-                assumeYes: parsed.assumeYes,
-            });
-            return writeMutationCommandSuccess(parsed, context, {
-                data: buildFieldMutationData(result),
-                previewData: buildFieldPreviewData(result),
-                reusedExisting: result.reusedExisting,
-                reusedMessage: "The existing pending field clear was reconciled instead of creating a duplicate.",
-                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 },
-                    ],
-                },
-            });
-        }
-        if (isSendMutationCommand(parsed.command)) {
-            const result = await context.sendCog({
-                amountCogtoshi: parseCogAmountToCogtoshi(parsed.args[0]),
-                target: parsed.transferTarget,
-                fromIdentity: parsed.fromIdentity,
-                dataDir,
-                databasePath: dbPath,
-                provider: context.walletSecretProvider,
-                prompter,
-                assumeYes: parsed.assumeYes,
-            });
-            return writeMutationCommandSuccess(parsed, context, {
-                data: buildCogMutationData(result, {
-                    commandKind: "send",
-                    fromIdentity: parsed.fromIdentity,
-                }),
-                previewData: buildCogPreviewData(result, {
-                    commandKind: "send",
-                    fromIdentity: parsed.fromIdentity,
-                }),
-                reusedExisting: result.reusedExisting,
-                reusedMessage: "The existing pending COG transfer was reconciled instead of creating a duplicate.",
-                nextSteps: commandMutationNextSteps("cogcoin balance"),
-                text: {
-                    heading: "COG transfer submitted.",
-                    fields: [
-                        { label: "Sender", value: formatCogSenderSummary(result) },
-                        { label: "Amount", value: `${result.amountCogtoshi?.toString() ?? "unknown"} cogtoshi` },
-                        { label: "Recipient", value: result.recipientScriptPubKeyHex === null || result.recipientScriptPubKeyHex === undefined ? "unknown" : `spk:${result.recipientScriptPubKeyHex}` },
-                        { label: "Status", value: result.status },
-                        { label: "Txid", value: result.txid },
-                    ],
-                },
-            });
-        }
-        if (parsed.command === "cog-lock") {
-            const result = await context.lockCogToDomain({
-                amountCogtoshi: parseCogAmountToCogtoshi(parsed.args[0]),
-                recipientDomainName: parsed.lockRecipientDomain,
-                fromIdentity: parsed.fromIdentity,
-                timeoutBlocksOrDuration: parsed.unlockFor,
-                timeoutHeight: parsed.untilHeight === null ? null : Number.parseInt(parsed.untilHeight, 10),
-                conditionHex: parsed.conditionHex,
-                dataDir,
-                databasePath: dbPath,
-                provider: context.walletSecretProvider,
-                prompter,
-                assumeYes: parsed.assumeYes,
-            });
-            return writeMutationCommandSuccess(parsed, context, {
-                data: buildCogMutationData(result, {
-                    commandKind: "cog-lock",
+                return writeMutationCommandSuccess(parsed, context, {
+                    data: buildFieldMutationData(result),
+                    previewData: buildFieldPreviewData(result),
+                    reusedExisting: result.reusedExisting,
+                    reusedMessage: "The existing pending field clear was reconciled instead of creating a duplicate.",
+                    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 },
+                        ],
+                    },
+                });
+            }
+            if (isSendMutationCommand(parsed.command)) {
+                const result = await context.sendCog({
+                    amountCogtoshi: parseCogAmountToCogtoshi(parsed.args[0]),
+                    target: parsed.transferTarget,
                     fromIdentity: parsed.fromIdentity,
-                    timeoutBlocksOrDuration: parsed.unlockFor,
-                    timeoutHeight: parsed.untilHeight,
-                    conditionHex: parsed.conditionHex,
-                }),
-                previewData: buildCogPreviewData(result, {
-                    commandKind: "cog-lock",
+                    dataDir,
+                    databasePath: dbPath,
+                    provider: context.walletSecretProvider,
+                    prompter,
+                    assumeYes: parsed.assumeYes,
+                });
+                return writeMutationCommandSuccess(parsed, context, {
+                    data: buildCogMutationData(result, {
+                        commandKind: "send",
+                        fromIdentity: parsed.fromIdentity,
+                    }),
+                    previewData: buildCogPreviewData(result, {
+                        commandKind: "send",
+                        fromIdentity: parsed.fromIdentity,
+                    }),
+                    reusedExisting: result.reusedExisting,
+                    reusedMessage: "The existing pending COG transfer was reconciled instead of creating a duplicate.",
+                    nextSteps: commandMutationNextSteps("cogcoin balance"),
+                    text: {
+                        heading: "COG transfer submitted.",
+                        fields: [
+                            { label: "Sender", value: formatCogSenderSummary(result) },
+                            { label: "Amount", value: `${result.amountCogtoshi?.toString() ?? "unknown"} cogtoshi` },
+                            { label: "Recipient", value: result.recipientScriptPubKeyHex === null || result.recipientScriptPubKeyHex === undefined ? "unknown" : `spk:${result.recipientScriptPubKeyHex}` },
+                            { label: "Status", value: result.status },
+                            { label: "Txid", value: result.txid },
+                        ],
+                    },
+                });
+            }
+            if (parsed.command === "cog-lock") {
+                const result = await context.lockCogToDomain({
+                    amountCogtoshi: parseCogAmountToCogtoshi(parsed.args[0]),
+                    recipientDomainName: parsed.lockRecipientDomain,
                     fromIdentity: parsed.fromIdentity,
                     timeoutBlocksOrDuration: parsed.unlockFor,
-                    timeoutHeight: parsed.untilHeight,
+                    timeoutHeight: parsed.untilHeight === null ? null : Number.parseInt(parsed.untilHeight, 10),
                     conditionHex: parsed.conditionHex,
-                }),
-                reusedExisting: result.reusedExisting,
-                reusedMessage: "The existing pending lock was reconciled instead of creating a duplicate.",
-                nextSteps: commandMutationNextSteps("cogcoin locks"),
-                text: {
-                    heading: "COG lock submitted.",
-                    fields: [
-                        { label: "Sender", value: formatCogSenderSummary(result) },
-                        { label: "Amount", value: `${result.amountCogtoshi?.toString() ?? "unknown"} cogtoshi` },
-                        { label: "Recipient domain", value: result.recipientDomainName ?? "unknown" },
-                        { label: "Status", value: result.status },
-                        { label: "Txid", value: result.txid },
-                    ],
-                },
-            });
-        }
-        if (isClaimMutationCommand(parsed.command)) {
-            const result = await context.claimCogLock({
-                lockId: Number.parseInt(parsed.args[0], 10),
-                preimageHex: parsed.preimageHex,
-                dataDir,
-                databasePath: dbPath,
-                provider: context.walletSecretProvider,
-                prompter,
-            });
-            return writeMutationCommandSuccess(parsed, context, {
-                data: buildCogMutationData(result, {
-                    commandKind: "claim",
-                    fromIdentity: null,
-                }),
-                previewData: buildCogPreviewData(result, {
-                    commandKind: "claim",
-                    fromIdentity: null,
-                }),
-                reusedExisting: result.reusedExisting,
-                reusedMessage: "The existing pending claim was reconciled instead of creating a duplicate.",
-                nextSteps: commandMutationNextSteps("cogcoin locks --claimable"),
-                text: {
-                    heading: "Lock claim submitted.",
-                    fields: [
-                        { label: "Lock", value: String(result.lockId ?? "unknown") },
-                        { label: "Path", value: formatCogClaimPath(result) },
-                        { label: "Sender", value: formatCogSenderSummary(result) },
-                        { label: "Amount", value: `${result.amountCogtoshi?.toString() ?? "unknown"} cogtoshi` },
-                        { label: "Status", value: result.status },
-                        { label: "Txid", value: result.txid },
-                    ],
-                },
-            });
-        }
-        if (isReclaimMutationCommand(parsed.command)) {
-            const result = await context.reclaimCogLock({
-                lockId: Number.parseInt(parsed.args[0], 10),
-                dataDir,
-                databasePath: dbPath,
-                provider: context.walletSecretProvider,
-                prompter,
-            });
-            return writeMutationCommandSuccess(parsed, context, {
-                data: buildCogMutationData(result, {
-                    commandKind: "reclaim",
-                    fromIdentity: null,
-                }),
-                previewData: buildCogPreviewData(result, {
-                    commandKind: "reclaim",
-                    fromIdentity: null,
-                }),
-                reusedExisting: result.reusedExisting,
-                reusedMessage: "The existing pending reclaim was reconciled instead of creating a duplicate.",
-                nextSteps: commandMutationNextSteps("cogcoin locks --reclaimable"),
-                text: {
-                    heading: "Lock reclaim submitted.",
-                    fields: [
-                        { label: "Lock", value: String(result.lockId ?? "unknown") },
-                        { label: "Path", value: formatCogClaimPath(result) },
-                        { label: "Sender", value: formatCogSenderSummary(result) },
-                        { label: "Amount", value: `${result.amountCogtoshi?.toString() ?? "unknown"} cogtoshi` },
-                        { label: "Status", value: result.status },
-                        { label: "Txid", value: result.txid },
-                    ],
-                },
-            });
-        }
-        if (isReputationMutationCommand(parsed.command)) {
-            const result = parsed.command === "rep-give"
-                ? await context.giveReputation({
-                    sourceDomainName: parsed.args[0],
-                    targetDomainName: parsed.args[1],
-                    amountCogtoshi: parseCogAmountToCogtoshi(parsed.args[2]),
-                    reviewText: parsed.reviewText,
                     dataDir,
                     databasePath: dbPath,
                     provider: context.walletSecretProvider,
                     prompter,
                     assumeYes: parsed.assumeYes,
-                })
-                : await context.revokeReputation({
-                    sourceDomainName: parsed.args[0],
-                    targetDomainName: parsed.args[1],
-                    amountCogtoshi: parseCogAmountToCogtoshi(parsed.args[2]),
-                    reviewText: parsed.reviewText,
+                });
+                return writeMutationCommandSuccess(parsed, context, {
+                    data: buildCogMutationData(result, {
+                        commandKind: "cog-lock",
+                        fromIdentity: parsed.fromIdentity,
+                        timeoutBlocksOrDuration: parsed.unlockFor,
+                        timeoutHeight: parsed.untilHeight,
+                        conditionHex: parsed.conditionHex,
+                    }),
+                    previewData: buildCogPreviewData(result, {
+                        commandKind: "cog-lock",
+                        fromIdentity: parsed.fromIdentity,
+                        timeoutBlocksOrDuration: parsed.unlockFor,
+                        timeoutHeight: parsed.untilHeight,
+                        conditionHex: parsed.conditionHex,
+                    }),
+                    reusedExisting: result.reusedExisting,
+                    reusedMessage: "The existing pending lock was reconciled instead of creating a duplicate.",
+                    nextSteps: commandMutationNextSteps("cogcoin locks"),
+                    text: {
+                        heading: "COG lock submitted.",
+                        fields: [
+                            { label: "Sender", value: formatCogSenderSummary(result) },
+                            { label: "Amount", value: `${result.amountCogtoshi?.toString() ?? "unknown"} cogtoshi` },
+                            { label: "Recipient domain", value: result.recipientDomainName ?? "unknown" },
+                            { label: "Status", value: result.status },
+                            { label: "Txid", value: result.txid },
+                        ],
+                    },
+                });
+            }
+            if (isClaimMutationCommand(parsed.command)) {
+                const result = await context.claimCogLock({
+                    lockId: Number.parseInt(parsed.args[0], 10),
+                    preimageHex: parsed.preimageHex,
                     dataDir,
                     databasePath: dbPath,
                     provider: context.walletSecretProvider,
                     prompter,
-                    assumeYes: parsed.assumeYes,
                 });
-            return writeMutationCommandSuccess(parsed, context, {
-                data: buildReputationMutationData(result),
-                previewData: buildReputationPreviewData(result),
-                reusedExisting: result.reusedExisting,
-                reusedMessage: "The existing pending reputation mutation was reconciled instead of creating a duplicate.",
-                nextSteps: commandMutationNextSteps(`cogcoin show ${result.targetDomainName}`),
-                text: {
-                    heading: 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 },
-                    ],
-                },
-            });
-        }
-        if (isBuyMutationCommand(parsed.command)) {
-            const result = await context.buyDomain({
-                domainName: parsed.args[0],
-                fromIdentity: parsed.fromIdentity,
-                dataDir,
-                databasePath: dbPath,
-                provider: context.walletSecretProvider,
-                prompter,
-                assumeYes: parsed.assumeYes,
-            });
-            return writeMutationCommandSuccess(parsed, context, {
-                data: buildDomainMarketMutationData(result, {
-                    commandKind: "buy",
-                    fromIdentity: parsed.fromIdentity,
-                }),
-                previewData: buildDomainMarketPreviewData(result, {
-                    commandKind: "buy",
+                return writeMutationCommandSuccess(parsed, context, {
+                    data: buildCogMutationData(result, {
+                        commandKind: "claim",
+                        fromIdentity: null,
+                    }),
+                    previewData: buildCogPreviewData(result, {
+                        commandKind: "claim",
+                        fromIdentity: null,
+                    }),
+                    reusedExisting: result.reusedExisting,
+                    reusedMessage: "The existing pending claim was reconciled instead of creating a duplicate.",
+                    nextSteps: commandMutationNextSteps("cogcoin locks --claimable"),
+                    text: {
+                        heading: "Lock claim submitted.",
+                        fields: [
+                            { label: "Lock", value: String(result.lockId ?? "unknown") },
+                            { label: "Path", value: formatCogClaimPath(result) },
+                            { label: "Sender", value: formatCogSenderSummary(result) },
+                            { label: "Amount", value: `${result.amountCogtoshi?.toString() ?? "unknown"} cogtoshi` },
+                            { label: "Status", value: result.status },
+                            { label: "Txid", value: result.txid },
+                        ],
+                    },
+                });
+            }
+            if (isReclaimMutationCommand(parsed.command)) {
+                const result = await context.reclaimCogLock({
+                    lockId: Number.parseInt(parsed.args[0], 10),
+                    dataDir,
+                    databasePath: dbPath,
+                    provider: context.walletSecretProvider,
+                    prompter,
+                });
+                return writeMutationCommandSuccess(parsed, context, {
+                    data: buildCogMutationData(result, {
+                        commandKind: "reclaim",
+                        fromIdentity: null,
+                    }),
+                    previewData: buildCogPreviewData(result, {
+                        commandKind: "reclaim",
+                        fromIdentity: null,
+                    }),
+                    reusedExisting: result.reusedExisting,
+                    reusedMessage: "The existing pending reclaim was reconciled instead of creating a duplicate.",
+                    nextSteps: commandMutationNextSteps("cogcoin locks --reclaimable"),
+                    text: {
+                        heading: "Lock reclaim submitted.",
+                        fields: [
+                            { label: "Lock", value: String(result.lockId ?? "unknown") },
+                            { label: "Path", value: formatCogClaimPath(result) },
+                            { label: "Sender", value: formatCogSenderSummary(result) },
+                            { label: "Amount", value: `${result.amountCogtoshi?.toString() ?? "unknown"} cogtoshi` },
+                            { label: "Status", value: result.status },
+                            { label: "Txid", value: result.txid },
+                        ],
+                    },
+                });
+            }
+            if (isReputationMutationCommand(parsed.command)) {
+                const result = parsed.command === "rep-give"
+                    ? await context.giveReputation({
+                        sourceDomainName: parsed.args[0],
+                        targetDomainName: parsed.args[1],
+                        amountCogtoshi: parseCogAmountToCogtoshi(parsed.args[2]),
+                        reviewText: parsed.reviewText,
+                        dataDir,
+                        databasePath: dbPath,
+                        provider: context.walletSecretProvider,
+                        prompter,
+                        assumeYes: parsed.assumeYes,
+                    })
+                    : await context.revokeReputation({
+                        sourceDomainName: parsed.args[0],
+                        targetDomainName: parsed.args[1],
+                        amountCogtoshi: parseCogAmountToCogtoshi(parsed.args[2]),
+                        reviewText: parsed.reviewText,
+                        dataDir,
+                        databasePath: dbPath,
+                        provider: context.walletSecretProvider,
+                        prompter,
+                        assumeYes: parsed.assumeYes,
+                    });
+                return writeMutationCommandSuccess(parsed, context, {
+                    data: buildReputationMutationData(result),
+                    previewData: buildReputationPreviewData(result),
+                    reusedExisting: result.reusedExisting,
+                    reusedMessage: "The existing pending reputation mutation was reconciled instead of creating a duplicate.",
+                    nextSteps: commandMutationNextSteps(`cogcoin show ${result.targetDomainName}`),
+                    text: {
+                        heading: 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 },
+                        ],
+                    },
+                });
+            }
+            if (isBuyMutationCommand(parsed.command)) {
+                const result = await context.buyDomain({
+                    domainName: parsed.args[0],
                     fromIdentity: parsed.fromIdentity,
-                }),
-                reusedExisting: result.reusedExisting,
-                reusedMessage: "The existing pending purchase was reconciled instead of creating a duplicate.",
-                nextSteps: commandMutationNextSteps(`cogcoin show ${result.domainName}`),
-                text: {
-                    heading: "Purchase submitted.",
-                    fields: [
-                        { label: "Domain", value: result.domainName },
-                        { label: "Buyer", value: formatBuyBuyerSummary(result) },
-                        { label: "Seller", value: formatBuySellerSummary(result) },
-                        { label: "Price", value: `${result.listedPriceCogtoshi?.toString() ?? "unknown"} cogtoshi` },
-                        { label: "Settlement", value: formatBuySettlementSummary() },
-                        { label: "Status", value: result.status },
-                        { label: "Txid", value: result.txid },
-                    ],
-                },
-            });
+                    dataDir,
+                    databasePath: dbPath,
+                    provider: context.walletSecretProvider,
+                    prompter,
+                    assumeYes: parsed.assumeYes,
+                });
+                return writeMutationCommandSuccess(parsed, context, {
+                    data: buildDomainMarketMutationData(result, {
+                        commandKind: "buy",
+                        fromIdentity: parsed.fromIdentity,
+                    }),
+                    previewData: buildDomainMarketPreviewData(result, {
+                        commandKind: "buy",
+                        fromIdentity: parsed.fromIdentity,
+                    }),
+                    reusedExisting: result.reusedExisting,
+                    reusedMessage: "The existing pending purchase was reconciled instead of creating a duplicate.",
+                    nextSteps: commandMutationNextSteps(`cogcoin show ${result.domainName}`),
+                    text: {
+                        heading: "Purchase submitted.",
+                        fields: [
+                            { label: "Domain", value: result.domainName },
+                            { label: "Buyer", value: formatBuyBuyerSummary(result) },
+                            { label: "Seller", value: formatBuySellerSummary(result) },
+                            { label: "Price", value: `${result.listedPriceCogtoshi?.toString() ?? "unknown"} cogtoshi` },
+                            { label: "Settlement", value: formatBuySettlementSummary() },
+                            { label: "Status", value: result.status },
+                            { label: "Txid", value: result.txid },
+                        ],
+                    },
+                });
+            }
+            writeLine(context.stderr, `wallet mutation command not implemented: ${parsed.command}`);
+            return 1;
+        })(), stopWatcher);
+        if (outcome.kind === "stopped") {
+            return outcome.code;
         }
-        writeLine(context.stderr, `wallet mutation command not implemented: ${parsed.command}`);
-        return 1;
+        return outcome.value;
     }
     catch (error) {
         return writeHandledCliError({
@@ -678,4 +692,7 @@ export async function runWalletMutationCommand(parsed, context) {
             error,
         });
     }
+    finally {
+        stopWatcher.cleanup();
+    }
 }