@cogcoin/client 0.5.15 → 1.0.0

package/dist/wallet/tx/field.js

@@ -10,9 +10,8 @@ import { createDefaultWalletSecretProvider, } from "../state/provider.js";
 import { FIELD_FORMAT_BYTES, serializeDataUpdate, serializeFieldReg, } from "../cogop/index.js";
 import { validateFieldName } from "../cogop/validate-name.js";
 import { findDomainField, openWalletReadContext, } from "../read/index.js";
-import { assertFixedInputPrefixMatches, assertFundingInputsAfterFixedPrefix, assertWalletMutationContextReady, buildWalletMutationTransactionWithReserveFallback, findSpendableFundingInputsFromTransaction, getDecodedInputScriptPubKeyHex, isAlreadyAcceptedError, isBroadcastUnknownError, outpointKey, pauseMiningForWalletMutation, saveWalletStatePreservingUnlock, unlockTemporaryBuilderLocks, updateMutationRecord, } from "./common.js";
+import { assertWalletMutationContextReady, buildWalletMutationTransactionWithReserveFallback, createBuiltWalletMutationFeeSummary, createWalletMutationFeeMetadata, isAlreadyAcceptedError, isBroadcastUnknownError, mergeFixedWalletInputs, outpointKey, pauseMiningForWalletMutation, resolvePendingMutationReuseDecision, resolveWalletMutationFeeSelection, saveWalletStatePreservingUnlock, unlockTemporaryBuilderLocks, updateMutationRecord, } from "./common.js";
 import { confirmTypedAcknowledgement as confirmSharedTypedAcknowledgement, confirmYesNo as confirmSharedYesNo, } from "./confirm.js";
-import { getCanonicalIdentitySelector } from "./identity-selector.js";
 import { findPendingMutationByIntent, upsertPendingMutation } from "./journal.js";
 function createResolvedFieldSenderSummary(sender, selector) {
     return {
@@ -30,18 +29,6 @@ function createResolvedFieldValueSummary(format, value) {
 }
 function createResolvedFieldSummary(options) {
     if (options.kind === "field-create") {
-        if (options.family) {
-            return {
-                sender: createResolvedFieldSenderSummary(options.sender, options.senderSelector),
-                path: "field-reg-plus-data-update-family",
-                value: options.value,
-                effect: {
-                    kind: "create-and-initialize-field",
-                    tx1BurnCogtoshi: "100",
-                    tx2AdditionalBurnCogtoshi: "1",
-                },
-            };
-        }
         return {
             sender: createResolvedFieldSenderSummary(options.sender, options.senderSelector),
             path: "standalone-field-reg",
@@ -83,8 +70,6 @@ function describeFieldEffect(effect) {
     switch (effect.kind) {
         case "create-empty-field":
             return `burn ${effect.burnCogtoshi} cogtoshi to create an empty field`;
-        case "create-and-initialize-field":
-            return `burn ${effect.tx1BurnCogtoshi} cogtoshi in Tx1 and ${effect.tx2AdditionalBurnCogtoshi} additional cogtoshi in Tx2`;
         case "write-field-value":
             return `burn ${effect.burnCogtoshi} cogtoshi to write the field value`;
         case "clear-field-value":
@@ -150,61 +135,12 @@ function isActiveMutationStatus(status) {
         || status === "live"
         || status === "repair-required";
 }
-function isActiveFamilyStatus(status) {
-    return status === "draft"
-        || status === "broadcasting"
-        || status === "broadcast-unknown"
-        || status === "live"
-        || status === "repair-required";
-}
-function createFamilyTransactionRecord() {
-    return {
-        status: "draft",
-        attemptedTxid: null,
-        attemptedWtxid: null,
-        temporaryBuilderLockedOutpoints: [],
-        rawHex: null,
-    };
-}
-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 findFieldFamilyByIntent(state, intentFingerprintHex) {
-    return state.proactiveFamilies.find((family) => family.type === "field" && family.intentFingerprintHex === intentFingerprintHex) ?? null;
-}
-function findActiveFieldFamilyByDomain(state, domainName) {
-    return state.proactiveFamilies.find((family) => family.type === "field"
-        && family.domainName === domainName
-        && isActiveFamilyStatus(family.status)) ?? null;
-}
 function findActiveFieldCreateMutationByDomain(state, domainName, intentFingerprintHex) {
     return (state.pendingMutations ?? []).find((mutation) => mutation.kind === "field-create"
         && mutation.domainName === domainName
         && mutation.intentFingerprintHex !== intentFingerprintHex
         && isActiveMutationStatus(mutation.status)) ?? null;
 }
-function resolveAnchorOutpointForSender(state, sender, errorPrefix) {
-    const anchoredDomain = state.domains.find((domain) => domain.currentOwnerLocalIndex === sender.index
-        && domain.canonicalChainStatus === "anchored") ?? null;
-    if (anchoredDomain?.currentCanonicalAnchorOutpoint === null || anchoredDomain === null) {
-        throw new Error(`${errorPrefix}_anchor_outpoint_unavailable`);
-    }
-    return {
-        txid: anchoredDomain.currentCanonicalAnchorOutpoint.txid,
-        vout: anchoredDomain.currentCanonicalAnchorOutpoint.vout,
-    };
-}
 function resolveAnchoredFieldOperation(context, domainName, errorPrefix) {
     assertWalletMutationContextReady(context, errorPrefix);
     const chainDomain = lookupDomain(context.snapshot.state, domainName);
@@ -215,24 +151,19 @@ function resolveAnchoredFieldOperation(context, domainName, errorPrefix) {
         throw new Error(`${errorPrefix}_domain_not_anchored`);
     }
     const ownerHex = Buffer.from(chainDomain.ownerScriptPubKey).toString("hex");
-    const ownerIdentity = context.model.identities.find((identity) => identity.scriptPubKeyHex === ownerHex) ?? null;
-    if (ownerIdentity === null || ownerIdentity.address === null) {
+    const state = context.localState.state;
+    if (ownerHex !== state.funding.scriptPubKeyHex || state.funding.address.trim() === "") {
         throw new Error(`${errorPrefix}_owner_not_locally_controlled`);
     }
-    if (ownerIdentity.readOnly) {
-        throw new Error(`${errorPrefix}_owner_read_only`);
-    }
     return {
         readContext: context,
-        state: context.localState.state,
-        unlockUntilUnixMs: context.localState.unlockUntilUnixMs,
+        state,
         sender: {
-            localIndex: ownerIdentity.index,
-            scriptPubKeyHex: ownerIdentity.scriptPubKeyHex,
-            address: ownerIdentity.address,
+            localIndex: 0,
+            scriptPubKeyHex: state.funding.scriptPubKeyHex,
+            address: state.funding.address,
         },
-        senderSelector: getCanonicalIdentitySelector(ownerIdentity),
-        anchorOutpoint: resolveAnchorOutpointForSender(context.localState.state, ownerIdentity, errorPrefix),
+        senderSelector: state.funding.address,
         chainDomain,
     };
 }
@@ -241,98 +172,34 @@ function buildAnchoredFieldPlan(options) {
         && entry.confirmations >= 1
         && entry.spendable !== false
         && entry.safe !== false);
-    const anchorUtxo = options.allUtxos.find((entry) => entry.txid === options.anchorOutpoint.txid
-        && entry.vout === options.anchorOutpoint.vout
-        && entry.scriptPubKey === options.sender.scriptPubKeyHex
-        && entry.confirmations >= 1
-        && entry.spendable !== false
-        && entry.safe !== false);
-    if (anchorUtxo === undefined) {
-        throw new Error(`${options.errorPrefix}_anchor_utxo_missing`);
-    }
     return {
         sender: options.sender,
         changeAddress: options.state.funding.address,
-        fixedInputs: [
-            { txid: anchorUtxo.txid, vout: anchorUtxo.vout },
-        ],
-        outputs: [
-            { data: Buffer.from(options.opReturnData).toString("hex") },
-            { [options.sender.address]: satsToBtcNumber(BigInt(options.state.anchorValueSats)) },
-        ],
-        changePosition: 2,
+        fixedInputs: [],
+        outputs: [{ data: Buffer.from(options.opReturnData).toString("hex") }],
+        changePosition: 1,
         expectedOpReturnScriptHex: encodeOpReturnScript(options.opReturnData),
-        expectedAnchorScriptHex: options.sender.scriptPubKeyHex,
-        expectedAnchorValueSats: BigInt(options.state.anchorValueSats),
         allowedFundingScriptPubKeyHex: options.state.funding.scriptPubKeyHex,
         eligibleFundingOutpointKeys: new Set(fundingUtxos.map((entry) => outpointKey({ txid: entry.txid, vout: entry.vout }))),
         errorPrefix: options.errorPrefix,
     };
 }
-function buildFieldFamilyTx2Plan(options) {
-    const fundingUtxos = options.allUtxos.filter((entry) => entry.scriptPubKey === options.state.funding.scriptPubKeyHex
-        && entry.confirmations >= 1
-        && entry.spendable !== false
-        && entry.safe !== false);
-    const tx1FundingChangeInputs = findSpendableFundingInputsFromTransaction({
-        allUtxos: options.allUtxos,
-        txid: options.tx1Txid,
-        fundingScriptPubKeyHex: options.state.funding.scriptPubKeyHex,
-        minConf: 0,
-    });
-    return {
-        sender: options.sender,
-        changeAddress: options.state.funding.address,
-        fixedInputs: [
-            { txid: options.tx1Txid, vout: 1 },
-            ...tx1FundingChangeInputs,
-        ],
-        outputs: [
-            { data: Buffer.from(options.opReturnData).toString("hex") },
-            { [options.sender.address]: satsToBtcNumber(BigInt(options.state.anchorValueSats)) },
-        ],
-        changePosition: 2,
-        expectedOpReturnScriptHex: encodeOpReturnScript(options.opReturnData),
-        expectedAnchorScriptHex: options.sender.scriptPubKeyHex,
-        expectedAnchorValueSats: BigInt(options.state.anchorValueSats),
-        allowedFundingScriptPubKeyHex: options.state.funding.scriptPubKeyHex,
-        eligibleFundingOutpointKeys: new Set(fundingUtxos.map((entry) => outpointKey({ txid: entry.txid, vout: entry.vout }))),
-        errorPrefix: "wallet_field_create_tx2",
-    };
-}
 function validateFieldDraft(decoded, funded, plan) {
     const inputs = decoded.tx.vin;
     const outputs = decoded.tx.vout;
     if (inputs.length === 0) {
         throw new Error(`${plan.errorPrefix}_missing_sender_input`);
     }
-    assertFixedInputPrefixMatches(inputs, plan.fixedInputs, `${plan.errorPrefix}_sender_input_mismatch`);
-    if (getDecodedInputScriptPubKeyHex(decoded, 0) !== plan.sender.scriptPubKeyHex) {
-        throw new Error(`${plan.errorPrefix}_sender_input_mismatch`);
-    }
-    assertFundingInputsAfterFixedPrefix({
-        decoded,
-        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.expectedAnchorScriptHex) {
-        throw new Error(`${plan.errorPrefix}_anchor_output_mismatch`);
-    }
-    if (valueToSats(outputs[1]?.value ?? 0) !== plan.expectedAnchorValueSats) {
-        throw new Error(`${plan.errorPrefix}_anchor_value_mismatch`);
-    }
     if (funded.changepos === -1) {
-        if (outputs.length !== 2) {
+        if (outputs.length !== 1) {
             throw new Error(`${plan.errorPrefix}_unexpected_output_count`);
         }
         return;
     }
-    if (funded.changepos !== plan.changePosition || outputs.length !== 3) {
+    if (funded.changepos !== plan.changePosition || outputs.length !== 2) {
         throw new Error(`${plan.errorPrefix}_change_position_mismatch`);
     }
     if (outputs[funded.changepos]?.scriptPubKey?.hex !== plan.allowedFundingScriptPubKeyHex) {
@@ -348,8 +215,8 @@ async function buildFieldTransaction(options) {
         validateFundedDraft: validateFieldDraft,
         finalizeErrorCode: `${options.plan.errorPrefix}_finalize_failed`,
         mempoolRejectPrefix: `${options.plan.errorPrefix}_mempool_rejected`,
+        feeRate: options.feeRateSatVb,
         availableFundingMinConf: options.availableFundingMinConf,
-        reserveCandidates: options.state.proactiveReserveOutpoints,
     });
 }
 async function saveUpdatedState(options) {
@@ -361,7 +228,6 @@ async function saveUpdatedState(options) {
     await saveWalletStatePreservingUnlock({
         state: nextState,
         provider: options.provider,
-        unlockUntilUnixMs: options.unlockUntilUnixMs,
         nowUnixMs: options.nowUnixMs,
         paths: options.paths,
     });
@@ -384,6 +250,7 @@ function createStandaloneFieldMutation(options) {
             lastUpdatedAtUnixMs: options.nowUnixMs,
             attemptedTxid: null,
             attemptedWtxid: null,
+            ...createWalletMutationFeeMetadata(options.feeSelection),
             temporaryBuilderLockedOutpoints: [],
         };
     }
@@ -405,61 +272,10 @@ function createStandaloneFieldMutation(options) {
         lastUpdatedAtUnixMs: options.nowUnixMs,
         attemptedTxid: null,
         attemptedWtxid: null,
+        ...createWalletMutationFeeMetadata(options.feeSelection),
         temporaryBuilderLockedOutpoints: [],
     };
 }
-function createFieldFamilyRecord(options) {
-    if (options.existing !== null && options.existing !== undefined) {
-        return {
-            ...options.existing,
-            type: "field",
-            status: "draft",
-            domainName: options.domainName,
-            domainId: options.domainId,
-            sourceSenderLocalIndex: options.sender.localIndex,
-            sourceSenderScriptPubKeyHex: options.sender.scriptPubKeyHex,
-            fieldName: options.fieldName,
-            expectedFieldId: options.expectedFieldId,
-            fieldPermanent: options.permanence,
-            fieldFormat: options.format,
-            fieldValueHex: options.valueHex,
-            currentStep: "tx1",
-            lastUpdatedAtUnixMs: options.nowUnixMs,
-            tx1: createFamilyTransactionRecord(),
-            tx2: createFamilyTransactionRecord(),
-        };
-    }
-    return {
-        familyId: randomBytes(12).toString("hex"),
-        type: "field",
-        status: "draft",
-        intentFingerprintHex: options.intentFingerprintHex,
-        createdAtUnixMs: options.nowUnixMs,
-        lastUpdatedAtUnixMs: options.nowUnixMs,
-        domainName: options.domainName,
-        domainId: options.domainId,
-        sourceSenderLocalIndex: options.sender.localIndex,
-        sourceSenderScriptPubKeyHex: options.sender.scriptPubKeyHex,
-        fieldName: options.fieldName,
-        expectedFieldId: options.expectedFieldId,
-        fieldPermanent: options.permanence,
-        fieldFormat: options.format,
-        fieldValueHex: options.valueHex,
-        currentStep: "tx1",
-        tx1: createFamilyTransactionRecord(),
-        tx2: createFamilyTransactionRecord(),
-    };
-}
-function updateFieldFamilyState(options) {
-    return upsertProactiveFamily(options.state, {
-        ...options.family,
-        status: options.status,
-        currentStep: options.currentStep,
-        lastUpdatedAtUnixMs: options.nowUnixMs,
-        tx1: options.tx1 ?? options.family.tx1 ?? createFamilyTransactionRecord(),
-        tx2: options.tx2 ?? options.family.tx2 ?? createFamilyTransactionRecord(),
-    });
-}
 function getObservedFieldState(context, domainName, fieldName) {
     if (context.snapshot === null) {
         return null;
@@ -542,7 +358,6 @@ async function reconcilePendingFieldMutation(options) {
         nextState = await saveUpdatedState({
             state: nextState,
             provider: options.provider,
-            unlockUntilUnixMs: options.unlockUntilUnixMs,
             nowUnixMs: options.nowUnixMs,
             paths: options.paths,
         });
@@ -557,7 +372,6 @@ async function reconcilePendingFieldMutation(options) {
         nextState = await saveUpdatedState({
             state: nextState,
             provider: options.provider,
-            unlockUntilUnixMs: options.unlockUntilUnixMs,
             nowUnixMs: options.nowUnixMs,
             paths: options.paths,
         });
@@ -575,7 +389,6 @@ async function reconcilePendingFieldMutation(options) {
         nextState = await saveUpdatedState({
             state: nextState,
             provider: options.provider,
-            unlockUntilUnixMs: options.unlockUntilUnixMs,
             nowUnixMs: options.nowUnixMs,
             paths: options.paths,
         });
@@ -592,7 +405,6 @@ async function reconcilePendingFieldMutation(options) {
         nextState = await saveUpdatedState({
             state: nextState,
             provider: options.provider,
-            unlockUntilUnixMs: options.unlockUntilUnixMs,
             nowUnixMs: options.nowUnixMs,
             paths: options.paths,
         });
@@ -604,180 +416,6 @@ async function reconcilePendingFieldMutation(options) {
         resolution: "continue",
     };
 }
-async function reconcileFieldFamily(options) {
-    const domainName = options.family.domainName ?? "";
-    const fieldName = options.family.fieldName ?? "";
-    const observed = getObservedFieldState(options.context, domainName, fieldName);
-    if (observed !== null) {
-        if (observed.fieldId === options.family.expectedFieldId
-            && observed.permanent === options.family.fieldPermanent
-            && observed.hasValue
-            && observed.format === options.family.fieldFormat
-            && observed.rawValueHex === options.family.fieldValueHex) {
-            await unlockTemporaryBuilderLocks(options.rpc, options.walletName, options.family.tx1?.temporaryBuilderLockedOutpoints ?? []);
-            await unlockTemporaryBuilderLocks(options.rpc, options.walletName, options.family.tx2?.temporaryBuilderLockedOutpoints ?? []);
-            let nextState = updateFieldFamilyState({
-                state: options.state,
-                family: options.family,
-                status: "confirmed",
-                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: [] },
-            });
-            nextState = await saveUpdatedState({
-                state: nextState,
-                provider: options.provider,
-                unlockUntilUnixMs: options.unlockUntilUnixMs,
-                nowUnixMs: options.nowUnixMs,
-                paths: options.paths,
-            });
-            return {
-                state: nextState,
-                family: findFieldFamilyByIntent(nextState, options.family.intentFingerprintHex) ?? {
-                    ...options.family,
-                    status: "confirmed",
-                },
-                resolution: "confirmed",
-            };
-        }
-        await unlockTemporaryBuilderLocks(options.rpc, options.walletName, options.family.tx1?.temporaryBuilderLockedOutpoints ?? []);
-        await unlockTemporaryBuilderLocks(options.rpc, options.walletName, options.family.tx2?.temporaryBuilderLockedOutpoints ?? []);
-        let nextState = updateFieldFamilyState({
-            state: options.state,
-            family: options.family,
-            status: "repair-required",
-            currentStep: "tx2",
-            nowUnixMs: options.nowUnixMs,
-            tx1: options.family.tx1 == null
-                ? undefined
-                : { ...options.family.tx1, temporaryBuilderLockedOutpoints: [] },
-            tx2: options.family.tx2 == null
-                ? undefined
-                : { ...options.family.tx2, temporaryBuilderLockedOutpoints: [] },
-        });
-        nextState = await saveUpdatedState({
-            state: nextState,
-            provider: options.provider,
-            unlockUntilUnixMs: options.unlockUntilUnixMs,
-            nowUnixMs: options.nowUnixMs,
-            paths: options.paths,
-        });
-        return {
-            state: nextState,
-            family: findFieldFamilyByIntent(nextState, options.family.intentFingerprintHex) ?? {
-                ...options.family,
-                status: "repair-required",
-            },
-            resolution: "repair-required",
-        };
-    }
-    const tx2Known = options.family.tx2?.attemptedTxid == null
-        ? false
-        : await options.rpc.getRawTransaction(options.family.tx2.attemptedTxid, true).then(() => true).catch(() => false);
-    if (tx2Known) {
-        await unlockTemporaryBuilderLocks(options.rpc, options.walletName, options.family.tx2?.temporaryBuilderLockedOutpoints ?? []);
-        let nextState = updateFieldFamilyState({
-            state: options.state,
-            family: options.family,
-            status: "live",
-            currentStep: "tx2",
-            nowUnixMs: options.nowUnixMs,
-            tx2: options.family.tx2 == null
-                ? undefined
-                : { ...options.family.tx2, status: "live", temporaryBuilderLockedOutpoints: [] },
-        });
-        nextState = await saveUpdatedState({
-            state: nextState,
-            provider: options.provider,
-            unlockUntilUnixMs: options.unlockUntilUnixMs,
-            nowUnixMs: options.nowUnixMs,
-            paths: options.paths,
-        });
-        return {
-            state: nextState,
-            family: findFieldFamilyByIntent(nextState, options.family.intentFingerprintHex) ?? {
-                ...options.family,
-                status: "live",
-            },
-            resolution: "live",
-        };
-    }
-    const tx1Known = options.family.tx1?.attemptedTxid == null
-        ? false
-        : await options.rpc.getRawTransaction(options.family.tx1.attemptedTxid, true).then(() => true).catch(() => false);
-    if (tx1Known) {
-        await unlockTemporaryBuilderLocks(options.rpc, options.walletName, options.family.tx1?.temporaryBuilderLockedOutpoints ?? []);
-        let nextState = updateFieldFamilyState({
-            state: options.state,
-            family: options.family,
-            status: "live",
-            currentStep: "tx1",
-            nowUnixMs: options.nowUnixMs,
-            tx1: options.family.tx1 == null
-                ? undefined
-                : { ...options.family.tx1, status: "live", temporaryBuilderLockedOutpoints: [] },
-        });
-        nextState = await saveUpdatedState({
-            state: nextState,
-            provider: options.provider,
-            unlockUntilUnixMs: options.unlockUntilUnixMs,
-            nowUnixMs: options.nowUnixMs,
-            paths: options.paths,
-        });
-        return {
-            state: nextState,
-            family: findFieldFamilyByIntent(nextState, options.family.intentFingerprintHex) ?? {
-                ...options.family,
-                status: "live",
-            },
-            resolution: "ready-for-tx2",
-        };
-    }
-    if (options.family.status === "broadcast-unknown"
-        || options.family.status === "draft"
-        || options.family.status === "broadcasting") {
-        await unlockTemporaryBuilderLocks(options.rpc, options.walletName, options.family.tx1?.temporaryBuilderLockedOutpoints ?? []);
-        await unlockTemporaryBuilderLocks(options.rpc, options.walletName, options.family.tx2?.temporaryBuilderLockedOutpoints ?? []);
-        let nextState = updateFieldFamilyState({
-            state: options.state,
-            family: options.family,
-            status: "canceled",
-            currentStep: options.family.currentStep,
-            nowUnixMs: options.nowUnixMs,
-            tx1: options.family.tx1 == null
-                ? undefined
-                : { ...options.family.tx1, status: options.family.tx1.attemptedTxid === null ? "canceled" : options.family.tx1.status, temporaryBuilderLockedOutpoints: [] },
-            tx2: options.family.tx2 == null
-                ? undefined
-                : { ...options.family.tx2, status: options.family.tx2.attemptedTxid === null ? "canceled" : options.family.tx2.status, temporaryBuilderLockedOutpoints: [] },
-        });
-        nextState = await saveUpdatedState({
-            state: nextState,
-            provider: options.provider,
-            unlockUntilUnixMs: options.unlockUntilUnixMs,
-            nowUnixMs: options.nowUnixMs,
-            paths: options.paths,
-        });
-        return {
-            state: nextState,
-            family: findFieldFamilyByIntent(nextState, options.family.intentFingerprintHex) ?? {
-                ...options.family,
-                status: "canceled",
-            },
-            resolution: "not-seen",
-        };
-    }
-    return {
-        state: options.state,
-        family: options.family,
-        resolution: "continue",
-    };
-}
 async function confirmYesNo(prompter, message, errorCode, options) {
     await confirmSharedYesNo(prompter, message, {
         assumeYes: options.assumeYes,
@@ -799,39 +437,10 @@ async function confirmFieldCreate(prompter, options) {
     const fieldRef = `${options.domainName}:${options.fieldName}`;
     prompter.writeLine(`Creating field "${fieldRef}" as ${options.permanent ? "permanent" : "mutable"}.`);
     prompter.writeLine(`Resolved sender: ${options.sender.selector} (${options.sender.address})`);
-    if (options.value === null) {
-        prompter.writeLine("Path: standalone-field-reg");
-        prompter.writeLine(`Effect: ${describeFieldEffect({ kind: "create-empty-field", burnCogtoshi: "100" })}.`);
-        prompter.writeLine("This publishes a standalone FIELD_REG and burns 0.00000100 COG.");
-        await confirmYesNo(prompter, "The field will be created empty and the burn is not reversible.", "wallet_field_create_confirmation_rejected", {
-            assumeYes: options.assumeYes,
-            requiresTtyErrorCode: "wallet_field_create_requires_tty",
-        });
-        return;
-    }
-    prompter.writeLine("Path: field-reg-plus-data-update-family");
-    prompter.writeLine(`Effect: ${describeFieldEffect({
-        kind: "create-and-initialize-field",
-        tx1BurnCogtoshi: "100",
-        tx2AdditionalBurnCogtoshi: "1",
-    })}.`);
-    prompter.writeLine(`Value: format ${options.value.format}, ${options.value.value.length} bytes`);
-    prompter.writeLine(`Initial value format: ${options.value.formatLabel}`);
-    prompter.writeLine(`Initial value bytes: ${options.value.value.length}`);
-    prompter.writeLine("Warning: non-clear field values are public in the mempool and on-chain.");
-    prompter.writeLine("This uses the same-block FIELD_REG -> DATA_UPDATE family.");
-    prompter.writeLine("Tx1 burns 0.00000100 COG. Tx2 may burn an additional 0.00000001 COG.");
-    prompter.writeLine("Tx1 may confirm even if Tx2 later fails, is canceled, or needs repair.");
-    if (options.permanent) {
-        prompter.writeLine("This is the first non-clear value write to a permanent field.");
-        await confirmTyped(prompter, fieldRef, `Type ${fieldRef} to continue: `, "wallet_field_create_confirmation_rejected", {
-            assumeYes: options.assumeYes,
-            requiresTtyErrorCode: "wallet_field_create_requires_tty",
-            typedAckRequiredErrorCode: "wallet_field_create_typed_ack_required",
-        });
-        return;
-    }
-    await confirmYesNo(prompter, "This creates and initializes the field in the same block family.", "wallet_field_create_confirmation_rejected", {
+    prompter.writeLine("Path: standalone-field-reg");
+    prompter.writeLine(`Effect: ${describeFieldEffect({ kind: "create-empty-field", burnCogtoshi: "100" })}.`);
+    prompter.writeLine("This publishes a standalone FIELD_REG and burns 0.00000100 COG.");
+    await confirmYesNo(prompter, "The field will be created empty and the burn is not reversible.", "wallet_field_create_confirmation_rejected", {
         assumeYes: options.assumeYes,
         requiresTtyErrorCode: "wallet_field_create_requires_tty",
     });
@@ -981,7 +590,6 @@ async function sendStandaloneMutation(options) {
     nextState = await saveUpdatedState({
         state: nextState,
         provider: options.provider,
-        unlockUntilUnixMs: options.unlockUntilUnixMs,
         nowUnixMs: options.nowUnixMs,
         paths: options.paths,
     });
@@ -1004,7 +612,6 @@ async function sendStandaloneMutation(options) {
                 nextState = await saveUpdatedState({
                     state: nextState,
                     provider: options.provider,
-                    unlockUntilUnixMs: options.unlockUntilUnixMs,
                     nowUnixMs: options.nowUnixMs,
                     paths: options.paths,
                 });
@@ -1020,7 +627,6 @@ async function sendStandaloneMutation(options) {
             nextState = await saveUpdatedState({
                 state: nextState,
                 provider: options.provider,
-                unlockUntilUnixMs: options.unlockUntilUnixMs,
                 nowUnixMs: options.nowUnixMs,
                 paths: options.paths,
             });
@@ -1037,228 +643,11 @@ async function sendStandaloneMutation(options) {
     nextState = await saveUpdatedState({
         state: nextState,
         provider: options.provider,
-        unlockUntilUnixMs: options.unlockUntilUnixMs,
         nowUnixMs: options.nowUnixMs,
         paths: options.paths,
     });
     return { state: nextState, mutation: live };
 }
-async function sendFamilyTx1(options) {
-    let nextState = updateFieldFamilyState({
-        state: options.state,
-        family: options.family,
-        status: "broadcasting",
-        currentStep: "tx1",
-        nowUnixMs: options.nowUnixMs,
-        tx1: {
-            status: "broadcasting",
-            attemptedTxid: options.built.txid,
-            attemptedWtxid: options.built.wtxid,
-            temporaryBuilderLockedOutpoints: options.built.temporaryBuilderLockedOutpoints,
-            rawHex: options.built.rawHex,
-        },
-    });
-    nextState = await saveUpdatedState({
-        state: nextState,
-        provider: options.provider,
-        unlockUntilUnixMs: options.unlockUntilUnixMs,
-        nowUnixMs: options.nowUnixMs,
-        paths: options.paths,
-    });
-    if (options.snapshotHeight !== null && options.snapshotHeight !== (await options.rpc.getBlockchainInfo()).blocks) {
-        await unlockTemporaryBuilderLocks(options.rpc, options.walletName, options.built.temporaryBuilderLockedOutpoints);
-        throw new Error("wallet_field_create_tx1_tip_mismatch");
-    }
-    try {
-        await options.rpc.sendRawTransaction(options.built.rawHex);
-    }
-    catch (error) {
-        if (!isAlreadyAcceptedError(error)) {
-            if (isBroadcastUnknownError(error)) {
-                nextState = updateFieldFamilyState({
-                    state: nextState,
-                    family: findFieldFamilyByIntent(nextState, options.family.intentFingerprintHex) ?? options.family,
-                    status: "broadcast-unknown",
-                    currentStep: "tx1",
-                    nowUnixMs: options.nowUnixMs,
-                    tx1: {
-                        status: "broadcast-unknown",
-                        attemptedTxid: options.built.txid,
-                        attemptedWtxid: options.built.wtxid,
-                        temporaryBuilderLockedOutpoints: options.built.temporaryBuilderLockedOutpoints,
-                        rawHex: options.built.rawHex,
-                    },
-                });
-                nextState = await saveUpdatedState({
-                    state: nextState,
-                    provider: options.provider,
-                    unlockUntilUnixMs: options.unlockUntilUnixMs,
-                    nowUnixMs: options.nowUnixMs,
-                    paths: options.paths,
-                });
-                throw new Error("wallet_field_create_tx1_broadcast_unknown");
-            }
-            await unlockTemporaryBuilderLocks(options.rpc, options.walletName, options.built.temporaryBuilderLockedOutpoints);
-            nextState = updateFieldFamilyState({
-                state: nextState,
-                family: findFieldFamilyByIntent(nextState, options.family.intentFingerprintHex) ?? options.family,
-                status: "canceled",
-                currentStep: "tx1",
-                nowUnixMs: options.nowUnixMs,
-                tx1: {
-                    status: "canceled",
-                    attemptedTxid: options.built.txid,
-                    attemptedWtxid: options.built.wtxid,
-                    temporaryBuilderLockedOutpoints: [],
-                    rawHex: options.built.rawHex,
-                },
-            });
-            nextState = await saveUpdatedState({
-                state: nextState,
-                provider: options.provider,
-                unlockUntilUnixMs: options.unlockUntilUnixMs,
-                nowUnixMs: options.nowUnixMs,
-                paths: options.paths,
-            });
-            throw error;
-        }
-    }
-    await unlockTemporaryBuilderLocks(options.rpc, options.walletName, options.built.temporaryBuilderLockedOutpoints);
-    nextState = updateFieldFamilyState({
-        state: nextState,
-        family: findFieldFamilyByIntent(nextState, options.family.intentFingerprintHex) ?? options.family,
-        status: "live",
-        currentStep: "tx1",
-        nowUnixMs: options.nowUnixMs,
-        tx1: {
-            status: "live",
-            attemptedTxid: options.built.txid,
-            attemptedWtxid: options.built.wtxid,
-            temporaryBuilderLockedOutpoints: [],
-            rawHex: options.built.rawHex,
-        },
-    });
-    nextState = await saveUpdatedState({
-        state: nextState,
-        provider: options.provider,
-        unlockUntilUnixMs: options.unlockUntilUnixMs,
-        nowUnixMs: options.nowUnixMs,
-        paths: options.paths,
-    });
-    return {
-        state: nextState,
-        family: findFieldFamilyByIntent(nextState, options.family.intentFingerprintHex) ?? {
-            ...options.family,
-            status: "live",
-        },
-    };
-}
-async function sendFamilyTx2(options) {
-    let nextState = updateFieldFamilyState({
-        state: options.state,
-        family: options.family,
-        status: "broadcasting",
-        currentStep: "tx2",
-        nowUnixMs: options.nowUnixMs,
-        tx2: {
-            status: "broadcasting",
-            attemptedTxid: options.built.txid,
-            attemptedWtxid: options.built.wtxid,
-            temporaryBuilderLockedOutpoints: options.built.temporaryBuilderLockedOutpoints,
-            rawHex: options.built.rawHex,
-        },
-    });
-    nextState = await saveUpdatedState({
-        state: nextState,
-        provider: options.provider,
-        unlockUntilUnixMs: options.unlockUntilUnixMs,
-        nowUnixMs: options.nowUnixMs,
-        paths: options.paths,
-    });
-    try {
-        await options.rpc.sendRawTransaction(options.built.rawHex);
-    }
-    catch (error) {
-        if (!isAlreadyAcceptedError(error)) {
-            if (isBroadcastUnknownError(error)) {
-                nextState = updateFieldFamilyState({
-                    state: nextState,
-                    family: findFieldFamilyByIntent(nextState, options.family.intentFingerprintHex) ?? options.family,
-                    status: "broadcast-unknown",
-                    currentStep: "tx2",
-                    nowUnixMs: options.nowUnixMs,
-                    tx2: {
-                        status: "broadcast-unknown",
-                        attemptedTxid: options.built.txid,
-                        attemptedWtxid: options.built.wtxid,
-                        temporaryBuilderLockedOutpoints: options.built.temporaryBuilderLockedOutpoints,
-                        rawHex: options.built.rawHex,
-                    },
-                });
-                nextState = await saveUpdatedState({
-                    state: nextState,
-                    provider: options.provider,
-                    unlockUntilUnixMs: options.unlockUntilUnixMs,
-                    nowUnixMs: options.nowUnixMs,
-                    paths: options.paths,
-                });
-                throw new Error("wallet_field_create_tx2_broadcast_unknown");
-            }
-            await unlockTemporaryBuilderLocks(options.rpc, options.walletName, options.built.temporaryBuilderLockedOutpoints);
-            nextState = updateFieldFamilyState({
-                state: nextState,
-                family: findFieldFamilyByIntent(nextState, options.family.intentFingerprintHex) ?? options.family,
-                status: "live",
-                currentStep: "tx1",
-                nowUnixMs: options.nowUnixMs,
-                tx2: {
-                    status: "canceled",
-                    attemptedTxid: options.built.txid,
-                    attemptedWtxid: options.built.wtxid,
-                    temporaryBuilderLockedOutpoints: [],
-                    rawHex: options.built.rawHex,
-                },
-            });
-            nextState = await saveUpdatedState({
-                state: nextState,
-                provider: options.provider,
-                unlockUntilUnixMs: options.unlockUntilUnixMs,
-                nowUnixMs: options.nowUnixMs,
-                paths: options.paths,
-            });
-            throw error;
-        }
-    }
-    await unlockTemporaryBuilderLocks(options.rpc, options.walletName, options.built.temporaryBuilderLockedOutpoints);
-    nextState = updateFieldFamilyState({
-        state: nextState,
-        family: findFieldFamilyByIntent(nextState, options.family.intentFingerprintHex) ?? options.family,
-        status: "live",
-        currentStep: "tx2",
-        nowUnixMs: options.nowUnixMs,
-        tx2: {
-            status: "live",
-            attemptedTxid: options.built.txid,
-            attemptedWtxid: options.built.wtxid,
-            temporaryBuilderLockedOutpoints: [],
-            rawHex: options.built.rawHex,
-        },
-    });
-    nextState = await saveUpdatedState({
-        state: nextState,
-        provider: options.provider,
-        unlockUntilUnixMs: options.unlockUntilUnixMs,
-        nowUnixMs: options.nowUnixMs,
-        paths: options.paths,
-    });
-    return {
-        state: nextState,
-        family: findFieldFamilyByIntent(nextState, options.family.intentFingerprintHex) ?? {
-            ...options.family,
-            status: "live",
-        },
-    };
-}
 async function submitStandaloneFieldMutation(options) {
     if (!options.prompter.isInteractive && options.assumeYes !== true) {
         throw new Error(`${options.errorPrefix}_requires_tty`);
@@ -1293,82 +682,91 @@ async function submitStandaloneFieldMutation(options) {
                 normalizedDomainName,
                 normalizedFieldName,
             ]);
+            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;
+            const feeSelection = await resolveWalletMutationFeeSelection({
+                rpc,
+                feeRateSatVb: options.feeRateSatVb ?? null,
+            });
             const existingMutation = findPendingMutationByIntent(operation.state, intentFingerprintHex);
+            let workingState = operation.state;
+            let replacementFixedInputs = null;
             if (existingMutation !== null) {
-                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;
                 const reconciled = await reconcilePendingFieldMutation({
                     state: operation.state,
                     mutation: existingMutation,
                     provider,
-                    unlockUntilUnixMs: operation.unlockUntilUnixMs,
                     nowUnixMs,
                     paths,
                     rpc,
                     walletName,
                     context: readContext,
                 });
+                workingState = reconciled.state;
                 if (reconciled.resolution === "confirmed" || reconciled.resolution === "live") {
-                    return {
-                        kind: options.kind,
-                        domainName: normalizedDomainName,
-                        fieldName: normalizedFieldName,
-                        fieldId: reconciled.mutation.fieldId ?? existingObservedField?.fieldId ?? null,
-                        txid: reconciled.mutation.attemptedTxid ?? "unknown",
-                        family: false,
-                        permanent: reconciled.mutation.fieldPermanent ?? existingObservedField?.permanent ?? null,
-                        format: reconciled.mutation.fieldFormat ?? existingObservedField?.format ?? null,
-                        status: reconciled.resolution,
-                        reusedExisting: true,
-                        resolved: createResolvedFieldSummary({
-                            sender: operation.sender,
-                            senderSelector: operation.senderSelector,
+                    const reuse = await resolvePendingMutationReuseDecision({
+                        rpc,
+                        walletName,
+                        mutation: reconciled.mutation,
+                        nextFeeSelection: feeSelection,
+                    });
+                    if (reuse.reuseExisting) {
+                        return {
                             kind: options.kind,
-                            family: false,
-                            value: createResolvedFieldValueFromStoredData(options.kind, reconciled.mutation.fieldFormat ?? existingObservedField?.format ?? null, reconciled.mutation.fieldValueHex),
-                        }),
-                    };
+                            domainName: normalizedDomainName,
+                            fieldName: normalizedFieldName,
+                            fieldId: reconciled.mutation.fieldId ?? existingObservedField?.fieldId ?? null,
+                            txid: reconciled.mutation.attemptedTxid ?? "unknown",
+                            permanent: reconciled.mutation.fieldPermanent ?? existingObservedField?.permanent ?? null,
+                            format: reconciled.mutation.fieldFormat ?? existingObservedField?.format ?? null,
+                            status: reconciled.resolution,
+                            reusedExisting: true,
+                            resolved: createResolvedFieldSummary({
+                                sender: operation.sender,
+                                senderSelector: operation.senderSelector,
+                                kind: options.kind,
+                                value: createResolvedFieldValueFromStoredData(options.kind, reconciled.mutation.fieldFormat ?? existingObservedField?.format ?? null, reconciled.mutation.fieldValueHex),
+                            }),
+                            fees: reuse.fees,
+                        };
+                    }
+                    replacementFixedInputs = reuse.replacementFixedInputs;
                 }
                 if (reconciled.resolution === "repair-required") {
                     throw new Error(`${options.errorPrefix}_repair_required`);
                 }
             }
             await options.confirm(operation);
-            const planned = await options.createMutation(operation, existingMutation);
-            let nextState = upsertPendingMutation(operation.state, planned.mutation);
+            const planned = await options.createMutation(operation, existingMutation, feeSelection);
+            let nextState = upsertPendingMutation(workingState, planned.mutation);
             nextState = await saveUpdatedState({
                 state: nextState,
                 provider,
-                unlockUntilUnixMs: operation.unlockUntilUnixMs,
                 nowUnixMs,
                 paths,
             });
-            const node = await (options.attachService ?? attachOrStartManagedBitcoindService)({
-                dataDir: options.dataDir,
-                chain: "main",
-                startHeight: 0,
-                walletRootId: operation.state.walletRootId,
+            const fieldPlan = buildAnchoredFieldPlan({
+                state: nextState,
+                allUtxos: await rpc.listUnspent(walletName, 1),
+                sender: operation.sender,
+                opReturnData: planned.opReturnData,
+                errorPrefix: options.errorPrefix,
             });
-            const rpc = (options.rpcFactory ?? createRpcClient)(node.rpc);
-            const walletName = operation.state.managedCoreWallet.walletName;
             const built = await buildFieldTransaction({
                 rpc,
                 walletName,
                 state: nextState,
-                plan: buildAnchoredFieldPlan({
-                    state: nextState,
-                    allUtxos: await rpc.listUnspent(walletName, 1),
-                    sender: operation.sender,
-                    anchorOutpoint: operation.anchorOutpoint,
-                    opReturnData: planned.opReturnData,
-                    errorPrefix: options.errorPrefix,
-                }),
+                plan: {
+                    ...fieldPlan,
+                    fixedInputs: mergeFixedWalletInputs(fieldPlan.fixedInputs, replacementFixedInputs),
+                },
+                feeRateSatVb: feeSelection.feeRateSatVb,
             });
             const final = await sendStandaloneMutation({
                 rpc,
@@ -1378,7 +776,6 @@ async function submitStandaloneFieldMutation(options) {
                 mutation: nextState.pendingMutations.find((mutation) => mutation.intentFingerprintHex === planned.mutation.intentFingerprintHex),
                 state: nextState,
                 provider,
-                unlockUntilUnixMs: operation.unlockUntilUnixMs,
                 nowUnixMs,
                 paths,
                 errorPrefix: options.errorPrefix,
@@ -1389,7 +786,6 @@ async function submitStandaloneFieldMutation(options) {
                 fieldName: normalizedFieldName,
                 fieldId: final.mutation.fieldId ?? existingObservedField?.fieldId ?? null,
                 txid: final.mutation.attemptedTxid ?? built.txid,
-                family: false,
                 permanent: final.mutation.fieldPermanent ?? existingObservedField?.permanent ?? null,
                 format: final.mutation.fieldFormat ?? existingObservedField?.format ?? null,
                 status: "live",
@@ -1398,238 +794,11 @@ async function submitStandaloneFieldMutation(options) {
                     sender: operation.sender,
                     senderSelector: operation.senderSelector,
                     kind: options.kind,
-                    family: false,
                     value: createResolvedFieldValueFromStoredData(options.kind, planned.mutation.fieldFormat ?? existingObservedField?.format ?? null, planned.mutation.fieldValueHex),
                 }),
-            };
-        }
-        finally {
-            await readContext.close();
-            await miningPreemption.release();
-        }
-    }
-    finally {
-        await controlLock.release();
-    }
-}
-async function submitFieldCreateFamily(options) {
-    if (!options.prompter.isInteractive && options.assumeYes !== true) {
-        throw new Error("wallet_field_create_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_field_create",
-        walletRootId: null,
-    });
-    try {
-        const miningPreemption = await pauseMiningForWalletMutation({
-            paths,
-            reason: "wallet_field_create",
-        });
-        const readContext = await (options.openReadContext ?? openWalletReadContext)({
-            dataDir: options.dataDir,
-            databasePath: options.databasePath,
-            secretProvider: provider,
-            walletControlLockHeld: true,
-            paths,
-        });
-        try {
-            const normalizedDomainName = normalizeDomainName(options.domainName);
-            const normalizedFieldName = normalizeFieldName(options.fieldName);
-            const operation = resolveAnchoredFieldOperation(readContext, normalizedDomainName, "wallet_field_create");
-            const existingField = getObservedFieldState(readContext, normalizedDomainName, normalizedFieldName);
-            if (existingField !== null) {
-                throw new Error("wallet_field_create_field_exists");
-            }
-            if (operation.chainDomain.nextFieldId === 0xffff_ffff) {
-                throw new Error("wallet_field_create_field_id_exhausted");
-            }
-            if (hex(operation.chainDomain.delegate) !== null) {
-                throw new Error("wallet_field_create_delegate_blocks_same_block_family");
-            }
-            const senderBalance = getBalance(operation.readContext.snapshot.state, Buffer.from(operation.sender.scriptPubKeyHex, "hex"));
-            if (senderBalance < 101n) {
-                throw new Error("wallet_field_create_insufficient_cog");
-            }
-            const intentFingerprintHex = createIntentFingerprint([
-                "field-create",
-                operation.state.walletRootId,
-                normalizedDomainName,
-                normalizedFieldName,
-                options.permanent ? 1 : 0,
-                options.value.format,
-                options.value.valueHex,
-            ]);
-            const existingFamily = findFieldFamilyByIntent(operation.state, intentFingerprintHex);
-            const conflictingFamily = findActiveFieldFamilyByDomain(operation.state, normalizedDomainName);
-            if (conflictingFamily !== null && conflictingFamily.intentFingerprintHex !== intentFingerprintHex) {
-                throw new Error("wallet_field_create_family_already_active");
-            }
-            const conflictingCreate = findActiveFieldCreateMutationByDomain(operation.state, normalizedDomainName, intentFingerprintHex);
-            if (conflictingCreate !== null) {
-                throw new Error("wallet_field_create_registration_already_pending");
-            }
-            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 workingState = operation.state;
-            let resumedFamily = null;
-            if (existingFamily !== null) {
-                const reconciled = await reconcileFieldFamily({
-                    state: workingState,
-                    family: existingFamily,
-                    provider,
-                    nowUnixMs,
-                    paths,
-                    unlockUntilUnixMs: operation.unlockUntilUnixMs,
-                    rpc,
-                    walletName,
-                    context: readContext,
-                });
-                workingState = reconciled.state;
-                if (reconciled.resolution === "confirmed" || reconciled.resolution === "live") {
-                    return {
-                        kind: "field-create",
-                        domainName: normalizedDomainName,
-                        fieldName: normalizedFieldName,
-                        fieldId: reconciled.family.expectedFieldId ?? null,
-                        txid: reconciled.family.tx2?.attemptedTxid ?? reconciled.family.tx1?.attemptedTxid ?? "unknown",
-                        tx1Txid: reconciled.family.tx1?.attemptedTxid ?? null,
-                        tx2Txid: reconciled.family.tx2?.attemptedTxid ?? null,
-                        family: true,
-                        permanent: reconciled.family.fieldPermanent ?? null,
-                        format: reconciled.family.fieldFormat ?? null,
-                        status: reconciled.resolution,
-                        reusedExisting: true,
-                        resolved: createResolvedFieldSummary({
-                            sender: operation.sender,
-                            senderSelector: operation.senderSelector,
-                            kind: "field-create",
-                            family: true,
-                            value: createResolvedFieldValueFromStoredData("field-create", reconciled.family.fieldFormat ?? null, reconciled.family.fieldValueHex),
-                        }),
-                    };
-                }
-                if (reconciled.resolution === "repair-required") {
-                    throw new Error("wallet_field_create_repair_required");
-                }
-                if (reconciled.resolution === "ready-for-tx2") {
-                    resumedFamily = reconciled.family;
-                }
-            }
-            if (resumedFamily === null) {
-                await confirmFieldCreate(options.prompter, {
-                    domainName: normalizedDomainName,
-                    fieldName: normalizedFieldName,
-                    permanent: options.permanent,
-                    value: options.value,
-                    sender: createResolvedFieldSenderSummary(operation.sender, operation.senderSelector),
-                    assumeYes: options.assumeYes,
-                });
-                let nextState = upsertProactiveFamily(workingState, createFieldFamilyRecord({
-                    domainName: normalizedDomainName,
-                    domainId: operation.chainDomain.domainId,
-                    fieldName: normalizedFieldName,
-                    expectedFieldId: operation.chainDomain.nextFieldId,
-                    sender: operation.sender,
-                    permanence: options.permanent,
-                    format: options.value.format,
-                    valueHex: options.value.valueHex,
-                    intentFingerprintHex,
-                    nowUnixMs,
-                    existing: existingFamily,
-                }));
-                nextState = await saveUpdatedState({
-                    state: nextState,
-                    provider,
-                    unlockUntilUnixMs: operation.unlockUntilUnixMs,
-                    nowUnixMs,
-                    paths,
-                });
-                const family = findFieldFamilyByIntent(nextState, intentFingerprintHex);
-                const tx1 = await buildFieldTransaction({
-                    rpc,
-                    walletName,
-                    state: nextState,
-                    plan: buildAnchoredFieldPlan({
-                        state: nextState,
-                        allUtxos: await rpc.listUnspent(walletName, 1),
-                        sender: operation.sender,
-                        anchorOutpoint: operation.anchorOutpoint,
-                        opReturnData: serializeFieldReg(operation.chainDomain.domainId, options.permanent, normalizedFieldName).opReturnData,
-                        errorPrefix: "wallet_field_create_tx1",
-                    }),
-                });
-                const afterTx1 = await sendFamilyTx1({
-                    rpc,
-                    walletName,
-                    snapshotHeight: readContext.snapshot?.tip?.height ?? null,
-                    built: tx1,
-                    family,
-                    state: nextState,
-                    provider,
-                    unlockUntilUnixMs: operation.unlockUntilUnixMs,
-                    nowUnixMs,
-                    paths,
-                });
-                workingState = afterTx1.state;
-                resumedFamily = afterTx1.family;
-            }
-            const tx1Txid = resumedFamily.tx1?.attemptedTxid;
-            if (tx1Txid == null) {
-                throw new Error("wallet_field_create_tx1_missing");
-            }
-            await rpc.getRawTransaction(tx1Txid, true);
-            const tx2 = await buildFieldTransaction({
-                rpc,
-                walletName,
-                state: workingState,
-                availableFundingMinConf: 0,
-                plan: buildFieldFamilyTx2Plan({
-                    state: workingState,
-                    allUtxos: await rpc.listUnspent(walletName, 0),
-                    sender: operation.sender,
-                    tx1Txid,
-                    opReturnData: serializeDataUpdate(operation.chainDomain.domainId, resumedFamily.expectedFieldId ?? operation.chainDomain.nextFieldId, options.value.format, options.value.value).opReturnData,
-                }),
-            });
-            const final = await sendFamilyTx2({
-                rpc,
-                walletName,
-                built: tx2,
-                family: resumedFamily,
-                state: workingState,
-                provider,
-                unlockUntilUnixMs: operation.unlockUntilUnixMs,
-                nowUnixMs,
-                paths,
-            });
-            return {
-                kind: "field-create",
-                domainName: normalizedDomainName,
-                fieldName: normalizedFieldName,
-                fieldId: final.family.expectedFieldId ?? null,
-                txid: final.family.tx2?.attemptedTxid ?? tx2.txid,
-                tx1Txid,
-                tx2Txid: final.family.tx2?.attemptedTxid ?? tx2.txid,
-                family: true,
-                permanent: final.family.fieldPermanent ?? null,
-                format: final.family.fieldFormat ?? null,
-                status: "live",
-                reusedExisting: existingFamily !== null,
-                resolved: createResolvedFieldSummary({
-                    sender: operation.sender,
-                    senderSelector: operation.senderSelector,
-                    kind: "field-create",
-                    family: true,
-                    value: createResolvedFieldValueSummary(options.value.format, options.value.value),
+                fees: createBuiltWalletMutationFeeSummary({
+                    selection: feeSelection,
+                    built,
                 }),
             };
         }
@@ -1643,15 +812,7 @@ async function submitFieldCreateFamily(options) {
     }
 }
 export async function createField(options) {
-    const normalizedSource = options.source == null ? null : await loadFieldValue(options.source);
     const permanent = options.permanent ?? false;
-    if (normalizedSource !== null) {
-        return submitFieldCreateFamily({
-            ...options,
-            permanent,
-            value: normalizedSource,
-        });
-    }
     return submitStandaloneFieldMutation({
         kind: "field-create",
         errorPrefix: "wallet_field_create",
@@ -1667,7 +828,7 @@ export async function createField(options) {
         openReadContext: options.openReadContext,
         attachService: options.attachService,
         rpcFactory: options.rpcFactory,
-        async createMutation(operation, existing) {
+        async createMutation(operation, existing, feeSelection) {
             const existingField = getObservedFieldState(operation.readContext, normalizeDomainName(options.domainName), normalizeFieldName(options.fieldName));
             if (existingField !== null) {
                 throw new Error("wallet_field_create_field_exists");
@@ -1688,10 +849,6 @@ export async function createField(options) {
                 normalizedFieldName,
                 permanent ? 1 : 0,
             ]);
-            const conflictFamily = findActiveFieldFamilyByDomain(operation.state, normalizedDomainName);
-            if (conflictFamily !== null && conflictFamily.intentFingerprintHex !== intentFingerprintHex) {
-                throw new Error("wallet_field_create_family_already_active");
-            }
             const conflictCreate = findActiveFieldCreateMutationByDomain(operation.state, normalizedDomainName, intentFingerprintHex);
             if (conflictCreate !== null) {
                 throw new Error("wallet_field_create_registration_already_pending");
@@ -1705,6 +862,7 @@ export async function createField(options) {
                     sender: operation.sender,
                     intentFingerprintHex,
                     nowUnixMs: options.nowUnixMs ?? Date.now(),
+                    feeSelection,
                     existing,
                     fieldId: operation.chainDomain.nextFieldId,
                     fieldPermanent: permanent,
@@ -1716,7 +874,6 @@ export async function createField(options) {
                 domainName: normalizeDomainName(options.domainName),
                 fieldName: normalizeFieldName(options.fieldName),
                 permanent,
-                value: null,
                 sender: createResolvedFieldSenderSummary(operation.sender, operation.senderSelector),
                 assumeYes: options.assumeYes,
             });
@@ -1740,7 +897,7 @@ export async function setField(options) {
         openReadContext: options.openReadContext,
         attachService: options.attachService,
         rpcFactory: options.rpcFactory,
-        async createMutation(operation, existing) {
+        async createMutation(operation, existing, feeSelection) {
             const normalizedDomainName = normalizeDomainName(options.domainName);
             const normalizedFieldName = normalizeFieldName(options.fieldName);
             const observedField = getObservedFieldState(operation.readContext, normalizedDomainName, normalizedFieldName);
@@ -1771,6 +928,7 @@ export async function setField(options) {
                     sender: operation.sender,
                     intentFingerprintHex,
                     nowUnixMs: options.nowUnixMs ?? Date.now(),
+                    feeSelection,
                     existing,
                     fieldId: observedField.fieldId,
                     fieldPermanent: observedField.permanent,
@@ -1814,7 +972,7 @@ export async function clearField(options) {
         openReadContext: options.openReadContext,
         attachService: options.attachService,
         rpcFactory: options.rpcFactory,
-        async createMutation(operation, existing) {
+        async createMutation(operation, existing, feeSelection) {
             const normalizedDomainName = normalizeDomainName(options.domainName);
             const normalizedFieldName = normalizeFieldName(options.fieldName);
             const observedField = getObservedFieldState(operation.readContext, normalizedDomainName, normalizedFieldName);
@@ -1839,6 +997,7 @@ export async function clearField(options) {
                     sender: operation.sender,
                     intentFingerprintHex,
                     nowUnixMs: options.nowUnixMs ?? Date.now(),
+                    feeSelection,
                     existing,
                     fieldId: observedField.fieldId,
                     fieldPermanent: observedField.permanent,