@cogcoin/client 1.1.8 → 1.1.9

package/dist/wallet/tx/common.js

@@ -1,298 +1,14 @@
-import { saveWalletState } from "../state/storage.js";
-import { createWalletSecretReference, } from "../state/provider.js";
-import { MANAGED_CORE_WALLET_UNLOCK_TIMEOUT_SECONDS, withUnlockedManagedCoreWallet, } from "../managed-core-wallet.js";
 import { reconcilePersistentPolicyLocks as reconcileWalletCoinControlLocks } from "../coin-control.js";
-import { requestMiningGenerationPreemption } from "../mining/coordination.js";
-export const DEFAULT_WALLET_MUTATION_FEE_RATE_SAT_VB = 10;
-export const NEXT_BLOCK_FEE_CONFIRM_TARGET = 1;
-export function isLocalWalletScript(state, scriptPubKeyHex) {
-    if (typeof scriptPubKeyHex !== "string" || scriptPubKeyHex.length === 0) {
-        return false;
-    }
-    return scriptPubKeyHex === state.funding.scriptPubKeyHex
-        || (state.localScriptPubKeyHexes ?? []).includes(scriptPubKeyHex);
-}
-export function createFundingMutationSender(state) {
-    return {
-        localIndex: 0,
-        scriptPubKeyHex: state.funding.scriptPubKeyHex,
-        address: state.funding.address,
-    };
-}
-function btcNumberToSats(value) {
-    return BigInt(Math.round(value * 100_000_000));
-}
-function normalizeSatVb(value) {
-    return Number.parseFloat(value.toFixed(8));
-}
-function satVbFromBtcPerKvB(value) {
-    return normalizeSatVb((value * 100_000_000) / 1_000);
-}
-function valueToSats(value) {
-    return typeof value === "string"
-        ? BigInt(Math.round(Number(value) * 100_000_000))
-        : btcNumberToSats(value);
-}
-function feeRateFromMempoolEntry(entry) {
-    if (!Number.isFinite(entry.vsize) || entry.vsize <= 0) {
-        return null;
-    }
-    const feeSats = Number(btcNumberToSats(entry.fees.base));
-    if (!Number.isFinite(feeSats) || feeSats <= 0) {
-        return null;
-    }
-    return normalizeSatVb(feeSats / entry.vsize);
-}
-export function formatSatVb(value) {
-    return normalizeSatVb(value).toString();
-}
-export function createWalletMutationFeeMetadata(selection) {
-    return {
-        selectedFeeRateSatVb: selection.feeRateSatVb,
-        feeSelectionSource: selection.source,
-    };
-}
-export async function resolveWalletMutationFeeSelection(options) {
-    if (typeof options.feeRateSatVb === "number") {
-        return {
-            feeRateSatVb: normalizeSatVb(options.feeRateSatVb),
-            source: "custom-satvb",
-        };
-    }
-    if (options.rpc.estimateSmartFee !== undefined) {
-        try {
-            const estimate = await options.rpc.estimateSmartFee(NEXT_BLOCK_FEE_CONFIRM_TARGET, "conservative");
-            const estimatedSatVb = typeof estimate.feerate === "number"
-                ? satVbFromBtcPerKvB(estimate.feerate)
-                : null;
-            if (estimatedSatVb !== null && Number.isFinite(estimatedSatVb) && estimatedSatVb > 0) {
-                return {
-                    feeRateSatVb: normalizeSatVb(estimatedSatVb + 1),
-                    source: "estimated-next-block-plus-one",
-                };
-            }
-        }
-        catch {
-            // Fall through to the compatibility default.
-        }
-    }
-    return {
-        feeRateSatVb: DEFAULT_WALLET_MUTATION_FEE_RATE_SAT_VB,
-        source: "fallback-default",
-    };
-}
-export function createWalletMutationFeeSummary(selection, feeSats) {
-    return {
-        feeRateSatVb: selection.feeRateSatVb,
-        feeSats,
-        source: selection.source,
-    };
-}
-export function createBuiltWalletMutationFeeSummary(options) {
-    return createWalletMutationFeeSummary(options.selection, btcNumberToSats(options.built.funded.fee).toString());
-}
-export async function resolvePendingMutationFeeSummary(options) {
-    const source = options.mutation.feeSelectionSource ?? "fallback-default";
-    const selectedFeeRateSatVb = typeof options.mutation.selectedFeeRateSatVb === "number"
-        && Number.isFinite(options.mutation.selectedFeeRateSatVb)
-        && options.mutation.selectedFeeRateSatVb > 0
-        ? normalizeSatVb(options.mutation.selectedFeeRateSatVb)
-        : DEFAULT_WALLET_MUTATION_FEE_RATE_SAT_VB;
-    if (options.mutation.attemptedTxid !== null && options.rpc.getMempoolEntry !== undefined) {
-        try {
-            const entry = await options.rpc.getMempoolEntry(options.mutation.attemptedTxid);
-            const feeRateSatVb = feeRateFromMempoolEntry(entry);
-            if (feeRateSatVb !== null) {
-                return {
-                    feeRateSatVb,
-                    feeSats: btcNumberToSats(entry.fees.base).toString(),
-                    source,
-                };
-            }
-        }
-        catch {
-            // Fall back to stored metadata or the historical default.
-        }
-    }
-    return {
-        feeRateSatVb: selectedFeeRateSatVb,
-        feeSats: null,
-        source,
-    };
-}
-export async function loadAttemptedMutationFixedInputs(options) {
-    if (options.mutation.attemptedTxid === null) {
-        return null;
-    }
-    const txid = options.mutation.attemptedTxid;
-    let decoded = null;
-    if (options.rpc.getTransaction !== undefined) {
-        try {
-            decoded = (await options.rpc.getTransaction(options.walletName, txid)).decoded ?? null;
-        }
-        catch {
-            decoded = null;
-        }
-    }
-    if (decoded === null && options.rpc.getRawTransaction !== undefined) {
-        try {
-            decoded = await options.rpc.getRawTransaction(txid, true);
-        }
-        catch {
-            decoded = null;
-        }
-    }
-    if (decoded === null) {
-        return null;
-    }
-    const fixedInputs = decoded.vin
-        .filter((input) => typeof input.txid === "string" && typeof input.vout === "number")
-        .map((input) => ({
-        txid: input.txid,
-        vout: input.vout,
-    }));
-    return fixedInputs.length > 0 ? fixedInputs : null;
-}
-export async function resolvePendingMutationReuseDecision(options) {
-    const fees = await resolvePendingMutationFeeSummary({
-        rpc: options.rpc,
-        mutation: options.mutation,
-    });
-    if (options.mutation.status === "confirmed"
-        || options.nextFeeSelection.feeRateSatVb <= fees.feeRateSatVb) {
-        return {
-            reuseExisting: true,
-            fees,
-            replacementFixedInputs: null,
-        };
-    }
-    return {
-        reuseExisting: false,
-        fees,
-        replacementFixedInputs: await loadAttemptedMutationFixedInputs({
-            rpc: options.rpc,
-            walletName: options.walletName,
-            mutation: options.mutation,
-        }),
-    };
-}
-export function mergeFixedWalletInputs(fixedInputs, replacementInputs) {
-    if (replacementInputs === null || replacementInputs.length === 0) {
-        return [...fixedInputs];
-    }
-    const merged = new Map();
-    for (const input of fixedInputs) {
-        merged.set(outpointKey(input), { txid: input.txid, vout: input.vout });
-    }
-    for (const input of replacementInputs) {
-        merged.set(outpointKey(input), { txid: input.txid, vout: input.vout });
-    }
-    return [...merged.values()];
-}
-export async function saveWalletStatePreservingUnlock(options) {
-    const secretReference = createWalletSecretReference(options.state.walletRootId);
-    await saveWalletState({
-        primaryPath: options.paths.walletStatePath,
-        backupPath: options.paths.walletStateBackupPath,
-    }, options.state, {
-        provider: options.provider,
-        secretReference,
-    });
-}
-export function formatCogAmount(value) {
-    const sign = value < 0n ? "-" : "";
-    const absolute = value < 0n ? -value : value;
-    const whole = absolute / 100000000n;
-    const fraction = absolute % 100000000n;
-    return `${sign}${whole.toString()}.${fraction.toString().padStart(8, "0")} COG`;
-}
-export function outpointKey(outpoint) {
-    return `${outpoint.txid}:${outpoint.vout}`;
-}
-function isSpendableFundingUtxo(entry, fundingScriptPubKeyHex, minConf) {
-    return entry.scriptPubKey === fundingScriptPubKeyHex
-        && entry.confirmations >= minConf
-        && entry.spendable !== false
-        && entry.safe !== false;
-}
-export function findSpendableFundingInputsFromTransaction(options) {
-    const minConf = options.minConf ?? 0;
-    return options.allUtxos
-        .filter((entry) => entry.txid === options.txid
-        && isSpendableFundingUtxo(entry, options.fundingScriptPubKeyHex, minConf))
-        .sort((left, right) => left.vout - right.vout
-        || left.txid.localeCompare(right.txid))
-        .map((entry) => ({
-        txid: entry.txid,
-        vout: entry.vout,
-    }));
-}
-export function updateMutationRecord(mutation, status, nowUnixMs, options = {}) {
-    return {
-        ...mutation,
-        status,
-        lastUpdatedAtUnixMs: nowUnixMs,
-        attemptedTxid: options.attemptedTxid ?? mutation.attemptedTxid,
-        attemptedWtxid: options.attemptedWtxid ?? mutation.attemptedWtxid,
-        temporaryBuilderLockedOutpoints: options.temporaryBuilderLockedOutpoints ?? mutation.temporaryBuilderLockedOutpoints,
-        selectedFeeRateSatVb: options.selectedFeeRateSatVb ?? mutation.selectedFeeRateSatVb,
-        feeSelectionSource: options.feeSelectionSource ?? mutation.feeSelectionSource,
-    };
-}
-export async function unlockTemporaryBuilderLocks(rpc, walletName, outpoints) {
-    if (outpoints.length === 0 || rpc.lockUnspent === undefined) {
-        return;
-    }
-    await rpc.lockUnspent(walletName, true, outpoints).catch(() => undefined);
-}
-export function diffTemporaryLockedOutpoints(before, after) {
-    const beforeKeys = new Set(before.map((entry) => outpointKey(entry)));
-    return after
-        .filter((entry) => !beforeKeys.has(outpointKey(entry)))
-        .map((entry) => ({
-        txid: entry.txid,
-        vout: entry.vout,
-    }));
-}
-export function getDecodedInputVout(input) {
-    return typeof input.vout === "number" ? input.vout : null;
-}
-export function getDecodedInputScriptPubKeyHex(decoded, inputIndex) {
-    const input = decoded.tx.vin[inputIndex];
-    if (input === undefined) {
-        return null;
-    }
-    const prevoutScriptPubKeyHex = input.prevout?.scriptPubKey?.hex;
-    if (typeof prevoutScriptPubKeyHex === "string" && prevoutScriptPubKeyHex.length > 0) {
-        return prevoutScriptPubKeyHex;
-    }
-    const psbtInput = decoded.inputs?.[inputIndex];
-    const witnessScriptPubKeyHex = psbtInput?.witness_utxo?.scriptPubKey?.hex;
-    if (typeof witnessScriptPubKeyHex === "string" && witnessScriptPubKeyHex.length > 0) {
-        return witnessScriptPubKeyHex;
-    }
-    const vout = getDecodedInputVout(input);
-    if (vout === null) {
-        return null;
-    }
-    const nonWitnessScriptPubKeyHex = psbtInput?.non_witness_utxo?.vout
-        .find((output) => output.n === vout)
-        ?.scriptPubKey?.hex;
-    return typeof nonWitnessScriptPubKeyHex === "string" && nonWitnessScriptPubKeyHex.length > 0
-        ? nonWitnessScriptPubKeyHex
-        : null;
-}
-export function inputMatchesOutpoint(input, outpoint) {
-    return input.txid === outpoint.txid && getDecodedInputVout(input) === outpoint.vout;
-}
-export function assertFixedInputPrefixMatches(inputs, fixedInputs, errorCode) {
-    void inputs;
-    void fixedInputs;
-    void errorCode;
-}
-export function assertFundingInputsAfterFixedPrefix(options) {
-    void options;
-}
+export * from "./types.js";
+export * from "./primitives.js";
+export * from "./fee.js";
+export * from "./reconcile.js";
+export * from "./state-persist.js";
+export * from "./psbt-assert.js";
+export * from "./readiness.js";
+export * from "./mining-preemption.js";
+export * from "./signing.js";
+export * from "./draft-build.js";
 export async function reconcilePersistentPolicyLocks(options) {
     await reconcileWalletCoinControlLocks({
         rpc: options.rpc,
@@ -320,202 +36,3 @@ export function isInsufficientFundsError(error) {
     const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
     return message.includes("insufficient funds");
 }
-function isReserveFloorFundingError(error) {
-    void error;
-    return false;
-}
-function computeRemainingFundingValueSats(options) {
-    let remaining = 0n;
-    for (const value of options.availableFundingValueByKey.values()) {
-        remaining += value;
-    }
-    for (const [index, input] of options.decoded.tx.vin.entries()) {
-        const scriptPubKeyHex = getDecodedInputScriptPubKeyHex(options.decoded, index);
-        const vout = getDecodedInputVout(input);
-        if (scriptPubKeyHex !== options.fundingScriptPubKeyHex || vout === null || typeof input.txid !== "string") {
-            continue;
-        }
-        remaining -= options.availableFundingValueByKey.get(outpointKey({
-            txid: input.txid,
-            vout,
-        })) ?? 0n;
-    }
-    for (const output of options.decoded.tx.vout) {
-        if (output.scriptPubKey?.hex !== options.fundingScriptPubKeyHex) {
-            continue;
-        }
-        remaining += valueToSats(output.value);
-    }
-    return remaining;
-}
-export function assertWalletMutationContextReady(context, errorPrefix) {
-    if (context.localState.availability === "uninitialized") {
-        throw new Error("wallet_uninitialized");
-    }
-    if (context.localState.clientPasswordReadiness === "setup-required") {
-        throw new Error("wallet_client_password_setup_required");
-    }
-    if (context.localState.clientPasswordReadiness === "migration-required") {
-        throw new Error("wallet_client_password_migration_required");
-    }
-    if (context.localState.unlockRequired) {
-        throw new Error("wallet_client_password_locked");
-    }
-    if (context.localState.availability === "local-state-corrupt") {
-        throw new Error("local-state-corrupt");
-    }
-    if (context.localState.availability !== "ready" || context.localState.state === null) {
-        throw new Error("wallet_secret_provider_unavailable");
-    }
-    if (context.bitcoind.health !== "ready") {
-        throw new Error(`${errorPrefix}_bitcoind_${context.bitcoind.health.replaceAll("-", "_")}`);
-    }
-    if (context.nodeHealth !== "synced") {
-        throw new Error(`${errorPrefix}_node_${context.nodeHealth.replaceAll("-", "_")}`);
-    }
-    if (context.indexer.health !== "synced" || context.snapshot === null || context.model === null) {
-        throw new Error(`${errorPrefix}_indexer_${context.indexer.health.replaceAll("-", "_")}`);
-    }
-    if (context.nodeStatus?.walletReplica?.proofStatus !== "ready") {
-        throw new Error(`${errorPrefix}_core_replica_not_ready`);
-    }
-}
-export function assertWalletBitcoinTransferContextReady(context, errorPrefix) {
-    if (context.localState.availability === "uninitialized") {
-        throw new Error("wallet_uninitialized");
-    }
-    if (context.localState.clientPasswordReadiness === "setup-required") {
-        throw new Error("wallet_client_password_setup_required");
-    }
-    if (context.localState.clientPasswordReadiness === "migration-required") {
-        throw new Error("wallet_client_password_migration_required");
-    }
-    if (context.localState.unlockRequired) {
-        throw new Error("wallet_client_password_locked");
-    }
-    if (context.localState.availability === "local-state-corrupt") {
-        throw new Error("local-state-corrupt");
-    }
-    if (context.localState.availability !== "ready" || context.localState.state === null) {
-        throw new Error("wallet_secret_provider_unavailable");
-    }
-    if (context.bitcoind.health !== "ready") {
-        throw new Error(`${errorPrefix}_bitcoind_${context.bitcoind.health.replaceAll("-", "_")}`);
-    }
-    if (context.nodeHealth !== "synced") {
-        throw new Error(`${errorPrefix}_node_${context.nodeHealth.replaceAll("-", "_")}`);
-    }
-    if (context.nodeStatus?.walletReplica?.proofStatus !== "ready") {
-        throw new Error(`${errorPrefix}_core_replica_not_ready`);
-    }
-}
-export async function pauseMiningForWalletMutation(options) {
-    return requestMiningGenerationPreemption({
-        paths: options.paths,
-        reason: options.reason,
-    });
-}
-export async function buildWalletMutationTransaction(options) {
-    const temporaryBuilderLockedOutpoints = [];
-    try {
-        const { funded, decoded } = await fundAndValidateWalletMutationDraft({
-            rpc: options.rpc,
-            walletName: options.walletName,
-            plan: options.plan,
-            validateFundedDraft: options.validateFundedDraft,
-            feeRate: options.feeRate,
-            availableFundingMinConf: options.availableFundingMinConf,
-        });
-        let signed;
-        let finalized;
-        let rawHex;
-        let decodedRaw;
-        ({ signed, finalized, rawHex, decodedRaw } = await withUnlockedManagedCoreWallet({
-            rpc: options.rpc,
-            walletName: options.walletName,
-            internalPassphrase: options.state.managedCoreWallet.internalPassphrase,
-            timeoutSeconds: MANAGED_CORE_WALLET_UNLOCK_TIMEOUT_SECONDS,
-            recoverLockedWalletOnce: options.recoverManagedCoreWalletLockedOnce,
-            onLockedWalletRecoveryOutcome: options.onManagedCoreWalletLockedRecoveryOutcome,
-            run: async () => {
-                const signed = await options.rpc.walletProcessPsbt(options.walletName, funded.psbt, true, "DEFAULT");
-                const finalized = await options.rpc.finalizePsbt(signed.psbt, true);
-                if (!finalized.complete || finalized.hex == null) {
-                    throw new Error(options.finalizeErrorCode);
-                }
-                const rawHex = finalized.hex;
-                const decodedRaw = await options.rpc.decodeRawTransaction(rawHex);
-                const mempoolResult = await options.rpc.testMempoolAccept([rawHex]);
-                const accepted = mempoolResult[0];
-                if (accepted == null || !accepted.allowed) {
-                    throw new Error(`${options.mempoolRejectPrefix}_${accepted?.["reject-reason"] ?? "unknown"}`);
-                }
-                return {
-                    signed,
-                    finalized,
-                    rawHex,
-                    decodedRaw,
-                };
-            },
-        }));
-        return {
-            funded,
-            decoded,
-            psbt: signed.psbt,
-            rawHex,
-            txid: decodedRaw.txid,
-            wtxid: decodedRaw.hash ?? null,
-            temporaryBuilderLockedOutpoints,
-        };
-    }
-    catch (error) {
-        await unlockTemporaryBuilderLocks(options.rpc, options.walletName, temporaryBuilderLockedOutpoints);
-        throw error;
-    }
-}
-export async function fundAndValidateWalletMutationDraft(options) {
-    const availableFundingMinConf = options.availableFundingMinConf ?? 1;
-    const availableFundingUtxos = (await options.rpc.listUnspent(options.walletName, availableFundingMinConf))
-        .filter((entry) => isSpendableFundingUtxo(entry, options.plan.allowedFundingScriptPubKeyHex, availableFundingMinConf));
-    const availableFundingValueByKey = new Map(availableFundingUtxos.map((entry) => [
-        outpointKey({ txid: entry.txid, vout: entry.vout }),
-        btcNumberToSats(entry.amount),
-    ]));
-    const validationPlan = {
-        ...options.plan,
-        eligibleFundingOutpointKeys: new Set([
-            ...options.plan.eligibleFundingOutpointKeys,
-            ...availableFundingUtxos.map((entry) => outpointKey({ txid: entry.txid, vout: entry.vout })),
-        ]),
-    };
-    const funded = await options.rpc.walletCreateFundedPsbt(options.walletName, options.plan.fixedInputs, options.plan.outputs, 0, {
-        add_inputs: true,
-        include_unsafe: false,
-        minconf: availableFundingMinConf,
-        changeAddress: options.plan.changeAddress,
-        ...(options.plan.changePosition == null ? {} : { changePosition: options.plan.changePosition }),
-        lockUnspents: false,
-        fee_rate: options.feeRate ?? DEFAULT_WALLET_MUTATION_FEE_RATE_SAT_VB,
-        replaceable: true,
-        subtractFeeFromOutputs: [],
-    });
-    const decoded = await options.rpc.decodePsbt(funded.psbt);
-    options.validateFundedDraft(decoded, funded, validationPlan);
-    return {
-        funded,
-        decoded,
-    };
-}
-export async function buildWalletMutationTransactionWithReserveFallback(options) {
-    return buildWalletMutationTransaction({
-        rpc: options.rpc,
-        walletName: options.walletName,
-        state: options.state,
-        plan: options.plan,
-        validateFundedDraft: options.validateFundedDraft,
-        finalizeErrorCode: options.finalizeErrorCode,
-        mempoolRejectPrefix: options.mempoolRejectPrefix,
-        feeRate: options.feeRate,
-        availableFundingMinConf: options.availableFundingMinConf,
-    });
-}

package/dist/wallet/tx/domain-admin/confirm.d.ts

@@ -0,0 +1,17 @@
+import type { WalletPrompter } from "../../lifecycle.js";
+import type { DomainAdminResolvedSenderSummary } from "./types.js";
+import { normalizeBtcTarget } from "../targets.js";
+export declare function confirmEndpointMutation(prompter: WalletPrompter, domainName: string, payload: Uint8Array, options: {
+    clear: boolean;
+    sender: DomainAdminResolvedSenderSummary;
+    sourceKind?: "text" | "json" | "bytes";
+    assumeYes?: boolean;
+}): Promise<void>;
+export declare function confirmTargetMutation(prompter: WalletPrompter, options: {
+    kind: "delegate" | "miner";
+    domainName: string;
+    target: ReturnType<typeof normalizeBtcTarget> | null;
+    sender: DomainAdminResolvedSenderSummary;
+    assumeYes?: boolean;
+}): Promise<void>;
+export declare function confirmCanonicalMutation(prompter: WalletPrompter, domainName: string, sender: DomainAdminResolvedSenderSummary, assumeYes?: boolean): Promise<void>;

package/dist/wallet/tx/domain-admin/confirm.js

@@ -0,0 +1,58 @@
+import { confirmYesNo } from "../confirm.js";
+import { normalizeBtcTarget } from "../targets.js";
+export async function confirmEndpointMutation(prompter, domainName, payload, options) {
+    prompter.writeLine(`${options.clear ? "Clearing" : "Updating"} endpoint for "${domainName}".`);
+    prompter.writeLine(`Resolved sender: ${options.sender.selector} (${options.sender.address})`);
+    prompter.writeLine(options.clear
+        ? "Effect: clear the endpoint payload."
+        : `Effect: set the endpoint payload to ${payload.length} bytes.`);
+    if (!options.clear) {
+        prompter.writeLine(`Payload bytes: ${payload.length}`);
+        if (options.sourceKind !== undefined) {
+            prompter.writeLine(`Payload source: ${options.sourceKind}`);
+        }
+        prompter.writeLine("Warning: endpoint data is public in the mempool and on-chain.");
+    }
+    await confirmYesNo(prompter, options.clear
+        ? "This publishes a standalone anchored endpoint clear."
+        : "This publishes a standalone anchored endpoint update.", {
+        assumeYes: options.assumeYes,
+        errorCode: "wallet_domain_endpoint_confirmation_rejected",
+        requiresTtyErrorCode: "wallet_domain_endpoint_requires_tty",
+    });
+}
+export async function confirmTargetMutation(prompter, options) {
+    prompter.writeLine(`${options.target === null ? "Clearing" : "Updating"} ${options.kind} for "${options.domainName}".`);
+    prompter.writeLine(`Resolved sender: ${options.sender.selector} (${options.sender.address})`);
+    if (options.target === null) {
+        prompter.writeLine(`Effect: clear the ${options.kind === "delegate" ? "delegate" : "designated miner"} target.`);
+        await confirmYesNo(prompter, `This clears the current ${options.kind} target.`, {
+            assumeYes: options.assumeYes,
+            errorCode: `wallet_domain_${options.kind}_confirmation_rejected`,
+            requiresTtyErrorCode: `wallet_domain_${options.kind}_requires_tty`,
+        });
+        return;
+    }
+    prompter.writeLine(`Resolved target: ${options.target.address ?? `spk:${options.target.scriptPubKeyHex}`}`);
+    prompter.writeLine(`Effect: set the ${options.kind === "delegate" ? "delegate" : "designated miner"} target.`);
+    if (options.kind === "miner" && options.target.scriptPubKeyHex === options.sender.scriptPubKeyHex) {
+        prompter.writeLine("Warning: setting the designated miner to the current owner is usually redundant.");
+    }
+    await confirmYesNo(prompter, options.kind === "delegate"
+        ? "This changes who may act for the domain as delegate."
+        : "This changes who may mine for the domain as designated miner.", {
+        assumeYes: options.assumeYes,
+        errorCode: `wallet_domain_${options.kind}_confirmation_rejected`,
+        requiresTtyErrorCode: `wallet_domain_${options.kind}_requires_tty`,
+    });
+}
+export async function confirmCanonicalMutation(prompter, domainName, sender, assumeYes = false) {
+    prompter.writeLine(`Canonicalizing "${domainName}" as the anchored owner.`);
+    prompter.writeLine(`Resolved sender: ${sender.selector} (${sender.address})`);
+    prompter.writeLine("Effect: canonicalize the current anchored owner.");
+    await confirmYesNo(prompter, "This publishes a standalone SET_CANONICAL operation.", {
+        assumeYes,
+        errorCode: "wallet_domain_canonical_confirmation_rejected",
+        requiresTtyErrorCode: "wallet_domain_canonical_requires_tty",
+    });
+}

package/dist/wallet/tx/domain-admin/draft.d.ts

@@ -0,0 +1,20 @@
+import type { WalletRuntimePaths } from "../../runtime.js";
+import type { WalletSecretProvider } from "../../state/provider.js";
+import type { PendingMutationRecord, WalletStateV1 } from "../../types.js";
+import type { WalletReadContext } from "../../read/index.js";
+import type { DomainAdminDraftMutationOptions, DomainAdminRpcClient } from "./types.js";
+export declare function createDomainAdminDraftMutation(options: DomainAdminDraftMutationOptions): PendingMutationRecord;
+export declare function reconcilePendingAdminMutation(options: {
+    state: WalletStateV1;
+    mutation: PendingMutationRecord;
+    provider: WalletSecretProvider;
+    nowUnixMs: number;
+    paths: WalletRuntimePaths;
+    rpc: DomainAdminRpcClient;
+    walletName: string;
+    context: WalletReadContext;
+}): Promise<{
+    state: WalletStateV1;
+    mutation: PendingMutationRecord;
+    resolution: "confirmed" | "live" | "repair-required" | "not-seen" | "continue";
+}>;