@cogcoin/client 0.5.0

package/dist/wallet/tx/anchor.js

@@ -0,0 +1,1210 @@
+import { createHash, randomBytes } from "node:crypto";
+import { encodeSentence } from "@cogcoin/scoring";
+import { getListing, 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 { openWalletReadContext } from "../read/index.js";
+import { assertWalletMutationContextReady, buildWalletMutationTransaction, isAlreadyAcceptedError, isBroadcastUnknownError, pauseMiningForWalletMutation, saveWalletStatePreservingUnlock, unlockTemporaryBuilderLocks, } from "./common.js";
+const ACTIVE_FAMILY_STATUSES = new Set([
+    "draft",
+    "broadcasting",
+    "broadcast-unknown",
+    "live",
+    "repair-required",
+]);
+function normalizeDomainName(domainName) {
+    const normalized = domainName.trim().toLowerCase();
+    if (normalized.length === 0) {
+        throw new Error("wallet_anchor_missing_domain");
+    }
+    validateDomainName(normalized);
+    return normalized;
+}
+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 satsToBtcNumber(value) {
+    return Number(value) / 100_000_000;
+}
+function valueToSats(value) {
+    const text = typeof value === "number" ? value.toFixed(8) : value;
+    const match = /^(-?)(\d+)(?:\.(\d{0,8}))?$/.exec(text.trim());
+    if (match == null) {
+        throw new Error(`wallet_anchor_invalid_amount_${text}`);
+    }
+    const sign = match[1] === "-" ? -1n : 1n;
+    const whole = BigInt(match[2] ?? "0");
+    const fraction = BigInt((match[3] ?? "").padEnd(8, "0"));
+    return sign * ((whole * 100000000n) + fraction);
+}
+function createIntentFingerprint(parts) {
+    return createHash("sha256")
+        .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()
+        .sort((left, right) => right.amount - left.amount
+        || 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 findAnchorFamilyById(state, familyId) {
+    return state.proactiveFamilies.find((family) => family.familyId === familyId) ?? null;
+}
+function selectNextDedicatedIdentityTarget(state) {
+    const reservedIndices = new Set();
+    for (const domain of state.domains) {
+        if (domain.dedicatedIndex !== null) {
+            reservedIndices.add(domain.dedicatedIndex);
+        }
+    }
+    for (const family of state.proactiveFamilies) {
+        if (family.type === "anchor" && family.reservedDedicatedIndex !== null && family.reservedDedicatedIndex !== undefined) {
+            reservedIndices.add(family.reservedDedicatedIndex);
+        }
+    }
+    const startIndex = Math.max(1, state.nextDedicatedIndex);
+    for (let index = startIndex; index <= state.descriptor.rangeEnd; index += 1) {
+        if (reservedIndices.has(index)) {
+            continue;
+        }
+        const material = deriveWalletIdentityMaterial(state.keys.accountXprv, index);
+        return {
+            ...material,
+            localIndex: index,
+        };
+    }
+    throw new Error("wallet_anchor_no_fresh_dedicated_index");
+}
+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 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,
+    };
+}
+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) {
+        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.");
+    }
+    const answer = (await prompter.prompt("Type the domain name to continue: ")).trim();
+    if (answer !== operation.chainDomain.name) {
+        throw new Error("wallet_anchor_confirmation_rejected");
+    }
+}
+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");
+    }
+    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 (senderIdentity.readOnly) {
+        throw new Error("wallet_anchor_owner_read_only");
+    }
+    const sourceAnchorOutpoint = senderIdentity.index === context.localState.state.fundingIndex
+        ? null
+        : resolveAnchorOutpointForSender(context.localState.state, senderIdentity.index);
+    if (senderIdentity.index !== context.localState.state.fundingIndex && sourceAnchorOutpoint === null) {
+        throw new Error("wallet_anchor_owner_identity_not_supported");
+    }
+    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 createFamilyTransactionRecord() {
+    return {
+        status: "draft",
+        attemptedTxid: null,
+        attemptedWtxid: null,
+        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 ensureReservedIdentity(identities, target) {
+    if (identities.some((identity) => identity.index === target.localIndex)) {
+        return identities;
+    }
+    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 ?? "",
+        });
+    }
+    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,
+        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) {
+        if (fundingUtxos.length === 0) {
+            throw new Error("wallet_anchor_sender_utxo_unavailable");
+        }
+        const senderInput = fundingUtxos[0];
+        return {
+            sender: options.operation.sourceSender,
+            changeAddress: options.state.funding.address,
+            inputs: fundingUtxos.map((entry, index) => index === 0
+                ? { txid: senderInput.txid, vout: senderInput.vout }
+                : { txid: entry.txid, vout: entry.vout }),
+            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,
+            errorPrefix: "wallet_anchor_tx1",
+        };
+    }
+    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,
+        inputs: [
+            { txid: sourceAnchor.txid, vout: sourceAnchor.vout },
+            ...fundingUtxos.map((entry) => ({ txid: entry.txid, vout: entry.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,
+        errorPrefix: "wallet_anchor_tx1",
+    };
+}
+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,
+        inputs: [
+            { txid: provisional.txid, vout: provisional.vout },
+            ...fundingUtxos.map((entry) => ({ txid: entry.txid, vout: entry.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,
+        errorPrefix: "wallet_anchor_tx2",
+    };
+}
+function validateTx1Draft(decoded, funded, plan) {
+    const inputs = decoded.tx.vin;
+    const outputs = decoded.tx.vout;
+    if (inputs.length === 0 || inputs[0]?.prevout?.scriptPubKey?.hex !== plan.sender.scriptPubKeyHex) {
+        throw new Error(`${plan.errorPrefix}_sender_input_mismatch`);
+    }
+    for (let index = 1; index < inputs.length; index += 1) {
+        if (inputs[index]?.prevout?.scriptPubKey?.hex !== plan.allowedFundingScriptPubKeyHex) {
+            throw new Error(`${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}_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`);
+    }
+}
+function validateTx2Draft(decoded, funded, plan) {
+    const inputs = decoded.tx.vin;
+    const outputs = decoded.tx.vout;
+    if (inputs.length === 0 || inputs[0]?.prevout?.scriptPubKey?.hex !== plan.sender.scriptPubKeyHex) {
+        throw new Error(`${plan.errorPrefix}_provisional_input_mismatch`);
+    }
+    for (let index = 1; index < inputs.length; index += 1) {
+        if (inputs[index]?.prevout?.scriptPubKey?.hex !== plan.allowedFundingScriptPubKeyHex) {
+            throw new Error(`${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 buildTx1(options) {
+    return buildWalletMutationTransaction({
+        rpc: options.rpc,
+        walletName: options.walletName,
+        plan: options.plan,
+        validateFundedDraft: validateTx1Draft,
+        finalizeErrorCode: "wallet_anchor_tx1_finalize_failed",
+        mempoolRejectPrefix: "wallet_anchor_tx1_mempool_rejected",
+    });
+}
+async function buildTx2(options) {
+    return buildWalletMutationTransaction({
+        rpc: options.rpc,
+        walletName: options.walletName,
+        plan: options.plan,
+        validateFundedDraft: validateTx2Draft,
+        finalizeErrorCode: "wallet_anchor_tx2_finalize_failed",
+        mempoolRejectPrefix: "wallet_anchor_tx2_mempool_rejected",
+        builderOptions: {
+            includeUnsafe: true,
+            minConf: 0,
+        },
+    });
+}
+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 {
+                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",
+        };
+    }
+    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",
+                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,
+            });
+        }
+        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,
+        });
+        return {
+            state: nextState,
+            family: findAnchorFamilyById(nextState, options.family.familyId) ?? {
+                ...options.family,
+                status: "canceled",
+            },
+            resolution: "not-seen",
+        };
+    }
+    return {
+        state: options.state,
+        family: options.family,
+        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,
+        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,
+    };
+}
+function ensureSameTipHeight(context, bestHeight, errorCode) {
+    if (context.snapshot?.tip?.height !== bestHeight) {
+        throw new Error(errorCode);
+    }
+}
+export async function anchorDomain(options) {
+    if (!options.prompter.isInteractive) {
+        throw new Error("wallet_anchor_requires_tty");
+    }
+    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",
+        walletRootId: null,
+    });
+    const normalizedDomainName = normalizeDomainName(options.domainName);
+    try {
+        const miningPreemption = await pauseMiningForWalletMutation({
+            paths,
+            reason: "wallet-anchor",
+        });
+        const message = await encodeFoundingMessage(options.foundingMessageText ?? null);
+        const readContext = await (options.openReadContext ?? openWalletReadContext)({
+            dataDir: options.dataDir,
+            databasePath: options.databasePath,
+            secretProvider: provider,
+            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 && conflictingFamily !== null) {
+                throw new Error("wallet_anchor_prior_family_unresolved");
+            }
+            const node = await (options.attachService ?? attachOrStartManagedBitcoindService)({
+                dataDir: options.dataDir,
+                chain: "main",
+                startHeight: 0,
+                walletRootId: operation.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 = {
+                    ...deriveWalletIdentityMaterial(operation.state.keys.accountXprv, existingReservedIndex),
+                    localIndex: existingReservedIndex,
+                };
+                const reconciled = await reconcileAnchorFamily({
+                    state: operation.state,
+                    family: existingFamily,
+                    operation: {
+                        ...operation,
+                        targetIdentity: existingTargetIdentity,
+                    },
+                    provider,
+                    nowUnixMs,
+                    paths,
+                    unlockUntilUnixMs: operation.unlockUntilUnixMs,
+                    rpc,
+                    walletName,
+                });
+                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,
+                    };
+                }
+                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,
+                    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: [],
+                            },
+                        };
+                        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;
+                    }
+                }
+                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,
+                    });
+                }
+            }
+            const result = await submitTx2({
+                state: nextState,
+                family,
+                operation,
+                readContext: operation.readContext,
+                provider,
+                rpc,
+                walletName,
+                nowUnixMs,
+                paths,
+                unlockUntilUnixMs: operation.unlockUntilUnixMs,
+            });
+            return {
+                ...result,
+                reusedExisting: resumedExisting,
+            };
+        }
+        finally {
+            await readContext.close();
+            await miningPreemption.release();
+        }
+    }
+    finally {
+        await controlLock.release();
+    }
+}