@cogcoin/client 0.5.14 → 1.0.0

package/dist/wallet/tx/anchor.js

@@ -1,23 +1,15 @@
 import { createHash, randomBytes } from "node:crypto";
 import { encodeSentence } from "@cogcoin/scoring";
-import { getListing, lookupDomain } from "@cogcoin/indexer/queries";
+import { lookupDomain } from "@cogcoin/indexer/queries";
 import { attachOrStartManagedBitcoindService } from "../../bitcoind/service.js";
 import { createRpcClient } from "../../bitcoind/node.js";
 import { acquireFileLock } from "../fs/lock.js";
-import { deriveWalletIdentityMaterial, } from "../material.js";
 import { resolveWalletRuntimePathsForTesting } from "../runtime.js";
 import { createDefaultWalletSecretProvider, } from "../state/provider.js";
-import { serializeDomainAnchor, serializeDomainTransfer, validateDomainName, } from "../cogop/index.js";
+import { serializeDomainAnchor, validateDomainName, } from "../cogop/index.js";
 import { openWalletReadContext } from "../read/index.js";
-import { assertFixedInputPrefixMatches, assertFundingInputsAfterFixedPrefix, assertWalletMutationContextReady, buildWalletMutationTransactionWithReserveFallback, getDecodedInputScriptPubKeyHex, isAlreadyAcceptedError, isBroadcastUnknownError, outpointKey, pauseMiningForWalletMutation, saveWalletStatePreservingUnlock, unlockTemporaryBuilderLocks, inputMatchesOutpoint, } from "./common.js";
-import { confirmYesNo } from "./confirm.js";
-const ACTIVE_FAMILY_STATUSES = new Set([
-    "draft",
-    "broadcasting",
-    "broadcast-unknown",
-    "live",
-    "repair-required",
-]);
+import { assertWalletMutationContextReady, buildWalletMutationTransactionWithReserveFallback, createBuiltWalletMutationFeeSummary, createWalletMutationFeeMetadata, isAlreadyAcceptedError, isBroadcastUnknownError, mergeFixedWalletInputs, outpointKey, pauseMiningForWalletMutation, resolvePendingMutationReuseDecision, resolveWalletMutationFeeSelection, saveWalletStatePreservingUnlock, unlockTemporaryBuilderLocks, updateMutationRecord, } from "./common.js";
+import { findPendingMutationByIntent, upsertPendingMutation } from "./journal.js";
 function normalizeDomainName(domainName) {
     const normalized = domainName.trim().toLowerCase();
     if (normalized.length === 0) {
@@ -57,11 +49,6 @@ function createIntentFingerprint(parts) {
         .update(parts.map((part) => String(part)).join("\n"))
         .digest("hex");
 }
-function isSpendableConfirmedUtxo(entry) {
-    return entry.confirmations >= 1
-        && entry.spendable !== false
-        && entry.safe !== false;
-}
 function sortUtxos(entries) {
     return entries
         .slice()
@@ -69,139 +56,11 @@ function sortUtxos(entries) {
         || left.txid.localeCompare(right.txid)
         || left.vout - right.vout);
 }
-function createReservedIdentityRecord(target) {
-    return {
-        index: target.localIndex,
-        scriptPubKeyHex: target.scriptPubKeyHex,
-        address: target.address,
-        status: "dedicated",
-        assignedDomainNames: [],
-    };
-}
-function withUpdatedAssignedDomain(options) {
-    return options.identities.map((identity) => {
-        let assigned = identity.assignedDomainNames.filter((name) => name !== options.domainName);
-        if (identity.index === options.targetLocalIndex) {
-            assigned = [...assigned, options.domainName];
-        }
-        if (identity.index !== options.sourceLocalIndex && identity.index !== options.targetLocalIndex) {
-            assigned = identity.assignedDomainNames.slice();
-        }
-        return {
-            ...identity,
-            assignedDomainNames: assigned.sort((left, right) => left.localeCompare(right)),
-        };
-    });
-}
-function upsertProactiveFamily(state, family) {
-    const families = state.proactiveFamilies.slice();
-    const existingIndex = families.findIndex((entry) => entry.familyId === family.familyId);
-    if (existingIndex >= 0) {
-        families[existingIndex] = family;
-    }
-    else {
-        families.push(family);
-    }
-    return {
-        ...state,
-        proactiveFamilies: families,
-    };
-}
-function findAnchorFamilyByIntent(state, intentFingerprintHex) {
-    return state.proactiveFamilies.find((family) => family.type === "anchor" && family.intentFingerprintHex === intentFingerprintHex) ?? null;
-}
-function findActiveAnchorFamilyByDomain(state, domainName) {
-    return state.proactiveFamilies.find((family) => family.type === "anchor"
-        && family.domainName === domainName
-        && ACTIVE_FAMILY_STATUSES.has(family.status)) ?? null;
-}
-function isClearableReservedAnchorFamily(family) {
-    return family?.type === "anchor"
-        && family.status === "draft"
-        && family.currentStep === "reserved";
-}
-function findAnchorFamilyById(state, familyId) {
-    return state.proactiveFamilies.find((family) => family.familyId === familyId) ?? null;
-}
-function collectActivelyReservedDedicatedIndices(state) {
-    const reservedIndices = new Set();
-    for (const domain of state.domains) {
-        if (domain.dedicatedIndex !== null && domain.localAnchorIntent !== "none") {
-            reservedIndices.add(domain.dedicatedIndex);
-        }
-    }
-    for (const family of state.proactiveFamilies) {
-        if (family.type === "anchor"
-            && ACTIVE_FAMILY_STATUSES.has(family.status)
-            && family.reservedDedicatedIndex !== null
-            && family.reservedDedicatedIndex !== undefined) {
-            reservedIndices.add(family.reservedDedicatedIndex);
-        }
-    }
-    return reservedIndices;
-}
-function selectReusableDedicatedIdentityTarget(state) {
-    const reservedIndices = collectActivelyReservedDedicatedIndices(state);
-    const reusableIdentity = state.identities
-        .filter((identity) => identity.status === "dedicated"
-        && identity.address !== null
-        && identity.assignedDomainNames.length === 0
-        && !reservedIndices.has(identity.index))
-        .sort((left, right) => left.index - right.index)[0];
-    if (reusableIdentity == null) {
-        return null;
-    }
-    const material = deriveWalletIdentityMaterial(state.keys.accountXprv, reusableIdentity.index);
-    const reusableAddress = reusableIdentity.address;
-    if (reusableAddress === null) {
-        return null;
-    }
-    return {
-        ...material,
-        localIndex: reusableIdentity.index,
-        address: reusableAddress,
-        scriptPubKeyHex: reusableIdentity.scriptPubKeyHex,
-    };
-}
-function selectFreshDedicatedIdentityTarget(state) {
-    const unavailableIndices = new Set();
-    for (const identity of state.identities) {
-        unavailableIndices.add(identity.index);
-    }
-    for (const domain of state.domains) {
-        if (domain.dedicatedIndex !== null) {
-            unavailableIndices.add(domain.dedicatedIndex);
-        }
-    }
-    for (const index of collectActivelyReservedDedicatedIndices(state)) {
-        unavailableIndices.add(index);
-    }
-    const startIndex = Math.max(1, state.nextDedicatedIndex);
-    for (let index = startIndex; index <= state.descriptor.rangeEnd; index += 1) {
-        if (unavailableIndices.has(index)) {
-            continue;
-        }
-        const material = deriveWalletIdentityMaterial(state.keys.accountXprv, index);
-        return {
-            ...material,
-            localIndex: index,
-        };
-    }
-    throw new Error("wallet_anchor_no_fresh_dedicated_index");
-}
-function selectNextDedicatedIdentityTarget(state) {
-    return selectReusableDedicatedIdentityTarget(state) ?? selectFreshDedicatedIdentityTarget(state);
-}
-function deriveAnchorTargetIdentityForIndex(state, localIndex) {
-    const existingIdentity = state.identities.find((identity) => identity.index === localIndex
-        && identity.address !== null) ?? null;
-    const material = deriveWalletIdentityMaterial(state.keys.accountXprv, localIndex);
-    return {
-        ...material,
-        localIndex,
-        address: existingIdentity?.address ?? material.address,
-        scriptPubKeyHex: existingIdentity?.scriptPubKeyHex ?? material.scriptPubKeyHex,
-    };
+function isSpendableFundingUtxo(entry, fundingScriptPubKeyHex) {
+    return entry.scriptPubKey === fundingScriptPubKeyHex
+        && entry.confirmations >= 1
+        && entry.spendable !== false
+        && entry.safe !== false;
 }
 function encodeFoundingMessage(foundingMessageText) {
     const trimmed = foundingMessageText?.trim() ?? "";
@@ -249,892 +108,226 @@ async function resolveFoundingMessage(options) {
         }
     }
 }
-function resolveAnchorOutpointForSender(state, senderIndex) {
-    const anchoredDomain = state.domains.find((domain) => domain.currentOwnerLocalIndex === senderIndex
-        && domain.canonicalChainStatus === "anchored"
-        && domain.currentCanonicalAnchorOutpoint !== null) ?? null;
-    if (anchoredDomain?.currentCanonicalAnchorOutpoint === null || anchoredDomain === null) {
-        return null;
-    }
-    return {
-        txid: anchoredDomain.currentCanonicalAnchorOutpoint.txid,
-        vout: anchoredDomain.currentCanonicalAnchorOutpoint.vout,
-    };
-}
-function isFundingSender(state, sender) {
-    return sender.scriptPubKeyHex === state.funding.scriptPubKeyHex;
-}
-async function confirmAnchor(prompter, operation) {
-    prompter.writeLine(`You are anchoring "${operation.chainDomain.name}" onto dedicated index ${operation.targetIdentity.localIndex}.`);
-    prompter.writeLine("Anchoring is permanent chain state. This flow uses two transactions and is not rolled back automatically.");
-    prompter.writeLine(`Dedicated BTC address: ${operation.targetIdentity.address}`);
-    prompter.writeLine(`Dedicated Ethereum address: ${operation.targetIdentity.ethereumAddress}`);
-    prompter.writeLine(`Dedicated Nostr npub: ${operation.targetIdentity.nostrNpub}`);
-    if (operation.foundingMessageText !== null) {
+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: ${operation.foundingMessageText}`);
-    }
-    if (operation.hadListing) {
-        prompter.writeLine("Warning: Tx1 will cancel the current listing for this domain.");
-        prompter.writeLine("That listing-cancel side effect is not rolled back automatically if Tx2 later fails.");
+        prompter.writeLine(`Founding message: ${options.foundingMessageText}`);
     }
     const answer = (await prompter.prompt("Type the domain name to continue: ")).trim();
-    if (answer !== operation.chainDomain.name) {
+    if (answer !== options.domainName) {
         throw new Error("wallet_anchor_confirmation_rejected");
     }
 }
-async function confirmAnchorClear(prompter, domainName, dedicatedIndex, assumeYes = false) {
-    const releaseLine = dedicatedIndex === null
-        ? "This will cancel the local pending anchor reservation."
-        : `This will cancel the local pending anchor reservation and release dedicated index ${dedicatedIndex} for reuse.`;
-    await confirmYesNo(prompter, releaseLine, {
-        assumeYes,
-        errorCode: "wallet_anchor_clear_confirmation_rejected",
-        requiresTtyErrorCode: "wallet_anchor_clear_requires_tty",
-        prompt: `Clear pending anchor for "${domainName}"? [y/N]: `,
-    });
+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 }))),
+    };
 }
-function resolveAnchorOperation(context, domainName, foundingMessageText, foundingMessagePayloadHex) {
-    assertWalletMutationContextReady(context, "wallet_anchor");
-    const chainDomain = lookupDomain(context.snapshot.state, domainName);
-    if (chainDomain === null) {
-        throw new Error("wallet_anchor_domain_not_found");
-    }
-    if (chainDomain.anchored) {
-        throw new Error("wallet_anchor_domain_already_anchored");
+function validateDirectAnchorDraft(decoded, funded, plan) {
+    const outputs = decoded.tx.vout;
+    if (outputs[0]?.scriptPubKey?.hex !== plan.expectedOpReturnScriptHex) {
+        throw new Error("wallet_anchor_opreturn_mismatch");
     }
-    const ownerHex = Buffer.from(chainDomain.ownerScriptPubKey).toString("hex");
-    const senderIdentity = context.model.identities.find((identity) => identity.scriptPubKeyHex === ownerHex) ?? null;
-    if (senderIdentity === null || senderIdentity.address === null) {
-        throw new Error("wallet_anchor_owner_not_locally_controlled");
+    if (funded.changepos === -1) {
+        if (outputs.length !== 1) {
+            throw new Error("wallet_anchor_unexpected_output_count");
+        }
+        return;
     }
-    if (senderIdentity.readOnly) {
-        throw new Error("wallet_anchor_owner_read_only");
+    if (funded.changepos !== plan.changePosition || outputs.length !== 2) {
+        throw new Error("wallet_anchor_change_position_mismatch");
     }
-    const sourceAnchorOutpoint = isFundingSender(context.localState.state, {
-        localIndex: senderIdentity.index,
-        scriptPubKeyHex: senderIdentity.scriptPubKeyHex,
-        address: senderIdentity.address,
-    })
-        ? null
-        : resolveAnchorOutpointForSender(context.localState.state, senderIdentity.index);
-    if (sourceAnchorOutpoint === null
-        && senderIdentity.scriptPubKeyHex !== context.localState.state.funding.scriptPubKeyHex) {
-        throw new Error("wallet_anchor_owner_identity_not_supported");
+    if (outputs[funded.changepos]?.scriptPubKey?.hex !== plan.allowedFundingScriptPubKeyHex) {
+        throw new Error("wallet_anchor_change_output_mismatch");
     }
-    const targetIdentity = selectNextDedicatedIdentityTarget(context.localState.state);
-    return {
-        readContext: context,
-        state: context.localState.state,
-        unlockUntilUnixMs: context.localState.unlockUntilUnixMs,
-        sourceSender: {
-            localIndex: senderIdentity.index,
-            scriptPubKeyHex: senderIdentity.scriptPubKeyHex,
-            address: senderIdentity.address,
-        },
-        sourceAnchorOutpoint,
-        chainDomain,
-        targetIdentity,
-        foundingMessageText,
-        foundingMessagePayloadHex,
-        hadListing: getListing(context.snapshot.state, chainDomain.domainId) !== null,
-    };
 }
-function releaseClearedAnchorReservationState(options) {
-    const family = findAnchorFamilyById(options.state, options.familyId);
-    const domains = options.state.domains.map((domain) => {
-        if (domain.name !== options.domainName) {
-            return domain;
-        }
+function createDraftAnchorMutation(options) {
+    const existing = options.existing ?? null;
+    if (existing !== null) {
         return {
-            ...domain,
-            dedicatedIndex: null,
-            localAnchorIntent: "none",
+            ...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: [],
         };
-    });
-    const nextState = {
-        ...options.state,
-        domains,
-    };
-    if (family === null) {
-        return nextState;
     }
-    return upsertProactiveFamily(nextState, {
-        ...family,
-        status: "canceled",
-        lastUpdatedAtUnixMs: options.nowUnixMs,
-        tx1: family.tx1 == null ? family.tx1 : {
-            ...family.tx1,
-            status: "canceled",
-            temporaryBuilderLockedOutpoints: [],
-        },
-        tx2: family.tx2 == null ? family.tx2 : {
-            ...family.tx2,
-            status: "canceled",
-            temporaryBuilderLockedOutpoints: [],
-        },
-    });
-}
-function createFamilyTransactionRecord() {
     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: [],
-        rawHex: null,
     };
 }
-function createDraftAnchorFamily(operation, nowUnixMs) {
-    return {
-        familyId: randomBytes(12).toString("hex"),
-        type: "anchor",
-        status: "draft",
-        intentFingerprintHex: createIntentFingerprint([
-            "anchor",
-            operation.state.walletRootId,
-            operation.chainDomain.name,
-            operation.sourceSender.scriptPubKeyHex,
-            operation.foundingMessagePayloadHex ?? "",
-        ]),
-        createdAtUnixMs: nowUnixMs,
-        lastUpdatedAtUnixMs: nowUnixMs,
-        domainName: operation.chainDomain.name,
-        domainId: operation.chainDomain.domainId,
-        sourceSenderLocalIndex: operation.sourceSender.localIndex,
-        sourceSenderScriptPubKeyHex: operation.sourceSender.scriptPubKeyHex,
-        reservedDedicatedIndex: operation.targetIdentity.localIndex,
-        reservedScriptPubKeyHex: operation.targetIdentity.scriptPubKeyHex,
-        foundingMessageText: operation.foundingMessageText,
-        foundingMessagePayloadHex: operation.foundingMessagePayloadHex,
-        listingCancelCommitted: false,
-        currentStep: "reserved",
-        tx1: createFamilyTransactionRecord(),
-        tx2: createFamilyTransactionRecord(),
+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,
     };
-}
-function ensureReservedIdentity(identities, target) {
-    if (identities.some((identity) => identity.index === target.localIndex)) {
-        return identities;
+    if (existingIndex >= 0) {
+        domains[existingIndex] = nextRecord;
     }
-    return [...identities, createReservedIdentityRecord(target)]
-        .sort((left, right) => left.index - right.index);
-}
-function reserveAnchorFamilyState(state, family, target, foundingMessageText) {
-    const domains = state.domains.map((domain) => {
-        if (domain.name !== family.domainName) {
-            return domain;
-        }
-        return {
-            ...domain,
-            dedicatedIndex: target.localIndex,
-            localAnchorIntent: "reserved",
-            foundingMessageText: foundingMessageText ?? domain.foundingMessageText,
-        };
-    });
-    return {
-        ...upsertProactiveFamily(state, family),
-        nextDedicatedIndex: Math.max(state.nextDedicatedIndex, target.localIndex + 1),
-        identities: ensureReservedIdentity(state.identities, target),
-        domains,
-    };
-}
-function updateAnchorFamilyState(options) {
-    const nextFamily = {
-        ...options.family,
-        status: options.status,
-        currentStep: options.currentStep,
-        lastUpdatedAtUnixMs: options.nowUnixMs,
-        listingCancelCommitted: options.listingCancelCommitted ?? options.family.listingCancelCommitted,
-        tx1: options.tx1 ?? options.family.tx1 ?? createFamilyTransactionRecord(),
-        tx2: options.tx2 ?? options.family.tx2 ?? createFamilyTransactionRecord(),
-    };
-    let identities = ensureReservedIdentity(options.state.identities, options.target);
-    if (options.moveOwnershipToTarget) {
-        identities = withUpdatedAssignedDomain({
-            identities,
-            sourceLocalIndex: options.family.sourceSenderLocalIndex ?? null,
-            targetLocalIndex: options.target.localIndex,
-            domainName: options.family.domainName ?? "",
-        });
+    else {
+        domains.push(nextRecord);
     }
-    const domains = options.state.domains.map((domain) => {
-        if (domain.name !== options.family.domainName) {
-            return domain;
-        }
-        return {
-            ...domain,
-            dedicatedIndex: options.target.localIndex,
-            currentOwnerScriptPubKeyHex: options.moveOwnershipToTarget
-                ? options.target.scriptPubKeyHex
-                : domain.currentOwnerScriptPubKeyHex,
-            currentOwnerLocalIndex: options.moveOwnershipToTarget
-                ? options.target.localIndex
-                : domain.currentOwnerLocalIndex,
-            localAnchorIntent: options.localAnchorIntent,
-            canonicalChainStatus: options.canonicalChainStatus ?? domain.canonicalChainStatus,
-            currentCanonicalAnchorOutpoint: options.currentCanonicalAnchorOutpoint ?? domain.currentCanonicalAnchorOutpoint,
-            foundingMessageText: options.family.foundingMessageText ?? domain.foundingMessageText,
-        };
-    });
     return {
-        ...upsertProactiveFamily(options.state, nextFamily),
-        identities,
+        ...options.state,
         domains,
     };
 }
-function buildTx1Plan(options) {
-    const fundingUtxos = sortUtxos(options.allUtxos.filter((entry) => entry.scriptPubKey === options.state.funding.scriptPubKeyHex
-        && isSpendableConfirmedUtxo(entry)));
-    const outputs = [
-        { data: Buffer.from(serializeDomainTransfer(options.operation.chainDomain.domainId, Buffer.from(options.operation.targetIdentity.scriptPubKeyHex, "hex")).opReturnData).toString("hex") },
-        { [options.operation.targetIdentity.address]: satsToBtcNumber(BigInt(options.state.anchorValueSats)) },
-    ];
-    if (options.operation.sourceAnchorOutpoint === null) {
-        return {
-            sender: options.operation.sourceSender,
-            changeAddress: options.state.funding.address,
-            fixedInputs: [],
-            outputs,
-            changePosition: 2,
-            expectedOpReturnScriptHex: encodeOpReturnScript(serializeDomainTransfer(options.operation.chainDomain.domainId, Buffer.from(options.operation.targetIdentity.scriptPubKeyHex, "hex")).opReturnData),
-            expectedProvisionalAnchorScriptHex: options.operation.targetIdentity.scriptPubKeyHex,
-            expectedProvisionalAnchorValueSats: BigInt(options.state.anchorValueSats),
-            expectedReplacementAnchorScriptHex: null,
-            expectedReplacementAnchorValueSats: null,
-            allowedFundingScriptPubKeyHex: options.state.funding.scriptPubKeyHex,
-            eligibleFundingOutpointKeys: new Set(fundingUtxos.map((entry) => outpointKey({ txid: entry.txid, vout: entry.vout }))),
-            requiredSenderOutpoint: null,
-            requiredProvisionalOutpoint: null,
-            errorPrefix: "wallet_anchor_tx1",
-        };
+function anchorConfirmedOnSnapshot(options) {
+    const chainDomain = lookupDomain(options.snapshot.state, options.domainName);
+    if (chainDomain === null || !chainDomain.anchored) {
+        return false;
     }
-    const sourceAnchor = options.allUtxos.find((entry) => entry.txid === options.operation.sourceAnchorOutpoint?.txid
-        && entry.vout === options.operation.sourceAnchorOutpoint.vout
-        && entry.scriptPubKey === options.operation.sourceSender.scriptPubKeyHex
-        && isSpendableConfirmedUtxo(entry));
-    if (sourceAnchor === undefined) {
-        throw new Error("wallet_anchor_source_anchor_missing");
-    }
-    outputs.push({
-        [options.operation.sourceSender.address]: satsToBtcNumber(BigInt(options.state.anchorValueSats)),
-    });
-    return {
-        sender: options.operation.sourceSender,
-        changeAddress: options.state.funding.address,
-        fixedInputs: [{ txid: sourceAnchor.txid, vout: sourceAnchor.vout }],
-        outputs,
-        changePosition: 3,
-        expectedOpReturnScriptHex: encodeOpReturnScript(serializeDomainTransfer(options.operation.chainDomain.domainId, Buffer.from(options.operation.targetIdentity.scriptPubKeyHex, "hex")).opReturnData),
-        expectedProvisionalAnchorScriptHex: options.operation.targetIdentity.scriptPubKeyHex,
-        expectedProvisionalAnchorValueSats: BigInt(options.state.anchorValueSats),
-        expectedReplacementAnchorScriptHex: options.operation.sourceSender.scriptPubKeyHex,
-        expectedReplacementAnchorValueSats: BigInt(options.state.anchorValueSats),
-        allowedFundingScriptPubKeyHex: options.state.funding.scriptPubKeyHex,
-        eligibleFundingOutpointKeys: new Set(fundingUtxos.map((entry) => outpointKey({ txid: entry.txid, vout: entry.vout }))),
-        requiredSenderOutpoint: options.operation.sourceAnchorOutpoint,
-        requiredProvisionalOutpoint: null,
-        errorPrefix: "wallet_anchor_tx1",
-    };
+    const ownerHex = Buffer.from(chainDomain.ownerScriptPubKey).toString("hex");
+    return ownerHex === options.state.funding.scriptPubKeyHex
+        || (options.state.localScriptPubKeyHexes ?? []).includes(ownerHex);
 }
-function buildTx2Plan(options) {
-    const tx1Txid = options.family.tx1?.attemptedTxid;
-    if (tx1Txid === null || tx1Txid === undefined) {
-        throw new Error("wallet_anchor_tx1_missing");
-    }
-    const provisional = options.allUtxos.find((entry) => entry.txid === tx1Txid
-        && entry.vout === 1
-        && entry.scriptPubKey === options.operation.targetIdentity.scriptPubKeyHex
-        && entry.spendable !== false
-        && entry.safe !== false);
-    if (provisional === undefined) {
-        throw new Error("wallet_anchor_provisional_anchor_missing");
-    }
-    const fundingUtxos = sortUtxos(options.allUtxos.filter((entry) => entry.scriptPubKey === options.state.funding.scriptPubKeyHex
-        && isSpendableConfirmedUtxo(entry)));
-    const foundingPayload = options.operation.foundingMessagePayloadHex === null
-        ? undefined
-        : Buffer.from(options.operation.foundingMessagePayloadHex, "hex");
-    const opReturnData = serializeDomainAnchor(options.operation.chainDomain.domainId, foundingPayload).opReturnData;
-    return {
-        sender: {
-            localIndex: options.operation.targetIdentity.localIndex,
-            scriptPubKeyHex: options.operation.targetIdentity.scriptPubKeyHex,
-            address: options.operation.targetIdentity.address,
-        },
-        changeAddress: options.state.funding.address,
-        fixedInputs: [{ txid: provisional.txid, vout: provisional.vout }],
-        outputs: [
-            { data: Buffer.from(opReturnData).toString("hex") },
-            { [options.operation.targetIdentity.address]: satsToBtcNumber(BigInt(options.state.anchorValueSats)) },
-        ],
-        changePosition: 2,
-        expectedOpReturnScriptHex: encodeOpReturnScript(opReturnData),
-        expectedProvisionalAnchorScriptHex: options.operation.targetIdentity.scriptPubKeyHex,
-        expectedProvisionalAnchorValueSats: BigInt(options.state.anchorValueSats),
-        expectedReplacementAnchorScriptHex: null,
-        expectedReplacementAnchorValueSats: null,
-        allowedFundingScriptPubKeyHex: options.state.funding.scriptPubKeyHex,
-        eligibleFundingOutpointKeys: new Set(fundingUtxos.map((entry) => outpointKey({ txid: entry.txid, vout: entry.vout }))),
-        requiredSenderOutpoint: null,
-        requiredProvisionalOutpoint: {
-            txid: provisional.txid,
-            vout: provisional.vout,
-        },
-        errorPrefix: "wallet_anchor_tx2",
+async function saveState(options) {
+    const nextState = {
+        ...options.state,
+        stateRevision: options.state.stateRevision + 1,
+        lastWrittenAtUnixMs: options.nowUnixMs,
     };
-}
-function validateTx1Draft(decoded, funded, plan) {
-    const inputs = decoded.tx.vin;
-    const outputs = decoded.tx.vout;
-    if (inputs.length === 0) {
-        throw new Error(`${plan.errorPrefix}_sender_input_mismatch`);
-    }
-    assertFixedInputPrefixMatches(inputs, plan.fixedInputs, `${plan.errorPrefix}_sender_input_mismatch`);
-    const firstInputScriptPubKeyHex = getDecodedInputScriptPubKeyHex(inputs[0]);
-    if (firstInputScriptPubKeyHex !== plan.sender.scriptPubKeyHex) {
-        throw new Error(`${plan.errorPrefix}_sender_input_mismatch`);
-    }
-    if (plan.requiredSenderOutpoint !== null) {
-        if (!inputMatchesOutpoint(inputs[0], plan.requiredSenderOutpoint)) {
-            throw new Error(`${plan.errorPrefix}_sender_input_mismatch`);
-        }
-    }
-    assertFundingInputsAfterFixedPrefix({
-        inputs,
-        fixedInputs: plan.fixedInputs,
-        allowedFundingScriptPubKeyHex: plan.allowedFundingScriptPubKeyHex,
-        eligibleFundingOutpointKeys: plan.eligibleFundingOutpointKeys,
-        errorCode: `${plan.errorPrefix}_unexpected_funding_input`,
+    await saveWalletStatePreservingUnlock({
+        state: nextState,
+        provider: options.provider,
+        nowUnixMs: options.nowUnixMs,
+        paths: options.paths,
     });
-    if (outputs[0]?.scriptPubKey?.hex !== plan.expectedOpReturnScriptHex) {
-        throw new Error(`${plan.errorPrefix}_opreturn_mismatch`);
-    }
-    if (outputs[1]?.scriptPubKey?.hex !== plan.expectedProvisionalAnchorScriptHex) {
-        throw new Error(`${plan.errorPrefix}_provisional_anchor_output_mismatch`);
-    }
-    if (valueToSats(outputs[1]?.value ?? 0) !== plan.expectedProvisionalAnchorValueSats) {
-        throw new Error(`${plan.errorPrefix}_provisional_anchor_value_mismatch`);
-    }
-    const expectedWithoutChange = plan.expectedReplacementAnchorScriptHex === null ? 2 : 3;
-    if (plan.expectedReplacementAnchorScriptHex !== null) {
-        if (outputs[2]?.scriptPubKey?.hex !== plan.expectedReplacementAnchorScriptHex) {
-            throw new Error(`${plan.errorPrefix}_replacement_anchor_output_mismatch`);
-        }
-        if (valueToSats(outputs[2]?.value ?? 0) !== (plan.expectedReplacementAnchorValueSats ?? 0n)) {
-            throw new Error(`${plan.errorPrefix}_replacement_anchor_value_mismatch`);
-        }
-    }
-    if (funded.changepos === -1) {
-        if (outputs.length !== expectedWithoutChange) {
-            throw new Error(`${plan.errorPrefix}_unexpected_output_count`);
-        }
-        return;
-    }
-    if (funded.changepos !== plan.changePosition || outputs.length !== expectedWithoutChange + 1) {
-        throw new Error(`${plan.errorPrefix}_change_position_mismatch`);
-    }
-    if (outputs[funded.changepos]?.scriptPubKey?.hex !== plan.allowedFundingScriptPubKeyHex) {
-        throw new Error(`${plan.errorPrefix}_change_output_mismatch`);
-    }
+    return nextState;
 }
-function validateTx2Draft(decoded, funded, plan) {
-    const inputs = decoded.tx.vin;
-    const outputs = decoded.tx.vout;
-    if (inputs.length === 0 || plan.requiredProvisionalOutpoint === null) {
-        throw new Error(`${plan.errorPrefix}_provisional_input_mismatch`);
-    }
-    assertFixedInputPrefixMatches(inputs, plan.fixedInputs, `${plan.errorPrefix}_provisional_input_mismatch`);
-    const firstInputScriptPubKeyHex = getDecodedInputScriptPubKeyHex(inputs[0]);
-    if (firstInputScriptPubKeyHex !== plan.sender.scriptPubKeyHex
-        || !inputMatchesOutpoint(inputs[0], plan.requiredProvisionalOutpoint)) {
-        throw new Error(`${plan.errorPrefix}_provisional_input_mismatch`);
-    }
-    assertFundingInputsAfterFixedPrefix({
-        inputs,
-        fixedInputs: plan.fixedInputs,
-        allowedFundingScriptPubKeyHex: plan.allowedFundingScriptPubKeyHex,
-        eligibleFundingOutpointKeys: plan.eligibleFundingOutpointKeys,
-        errorCode: `${plan.errorPrefix}_unexpected_funding_input`,
-    });
-    if (outputs[0]?.scriptPubKey?.hex !== plan.expectedOpReturnScriptHex) {
-        throw new Error(`${plan.errorPrefix}_opreturn_mismatch`);
-    }
-    if (outputs[1]?.scriptPubKey?.hex !== plan.expectedProvisionalAnchorScriptHex) {
-        throw new Error(`${plan.errorPrefix}_canonical_anchor_output_mismatch`);
-    }
-    if (valueToSats(outputs[1]?.value ?? 0) !== plan.expectedProvisionalAnchorValueSats) {
-        throw new Error(`${plan.errorPrefix}_canonical_anchor_value_mismatch`);
-    }
-    const expectedWithoutChange = 2;
-    if (funded.changepos === -1) {
-        if (outputs.length !== expectedWithoutChange) {
-            throw new Error(`${plan.errorPrefix}_unexpected_output_count`);
-        }
-        return;
-    }
-    if (funded.changepos !== plan.changePosition || outputs.length !== expectedWithoutChange + 1) {
-        throw new Error(`${plan.errorPrefix}_change_position_mismatch`);
-    }
-    if (outputs[funded.changepos]?.scriptPubKey?.hex !== plan.allowedFundingScriptPubKeyHex) {
-        throw new Error(`${plan.errorPrefix}_change_output_mismatch`);
+async function reconcilePendingAnchorMutation(options) {
+    if (options.mutation.status === "repair-required") {
+        return {
+            state: options.state,
+            mutation: options.mutation,
+            resolution: "repair-required",
+        };
     }
-}
-async function buildTx1(options) {
-    return buildWalletMutationTransactionWithReserveFallback({
-        rpc: options.rpc,
-        walletName: options.walletName,
-        state: options.state,
-        plan: options.plan,
-        validateFundedDraft: validateTx1Draft,
-        finalizeErrorCode: "wallet_anchor_tx1_finalize_failed",
-        mempoolRejectPrefix: "wallet_anchor_tx1_mempool_rejected",
-        reserveCandidates: options.state.proactiveReserveOutpoints,
-    });
-}
-async function buildTx2(options) {
-    return buildWalletMutationTransactionWithReserveFallback({
-        rpc: options.rpc,
-        walletName: options.walletName,
+    if (options.context.snapshot !== null && anchorConfirmedOnSnapshot({
+        snapshot: options.context.snapshot,
         state: options.state,
-        plan: options.plan,
-        validateFundedDraft: validateTx2Draft,
-        finalizeErrorCode: "wallet_anchor_tx2_finalize_failed",
-        mempoolRejectPrefix: "wallet_anchor_tx2_mempool_rejected",
-        reserveCandidates: options.state.proactiveReserveOutpoints,
-    });
-}
-async function relockAnchorOutpoint(rpc, walletName, outpoint) {
-    if (outpoint === null) {
-        return;
-    }
-    await rpc.lockUnspent(walletName, false, [outpoint]).catch(() => undefined);
-}
-function resolveAcceptedFamilyStatus(options) {
-    const chainDomain = options.snapshot === null || options.family.domainName == null
-        ? null
-        : lookupDomain(options.snapshot.state, options.family.domainName);
-    if (chainDomain === null) {
-        return "live";
-    }
-    const ownerHex = Buffer.from(chainDomain.ownerScriptPubKey).toString("hex");
-    return chainDomain.anchored && ownerHex === options.target.scriptPubKeyHex
-        ? "confirmed"
-        : "live";
-}
-async function reconcileAnchorFamily(options) {
-    const chainDomain = lookupDomain(options.operation.readContext.snapshot.state, options.operation.chainDomain.name);
-    const targetScript = options.operation.targetIdentity.scriptPubKeyHex;
-    if (chainDomain !== null) {
-        const ownerHex = Buffer.from(chainDomain.ownerScriptPubKey).toString("hex");
-        if (chainDomain.anchored && ownerHex === targetScript) {
-            const nextState = updateAnchorFamilyState({
-                state: options.state,
-                family: options.family,
-                target: options.operation.targetIdentity,
-                status: "confirmed",
-                localAnchorIntent: "none",
-                currentStep: "tx2",
-                nowUnixMs: options.nowUnixMs,
-                tx1: options.family.tx1 == null ? undefined : { ...options.family.tx1, status: "confirmed", temporaryBuilderLockedOutpoints: [] },
-                tx2: options.family.tx2 == null ? undefined : { ...options.family.tx2, status: "confirmed", temporaryBuilderLockedOutpoints: [] },
-                moveOwnershipToTarget: true,
-                canonicalChainStatus: "anchored",
-                currentCanonicalAnchorOutpoint: options.family.tx2?.attemptedTxid == null
-                    ? options.state.domains.find((domain) => domain.name === options.family.domainName)?.currentCanonicalAnchorOutpoint ?? null
-                    : {
-                        txid: options.family.tx2.attemptedTxid,
-                        vout: 1,
-                        valueSats: options.state.anchorValueSats,
-                    },
-            });
-            await saveWalletStatePreservingUnlock({
-                state: {
-                    ...nextState,
-                    stateRevision: nextState.stateRevision + 1,
-                    lastWrittenAtUnixMs: options.nowUnixMs,
-                },
-                provider: options.provider,
-                unlockUntilUnixMs: options.unlockUntilUnixMs,
-                nowUnixMs: options.nowUnixMs,
-                paths: options.paths,
-            });
-            return {
+        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.state, confirmedMutation),
+            domainName: options.mutation.domainName,
+            domainId: chainDomain?.domainId ?? 0,
+            foundingMessageText: options.foundingMessageText,
+        });
+        return {
+            state: await saveState({
                 state: nextState,
-                family: findAnchorFamilyById(nextState, options.family.familyId) ?? {
-                    ...options.family,
-                    status: "confirmed",
-                },
-                resolution: "confirmed",
-            };
-        }
-        if (ownerHex === targetScript && !chainDomain.anchored) {
-            const nextState = updateAnchorFamilyState({
-                state: options.state,
-                family: options.family,
-                target: options.operation.targetIdentity,
-                status: "repair-required",
-                localAnchorIntent: "repair-required",
-                currentStep: "tx2",
-                nowUnixMs: options.nowUnixMs,
-                listingCancelCommitted: true,
-                moveOwnershipToTarget: true,
-            });
-            await saveWalletStatePreservingUnlock({
-                state: {
-                    ...nextState,
-                    stateRevision: nextState.stateRevision + 1,
-                    lastWrittenAtUnixMs: options.nowUnixMs,
-                },
                 provider: options.provider,
-                unlockUntilUnixMs: options.unlockUntilUnixMs,
                 nowUnixMs: options.nowUnixMs,
                 paths: options.paths,
-            });
-            return {
-                state: nextState,
-                family: findAnchorFamilyById(nextState, options.family.familyId) ?? {
-                    ...options.family,
-                    status: "repair-required",
-                },
-                resolution: "repair-required",
-            };
-        }
-    }
-    const mempool = await options.rpc.getRawMempool().catch(() => []);
-    if (options.family.tx2?.attemptedTxid != null && mempool.includes(options.family.tx2.attemptedTxid)) {
-        await unlockTemporaryBuilderLocks(options.rpc, options.walletName, options.family.tx2.temporaryBuilderLockedOutpoints);
-        const nextState = updateAnchorFamilyState({
-            state: options.state,
-            family: options.family,
-            target: options.operation.targetIdentity,
-            status: "live",
-            localAnchorIntent: "tx2-live",
-            currentStep: "tx2",
-            nowUnixMs: options.nowUnixMs,
-            tx2: {
-                ...options.family.tx2,
-                status: "live",
-                temporaryBuilderLockedOutpoints: [],
-            },
-            listingCancelCommitted: true,
-            moveOwnershipToTarget: true,
-            currentCanonicalAnchorOutpoint: {
-                txid: options.family.tx2.attemptedTxid,
-                vout: 1,
-                valueSats: options.state.anchorValueSats,
-            },
-        });
-        await relockAnchorOutpoint(options.rpc, options.walletName, {
-            txid: options.family.tx2.attemptedTxid,
-            vout: 1,
-        });
-        await saveWalletStatePreservingUnlock({
-            state: {
-                ...nextState,
-                stateRevision: nextState.stateRevision + 1,
-                lastWrittenAtUnixMs: options.nowUnixMs,
-            },
-            provider: options.provider,
-            unlockUntilUnixMs: options.unlockUntilUnixMs,
-            nowUnixMs: options.nowUnixMs,
-            paths: options.paths,
-        });
-        return {
-            state: nextState,
-            family: findAnchorFamilyById(nextState, options.family.familyId) ?? {
-                ...options.family,
-                status: "live",
-            },
-            resolution: "live",
+            }),
+            mutation: confirmedMutation,
+            resolution: "confirmed",
         };
     }
-    if (options.family.tx1?.attemptedTxid != null && mempool.includes(options.family.tx1.attemptedTxid)) {
-        await unlockTemporaryBuilderLocks(options.rpc, options.walletName, options.family.tx1.temporaryBuilderLockedOutpoints);
-        const nextState = updateAnchorFamilyState({
-            state: options.state,
-            family: options.family,
-            target: options.operation.targetIdentity,
-            status: "live",
-            localAnchorIntent: "tx1-live",
-            currentStep: "tx1",
-            nowUnixMs: options.nowUnixMs,
-            tx1: {
-                ...options.family.tx1,
-                status: "live",
+    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: [],
-            },
-            listingCancelCommitted: options.operation.hadListing,
-            moveOwnershipToTarget: true,
-        });
-        if (options.operation.sourceAnchorOutpoint !== null) {
-            await relockAnchorOutpoint(options.rpc, options.walletName, {
-                txid: options.family.tx1.attemptedTxid,
-                vout: 2,
             });
+            const domainId = (options.context.snapshot === null
+                ? null
+                : lookupDomain(options.context.snapshot.state, options.mutation.domainName)?.domainId)
+                ?? options.state.domains.find((domain) => domain.name === options.mutation.domainName)?.domainId
+                ?? 0;
+            const nextState = upsertAnchoredDomainRecord({
+                state: upsertPendingMutation(options.state, liveMutation),
+                domainName: options.mutation.domainName,
+                domainId,
+                foundingMessageText: options.foundingMessageText,
+            });
+            return {
+                state: await saveState({
+                    state: nextState,
+                    provider: options.provider,
+                    nowUnixMs: options.nowUnixMs,
+                    paths: options.paths,
+                }),
+                mutation: liveMutation,
+                resolution: "live",
+            };
         }
-        await saveWalletStatePreservingUnlock({
-            state: {
-                ...nextState,
-                stateRevision: nextState.stateRevision + 1,
-                lastWrittenAtUnixMs: options.nowUnixMs,
-            },
-            provider: options.provider,
-            unlockUntilUnixMs: options.unlockUntilUnixMs,
-            nowUnixMs: options.nowUnixMs,
-            paths: options.paths,
-        });
-        return {
-            state: nextState,
-            family: findAnchorFamilyById(nextState, options.family.familyId) ?? {
-                ...options.family,
-                status: "live",
-            },
-            resolution: "ready-for-tx2",
-        };
-    }
-    if (options.family.currentStep === "tx2" || options.family.tx2?.attemptedTxid != null) {
-        const nextState = updateAnchorFamilyState({
-            state: options.state,
-            family: options.family,
-            target: options.operation.targetIdentity,
-            status: "repair-required",
-            localAnchorIntent: "repair-required",
-            currentStep: "tx2",
-            nowUnixMs: options.nowUnixMs,
-            listingCancelCommitted: true,
-            moveOwnershipToTarget: true,
-        });
-        await saveWalletStatePreservingUnlock({
-            state: {
-                ...nextState,
-                stateRevision: nextState.stateRevision + 1,
-                lastWrittenAtUnixMs: options.nowUnixMs,
-            },
-            provider: options.provider,
-            unlockUntilUnixMs: options.unlockUntilUnixMs,
-            nowUnixMs: options.nowUnixMs,
-            paths: options.paths,
-        });
-        return {
-            state: nextState,
-            family: findAnchorFamilyById(nextState, options.family.familyId) ?? {
-                ...options.family,
-                status: "repair-required",
-            },
-            resolution: "repair-required",
-        };
     }
-    if (ACTIVE_FAMILY_STATUSES.has(options.family.status)) {
-        const nextState = updateAnchorFamilyState({
-            state: options.state,
-            family: options.family,
-            target: options.operation.targetIdentity,
-            status: "canceled",
-            localAnchorIntent: "none",
-            currentStep: options.family.currentStep,
-            nowUnixMs: options.nowUnixMs,
-            tx1: options.family.tx1 == null ? undefined : {
-                ...options.family.tx1,
-                status: "canceled",
-                temporaryBuilderLockedOutpoints: [],
-            },
-            tx2: options.family.tx2 == null ? undefined : {
-                ...options.family.tx2,
-                status: "canceled",
-                temporaryBuilderLockedOutpoints: [],
-            },
-        });
-        await saveWalletStatePreservingUnlock({
-            state: {
-                ...nextState,
-                stateRevision: nextState.stateRevision + 1,
-                lastWrittenAtUnixMs: options.nowUnixMs,
-            },
-            provider: options.provider,
-            unlockUntilUnixMs: options.unlockUntilUnixMs,
-            nowUnixMs: options.nowUnixMs,
-            paths: options.paths,
+    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.state, canceledMutation);
         return {
-            state: nextState,
-            family: findAnchorFamilyById(nextState, options.family.familyId) ?? {
-                ...options.family,
-                status: "canceled",
-            },
+            state: await saveState({
+                state: nextState,
+                provider: options.provider,
+                nowUnixMs: options.nowUnixMs,
+                paths: options.paths,
+            }),
+            mutation: canceledMutation,
             resolution: "not-seen",
         };
     }
     return {
         state: options.state,
-        family: options.family,
+        mutation: options.mutation,
         resolution: "continue",
     };
 }
-function createBroadcastingTxRecord(built) {
-    return {
-        status: "broadcasting",
-        attemptedTxid: built.txid,
-        attemptedWtxid: built.wtxid,
-        temporaryBuilderLockedOutpoints: built.temporaryBuilderLockedOutpoints,
-        rawHex: built.rawHex,
-    };
-}
-async function saveState(state, provider, unlockUntilUnixMs, nowUnixMs, paths) {
-    const nextState = {
-        ...state,
-        stateRevision: state.stateRevision + 1,
-        lastWrittenAtUnixMs: nowUnixMs,
-    };
-    await saveWalletStatePreservingUnlock({
-        state: nextState,
-        provider,
-        unlockUntilUnixMs,
-        nowUnixMs,
-        paths,
-    });
-    return nextState;
-}
-async function submitTx2(options) {
-    let nextState = options.state;
-    let family = options.family;
-    const tx2Plan = buildTx2Plan({
-        state: nextState,
-        allUtxos: await options.rpc.listUnspent(options.walletName, 0),
-        operation: options.operation,
-        family,
-    });
-    const builtTx2 = await buildTx2({
-        rpc: options.rpc,
-        walletName: options.walletName,
-        state: nextState,
-        plan: tx2Plan,
-    });
-    const broadcastingTx2 = createBroadcastingTxRecord(builtTx2);
-    family = {
-        ...family,
-        status: "broadcasting",
-        currentStep: "tx2",
-        tx2: broadcastingTx2,
-    };
-    nextState = updateAnchorFamilyState({
-        state: nextState,
-        family,
-        target: options.operation.targetIdentity,
-        status: "broadcasting",
-        localAnchorIntent: "tx1-live",
-        currentStep: "tx2",
-        nowUnixMs: options.nowUnixMs,
-        tx2: broadcastingTx2,
-        listingCancelCommitted: true,
-        moveOwnershipToTarget: true,
-    });
-    nextState = await saveState(nextState, options.provider, options.unlockUntilUnixMs, options.nowUnixMs, options.paths);
-    ensureSameTipHeight(options.readContext, (await options.rpc.getBlockchainInfo()).blocks, "wallet_anchor_tip_mismatch");
-    try {
-        await options.rpc.sendRawTransaction(builtTx2.rawHex);
-    }
-    catch (error) {
-        if (!isAlreadyAcceptedError(error)) {
-            if (isBroadcastUnknownError(error)) {
-                family = {
-                    ...family,
-                    status: "broadcast-unknown",
-                    tx2: {
-                        ...broadcastingTx2,
-                        status: "broadcast-unknown",
-                    },
-                };
-                nextState = updateAnchorFamilyState({
-                    state: nextState,
-                    family,
-                    target: options.operation.targetIdentity,
-                    status: "broadcast-unknown",
-                    localAnchorIntent: "tx1-live",
-                    currentStep: "tx2",
-                    nowUnixMs: options.nowUnixMs,
-                    tx2: family.tx2,
-                    listingCancelCommitted: true,
-                    moveOwnershipToTarget: true,
-                });
-                await saveState(nextState, options.provider, options.unlockUntilUnixMs, options.nowUnixMs, options.paths);
-                throw new Error("wallet_anchor_tx2_broadcast_unknown");
-            }
-            await unlockTemporaryBuilderLocks(options.rpc, options.walletName, builtTx2.temporaryBuilderLockedOutpoints);
-            family = {
-                ...family,
-                status: "repair-required",
-                tx2: {
-                    ...broadcastingTx2,
-                    status: "repair-required",
-                    temporaryBuilderLockedOutpoints: [],
-                },
-            };
-            nextState = updateAnchorFamilyState({
-                state: nextState,
-                family,
-                target: options.operation.targetIdentity,
-                status: "repair-required",
-                localAnchorIntent: "repair-required",
-                currentStep: "tx2",
-                nowUnixMs: options.nowUnixMs,
-                tx2: family.tx2,
-                listingCancelCommitted: true,
-                moveOwnershipToTarget: true,
-            });
-            await saveState(nextState, options.provider, options.unlockUntilUnixMs, options.nowUnixMs, options.paths);
-            throw error;
-        }
-    }
-    await unlockTemporaryBuilderLocks(options.rpc, options.walletName, builtTx2.temporaryBuilderLockedOutpoints);
-    const finalStatus = resolveAcceptedFamilyStatus({
-        snapshot: options.readContext.snapshot,
-        family,
-        target: options.operation.targetIdentity,
-    });
-    family = {
-        ...family,
-        status: finalStatus,
-        currentStep: "tx2",
-        tx2: {
-            ...broadcastingTx2,
-            status: finalStatus,
-            temporaryBuilderLockedOutpoints: [],
-        },
-    };
-    nextState = updateAnchorFamilyState({
-        state: nextState,
-        family,
-        target: options.operation.targetIdentity,
-        status: finalStatus,
-        localAnchorIntent: finalStatus === "confirmed" ? "none" : "tx2-live",
-        currentStep: "tx2",
-        nowUnixMs: options.nowUnixMs,
-        tx2: family.tx2,
-        listingCancelCommitted: true,
-        moveOwnershipToTarget: true,
-        canonicalChainStatus: finalStatus === "confirmed" ? "anchored" : undefined,
-        currentCanonicalAnchorOutpoint: {
-            txid: builtTx2.txid,
-            vout: 1,
-            valueSats: nextState.anchorValueSats,
-        },
-    });
-    nextState = await saveState(nextState, options.provider, options.unlockUntilUnixMs, options.nowUnixMs, options.paths);
-    await relockAnchorOutpoint(options.rpc, options.walletName, {
-        txid: builtTx2.txid,
-        vout: 1,
-    });
-    return {
-        domainName: options.operation.chainDomain.name,
-        txid: builtTx2.txid,
-        tx1Txid: family.tx1?.attemptedTxid ?? "unknown",
-        tx2Txid: builtTx2.txid,
-        dedicatedIndex: options.operation.targetIdentity.localIndex,
-        status: finalStatus,
-        reusedExisting: false,
-        foundingMessageText: options.operation.foundingMessageText,
-    };
-}
 function ensureSameTipHeight(context, bestHeight, errorCode) {
     if (context.snapshot?.tip?.height !== bestHeight) {
         throw new Error(errorCode);
@@ -1147,21 +340,16 @@ export async function anchorDomain(options) {
     const provider = options.provider ?? createDefaultWalletSecretProvider();
     const nowUnixMs = options.nowUnixMs ?? Date.now();
     const paths = options.paths ?? resolveWalletRuntimePathsForTesting();
+    const normalizedDomainName = normalizeDomainName(options.domainName);
     const controlLock = await acquireFileLock(paths.walletControlLockPath, {
         purpose: "wallet-anchor",
         walletRootId: null,
     });
-    const normalizedDomainName = normalizeDomainName(options.domainName);
     try {
         const miningPreemption = await pauseMiningForWalletMutation({
             paths,
             reason: "wallet-anchor",
         });
-        const message = await resolveFoundingMessage({
-            foundingMessageText: options.foundingMessageText,
-            promptForFoundingMessageWhenMissing: options.promptForFoundingMessageWhenMissing,
-            prompter: options.prompter,
-        });
         const readContext = await (options.openReadContext ?? openWalletReadContext)({
             dataDir: options.dataDir,
             databasePath: options.databasePath,
@@ -1170,301 +358,222 @@ export async function anchorDomain(options) {
             paths,
         });
         try {
-            let operation = resolveAnchorOperation(readContext, normalizedDomainName, message.text, message.payloadHex);
-            const initialFamily = createDraftAnchorFamily(operation, nowUnixMs);
-            const existingFamily = findAnchorFamilyByIntent(operation.state, initialFamily.intentFingerprintHex);
-            const conflictingFamily = findActiveAnchorFamilyByDomain(operation.state, normalizedDomainName);
-            if (existingFamily === null && isClearableReservedAnchorFamily(conflictingFamily)) {
-                throw new Error(`wallet_anchor_clear_pending_first_${conflictingFamily.domainName}`);
+            assertWalletMutationContextReady(readContext, "wallet_anchor");
+            const message = await resolveFoundingMessage({
+                foundingMessageText: options.foundingMessageText,
+                promptForFoundingMessageWhenMissing: options.promptForFoundingMessageWhenMissing,
+                prompter: options.prompter,
+            });
+            const state = readContext.localState.state;
+            const chainDomain = lookupDomain(readContext.snapshot.state, 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 (existingFamily === null && conflictingFamily !== null) {
-                throw new Error("wallet_anchor_prior_family_unresolved");
+            if (state.funding.address.trim() === "") {
+                throw new Error("wallet_anchor_owner_identity_not_supported");
             }
+            const intentFingerprintHex = createIntentFingerprint([
+                "anchor",
+                state.walletRootId,
+                normalizedDomainName,
+                state.funding.scriptPubKeyHex,
+                message.payloadHex ?? "",
+            ]);
             const node = await (options.attachService ?? attachOrStartManagedBitcoindService)({
                 dataDir: options.dataDir,
                 chain: "main",
                 startHeight: 0,
-                walletRootId: operation.state.walletRootId,
+                walletRootId: state.walletRootId,
             });
             const rpc = (options.rpcFactory ?? createRpcClient)(node.rpc);
-            const walletName = operation.state.managedCoreWallet.walletName;
-            let resumedFamily = null;
-            let resumedExisting = false;
-            let workingState = operation.state;
-            if (existingFamily !== null) {
-                const existingReservedIndex = existingFamily.reservedDedicatedIndex ?? operation.targetIdentity.localIndex;
-                const existingTargetIdentity = deriveAnchorTargetIdentityForIndex(operation.state, existingReservedIndex);
-                const reconciled = await reconcileAnchorFamily({
-                    state: operation.state,
-                    family: existingFamily,
-                    operation: {
-                        ...operation,
-                        targetIdentity: existingTargetIdentity,
-                    },
+            const walletName = state.managedCoreWallet.walletName;
+            const feeSelection = await resolveWalletMutationFeeSelection({
+                rpc,
+                feeRateSatVb: options.feeRateSatVb ?? null,
+            });
+            const existingMutation = findPendingMutationByIntent(state, intentFingerprintHex);
+            let workingState = state;
+            let replacementFixedInputs = null;
+            if (existingMutation !== null) {
+                const reconciled = await reconcilePendingAnchorMutation({
+                    state,
+                    mutation: existingMutation,
                     provider,
                     nowUnixMs,
                     paths,
-                    unlockUntilUnixMs: operation.unlockUntilUnixMs,
                     rpc,
                     walletName,
+                    context: readContext,
+                    foundingMessageText: message.text,
                 });
                 workingState = reconciled.state;
                 if (reconciled.resolution === "confirmed" || reconciled.resolution === "live") {
-                    return {
-                        domainName: normalizedDomainName,
-                        txid: reconciled.family.tx2?.attemptedTxid ?? reconciled.family.tx1?.attemptedTxid ?? "unknown",
-                        tx1Txid: reconciled.family.tx1?.attemptedTxid ?? "unknown",
-                        tx2Txid: reconciled.family.tx2?.attemptedTxid ?? "unknown",
-                        dedicatedIndex: reconciled.family.reservedDedicatedIndex ?? existingTargetIdentity.localIndex,
-                        status: reconciled.resolution,
-                        reusedExisting: true,
-                        foundingMessageText: reconciled.family.foundingMessageText,
-                    };
-                }
-                if (reconciled.resolution === "repair-required") {
-                    throw new Error("wallet_anchor_repair_required");
-                }
-                if (reconciled.resolution === "ready-for-tx2") {
-                    operation = {
-                        ...operation,
-                        targetIdentity: existingTargetIdentity,
-                    };
-                    resumedFamily = reconciled.family;
-                    resumedExisting = true;
-                }
-            }
-            let nextState = workingState;
-            let family;
-            if (resumedFamily !== null) {
-                family = resumedFamily;
-            }
-            else {
-                await confirmAnchor(options.prompter, operation);
-                nextState = reserveAnchorFamilyState(nextState, initialFamily, operation.targetIdentity, operation.foundingMessageText);
-                nextState = await saveState(nextState, provider, operation.unlockUntilUnixMs, nowUnixMs, paths);
-                const tx1Plan = buildTx1Plan({
-                    state: nextState,
-                    allUtxos: await rpc.listUnspent(walletName, 1),
-                    operation,
-                });
-                const builtTx1 = await buildTx1({
-                    rpc,
-                    walletName,
-                    state: nextState,
-                    plan: tx1Plan,
-                });
-                const broadcastingTx1 = createBroadcastingTxRecord(builtTx1);
-                family = {
-                    ...(findAnchorFamilyByIntent(nextState, initialFamily.intentFingerprintHex) ?? initialFamily),
-                    status: "broadcasting",
-                    currentStep: "tx1",
-                    lastUpdatedAtUnixMs: nowUnixMs,
-                    tx1: broadcastingTx1,
-                };
-                nextState = updateAnchorFamilyState({
-                    state: nextState,
-                    family,
-                    target: operation.targetIdentity,
-                    status: "broadcasting",
-                    localAnchorIntent: "reserved",
-                    currentStep: "tx1",
-                    nowUnixMs,
-                    tx1: broadcastingTx1,
-                });
-                nextState = await saveState(nextState, provider, operation.unlockUntilUnixMs, nowUnixMs, paths);
-                ensureSameTipHeight(readContext, (await rpc.getBlockchainInfo()).blocks, "wallet_anchor_tip_mismatch");
-                try {
-                    await rpc.sendRawTransaction(builtTx1.rawHex);
-                }
-                catch (error) {
-                    if (!isAlreadyAcceptedError(error)) {
-                        if (isBroadcastUnknownError(error)) {
-                            family = {
-                                ...family,
-                                status: "broadcast-unknown",
-                                tx1: {
-                                    ...broadcastingTx1,
-                                    status: "broadcast-unknown",
-                                },
-                            };
-                            nextState = updateAnchorFamilyState({
-                                state: nextState,
-                                family,
-                                target: operation.targetIdentity,
-                                status: "broadcast-unknown",
-                                localAnchorIntent: "reserved",
-                                currentStep: "tx1",
-                                nowUnixMs,
-                                tx1: family.tx1,
-                            });
-                            await saveState(nextState, provider, operation.unlockUntilUnixMs, nowUnixMs, paths);
-                            throw new Error("wallet_anchor_tx1_broadcast_unknown");
-                        }
-                        await unlockTemporaryBuilderLocks(rpc, walletName, builtTx1.temporaryBuilderLockedOutpoints);
-                        family = {
-                            ...family,
-                            status: "canceled",
-                            tx1: {
-                                ...broadcastingTx1,
-                                status: "canceled",
-                                temporaryBuilderLockedOutpoints: [],
-                            },
+                    const reuse = await resolvePendingMutationReuseDecision({
+                        rpc,
+                        walletName,
+                        mutation: reconciled.mutation,
+                        nextFeeSelection: feeSelection,
+                    });
+                    if (reuse.reuseExisting) {
+                        return {
+                            domainName: normalizedDomainName,
+                            txid: reconciled.mutation.attemptedTxid ?? "unknown",
+                            status: reconciled.resolution,
+                            reusedExisting: true,
+                            foundingMessageText: message.text,
+                            fees: reuse.fees,
                         };
-                        nextState = updateAnchorFamilyState({
-                            state: nextState,
-                            family,
-                            target: operation.targetIdentity,
-                            status: "canceled",
-                            localAnchorIntent: "none",
-                            currentStep: "tx1",
-                            nowUnixMs,
-                            tx1: family.tx1,
-                        });
-                        await saveState(nextState, provider, operation.unlockUntilUnixMs, nowUnixMs, paths);
-                        throw error;
                     }
+                    replacementFixedInputs = reuse.replacementFixedInputs;
                 }
-                await unlockTemporaryBuilderLocks(rpc, walletName, builtTx1.temporaryBuilderLockedOutpoints);
-                family = {
-                    ...family,
-                    status: "live",
-                    currentStep: "tx1",
-                    tx1: {
-                        ...broadcastingTx1,
-                        status: "live",
-                        temporaryBuilderLockedOutpoints: [],
-                    },
-                };
-                nextState = updateAnchorFamilyState({
-                    state: nextState,
-                    family,
-                    target: operation.targetIdentity,
-                    status: "live",
-                    localAnchorIntent: "tx1-live",
-                    currentStep: "tx1",
-                    nowUnixMs,
-                    tx1: family.tx1,
-                    listingCancelCommitted: operation.hadListing,
-                    moveOwnershipToTarget: true,
-                });
-                nextState = await saveState(nextState, provider, operation.unlockUntilUnixMs, nowUnixMs, paths);
-                if (operation.sourceAnchorOutpoint !== null) {
-                    await relockAnchorOutpoint(rpc, walletName, {
-                        txid: builtTx1.txid,
-                        vout: 2,
-                    });
+                if (reconciled.resolution === "repair-required") {
+                    throw new Error("wallet_anchor_repair_required");
                 }
             }
-            const result = await submitTx2({
+            await confirmDirectAnchor(options.prompter, {
+                domainName: normalizedDomainName,
+                walletAddress: state.funding.address,
+                foundingMessageText: message.text,
+            });
+            let nextState = upsertPendingMutation(workingState, createDraftAnchorMutation({
+                state: workingState,
+                domainName: normalizedDomainName,
+                intentFingerprintHex,
+                nowUnixMs,
+                feeSelection,
+                existing: existingMutation ?? null,
+            }));
+            nextState = await saveState({
                 state: nextState,
-                family,
-                operation,
-                readContext: operation.readContext,
                 provider,
+                nowUnixMs,
+                paths,
+            });
+            const directAnchorPlan = buildDirectAnchorPlan({
+                state: nextState,
+                allUtxos: await rpc.listUnspent(walletName, 1),
+                domainId: chainDomain.domainId,
+                foundingMessagePayloadHex: message.payloadHex,
+            });
+            const built = await buildWalletMutationTransactionWithReserveFallback({
                 rpc,
                 walletName,
+                state: nextState,
+                plan: {
+                    ...directAnchorPlan,
+                    fixedInputs: mergeFixedWalletInputs(directAnchorPlan.fixedInputs, replacementFixedInputs),
+                },
+                validateFundedDraft: validateDirectAnchorDraft,
+                finalizeErrorCode: "wallet_anchor_finalize_failed",
+                mempoolRejectPrefix: "wallet_anchor_mempool_rejected",
+                feeRate: feeSelection.feeRateSatVb,
+            });
+            const currentMutation = nextState.pendingMutations?.find((mutation) => mutation.intentFingerprintHex === intentFingerprintHex)
+                ?? createDraftAnchorMutation({
+                    state: nextState,
+                    domainName: normalizedDomainName,
+                    intentFingerprintHex,
+                    nowUnixMs,
+                    feeSelection,
+                });
+            const broadcastingMutation = updateMutationRecord(currentMutation, "broadcasting", nowUnixMs, {
+                attemptedTxid: built.txid,
+                attemptedWtxid: built.wtxid,
+                temporaryBuilderLockedOutpoints: built.temporaryBuilderLockedOutpoints,
+            });
+            nextState = await saveState({
+                state: upsertPendingMutation(nextState, broadcastingMutation),
+                provider,
                 nowUnixMs,
                 paths,
-                unlockUntilUnixMs: operation.unlockUntilUnixMs,
             });
-            return {
-                ...result,
-                reusedExisting: resumedExisting,
-                foundingMessageText: result.foundingMessageText ?? operation.foundingMessageText,
-            };
-        }
-        finally {
-            await readContext.close();
-            await miningPreemption.release();
-        }
-    }
-    finally {
-        await controlLock.release();
-    }
-}
-export async function clearPendingAnchor(options) {
-    const provider = options.provider ?? createDefaultWalletSecretProvider();
-    const nowUnixMs = options.nowUnixMs ?? Date.now();
-    const paths = options.paths ?? resolveWalletRuntimePathsForTesting();
-    const controlLock = await acquireFileLock(paths.walletControlLockPath, {
-        purpose: "wallet-anchor-clear",
-        walletRootId: null,
-    });
-    const normalizedDomainName = normalizeDomainName(options.domainName);
-    try {
-        const miningPreemption = await pauseMiningForWalletMutation({
-            paths,
-            reason: "wallet-anchor-clear",
-        });
-        const readContext = await (options.openReadContext ?? openWalletReadContext)({
-            dataDir: options.dataDir,
-            databasePath: options.databasePath,
-            secretProvider: provider,
-            walletControlLockHeld: true,
-            paths,
-        });
-        try {
-            assertWalletMutationContextReady(readContext, "wallet_anchor_clear");
-            const family = findActiveAnchorFamilyByDomain(readContext.localState.state, normalizedDomainName);
-            const domain = readContext.localState.state.domains.find((entry) => entry.name === normalizedDomainName) ?? null;
-            if (domain === null && family === null) {
-                throw new Error("wallet_anchor_clear_domain_not_found");
+            ensureSameTipHeight(readContext, (await rpc.getBlockchainInfo()).blocks, "wallet_anchor_tip_mismatch");
+            let accepted = false;
+            try {
+                await rpc.sendRawTransaction(built.rawHex);
+                accepted = true;
             }
-            if (family === null) {
-                if (domain === null) {
-                    throw new Error("wallet_anchor_clear_domain_not_found");
+            catch (error) {
+                if (isAlreadyAcceptedError(error)) {
+                    accepted = true;
                 }
-                if (domain.localAnchorIntent !== "none") {
-                    throw new Error("wallet_anchor_clear_inconsistent_state");
+                else if (isBroadcastUnknownError(error)) {
+                    const unknownMutation = updateMutationRecord(broadcastingMutation, "broadcast-unknown", nowUnixMs, {
+                        attemptedTxid: built.txid,
+                        attemptedWtxid: built.wtxid,
+                        temporaryBuilderLockedOutpoints: built.temporaryBuilderLockedOutpoints,
+                    });
+                    await saveState({
+                        state: upsertPendingMutation(nextState, unknownMutation),
+                        provider,
+                        nowUnixMs,
+                        paths,
+                    });
+                    throw new Error("wallet_anchor_broadcast_unknown");
+                }
+                else {
+                    await unlockTemporaryBuilderLocks(rpc, walletName, built.temporaryBuilderLockedOutpoints);
+                    const canceledMutation = updateMutationRecord(broadcastingMutation, "canceled", nowUnixMs, {
+                        attemptedTxid: built.txid,
+                        attemptedWtxid: built.wtxid,
+                        temporaryBuilderLockedOutpoints: [],
+                    });
+                    await saveState({
+                        state: upsertPendingMutation(nextState, canceledMutation),
+                        provider,
+                        nowUnixMs,
+                        paths,
+                    });
+                    throw error;
                 }
-                return {
-                    domainName: normalizedDomainName,
-                    cleared: false,
-                    previousFamilyStatus: null,
-                    previousFamilyStep: null,
-                    releasedDedicatedIndex: null,
-                };
-            }
-            if (family.type !== "anchor") {
-                throw new Error("wallet_anchor_clear_inconsistent_state");
-            }
-            if (family.status !== "draft" || family.currentStep !== "reserved") {
-                throw new Error(`wallet_anchor_clear_not_clearable_${family.status}`);
             }
-            const reservedDedicatedIndex = family.reservedDedicatedIndex ?? null;
-            if (reservedDedicatedIndex === null
-                || family.tx1?.attemptedTxid !== null
-                || family.tx2?.attemptedTxid !== null
-                || (domain !== null
-                    && (domain.localAnchorIntent !== "reserved"
-                        || domain.dedicatedIndex === null
-                        || domain.dedicatedIndex !== reservedDedicatedIndex))) {
-                throw new Error("wallet_anchor_clear_inconsistent_state");
+            if (!accepted) {
+                throw new Error("wallet_anchor_broadcast_failed");
             }
-            await confirmAnchorClear(options.prompter, normalizedDomainName, reservedDedicatedIndex, options.assumeYes ?? false);
-            const releasedState = releaseClearedAnchorReservationState({
-                state: readContext.localState.state,
-                familyId: family.familyId,
+            await unlockTemporaryBuilderLocks(rpc, walletName, built.temporaryBuilderLockedOutpoints);
+            const finalStatus = anchorConfirmedOnSnapshot({
+                snapshot: readContext.snapshot,
+                state: nextState,
                 domainName: normalizedDomainName,
-                nowUnixMs,
+            }) ? "confirmed" : "live";
+            const finalMutation = updateMutationRecord(broadcastingMutation, finalStatus, nowUnixMs, {
+                attemptedTxid: built.txid,
+                attemptedWtxid: built.wtxid,
+                temporaryBuilderLockedOutpoints: [],
             });
-            await saveWalletStatePreservingUnlock({
-                state: {
-                    ...releasedState,
-                    stateRevision: releasedState.stateRevision + 1,
-                    lastWrittenAtUnixMs: nowUnixMs,
-                },
+            nextState = upsertAnchoredDomainRecord({
+                state: upsertPendingMutation(nextState, finalMutation),
+                domainName: normalizedDomainName,
+                domainId: chainDomain.domainId,
+                foundingMessageText: message.text,
+            });
+            nextState = await saveState({
+                state: nextState,
                 provider,
-                unlockUntilUnixMs: readContext.localState.unlockUntilUnixMs,
                 nowUnixMs,
                 paths,
             });
             return {
                 domainName: normalizedDomainName,
-                cleared: true,
-                previousFamilyStatus: family.status,
-                previousFamilyStep: family.currentStep ?? null,
-                releasedDedicatedIndex: reservedDedicatedIndex,
+                txid: built.txid,
+                status: finalStatus,
+                reusedExisting: false,
+                foundingMessageText: message.text,
+                fees: createBuiltWalletMutationFeeSummary({
+                    selection: feeSelection,
+                    built,
+                }),
             };
         }
         finally {