@cogcoin/client 1.1.8 → 1.1.10

package/dist/cli/commands/mining-read.js

@@ -2,7 +2,7 @@ import { dirname } from "node:path";
 import { stat } from "node:fs/promises";
 import { formatMineStatusReport, formatMiningEventRecord, formatMiningPromptListReport, } from "../mining-format.js";
 import { writeLine } from "../io.js";
-import { normalizeListPage, } from "../output.js";
+import { normalizeListPage, } from "../pagination.js";
 import { formatNextStepLines } from "../workflow-hints.js";
 import { withInteractiveWalletSecretProvider } from "../../wallet/state/provider.js";
 async function readRotationIndices(paths) {

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

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

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

@@ -0,0 +1,33 @@
+import { workflowMutationNextSteps, } from "../../mutation-success.js";
+import { getAnchorNextSteps } from "../../workflow-hints.js";
+export const anchorMutationCommandSpec = {
+    id: "anchor",
+    async run(command) {
+        const result = await command.context.anchorDomain({
+            domainName: command.parsed.args[0],
+            foundingMessageText: command.parsed.anchorMessage,
+            promptForFoundingMessageWhenMissing: command.parsed.anchorMessage === null,
+            feeRateSatVb: command.parsed.satvb,
+            dataDir: command.dataDir,
+            databasePath: command.dbPath,
+            provider: command.provider,
+            prompter: command.prompter,
+            paths: command.runtimePaths,
+        });
+        return {
+            reusedExisting: result.reusedExisting,
+            reusedMessage: "The existing pending anchor was reconciled instead of creating a duplicate.",
+            fees: result.fees,
+            explorerTxid: result.txid,
+            nextSteps: workflowMutationNextSteps(getAnchorNextSteps(result.domainName)),
+            text: {
+                heading: "Anchor submitted.",
+                fields: [
+                    { label: "Domain", value: result.domainName },
+                    { label: "Status", value: result.status },
+                    { label: "Txid", value: result.txid },
+                ],
+            },
+        };
+    },
+};

package/dist/cli/commands/wallet-mutation/bitcoin-transfer.d.ts

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

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

@@ -0,0 +1,32 @@
+import { workflowMutationNextSteps, } from "../../mutation-success.js";
+export const bitcoinTransferCommandSpec = {
+    id: "bitcoin-transfer",
+    async run(command) {
+        const result = await command.context.transferBitcoin({
+            amountSatsText: command.parsed.args[0],
+            target: command.parsed.transferTarget,
+            dataDir: command.dataDir,
+            databasePath: command.dbPath,
+            provider: command.provider,
+            prompter: command.prompter,
+            assumeYes: command.parsed.assumeYes,
+            paths: command.runtimePaths,
+        });
+        return {
+            reusedExisting: false,
+            reusedMessage: "",
+            explorerTxid: result.txid,
+            nextSteps: workflowMutationNextSteps([]),
+            text: {
+                heading: "Bitcoin transfer submitted.",
+                fields: [
+                    { label: "Sender", value: result.senderAddress },
+                    { label: "Recipient", value: result.recipientAddress },
+                    { label: "Amount", value: `${result.amountSats.toString()} sats` },
+                    { label: "Fee", value: `${result.feeSats.toString()} sats` },
+                    { label: "Txid", value: result.txid },
+                ],
+            },
+        };
+    },
+};

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

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

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

@@ -0,0 +1,131 @@
+import { parseCogAmountToCogtoshi } from "../../../wallet/tx/index.js";
+import { formatCogClaimPath, formatCogSenderSummary, } from "../../mutation-text-format.js";
+import { commandMutationNextSteps } from "../../mutation-success.js";
+export const cogMutationCommandSpec = {
+    id: "cog",
+    async run(command) {
+        if (command.parsed.command === "send") {
+            const result = await command.context.sendCog({
+                amountCogtoshi: parseCogAmountToCogtoshi(command.parsed.args[0]),
+                target: command.parsed.transferTarget,
+                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 COG transfer was reconciled instead of creating a duplicate.",
+                fees: result.fees,
+                explorerTxid: result.txid,
+                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 (command.parsed.command === "cog-lock") {
+            const result = await command.context.lockCogToDomain({
+                amountCogtoshi: parseCogAmountToCogtoshi(command.parsed.args[0]),
+                recipientDomainName: command.parsed.lockRecipientDomain,
+                timeoutBlocksOrDuration: command.parsed.unlockFor,
+                timeoutHeight: command.parsed.untilHeight === null ? null : Number.parseInt(command.parsed.untilHeight, 10),
+                conditionHex: command.parsed.conditionHex,
+                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 lock was reconciled instead of creating a duplicate.",
+                fees: result.fees,
+                explorerTxid: result.txid,
+                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 (command.parsed.command === "claim") {
+            const result = await command.context.claimCogLock({
+                lockId: Number.parseInt(command.parsed.args[0], 10),
+                preimageHex: command.parsed.preimageHex,
+                feeRateSatVb: command.parsed.satvb,
+                dataDir: command.dataDir,
+                databasePath: command.dbPath,
+                provider: command.provider,
+                prompter: command.prompter,
+                paths: command.runtimePaths,
+            });
+            return {
+                reusedExisting: result.reusedExisting,
+                reusedMessage: "The existing pending claim was reconciled instead of creating a duplicate.",
+                fees: result.fees,
+                explorerTxid: result.txid,
+                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 (command.parsed.command === "reclaim") {
+            const result = await command.context.reclaimCogLock({
+                lockId: Number.parseInt(command.parsed.args[0], 10),
+                feeRateSatVb: command.parsed.satvb,
+                dataDir: command.dataDir,
+                databasePath: command.dbPath,
+                provider: command.provider,
+                prompter: command.prompter,
+                paths: command.runtimePaths,
+            });
+            return {
+                reusedExisting: result.reusedExisting,
+                reusedMessage: "The existing pending reclaim was reconciled instead of creating a duplicate.",
+                fees: result.fees,
+                explorerTxid: result.txid,
+                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 },
+                    ],
+                },
+            };
+        }
+        throw new Error(`wallet mutation command not implemented: ${command.parsed.command}`);
+    },
+};

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

@@ -0,0 +1,3 @@
+import type { ParsedCliArgs, RequiredCliRunnerContext } from "../../types.js";
+import type { ResolvedWalletMutationCommandContext } from "./types.js";
+export declare function resolveWalletMutationCommandContext(parsed: ParsedCliArgs, context: RequiredCliRunnerContext, runtimePaths?: import("../../../wallet/runtime.js").WalletRuntimePaths): ResolvedWalletMutationCommandContext;

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

@@ -0,0 +1,18 @@
+import { withInteractiveWalletSecretProvider } from "../../../wallet/state/provider.js";
+export function resolveWalletMutationCommandContext(parsed, context, runtimePaths = context.resolveWalletRuntimePaths()) {
+    const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
+    const dbPath = parsed.dbPath ?? context.resolveDefaultClientDatabasePath();
+    const prompter = context.createPrompter();
+    const interactive = prompter.isInteractive;
+    const provider = withInteractiveWalletSecretProvider(context.walletSecretProvider, prompter);
+    return {
+        parsed,
+        context,
+        runtimePaths,
+        dataDir,
+        dbPath,
+        prompter,
+        provider,
+        interactive,
+    };
+}

package/dist/cli/commands/wallet-mutation/domain-admin.d.ts

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

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

@@ -0,0 +1,173 @@
+import { formatDomainAdminEffect, formatDomainAdminPayloadSummary, formatDomainAdminSenderSummary, formatDomainAdminTargetSummary, } from "../../mutation-text-format.js";
+import { commandMutationNextSteps } from "../../mutation-success.js";
+export const domainAdminMutationCommandSpec = {
+    id: "domain-admin",
+    async run(command) {
+        if (command.parsed.command === "domain-endpoint-set" || command.parsed.command === "domain-endpoint-clear") {
+            const result = command.parsed.command === "domain-endpoint-set"
+                ? await command.context.setDomainEndpoint({
+                    domainName: command.parsed.args[0],
+                    source: command.parsed.endpointText !== null
+                        ? { kind: "text", value: command.parsed.endpointText }
+                        : command.parsed.endpointJson !== null
+                            ? { kind: "json", value: command.parsed.endpointJson }
+                            : { kind: "bytes", value: command.parsed.endpointBytes },
+                    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.clearDomainEndpoint({
+                    domainName: command.parsed.args[0],
+                    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 endpoint mutation was reconciled instead of creating a duplicate.",
+                fees: result.fees,
+                explorerTxid: result.txid,
+                nextSteps: commandMutationNextSteps(`cogcoin show ${result.domainName}`),
+                text: {
+                    heading: command.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 (command.parsed.command === "domain-delegate-set" || command.parsed.command === "domain-delegate-clear") {
+            const result = command.parsed.command === "domain-delegate-set"
+                ? await command.context.setDomainDelegate({
+                    domainName: command.parsed.args[0],
+                    target: 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,
+                })
+                : await command.context.clearDomainDelegate({
+                    domainName: command.parsed.args[0],
+                    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 delegate mutation was reconciled instead of creating a duplicate.",
+                fees: result.fees,
+                explorerTxid: result.txid,
+                nextSteps: commandMutationNextSteps(`cogcoin show ${result.domainName}`),
+                text: {
+                    heading: command.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 (command.parsed.command === "domain-miner-set" || command.parsed.command === "domain-miner-clear") {
+            const result = command.parsed.command === "domain-miner-set"
+                ? await command.context.setDomainMiner({
+                    domainName: command.parsed.args[0],
+                    target: 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,
+                })
+                : await command.context.clearDomainMiner({
+                    domainName: command.parsed.args[0],
+                    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 miner mutation was reconciled instead of creating a duplicate.",
+                fees: result.fees,
+                explorerTxid: result.txid,
+                nextSteps: commandMutationNextSteps(`cogcoin show ${result.domainName}`),
+                text: {
+                    heading: command.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 (command.parsed.command === "domain-canonical") {
+            const result = await command.context.setDomainCanonical({
+                domainName: command.parsed.args[0],
+                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 canonical mutation was reconciled instead of creating a duplicate.",
+                fees: result.fees,
+                explorerTxid: result.txid,
+                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 },
+                    ],
+                },
+            };
+        }
+        throw new Error(`wallet mutation command not implemented: ${command.parsed.command}`);
+    },
+};

package/dist/cli/commands/wallet-mutation/domain-market.d.ts

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

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

@@ -0,0 +1,107 @@
+import { parseCogAmountToCogtoshi } from "../../../wallet/tx/index.js";
+import { formatBuyBuyerSummary, formatBuySellerSummary, formatBuySettlementSummary, formatDomainMarketEconomicEffect, formatDomainMarketRecipientSummary, formatDomainMarketSenderSummary, } from "../../mutation-text-format.js";
+import { commandMutationNextSteps, } from "../../mutation-success.js";
+export const domainMarketMutationCommandSpec = {
+    id: "domain-market",
+    async run(command) {
+        if (command.parsed.command === "transfer") {
+            const result = await command.context.transferDomain({
+                domainName: command.parsed.args[0],
+                target: command.parsed.transferTarget,
+                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 transfer was reconciled instead of creating a duplicate.",
+                fees: result.fees,
+                explorerTxid: result.txid,
+                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 (command.parsed.command === "sell" || command.parsed.command === "unsell") {
+            const listedPriceCogtoshi = command.parsed.command === "unsell"
+                ? 0n
+                : parseCogAmountToCogtoshi(command.parsed.args[1]);
+            const result = await command.context.sellDomain({
+                domainName: command.parsed.args[0],
+                listedPriceCogtoshi,
+                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 listing mutation was reconciled instead of creating a duplicate.",
+                fees: result.fees,
+                explorerTxid: result.txid,
+                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 (command.parsed.command === "buy") {
+            const result = await command.context.buyDomain({
+                domainName: command.parsed.args[0],
+                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 purchase was reconciled instead of creating a duplicate.",
+                fees: result.fees,
+                explorerTxid: result.txid,
+                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 },
+                    ],
+                },
+            };
+        }
+        throw new Error(`wallet mutation command not implemented: ${command.parsed.command}`);
+    },
+};

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

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