@cogcoin/client 0.5.12 → 0.5.14

package/dist/wallet/tx/common.js

@@ -2,8 +2,17 @@ import { randomBytes } from "node:crypto";
 import { saveUnlockSession } from "../state/session.js";
 import { saveWalletState } from "../state/storage.js";
 import { createWalletSecretReference, } from "../state/provider.js";
+import { reconcilePersistentPolicyLocks as reconcileWalletCoinControlLocks } from "../coin-control.js";
 import { requestMiningGenerationPreemption } from "../mining/coordination.js";
 export const DEFAULT_WALLET_MUTATION_FEE_RATE_SAT_VB = 10;
+function btcNumberToSats(value) {
+    return BigInt(Math.round(value * 100_000_000));
+}
+function valueToSats(value) {
+    return typeof value === "string"
+        ? BigInt(Math.round(Number(value) * 100_000_000))
+        : btcNumberToSats(value);
+}
 function createUnlockSessionState(state, unlockUntilUnixMs, nowUnixMs) {
     return {
         schemaVersion: 1,
@@ -39,6 +48,12 @@ export function formatCogAmount(value) {
 export function outpointKey(outpoint) {
     return `${outpoint.txid}:${outpoint.vout}`;
 }
+function isSpendableConfirmedFundingUtxo(entry, fundingScriptPubKeyHex) {
+    return entry.scriptPubKey === fundingScriptPubKeyHex
+        && entry.confirmations >= 1
+        && entry.spendable !== false
+        && entry.safe !== false;
+}
 export function updateMutationRecord(mutation, status, nowUnixMs, options = {}) {
     return {
         ...mutation,
@@ -64,6 +79,53 @@ export function diffTemporaryLockedOutpoints(before, after) {
         vout: entry.vout,
     }));
 }
+export function getDecodedInputScriptPubKeyHex(input) {
+    return input.prevout?.scriptPubKey?.hex ?? null;
+}
+export function getDecodedInputVout(input) {
+    const vout = input.vout;
+    return typeof vout === "number" ? vout : null;
+}
+export function inputMatchesOutpoint(input, outpoint) {
+    return input.txid === outpoint.txid && getDecodedInputVout(input) === outpoint.vout;
+}
+export function assertFixedInputPrefixMatches(inputs, fixedInputs, errorCode) {
+    if (inputs.length < fixedInputs.length) {
+        throw new Error(errorCode);
+    }
+    for (const [index, fixedInput] of fixedInputs.entries()) {
+        if (!inputMatchesOutpoint(inputs[index], fixedInput)) {
+            throw new Error(errorCode);
+        }
+    }
+}
+export function assertFundingInputsAfterFixedPrefix(options) {
+    for (let index = options.fixedInputs.length; index < options.inputs.length; index += 1) {
+        const input = options.inputs[index];
+        const scriptPubKeyHex = getDecodedInputScriptPubKeyHex(input);
+        const vout = getDecodedInputVout(input);
+        if (scriptPubKeyHex !== options.allowedFundingScriptPubKeyHex || vout === null || typeof input.txid !== "string") {
+            throw new Error(options.errorCode);
+        }
+        const key = outpointKey({
+            txid: input.txid,
+            vout,
+        });
+        if (!options.eligibleFundingOutpointKeys.has(key)) {
+            throw new Error(options.errorCode);
+        }
+    }
+}
+export async function reconcilePersistentPolicyLocks(options) {
+    await reconcileWalletCoinControlLocks({
+        rpc: options.rpc,
+        walletName: options.walletName,
+        state: options.state,
+        fixedInputs: options.fixedInputs,
+        temporarilyUnlockedOutpoints: options.temporarilyUnlockedOutpoints,
+        cleanupInactiveTemporaryBuilderLocks: options.cleanupInactiveTemporaryBuilderLocks,
+    });
+}
 export function isBroadcastUnknownError(error) {
     const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
     return message.includes("timeout")
@@ -80,6 +142,38 @@ export function isAlreadyAcceptedError(error) {
         || message.includes("already in blockchain")
         || message.includes("txn-already-known");
 }
+export function isInsufficientFundsError(error) {
+    const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+    return message.includes("insufficient funds");
+}
+function isReserveFloorFundingError(error) {
+    const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+    return message.includes("insufficient_funding_after_reserve");
+}
+function computeRemainingFundingValueSats(options) {
+    let remaining = 0n;
+    for (const value of options.availableFundingValueByKey.values()) {
+        remaining += value;
+    }
+    for (const input of options.transaction.vin) {
+        const scriptPubKeyHex = getDecodedInputScriptPubKeyHex(input);
+        const vout = getDecodedInputVout(input);
+        if (scriptPubKeyHex !== options.fundingScriptPubKeyHex || vout === null || typeof input.txid !== "string") {
+            continue;
+        }
+        remaining -= options.availableFundingValueByKey.get(outpointKey({
+            txid: input.txid,
+            vout,
+        })) ?? 0n;
+    }
+    for (const output of options.transaction.vout) {
+        if (output.scriptPubKey?.hex !== options.fundingScriptPubKeyHex) {
+            continue;
+        }
+        remaining += valueToSats(output.value);
+    }
+    return remaining;
+}
 export function assertWalletMutationContextReady(context, errorPrefix) {
     if (context.localState.availability === "uninitialized") {
         throw new Error("wallet_uninitialized");
@@ -110,16 +204,36 @@ export async function pauseMiningForWalletMutation(options) {
     });
 }
 export async function buildWalletMutationTransaction(options) {
+    await reconcilePersistentPolicyLocks({
+        rpc: options.rpc,
+        walletName: options.walletName,
+        state: options.state,
+        fixedInputs: options.plan.fixedInputs,
+        temporarilyUnlockedOutpoints: options.temporarilyUnlockedPolicyOutpoints,
+    });
+    const availableFundingUtxos = (await options.rpc.listUnspent(options.walletName, 1))
+        .filter((entry) => isSpendableConfirmedFundingUtxo(entry, options.plan.allowedFundingScriptPubKeyHex));
+    const availableFundingValueByKey = new Map(availableFundingUtxos.map((entry) => [
+        outpointKey({ txid: entry.txid, vout: entry.vout }),
+        btcNumberToSats(entry.amount),
+    ]));
+    const validationPlan = {
+        ...options.plan,
+        eligibleFundingOutpointKeys: new Set([
+            ...options.plan.eligibleFundingOutpointKeys,
+            ...availableFundingUtxos.map((entry) => outpointKey({ txid: entry.txid, vout: entry.vout })),
+        ]),
+    };
     const lockedBefore = await options.rpc.listLockUnspent(options.walletName);
     let temporaryBuilderLockedOutpoints = [];
     try {
-        const funded = await options.rpc.walletCreateFundedPsbt(options.walletName, options.plan.inputs, options.plan.outputs, 0, {
-            add_inputs: options.builderOptions?.addInputs ?? true,
-            include_unsafe: options.builderOptions?.includeUnsafe ?? false,
-            minconf: options.builderOptions?.minConf ?? 1,
+        const funded = await options.rpc.walletCreateFundedPsbt(options.walletName, options.plan.fixedInputs, options.plan.outputs, 0, {
+            add_inputs: true,
+            include_unsafe: false,
+            minconf: 1,
             changeAddress: options.plan.changeAddress,
             changePosition: options.plan.changePosition,
-            lockUnspents: options.builderOptions?.lockUnspents ?? true,
+            lockUnspents: true,
             fee_rate: options.feeRate ?? DEFAULT_WALLET_MUTATION_FEE_RATE_SAT_VB,
             replaceable: true,
             subtractFeeFromOutputs: [],
@@ -127,7 +241,17 @@ export async function buildWalletMutationTransaction(options) {
         const lockedAfter = await options.rpc.listLockUnspent(options.walletName);
         temporaryBuilderLockedOutpoints = diffTemporaryLockedOutpoints(lockedBefore, lockedAfter);
         const decoded = await options.rpc.decodePsbt(funded.psbt);
-        options.validateFundedDraft(decoded, funded, options.plan);
+        options.validateFundedDraft(decoded, funded, validationPlan);
+        if (options.state.proactiveReserveSats > 0) {
+            const remainingFundingValueSats = computeRemainingFundingValueSats({
+                transaction: decoded.tx,
+                fundingScriptPubKeyHex: options.plan.allowedFundingScriptPubKeyHex,
+                availableFundingValueByKey,
+            });
+            if (remainingFundingValueSats < BigInt(options.state.proactiveReserveSats)) {
+                throw new Error("wallet_mutation_insufficient_funding_after_reserve");
+            }
+        }
         const signed = await options.rpc.walletProcessPsbt(options.walletName, funded.psbt, true, "DEFAULT");
         const finalized = await options.rpc.finalizePsbt(signed.psbt, true);
         if (!finalized.complete || finalized.hex == null) {
@@ -139,6 +263,14 @@ export async function buildWalletMutationTransaction(options) {
         if (accepted == null || !accepted.allowed) {
             throw new Error(`${options.mempoolRejectPrefix}_${accepted?.["reject-reason"] ?? "unknown"}`);
         }
+        if ((options.temporarilyUnlockedPolicyOutpoints?.length ?? 0) > 0) {
+            await reconcilePersistentPolicyLocks({
+                rpc: options.rpc,
+                walletName: options.walletName,
+                state: options.state,
+                fixedInputs: options.plan.fixedInputs,
+            });
+        }
         return {
             funded,
             decoded,
@@ -151,6 +283,46 @@ export async function buildWalletMutationTransaction(options) {
     }
     catch (error) {
         await unlockTemporaryBuilderLocks(options.rpc, options.walletName, temporaryBuilderLockedOutpoints);
+        if ((options.temporarilyUnlockedPolicyOutpoints?.length ?? 0) > 0) {
+            await reconcilePersistentPolicyLocks({
+                rpc: options.rpc,
+                walletName: options.walletName,
+                state: options.state,
+                fixedInputs: options.plan.fixedInputs,
+            });
+        }
         throw error;
     }
 }
+export async function buildWalletMutationTransactionWithReserveFallback(options) {
+    let unlockedReserveOutpoints = [];
+    let lastError = null;
+    for (let attempt = 0; attempt <= options.reserveCandidates.length; attempt += 1) {
+        if (attempt > 0) {
+            unlockedReserveOutpoints = [
+                ...unlockedReserveOutpoints,
+                options.reserveCandidates[attempt - 1],
+            ];
+        }
+        try {
+            return await buildWalletMutationTransaction({
+                rpc: options.rpc,
+                walletName: options.walletName,
+                state: options.state,
+                plan: options.plan,
+                validateFundedDraft: options.validateFundedDraft,
+                finalizeErrorCode: options.finalizeErrorCode,
+                mempoolRejectPrefix: options.mempoolRejectPrefix,
+                feeRate: options.feeRate,
+                temporarilyUnlockedPolicyOutpoints: unlockedReserveOutpoints,
+            });
+        }
+        catch (error) {
+            lastError = error;
+            if ((!isInsufficientFundsError(error) && !isReserveFloorFundingError(error)) || attempt === options.reserveCandidates.length) {
+                throw error;
+            }
+        }
+    }
+    throw lastError;
+}

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

@@ -9,7 +9,7 @@ import { resolveWalletRuntimePathsForTesting } from "../runtime.js";
 import { createDefaultWalletSecretProvider, } from "../state/provider.js";
 import { serializeSetCanonical, serializeSetDelegate, serializeSetEndpoint, serializeSetMiner, validateDomainName, } from "../cogop/index.js";
 import { openWalletReadContext } from "../read/index.js";
-import { assertWalletMutationContextReady, buildWalletMutationTransaction, isAlreadyAcceptedError, isBroadcastUnknownError, pauseMiningForWalletMutation, saveWalletStatePreservingUnlock, unlockTemporaryBuilderLocks, updateMutationRecord, } from "./common.js";
+import { assertFixedInputPrefixMatches, assertFundingInputsAfterFixedPrefix, assertWalletMutationContextReady, buildWalletMutationTransactionWithReserveFallback, isAlreadyAcceptedError, isBroadcastUnknownError, outpointKey, pauseMiningForWalletMutation, saveWalletStatePreservingUnlock, unlockTemporaryBuilderLocks, updateMutationRecord, } from "./common.js";
 import { confirmYesNo } from "./confirm.js";
 import { getCanonicalIdentitySelector } from "./identity-selector.js";
 import { findPendingMutationByIntent, upsertPendingMutation } from "./journal.js";
@@ -133,9 +133,8 @@ function buildPlanForDomainAdminOperation(options) {
     return {
         sender: options.sender,
         changeAddress: options.state.funding.address,
-        inputs: [
+        fixedInputs: [
             { txid: anchorUtxo.txid, vout: anchorUtxo.vout },
-            ...fundingUtxos.map((entry) => ({ txid: entry.txid, vout: entry.vout })),
         ],
         outputs: [
             { data: Buffer.from(options.opReturnData).toString("hex") },
@@ -146,6 +145,7 @@ function buildPlanForDomainAdminOperation(options) {
         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,
     };
 }
@@ -155,14 +155,17 @@ function validateFundedDraft(decoded, funded, plan) {
     if (inputs.length === 0) {
         throw new Error(`${plan.errorPrefix}_missing_sender_input`);
     }
+    assertFixedInputPrefixMatches(inputs, plan.fixedInputs, `${plan.errorPrefix}_sender_input_mismatch`);
     if (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`);
-        }
-    }
+    assertFundingInputsAfterFixedPrefix({
+        inputs,
+        fixedInputs: plan.fixedInputs,
+        allowedFundingScriptPubKeyHex: plan.allowedFundingScriptPubKeyHex,
+        eligibleFundingOutpointKeys: plan.eligibleFundingOutpointKeys,
+        errorCode: `${plan.errorPrefix}_unexpected_funding_input`,
+    });
     if (outputs[0]?.scriptPubKey?.hex !== plan.expectedOpReturnScriptHex) {
         throw new Error(`${plan.errorPrefix}_opreturn_mismatch`);
     }
@@ -186,13 +189,15 @@ function validateFundedDraft(decoded, funded, plan) {
     }
 }
 async function buildTransaction(options) {
-    return buildWalletMutationTransaction({
+    return buildWalletMutationTransactionWithReserveFallback({
         rpc: options.rpc,
         walletName: options.walletName,
+        state: options.state,
         plan: options.plan,
         validateFundedDraft,
         finalizeErrorCode: `${options.plan.errorPrefix}_finalize_failed`,
         mempoolRejectPrefix: `${options.plan.errorPrefix}_mempool_rejected`,
+        reserveCandidates: options.state.proactiveReserveOutpoints,
     });
 }
 function createDraftMutation(options) {
@@ -632,6 +637,7 @@ async function submitDomainAdminMutation(options) {
             const built = await buildTransaction({
                 rpc,
                 walletName,
+                state: nextState,
                 plan: buildPlanForDomainAdminOperation({
                     state: nextState,
                     allUtxos: await rpc.listUnspent(walletName, 1),

package/dist/wallet/tx/domain-market.js

@@ -7,7 +7,7 @@ import { resolveWalletRuntimePathsForTesting } from "../runtime.js";
 import { createDefaultWalletSecretProvider, } from "../state/provider.js";
 import { serializeDomainBuy, serializeDomainSell, serializeDomainTransfer, validateDomainName, } from "../cogop/index.js";
 import { openWalletReadContext } from "../read/index.js";
-import { assertWalletMutationContextReady, buildWalletMutationTransaction, isAlreadyAcceptedError, isBroadcastUnknownError, pauseMiningForWalletMutation, saveWalletStatePreservingUnlock, unlockTemporaryBuilderLocks, updateMutationRecord, } from "./common.js";
+import { assertFixedInputPrefixMatches, assertFundingInputsAfterFixedPrefix, assertWalletMutationContextReady, buildWalletMutationTransactionWithReserveFallback, isAlreadyAcceptedError, isBroadcastUnknownError, outpointKey, pauseMiningForWalletMutation, saveWalletStatePreservingUnlock, unlockTemporaryBuilderLocks, updateMutationRecord, } from "./common.js";
 import { confirmTypedAcknowledgement, confirmYesNo } from "./confirm.js";
 import { getCanonicalIdentitySelector, resolveIdentityBySelector, } from "./identity-selector.js";
 import { findPendingMutationByIntent, upsertPendingMutation } from "./journal.js";
@@ -248,28 +248,17 @@ function buildPlanForDomainOperation(options) {
         && entry.safe !== false);
     const outputs = [{ data: Buffer.from(options.opReturnData).toString("hex") }];
     if (options.anchorOutpoint === null) {
-        const senderUtxo = options.allUtxos.find((entry) => entry.scriptPubKey === options.sender.scriptPubKeyHex
-            && entry.confirmations >= 1
-            && entry.spendable !== false
-            && entry.safe !== false);
-        if (senderUtxo === undefined) {
-            throw new Error(`${options.errorPrefix}_sender_utxo_unavailable`);
-        }
         return {
             sender: options.sender,
             changeAddress: options.state.funding.address,
-            inputs: [
-                { txid: senderUtxo.txid, vout: senderUtxo.vout },
-                ...fundingUtxos
-                    .filter((entry) => !(entry.txid === senderUtxo.txid && entry.vout === senderUtxo.vout))
-                    .map((entry) => ({ txid: entry.txid, vout: entry.vout })),
-            ],
+            fixedInputs: [],
             outputs,
             changePosition: 1,
             expectedOpReturnScriptHex: encodeOpReturnScript(options.opReturnData),
             expectedAnchorScriptHex: null,
             expectedAnchorValueSats: null,
             allowedFundingScriptPubKeyHex: options.state.funding.scriptPubKeyHex,
+            eligibleFundingOutpointKeys: new Set(fundingUtxos.map((entry) => outpointKey({ txid: entry.txid, vout: entry.vout }))),
             errorPrefix: options.errorPrefix,
         };
     }
@@ -288,9 +277,8 @@ function buildPlanForDomainOperation(options) {
     return {
         sender: options.sender,
         changeAddress: options.state.funding.address,
-        inputs: [
+        fixedInputs: [
             { txid: anchorUtxo.txid, vout: anchorUtxo.vout },
-            ...fundingUtxos.map((entry) => ({ txid: entry.txid, vout: entry.vout })),
         ],
         outputs,
         changePosition: 2,
@@ -298,6 +286,7 @@ function buildPlanForDomainOperation(options) {
         expectedAnchorScriptHex: options.sender.scriptPubKeyHex,
         expectedAnchorValueSats: options.anchorValueSats,
         allowedFundingScriptPubKeyHex: options.state.funding.scriptPubKeyHex,
+        eligibleFundingOutpointKeys: new Set(fundingUtxos.map((entry) => outpointKey({ txid: entry.txid, vout: entry.vout }))),
         errorPrefix: options.errorPrefix,
     };
 }
@@ -307,14 +296,17 @@ function validateFundedDraft(decoded, funded, plan) {
     if (inputs.length === 0) {
         throw new Error(`${plan.errorPrefix}_missing_sender_input`);
     }
+    assertFixedInputPrefixMatches(inputs, plan.fixedInputs, `${plan.errorPrefix}_sender_input_mismatch`);
     if (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`);
-        }
-    }
+    assertFundingInputsAfterFixedPrefix({
+        inputs,
+        fixedInputs: plan.fixedInputs,
+        allowedFundingScriptPubKeyHex: plan.allowedFundingScriptPubKeyHex,
+        eligibleFundingOutpointKeys: plan.eligibleFundingOutpointKeys,
+        errorCode: `${plan.errorPrefix}_unexpected_funding_input`,
+    });
     if (outputs[0]?.scriptPubKey?.hex !== plan.expectedOpReturnScriptHex) {
         throw new Error(`${plan.errorPrefix}_opreturn_mismatch`);
     }
@@ -341,13 +333,15 @@ function validateFundedDraft(decoded, funded, plan) {
     }
 }
 async function buildTransaction(options) {
-    return buildWalletMutationTransaction({
+    return buildWalletMutationTransactionWithReserveFallback({
         rpc: options.rpc,
         walletName: options.walletName,
+        state: options.state,
         plan: options.plan,
         validateFundedDraft,
         finalizeErrorCode: `${options.plan.errorPrefix}_finalize_failed`,
         mempoolRejectPrefix: `${options.plan.errorPrefix}_mempool_rejected`,
+        reserveCandidates: options.state.proactiveReserveOutpoints,
     });
 }
 function createDraftMutation(options) {
@@ -768,6 +762,7 @@ export async function transferDomain(options) {
             const built = await buildTransaction({
                 rpc,
                 walletName,
+                state: nextState,
                 plan: buildPlanForDomainOperation({
                     state: nextState,
                     allUtxos: await rpc.listUnspent(walletName, 1),
@@ -998,6 +993,7 @@ async function runSellMutation(options) {
             const built = await buildTransaction({
                 rpc,
                 walletName,
+                state: nextState,
                 plan: buildPlanForDomainOperation({
                     state: nextState,
                     allUtxos: await rpc.listUnspent(walletName, 1),
@@ -1233,6 +1229,7 @@ export async function buyDomain(options) {
             const built = await buildTransaction({
                 rpc,
                 walletName,
+                state: nextState,
                 plan: buildPlanForDomainOperation({
                     state: nextState,
                     allUtxos: await rpc.listUnspent(walletName, 1),

package/dist/wallet/tx/field.js

@@ -10,7 +10,7 @@ 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 { assertWalletMutationContextReady, buildWalletMutationTransaction, isAlreadyAcceptedError, isBroadcastUnknownError, pauseMiningForWalletMutation, saveWalletStatePreservingUnlock, unlockTemporaryBuilderLocks, updateMutationRecord, } from "./common.js";
+import { assertFixedInputPrefixMatches, assertFundingInputsAfterFixedPrefix, assertWalletMutationContextReady, buildWalletMutationTransactionWithReserveFallback, isAlreadyAcceptedError, isBroadcastUnknownError, outpointKey, pauseMiningForWalletMutation, 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";
@@ -253,9 +253,8 @@ function buildAnchoredFieldPlan(options) {
     return {
         sender: options.sender,
         changeAddress: options.state.funding.address,
-        inputs: [
+        fixedInputs: [
             { txid: anchorUtxo.txid, vout: anchorUtxo.vout },
-            ...fundingUtxos.map((entry) => ({ txid: entry.txid, vout: entry.vout })),
         ],
         outputs: [
             { data: Buffer.from(options.opReturnData).toString("hex") },
@@ -266,6 +265,7 @@ function buildAnchoredFieldPlan(options) {
         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,
     };
 }
@@ -277,10 +277,7 @@ function buildFieldFamilyTx2Plan(options) {
     return {
         sender: options.sender,
         changeAddress: options.state.funding.address,
-        inputs: [
-            { txid: options.tx1Txid, vout: 1 },
-            ...fundingUtxos.map((entry) => ({ txid: entry.txid, vout: entry.vout })),
-        ],
+        fixedInputs: [{ txid: options.tx1Txid, vout: 1 }],
         outputs: [
             { data: Buffer.from(options.opReturnData).toString("hex") },
             { [options.sender.address]: satsToBtcNumber(BigInt(options.state.anchorValueSats)) },
@@ -290,6 +287,7 @@ function buildFieldFamilyTx2Plan(options) {
         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",
     };
 }
@@ -299,14 +297,17 @@ function validateFieldDraft(decoded, funded, plan) {
     if (inputs.length === 0) {
         throw new Error(`${plan.errorPrefix}_missing_sender_input`);
     }
+    assertFixedInputPrefixMatches(inputs, plan.fixedInputs, `${plan.errorPrefix}_sender_input_mismatch`);
     if (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`);
-        }
-    }
+    assertFundingInputsAfterFixedPrefix({
+        inputs,
+        fixedInputs: plan.fixedInputs,
+        allowedFundingScriptPubKeyHex: plan.allowedFundingScriptPubKeyHex,
+        eligibleFundingOutpointKeys: plan.eligibleFundingOutpointKeys,
+        errorCode: `${plan.errorPrefix}_unexpected_funding_input`,
+    });
     if (outputs[0]?.scriptPubKey?.hex !== plan.expectedOpReturnScriptHex) {
         throw new Error(`${plan.errorPrefix}_opreturn_mismatch`);
     }
@@ -330,14 +331,15 @@ function validateFieldDraft(decoded, funded, plan) {
     }
 }
 async function buildFieldTransaction(options) {
-    return buildWalletMutationTransaction({
+    return buildWalletMutationTransactionWithReserveFallback({
         rpc: options.rpc,
         walletName: options.walletName,
+        state: options.state,
         plan: options.plan,
         validateFundedDraft: validateFieldDraft,
         finalizeErrorCode: `${options.plan.errorPrefix}_finalize_failed`,
         mempoolRejectPrefix: `${options.plan.errorPrefix}_mempool_rejected`,
-        builderOptions: options.builderOptions,
+        reserveCandidates: options.state.proactiveReserveOutpoints,
     });
 }
 async function saveUpdatedState(options) {
@@ -1348,6 +1350,7 @@ async function submitStandaloneFieldMutation(options) {
             const built = await buildFieldTransaction({
                 rpc,
                 walletName,
+                state: nextState,
                 plan: buildAnchoredFieldPlan({
                     state: nextState,
                     allUtxos: await rpc.listUnspent(walletName, 1),
@@ -1544,6 +1547,7 @@ async function submitFieldCreateFamily(options) {
                 const tx1 = await buildFieldTransaction({
                     rpc,
                     walletName,
+                    state: nextState,
                     plan: buildAnchoredFieldPlan({
                         state: nextState,
                         allUtxos: await rpc.listUnspent(walletName, 1),
@@ -1576,6 +1580,7 @@ async function submitFieldCreateFamily(options) {
             const tx2 = await buildFieldTransaction({
                 rpc,
                 walletName,
+                state: workingState,
                 plan: buildFieldFamilyTx2Plan({
                     state: workingState,
                     allUtxos: await rpc.listUnspent(walletName, 1),
@@ -1583,10 +1588,6 @@ async function submitFieldCreateFamily(options) {
                     tx1Txid,
                     opReturnData: serializeDataUpdate(operation.chainDomain.domainId, resumedFamily.expectedFieldId ?? operation.chainDomain.nextFieldId, options.value.format, options.value.value).opReturnData,
                 }),
-                builderOptions: {
-                    includeUnsafe: true,
-                    minConf: 0,
-                },
             });
             const final = await sendFamilyTx2({
                 rpc,