@cogcoin/client 1.1.7 → 1.1.9

package/dist/wallet/tx/anchor/confirm.d.ts

@@ -0,0 +1,15 @@
+import type { WalletPrompter } from "../../lifecycle.js";
+export interface AnchorFoundingMessage {
+    text: string | null;
+    payloadHex: string | null;
+}
+export declare function resolveFoundingMessage(options: {
+    foundingMessageText: string | null | undefined;
+    promptForFoundingMessageWhenMissing?: boolean;
+    prompter: WalletPrompter;
+}): Promise<AnchorFoundingMessage>;
+export declare function confirmDirectAnchor(prompter: WalletPrompter, options: {
+    domainName: string;
+    walletAddress: string;
+    foundingMessageText: string | null;
+}): Promise<void>;

package/dist/wallet/tx/anchor/confirm.js

@@ -0,0 +1,60 @@
+import { encodeSentence } from "@cogcoin/scoring";
+function encodeFoundingMessage(foundingMessageText) {
+    const trimmed = foundingMessageText?.trim() ?? "";
+    if (trimmed === "") {
+        return Promise.resolve({
+            text: null,
+            payloadHex: null,
+        });
+    }
+    return encodeSentence(trimmed)
+        .then((payload) => ({
+        text: trimmed,
+        payloadHex: Buffer.from(payload).toString("hex"),
+    }))
+        .catch((error) => {
+        throw new Error(error instanceof Error ? `wallet_anchor_invalid_message_${error.message}` : "wallet_anchor_invalid_message");
+    });
+}
+function extractAnchorInvalidMessageReason(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message === "wallet_anchor_invalid_message") {
+        return null;
+    }
+    if (!message.startsWith("wallet_anchor_invalid_message_")) {
+        return null;
+    }
+    const reason = message.slice("wallet_anchor_invalid_message_".length).trim();
+    return reason === "" ? null : reason;
+}
+export async function resolveFoundingMessage(options) {
+    if (!options.promptForFoundingMessageWhenMissing || options.foundingMessageText != null) {
+        return encodeFoundingMessage(options.foundingMessageText ?? null);
+    }
+    for (;;) {
+        const answer = await options.prompter.prompt("Founding message (optional, press Enter to skip): ");
+        try {
+            return await encodeFoundingMessage(answer);
+        }
+        catch (error) {
+            const reason = extractAnchorInvalidMessageReason(error);
+            options.prompter.writeLine("Founding message cannot be encoded in canonical Coglex.");
+            if (reason !== null) {
+                options.prompter.writeLine(`Reason: ${reason}`);
+            }
+        }
+    }
+}
+export async function confirmDirectAnchor(prompter, options) {
+    prompter.writeLine(`You are anchoring "${options.domainName}".`);
+    prompter.writeLine(`Wallet address: ${options.walletAddress}`);
+    prompter.writeLine("Anchoring publishes a standalone DOMAIN_ANCHOR from the local wallet address.");
+    if (options.foundingMessageText !== null) {
+        prompter.writeLine("The founding message bytes will be public in mempool and on-chain.");
+        prompter.writeLine(`Founding message: ${options.foundingMessageText}`);
+    }
+    const answer = (await prompter.prompt("Type the domain name to continue: ")).trim();
+    if (answer !== options.domainName) {
+        throw new Error("wallet_anchor_confirmation_rejected");
+    }
+}

package/dist/wallet/tx/anchor/draft.d.ts

@@ -0,0 +1,39 @@
+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 WalletMutationFeeSelection } from "../common.js";
+import type { AnchorMutationOperation, WalletAnchorRpcClient } from "./intent.js";
+export declare function createDraftAnchorMutation(options: {
+    state: WalletStateV1;
+    domainName: string;
+    intentFingerprintHex: string;
+    nowUnixMs: number;
+    feeSelection: WalletMutationFeeSelection;
+    existing?: PendingMutationRecord | null;
+}): PendingMutationRecord;
+export declare function upsertAnchoredDomainRecord(options: {
+    state: WalletStateV1;
+    domainName: string;
+    domainId: number;
+    foundingMessageText: string | null;
+}): WalletStateV1;
+export declare function anchorConfirmedOnSnapshot(options: {
+    snapshot: NonNullable<WalletReadContext["snapshot"]>;
+    state: WalletStateV1;
+    domainName: string;
+}): boolean;
+export declare function reconcilePendingAnchorMutation(options: {
+    operation: AnchorMutationOperation;
+    mutation: PendingMutationRecord;
+    provider: WalletSecretProvider;
+    nowUnixMs: number;
+    paths: WalletRuntimePaths;
+    rpc: WalletAnchorRpcClient;
+    walletName: string;
+    context: WalletReadContext;
+}): Promise<{
+    state: WalletStateV1;
+    mutation: PendingMutationRecord;
+    resolution: "confirmed" | "live" | "repair-required" | "not-seen" | "continue";
+}>;

package/dist/wallet/tx/anchor/draft.js

@@ -0,0 +1,167 @@
+import { randomBytes } from "node:crypto";
+import { lookupDomain } from "@cogcoin/indexer/queries";
+import { createWalletMutationFeeMetadata, unlockTemporaryBuilderLocks, updateMutationRecord, } from "../common.js";
+import { persistWalletMutationState } from "../executor.js";
+import { upsertPendingMutation } from "../journal.js";
+export function createDraftAnchorMutation(options) {
+    const existing = options.existing ?? null;
+    if (existing !== null) {
+        return {
+            ...existing,
+            kind: "anchor",
+            domainName: options.domainName,
+            parentDomainName: null,
+            senderScriptPubKeyHex: options.state.funding.scriptPubKeyHex,
+            senderLocalIndex: 0,
+            intentFingerprintHex: options.intentFingerprintHex,
+            status: "draft",
+            lastUpdatedAtUnixMs: options.nowUnixMs,
+            attemptedTxid: null,
+            attemptedWtxid: null,
+            ...createWalletMutationFeeMetadata(options.feeSelection),
+            temporaryBuilderLockedOutpoints: [],
+        };
+    }
+    return {
+        mutationId: randomBytes(12).toString("hex"),
+        kind: "anchor",
+        domainName: options.domainName,
+        parentDomainName: null,
+        senderScriptPubKeyHex: options.state.funding.scriptPubKeyHex,
+        senderLocalIndex: 0,
+        intentFingerprintHex: options.intentFingerprintHex,
+        status: "draft",
+        createdAtUnixMs: options.nowUnixMs,
+        lastUpdatedAtUnixMs: options.nowUnixMs,
+        attemptedTxid: null,
+        attemptedWtxid: null,
+        ...createWalletMutationFeeMetadata(options.feeSelection),
+        temporaryBuilderLockedOutpoints: [],
+    };
+}
+export function upsertAnchoredDomainRecord(options) {
+    const domains = options.state.domains.slice();
+    const existingIndex = domains.findIndex((entry) => entry.name === options.domainName);
+    const current = existingIndex >= 0 ? domains[existingIndex] : null;
+    const nextRecord = {
+        name: options.domainName,
+        domainId: options.domainId,
+        currentOwnerScriptPubKeyHex: options.state.funding.scriptPubKeyHex,
+        canonicalChainStatus: "anchored",
+        foundingMessageText: options.foundingMessageText ?? current?.foundingMessageText ?? null,
+        birthTime: current?.birthTime ?? options.state.lastWrittenAtUnixMs,
+    };
+    if (existingIndex >= 0) {
+        domains[existingIndex] = nextRecord;
+    }
+    else {
+        domains.push(nextRecord);
+    }
+    return {
+        ...options.state,
+        domains,
+    };
+}
+export function anchorConfirmedOnSnapshot(options) {
+    const chainDomain = lookupDomain(options.snapshot.state, options.domainName);
+    if (chainDomain === null || !chainDomain.anchored) {
+        return false;
+    }
+    const ownerHex = Buffer.from(chainDomain.ownerScriptPubKey).toString("hex");
+    return ownerHex === options.state.funding.scriptPubKeyHex
+        || (options.state.localScriptPubKeyHexes ?? []).includes(ownerHex);
+}
+async function saveState(options) {
+    return persistWalletMutationState(options);
+}
+export async function reconcilePendingAnchorMutation(options) {
+    if (options.mutation.status === "repair-required") {
+        return {
+            state: options.operation.state,
+            mutation: options.mutation,
+            resolution: "repair-required",
+        };
+    }
+    if (options.context.snapshot !== null && anchorConfirmedOnSnapshot({
+        snapshot: options.context.snapshot,
+        state: options.operation.state,
+        domainName: options.mutation.domainName,
+    })) {
+        await unlockTemporaryBuilderLocks(options.rpc, options.walletName, options.mutation.temporaryBuilderLockedOutpoints);
+        const confirmedMutation = updateMutationRecord(options.mutation, "confirmed", options.nowUnixMs, {
+            temporaryBuilderLockedOutpoints: [],
+        });
+        const chainDomain = lookupDomain(options.context.snapshot.state, options.mutation.domainName);
+        const nextState = upsertAnchoredDomainRecord({
+            state: upsertPendingMutation(options.operation.state, confirmedMutation),
+            domainName: options.mutation.domainName,
+            domainId: chainDomain?.domainId ?? 0,
+            foundingMessageText: options.operation.message.text,
+        });
+        return {
+            state: await saveState({
+                state: nextState,
+                provider: options.provider,
+                nowUnixMs: options.nowUnixMs,
+                paths: options.paths,
+            }),
+            mutation: confirmedMutation,
+            resolution: "confirmed",
+        };
+    }
+    if (options.mutation.attemptedTxid !== null) {
+        const mempool = await options.rpc.getRawMempool().catch(() => []);
+        if (mempool.includes(options.mutation.attemptedTxid)) {
+            await unlockTemporaryBuilderLocks(options.rpc, options.walletName, options.mutation.temporaryBuilderLockedOutpoints);
+            const liveMutation = updateMutationRecord(options.mutation, "live", options.nowUnixMs, {
+                temporaryBuilderLockedOutpoints: [],
+            });
+            const domainId = (options.context.snapshot === null
+                ? null
+                : lookupDomain(options.context.snapshot.state, options.mutation.domainName)?.domainId)
+                ?? options.operation.state.domains.find((domain) => domain.name === options.mutation.domainName)?.domainId
+                ?? 0;
+            const nextState = upsertAnchoredDomainRecord({
+                state: upsertPendingMutation(options.operation.state, liveMutation),
+                domainName: options.mutation.domainName,
+                domainId,
+                foundingMessageText: options.operation.message.text,
+            });
+            return {
+                state: await saveState({
+                    state: nextState,
+                    provider: options.provider,
+                    nowUnixMs: options.nowUnixMs,
+                    paths: options.paths,
+                }),
+                mutation: liveMutation,
+                resolution: "live",
+            };
+        }
+    }
+    if (options.mutation.status === "broadcast-unknown"
+        || options.mutation.status === "live"
+        || options.mutation.status === "draft"
+        || options.mutation.status === "broadcasting") {
+        await unlockTemporaryBuilderLocks(options.rpc, options.walletName, options.mutation.temporaryBuilderLockedOutpoints);
+        const canceledMutation = updateMutationRecord(options.mutation, "canceled", options.nowUnixMs, {
+            temporaryBuilderLockedOutpoints: [],
+        });
+        const nextState = upsertPendingMutation(options.operation.state, canceledMutation);
+        return {
+            state: await saveState({
+                state: nextState,
+                provider: options.provider,
+                nowUnixMs: options.nowUnixMs,
+                paths: options.paths,
+            }),
+            mutation: canceledMutation,
+            resolution: "not-seen",
+        };
+    }
+    return {
+        state: options.operation.state,
+        mutation: options.mutation,
+        resolution: "continue",
+    };
+}

package/dist/wallet/tx/anchor/index.d.ts

@@ -0,0 +1,5 @@
+import { type AnchorDomainOptions } from "./intent.js";
+import { type AnchorDomainResult } from "./result.js";
+export type { AnchorDomainOptions } from "./intent.js";
+export type { AnchorDomainResult } from "./result.js";
+export declare function anchorDomain(options: AnchorDomainOptions): Promise<AnchorDomainResult>;

package/dist/wallet/tx/anchor/index.js

@@ -0,0 +1,148 @@
+import { buildWalletMutationTransactionWithReserveFallback, mergeFixedWalletInputs, updateMutationRecord, } from "../common.js";
+import { executeWalletMutationOperation, publishWalletMutation, resolveExistingWalletMutation, } from "../executor.js";
+import { upsertPendingMutation } from "../journal.js";
+import { confirmDirectAnchor, resolveFoundingMessage } from "./confirm.js";
+import { anchorConfirmedOnSnapshot, createDraftAnchorMutation, reconcilePendingAnchorMutation, upsertAnchoredDomainRecord, } from "./draft.js";
+import { buildDirectAnchorPlan, createAnchorOperationFingerprint, normalizeAnchorDomainName, resolveAnchorOperation, } from "./intent.js";
+import { validateDirectAnchorDraft } from "./plan.js";
+import { createAnchorResult, createAnchorReuseResult, } from "./result.js";
+export async function anchorDomain(options) {
+    if (!options.prompter.isInteractive) {
+        throw new Error("wallet_anchor_requires_tty");
+    }
+    const normalizedDomainName = normalizeAnchorDomainName(options.domainName);
+    const execution = await executeWalletMutationOperation({
+        ...options,
+        controlLockPurpose: "wallet-anchor",
+        preemptionReason: "wallet-anchor",
+        async resolveOperation(readContext) {
+            const message = await resolveFoundingMessage({
+                foundingMessageText: options.foundingMessageText,
+                promptForFoundingMessageWhenMissing: options.promptForFoundingMessageWhenMissing,
+                prompter: options.prompter,
+            });
+            return resolveAnchorOperation({
+                readContext,
+                normalizedDomainName,
+                message,
+            });
+        },
+        createIntentFingerprint(operation) {
+            return createAnchorOperationFingerprint(operation);
+        },
+        async resolveExistingMutation({ operation, existingMutation, execution }) {
+            if (existingMutation === null) {
+                return { state: operation.state, replacementFixedInputs: null, result: null };
+            }
+            return resolveExistingWalletMutation({
+                existingMutation,
+                execution,
+                repairRequiredErrorCode: "wallet_anchor_repair_required",
+                reconcileExistingMutation: (mutation) => reconcilePendingAnchorMutation({
+                    operation,
+                    mutation,
+                    provider: execution.provider,
+                    nowUnixMs: execution.nowUnixMs,
+                    paths: execution.paths,
+                    rpc: execution.rpc,
+                    walletName: execution.walletName,
+                    context: execution.readContext,
+                }),
+                createReuseResult: ({ mutation, resolution, fees }) => createAnchorReuseResult({
+                    operation,
+                    mutation,
+                    resolution,
+                    fees,
+                }),
+            });
+        },
+        confirm({ operation }) {
+            return confirmDirectAnchor(options.prompter, {
+                domainName: operation.normalizedDomainName,
+                walletAddress: operation.state.funding.address,
+                foundingMessageText: operation.message.text,
+            });
+        },
+        createDraftMutation({ operation, existingMutation, execution, intentFingerprintHex }) {
+            return {
+                mutation: createDraftAnchorMutation({
+                    state: operation.state,
+                    domainName: operation.normalizedDomainName,
+                    intentFingerprintHex,
+                    nowUnixMs: execution.nowUnixMs,
+                    feeSelection: execution.feeSelection,
+                    existing: existingMutation ?? null,
+                }),
+                prepared: null,
+            };
+        },
+        async build({ operation, state, execution, replacementFixedInputs }) {
+            const directAnchorPlan = buildDirectAnchorPlan({
+                state,
+                allUtxos: await execution.rpc.listUnspent(execution.walletName, 1),
+                domainId: operation.chainDomain.domainId,
+                foundingMessagePayloadHex: operation.message.payloadHex,
+            });
+            return buildWalletMutationTransactionWithReserveFallback({
+                rpc: execution.rpc,
+                walletName: execution.walletName,
+                state,
+                plan: {
+                    ...directAnchorPlan,
+                    fixedInputs: mergeFixedWalletInputs(directAnchorPlan.fixedInputs, replacementFixedInputs),
+                },
+                validateFundedDraft: validateDirectAnchorDraft,
+                finalizeErrorCode: "wallet_anchor_finalize_failed",
+                mempoolRejectPrefix: "wallet_anchor_mempool_rejected",
+                feeRate: execution.feeSelection.feeRateSatVb,
+            });
+        },
+        publish({ operation, state, execution, built, mutation }) {
+            return publishWalletMutation({
+                rpc: execution.rpc,
+                walletName: execution.walletName,
+                snapshotHeight: execution.readContext.snapshot?.tip?.height ?? null,
+                built,
+                mutation,
+                state,
+                provider: execution.provider,
+                nowUnixMs: execution.nowUnixMs,
+                paths: execution.paths,
+                errorPrefix: "wallet_anchor",
+                async afterAccepted({ state: acceptedState, broadcastingMutation, built, nowUnixMs }) {
+                    const finalStatus = anchorConfirmedOnSnapshot({
+                        snapshot: execution.readContext.snapshot,
+                        state: acceptedState,
+                        domainName: operation.normalizedDomainName,
+                    }) ? "confirmed" : "live";
+                    const finalMutation = updateMutationRecord(broadcastingMutation, finalStatus, nowUnixMs, {
+                        attemptedTxid: built.txid,
+                        attemptedWtxid: built.wtxid,
+                        temporaryBuilderLockedOutpoints: [],
+                    });
+                    return {
+                        state: upsertAnchoredDomainRecord({
+                            state: upsertPendingMutation(acceptedState, finalMutation),
+                            domainName: operation.normalizedDomainName,
+                            domainId: operation.chainDomain.domainId,
+                            foundingMessageText: operation.message.text,
+                        }),
+                        mutation: finalMutation,
+                        status: finalStatus,
+                    };
+                },
+            });
+        },
+        createResult({ operation, mutation, built, status, reusedExisting, fees }) {
+            return createAnchorResult({
+                operation,
+                mutation,
+                builtTxid: built?.txid ?? null,
+                status: status,
+                reusedExisting,
+                fees,
+            });
+        },
+    });
+    return execution.result;
+}

package/dist/wallet/tx/anchor/intent.d.ts

@@ -0,0 +1,61 @@
+import { lookupDomain } from "@cogcoin/indexer/queries";
+import { attachOrStartManagedBitcoindService } from "../../../bitcoind/service.js";
+import { createRpcClient } from "../../../bitcoind/node.js";
+import type { RpcListUnspentEntry } from "../../../bitcoind/types.js";
+import type { WalletPrompter } from "../../lifecycle.js";
+import { openWalletReadContext, type WalletReadContext } from "../../read/index.js";
+import type { WalletRuntimePaths } from "../../runtime.js";
+import type { WalletSecretProvider } from "../../state/provider.js";
+import type { WalletStateV1 } from "../../types.js";
+import { type FixedWalletInput, type WalletMutationRpcClient } from "../common.js";
+import type { AnchorFoundingMessage } from "./confirm.js";
+export interface WalletAnchorRpcClient extends WalletMutationRpcClient {
+    getBlockchainInfo(): Promise<{
+        blocks: number;
+    }>;
+    sendRawTransaction(hex: string): Promise<string>;
+    getRawMempool(): Promise<string[]>;
+}
+export interface AnchorDomainOptions {
+    domainName: string;
+    foundingMessageText?: string | null;
+    promptForFoundingMessageWhenMissing?: boolean;
+    feeRateSatVb?: number | null;
+    dataDir: string;
+    databasePath: string;
+    provider?: WalletSecretProvider;
+    prompter: WalletPrompter;
+    nowUnixMs?: number;
+    paths?: WalletRuntimePaths;
+    openReadContext?: typeof openWalletReadContext;
+    attachService?: typeof attachOrStartManagedBitcoindService;
+    rpcFactory?: (config: Parameters<typeof createRpcClient>[0]) => WalletAnchorRpcClient;
+}
+export interface AnchorMutationOperation {
+    state: WalletStateV1;
+    normalizedDomainName: string;
+    chainDomain: NonNullable<ReturnType<typeof lookupDomain>>;
+    message: AnchorFoundingMessage;
+}
+export interface DirectAnchorPlan {
+    fixedInputs: FixedWalletInput[];
+    outputs: unknown[];
+    changeAddress: string;
+    changePosition: number;
+    expectedOpReturnScriptHex: string;
+    allowedFundingScriptPubKeyHex: string;
+    eligibleFundingOutpointKeys: Set<string>;
+}
+export declare function normalizeAnchorDomainName(domainName: string): string;
+export declare function resolveAnchorOperation(options: {
+    readContext: WalletReadContext;
+    normalizedDomainName: string;
+    message: AnchorFoundingMessage;
+}): AnchorMutationOperation;
+export declare function createAnchorOperationFingerprint(operation: AnchorMutationOperation): string;
+export declare function buildDirectAnchorPlan(options: {
+    state: WalletStateV1;
+    allUtxos: RpcListUnspentEntry[];
+    domainId: number;
+    foundingMessagePayloadHex: string | null;
+}): DirectAnchorPlan;

package/dist/wallet/tx/anchor/intent.js

@@ -0,0 +1,101 @@
+import { createHash } from "node:crypto";
+import { lookupDomain } from "@cogcoin/indexer/queries";
+import { attachOrStartManagedBitcoindService } from "../../../bitcoind/service.js";
+import { createRpcClient } from "../../../bitcoind/node.js";
+import { openWalletReadContext } from "../../read/index.js";
+import { serializeDomainAnchor, validateDomainName, } from "../../cogop/index.js";
+import { assertWalletMutationContextReady, outpointKey, } from "../common.js";
+function normalizeDomainName(domainName) {
+    const normalized = domainName.trim().toLowerCase();
+    if (normalized.length === 0) {
+        throw new Error("wallet_anchor_missing_domain");
+    }
+    validateDomainName(normalized);
+    return normalized;
+}
+function createIntentFingerprint(parts) {
+    return createHash("sha256")
+        .update(parts.map((part) => String(part)).join("\n"))
+        .digest("hex");
+}
+function encodeOpReturnScript(payload) {
+    if (payload.length <= 75) {
+        return Buffer.concat([
+            Buffer.from([0x6a, payload.length]),
+            Buffer.from(payload),
+        ]).toString("hex");
+    }
+    return Buffer.concat([
+        Buffer.from([0x6a, 0x4c, payload.length]),
+        Buffer.from(payload),
+    ]).toString("hex");
+}
+function sortUtxos(entries) {
+    return entries
+        .slice()
+        .sort((left, right) => right.amount - left.amount
+        || left.txid.localeCompare(right.txid)
+        || left.vout - right.vout);
+}
+function isSpendableFundingUtxo(entry, fundingScriptPubKeyHex) {
+    return entry.scriptPubKey === fundingScriptPubKeyHex
+        && entry.confirmations >= 1
+        && entry.spendable !== false
+        && entry.safe !== false;
+}
+export function normalizeAnchorDomainName(domainName) {
+    return normalizeDomainName(domainName);
+}
+export function resolveAnchorOperation(options) {
+    assertWalletMutationContextReady(options.readContext, "wallet_anchor");
+    const state = options.readContext.localState.state;
+    const chainDomain = lookupDomain(options.readContext.snapshot.state, options.normalizedDomainName);
+    if (chainDomain === null) {
+        throw new Error("wallet_anchor_domain_not_found");
+    }
+    if (chainDomain.anchored) {
+        throw new Error("wallet_anchor_domain_already_anchored");
+    }
+    const ownerHex = Buffer.from(chainDomain.ownerScriptPubKey).toString("hex");
+    const localScriptHexes = new Set([
+        state.funding.scriptPubKeyHex,
+        ...(state.localScriptPubKeyHexes ?? []),
+    ]);
+    if (!localScriptHexes.has(ownerHex)) {
+        throw new Error("wallet_anchor_owner_not_locally_controlled");
+    }
+    if (state.funding.address.trim() === "") {
+        throw new Error("wallet_anchor_owner_identity_not_supported");
+    }
+    return {
+        state,
+        normalizedDomainName: options.normalizedDomainName,
+        chainDomain,
+        message: options.message,
+    };
+}
+export function createAnchorOperationFingerprint(operation) {
+    return createIntentFingerprint([
+        "anchor",
+        operation.state.walletRootId,
+        operation.normalizedDomainName,
+        operation.state.funding.scriptPubKeyHex,
+        operation.message.payloadHex ?? "",
+    ]);
+}
+export function buildDirectAnchorPlan(options) {
+    const fundingUtxos = sortUtxos(options.allUtxos.filter((entry) => isSpendableFundingUtxo(entry, options.state.funding.scriptPubKeyHex)));
+    const foundingPayload = options.foundingMessagePayloadHex === null
+        ? undefined
+        : Buffer.from(options.foundingMessagePayloadHex, "hex");
+    const opReturnData = serializeDomainAnchor(options.domainId, foundingPayload).opReturnData;
+    return {
+        fixedInputs: [],
+        outputs: [{ data: Buffer.from(opReturnData).toString("hex") }],
+        changeAddress: options.state.funding.address,
+        changePosition: 1,
+        expectedOpReturnScriptHex: encodeOpReturnScript(opReturnData),
+        allowedFundingScriptPubKeyHex: options.state.funding.scriptPubKeyHex,
+        eligibleFundingOutpointKeys: new Set(fundingUtxos.map((entry) => outpointKey({ txid: entry.txid, vout: entry.vout }))),
+    };
+}

package/dist/wallet/tx/anchor/plan.d.ts

@@ -0,0 +1,3 @@
+import type { BuiltWalletMutationTransaction } from "../common.js";
+import type { DirectAnchorPlan } from "./intent.js";
+export declare function validateDirectAnchorDraft(decoded: BuiltWalletMutationTransaction["decoded"], funded: BuiltWalletMutationTransaction["funded"], plan: DirectAnchorPlan): void;

package/dist/wallet/tx/anchor/plan.js

@@ -0,0 +1,18 @@
+export function validateDirectAnchorDraft(decoded, funded, plan) {
+    const outputs = decoded.tx.vout;
+    if (outputs[0]?.scriptPubKey?.hex !== plan.expectedOpReturnScriptHex) {
+        throw new Error("wallet_anchor_opreturn_mismatch");
+    }
+    if (funded.changepos === -1) {
+        if (outputs.length !== 1) {
+            throw new Error("wallet_anchor_unexpected_output_count");
+        }
+        return;
+    }
+    if (funded.changepos !== plan.changePosition || outputs.length !== 2) {
+        throw new Error("wallet_anchor_change_position_mismatch");
+    }
+    if (outputs[funded.changepos]?.scriptPubKey?.hex !== plan.allowedFundingScriptPubKeyHex) {
+        throw new Error("wallet_anchor_change_output_mismatch");
+    }
+}

package/dist/wallet/tx/anchor/result.d.ts

@@ -0,0 +1,25 @@
+import type { PendingMutationRecord } from "../../types.js";
+import type { WalletMutationFeeSummary } from "../common.js";
+import type { AnchorMutationOperation } from "./intent.js";
+export interface AnchorDomainResult {
+    domainName: string;
+    txid: string;
+    status: "live" | "confirmed";
+    reusedExisting: boolean;
+    foundingMessageText?: string | null;
+    fees: WalletMutationFeeSummary;
+}
+export declare function createAnchorReuseResult(options: {
+    operation: AnchorMutationOperation;
+    mutation: PendingMutationRecord;
+    resolution: "confirmed" | "live";
+    fees: WalletMutationFeeSummary;
+}): AnchorDomainResult;
+export declare function createAnchorResult(options: {
+    operation: AnchorMutationOperation;
+    mutation: PendingMutationRecord;
+    builtTxid: string | null;
+    status: "live" | "confirmed";
+    reusedExisting: boolean;
+    fees: WalletMutationFeeSummary;
+}): AnchorDomainResult;

package/dist/wallet/tx/anchor/result.js

@@ -0,0 +1,20 @@
+export function createAnchorReuseResult(options) {
+    return {
+        domainName: options.operation.normalizedDomainName,
+        txid: options.mutation.attemptedTxid ?? "unknown",
+        status: options.resolution,
+        reusedExisting: true,
+        foundingMessageText: options.operation.message.text,
+        fees: options.fees,
+    };
+}
+export function createAnchorResult(options) {
+    return {
+        domainName: options.operation.normalizedDomainName,
+        txid: options.mutation.attemptedTxid ?? options.builtTxid ?? "unknown",
+        status: options.status,
+        reusedExisting: options.reusedExisting,
+        foundingMessageText: options.operation.message.text,
+        fees: options.fees,
+    };
+}