@cogcoin/client 0.5.13 → 0.5.15

package/dist/wallet/tx/common.js

@@ -5,6 +5,15 @@ 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;
+const MANAGED_CORE_WALLET_SIGNING_UNLOCK_TIMEOUT_SECONDS = 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,
@@ -40,6 +49,24 @@ export function formatCogAmount(value) {
 export function outpointKey(outpoint) {
     return `${outpoint.txid}:${outpoint.vout}`;
 }
+function isSpendableFundingUtxo(entry, fundingScriptPubKeyHex, minConf) {
+    return entry.scriptPubKey === fundingScriptPubKeyHex
+        && entry.confirmations >= minConf
+        && entry.spendable !== false
+        && entry.safe !== false;
+}
+export function findSpendableFundingInputsFromTransaction(options) {
+    const minConf = options.minConf ?? 0;
+    return options.allUtxos
+        .filter((entry) => entry.txid === options.txid
+        && isSpendableFundingUtxo(entry, options.fundingScriptPubKeyHex, minConf))
+        .sort((left, right) => left.vout - right.vout
+        || left.txid.localeCompare(right.txid))
+        .map((entry) => ({
+        txid: entry.txid,
+        vout: entry.vout,
+    }));
+}
 export function updateMutationRecord(mutation, status, nowUnixMs, options = {}) {
     return {
         ...mutation,
@@ -65,12 +92,33 @@ 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;
+    return typeof input.vout === "number" ? input.vout : null;
+}
+export function getDecodedInputScriptPubKeyHex(decoded, inputIndex) {
+    const input = decoded.tx.vin[inputIndex];
+    if (input === undefined) {
+        return null;
+    }
+    const prevoutScriptPubKeyHex = input.prevout?.scriptPubKey?.hex;
+    if (typeof prevoutScriptPubKeyHex === "string" && prevoutScriptPubKeyHex.length > 0) {
+        return prevoutScriptPubKeyHex;
+    }
+    const psbtInput = decoded.inputs?.[inputIndex];
+    const witnessScriptPubKeyHex = psbtInput?.witness_utxo?.scriptPubKey?.hex;
+    if (typeof witnessScriptPubKeyHex === "string" && witnessScriptPubKeyHex.length > 0) {
+        return witnessScriptPubKeyHex;
+    }
+    const vout = getDecodedInputVout(input);
+    if (vout === null) {
+        return null;
+    }
+    const nonWitnessScriptPubKeyHex = psbtInput?.non_witness_utxo?.vout
+        .find((output) => output.n === vout)
+        ?.scriptPubKey?.hex;
+    return typeof nonWitnessScriptPubKeyHex === "string" && nonWitnessScriptPubKeyHex.length > 0
+        ? nonWitnessScriptPubKeyHex
+        : null;
 }
 export function inputMatchesOutpoint(input, outpoint) {
     return input.txid === outpoint.txid && getDecodedInputVout(input) === outpoint.vout;
@@ -86,9 +134,9 @@ export function assertFixedInputPrefixMatches(inputs, fixedInputs, 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);
+    for (let index = options.fixedInputs.length; index < options.decoded.tx.vin.length; index += 1) {
+        const input = options.decoded.tx.vin[index];
+        const scriptPubKeyHex = getDecodedInputScriptPubKeyHex(options.decoded, index);
         const vout = getDecodedInputVout(input);
         if (scriptPubKeyHex !== options.allowedFundingScriptPubKeyHex || vout === null || typeof input.txid !== "string") {
             throw new Error(options.errorCode);
@@ -132,6 +180,34 @@ 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 [index, input] of options.decoded.tx.vin.entries()) {
+        const scriptPubKeyHex = getDecodedInputScriptPubKeyHex(options.decoded, index);
+        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.decoded.tx.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");
@@ -169,6 +245,20 @@ export async function buildWalletMutationTransaction(options) {
         fixedInputs: options.plan.fixedInputs,
         temporarilyUnlockedOutpoints: options.temporarilyUnlockedPolicyOutpoints,
     });
+    const availableFundingMinConf = options.availableFundingMinConf ?? 1;
+    const availableFundingUtxos = (await options.rpc.listUnspent(options.walletName, availableFundingMinConf))
+        .filter((entry) => isSpendableFundingUtxo(entry, options.plan.allowedFundingScriptPubKeyHex, availableFundingMinConf));
+    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 {
@@ -186,17 +276,36 @@ 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);
-        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) {
-            throw new Error(options.finalizeErrorCode);
+        options.validateFundedDraft(decoded, funded, validationPlan);
+        if (options.state.proactiveReserveSats > 0) {
+            const remainingFundingValueSats = computeRemainingFundingValueSats({
+                decoded,
+                fundingScriptPubKeyHex: options.plan.allowedFundingScriptPubKeyHex,
+                availableFundingValueByKey,
+            });
+            if (remainingFundingValueSats < BigInt(options.state.proactiveReserveSats)) {
+                throw new Error("wallet_mutation_insufficient_funding_after_reserve");
+            }
+        }
+        await options.rpc.walletPassphrase(options.walletName, options.state.managedCoreWallet.internalPassphrase, MANAGED_CORE_WALLET_SIGNING_UNLOCK_TIMEOUT_SECONDS);
+        let signed;
+        let finalized;
+        let decodedRaw;
+        try {
+            signed = await options.rpc.walletProcessPsbt(options.walletName, funded.psbt, true, "DEFAULT");
+            finalized = await options.rpc.finalizePsbt(signed.psbt, true);
+            if (!finalized.complete || finalized.hex == null) {
+                throw new Error(options.finalizeErrorCode);
+            }
+            decodedRaw = await options.rpc.decodeRawTransaction(finalized.hex);
+            const mempoolResult = await options.rpc.testMempoolAccept([finalized.hex]);
+            const accepted = mempoolResult[0];
+            if (accepted == null || !accepted.allowed) {
+                throw new Error(`${options.mempoolRejectPrefix}_${accepted?.["reject-reason"] ?? "unknown"}`);
+            }
         }
-        const decodedRaw = await options.rpc.decodeRawTransaction(finalized.hex);
-        const mempoolResult = await options.rpc.testMempoolAccept([finalized.hex]);
-        const accepted = mempoolResult[0];
-        if (accepted == null || !accepted.allowed) {
-            throw new Error(`${options.mempoolRejectPrefix}_${accepted?.["reject-reason"] ?? "unknown"}`);
+        finally {
+            await options.rpc.walletLock(options.walletName).catch(() => undefined);
         }
         if ((options.temporarilyUnlockedPolicyOutpoints?.length ?? 0) > 0) {
             await reconcilePersistentPolicyLocks({
@@ -230,31 +339,44 @@ export async function buildWalletMutationTransaction(options) {
     }
 }
 export async function buildWalletMutationTransactionWithReserveFallback(options) {
+    const preflightReconciled = options.reserveCandidates.length > 0
+        ? null
+        : await reconcileWalletCoinControlLocks({
+            rpc: options.rpc,
+            walletName: options.walletName,
+            state: options.state,
+            fixedInputs: options.plan.fixedInputs,
+        });
+    const effectiveState = preflightReconciled?.state ?? options.state;
+    const reserveCandidates = options.reserveCandidates.length > 0
+        ? [...options.reserveCandidates]
+        : [...effectiveState.proactiveReserveOutpoints];
     let unlockedReserveOutpoints = [];
     let lastError = null;
-    for (let attempt = 0; attempt <= options.reserveCandidates.length; attempt += 1) {
+    for (let attempt = 0; attempt <= reserveCandidates.length; attempt += 1) {
         if (attempt > 0) {
             unlockedReserveOutpoints = [
                 ...unlockedReserveOutpoints,
-                options.reserveCandidates[attempt - 1],
+                reserveCandidates[attempt - 1],
             ];
         }
         try {
             return await buildWalletMutationTransaction({
                 rpc: options.rpc,
                 walletName: options.walletName,
-                state: options.state,
+                state: effectiveState,
                 plan: options.plan,
                 validateFundedDraft: options.validateFundedDraft,
                 finalizeErrorCode: options.finalizeErrorCode,
                 mempoolRejectPrefix: options.mempoolRejectPrefix,
                 feeRate: options.feeRate,
+                availableFundingMinConf: options.availableFundingMinConf,
                 temporarilyUnlockedPolicyOutpoints: unlockedReserveOutpoints,
             });
         }
         catch (error) {
             lastError = error;
-            if (!isInsufficientFundsError(error) || attempt === options.reserveCandidates.length) {
+            if ((!isInsufficientFundsError(error) && !isReserveFloorFundingError(error)) || attempt === reserveCandidates.length) {
                 throw error;
             }
         }

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 { assertFixedInputPrefixMatches, assertFundingInputsAfterFixedPrefix, assertWalletMutationContextReady, buildWalletMutationTransaction, isAlreadyAcceptedError, isBroadcastUnknownError, outpointKey, pauseMiningForWalletMutation, saveWalletStatePreservingUnlock, unlockTemporaryBuilderLocks, updateMutationRecord, } from "./common.js";
+import { assertFixedInputPrefixMatches, assertFundingInputsAfterFixedPrefix, assertWalletMutationContextReady, buildWalletMutationTransactionWithReserveFallback, getDecodedInputScriptPubKeyHex, 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";
@@ -156,11 +156,11 @@ function validateFundedDraft(decoded, funded, plan) {
         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) {
+    if (getDecodedInputScriptPubKeyHex(decoded, 0) !== plan.sender.scriptPubKeyHex) {
         throw new Error(`${plan.errorPrefix}_sender_input_mismatch`);
     }
     assertFundingInputsAfterFixedPrefix({
-        inputs,
+        decoded,
         fixedInputs: plan.fixedInputs,
         allowedFundingScriptPubKeyHex: plan.allowedFundingScriptPubKeyHex,
         eligibleFundingOutpointKeys: plan.eligibleFundingOutpointKeys,
@@ -189,7 +189,7 @@ function validateFundedDraft(decoded, funded, plan) {
     }
 }
 async function buildTransaction(options) {
-    return buildWalletMutationTransaction({
+    return buildWalletMutationTransactionWithReserveFallback({
         rpc: options.rpc,
         walletName: options.walletName,
         state: options.state,
@@ -197,6 +197,7 @@ async function buildTransaction(options) {
         validateFundedDraft,
         finalizeErrorCode: `${options.plan.errorPrefix}_finalize_failed`,
         mempoolRejectPrefix: `${options.plan.errorPrefix}_mempool_rejected`,
+        reserveCandidates: options.state.proactiveReserveOutpoints,
     });
 }
 function createDraftMutation(options) {

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 { assertFixedInputPrefixMatches, assertFundingInputsAfterFixedPrefix, assertWalletMutationContextReady, buildWalletMutationTransaction, isAlreadyAcceptedError, isBroadcastUnknownError, outpointKey, pauseMiningForWalletMutation, saveWalletStatePreservingUnlock, unlockTemporaryBuilderLocks, updateMutationRecord, } from "./common.js";
+import { assertFixedInputPrefixMatches, assertFundingInputsAfterFixedPrefix, assertWalletMutationContextReady, buildWalletMutationTransactionWithReserveFallback, getDecodedInputScriptPubKeyHex, 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,
-            fixedInputs: [
-                { txid: senderUtxo.txid, vout: senderUtxo.vout },
-            ],
+            fixedInputs: [],
             outputs,
             changePosition: 1,
             expectedOpReturnScriptHex: encodeOpReturnScript(options.opReturnData),
             expectedAnchorScriptHex: null,
             expectedAnchorValueSats: null,
             allowedFundingScriptPubKeyHex: options.state.funding.scriptPubKeyHex,
-            eligibleFundingOutpointKeys: new Set(fundingUtxos
-                .filter((entry) => !(entry.txid === senderUtxo.txid && entry.vout === senderUtxo.vout))
-                .map((entry) => outpointKey({ txid: entry.txid, vout: entry.vout }))),
+            eligibleFundingOutpointKeys: new Set(fundingUtxos.map((entry) => outpointKey({ txid: entry.txid, vout: entry.vout }))),
             errorPrefix: options.errorPrefix,
         };
     }
@@ -308,11 +297,11 @@ function validateFundedDraft(decoded, funded, plan) {
         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) {
+    if (getDecodedInputScriptPubKeyHex(decoded, 0) !== plan.sender.scriptPubKeyHex) {
         throw new Error(`${plan.errorPrefix}_sender_input_mismatch`);
     }
     assertFundingInputsAfterFixedPrefix({
-        inputs,
+        decoded,
         fixedInputs: plan.fixedInputs,
         allowedFundingScriptPubKeyHex: plan.allowedFundingScriptPubKeyHex,
         eligibleFundingOutpointKeys: plan.eligibleFundingOutpointKeys,
@@ -344,7 +333,7 @@ function validateFundedDraft(decoded, funded, plan) {
     }
 }
 async function buildTransaction(options) {
-    return buildWalletMutationTransaction({
+    return buildWalletMutationTransactionWithReserveFallback({
         rpc: options.rpc,
         walletName: options.walletName,
         state: options.state,
@@ -352,6 +341,7 @@ async function buildTransaction(options) {
         validateFundedDraft,
         finalizeErrorCode: `${options.plan.errorPrefix}_finalize_failed`,
         mempoolRejectPrefix: `${options.plan.errorPrefix}_mempool_rejected`,
+        reserveCandidates: options.state.proactiveReserveOutpoints,
     });
 }
 function createDraftMutation(options) {

package/dist/wallet/tx/field.js

@@ -5,13 +5,12 @@ import { getBalance, lookupDomain, } from "@cogcoin/indexer/queries";
 import { attachOrStartManagedBitcoindService } from "../../bitcoind/service.js";
 import { createRpcClient } from "../../bitcoind/node.js";
 import { acquireFileLock } from "../fs/lock.js";
-import { computeDesignatedProactiveReserveOutpoints } from "../coin-control.js";
 import { resolveWalletRuntimePathsForTesting, } from "../runtime.js";
 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, isAlreadyAcceptedError, isBroadcastUnknownError, outpointKey, pauseMiningForWalletMutation, saveWalletStatePreservingUnlock, unlockTemporaryBuilderLocks, updateMutationRecord, } from "./common.js";
+import { assertFixedInputPrefixMatches, assertFundingInputsAfterFixedPrefix, assertWalletMutationContextReady, buildWalletMutationTransactionWithReserveFallback, findSpendableFundingInputsFromTransaction, getDecodedInputScriptPubKeyHex, 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";
@@ -275,10 +274,19 @@ function buildFieldFamilyTx2Plan(options) {
         && 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 }],
+        fixedInputs: [
+            { txid: options.tx1Txid, vout: 1 },
+            ...tx1FundingChangeInputs,
+        ],
         outputs: [
             { data: Buffer.from(options.opReturnData).toString("hex") },
             { [options.sender.address]: satsToBtcNumber(BigInt(options.state.anchorValueSats)) },
@@ -299,11 +307,11 @@ function validateFieldDraft(decoded, funded, plan) {
         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) {
+    if (getDecodedInputScriptPubKeyHex(decoded, 0) !== plan.sender.scriptPubKeyHex) {
         throw new Error(`${plan.errorPrefix}_sender_input_mismatch`);
     }
     assertFundingInputsAfterFixedPrefix({
-        inputs,
+        decoded,
         fixedInputs: plan.fixedInputs,
         allowedFundingScriptPubKeyHex: plan.allowedFundingScriptPubKeyHex,
         eligibleFundingOutpointKeys: plan.eligibleFundingOutpointKeys,
@@ -332,7 +340,6 @@ function validateFieldDraft(decoded, funded, plan) {
     }
 }
 async function buildFieldTransaction(options) {
-    const reserveCandidates = computeDesignatedProactiveReserveOutpoints(options.state, await options.rpc.listUnspent(options.walletName, 1));
     return buildWalletMutationTransactionWithReserveFallback({
         rpc: options.rpc,
         walletName: options.walletName,
@@ -341,7 +348,8 @@ async function buildFieldTransaction(options) {
         validateFundedDraft: validateFieldDraft,
         finalizeErrorCode: `${options.plan.errorPrefix}_finalize_failed`,
         mempoolRejectPrefix: `${options.plan.errorPrefix}_mempool_rejected`,
-        reserveCandidates,
+        availableFundingMinConf: options.availableFundingMinConf,
+        reserveCandidates: options.state.proactiveReserveOutpoints,
     });
 }
 async function saveUpdatedState(options) {
@@ -1583,9 +1591,10 @@ async function submitFieldCreateFamily(options) {
                 rpc,
                 walletName,
                 state: workingState,
+                availableFundingMinConf: 0,
                 plan: buildFieldFamilyTx2Plan({
                     state: workingState,
-                    allUtxos: await rpc.listUnspent(walletName, 1),
+                    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,

package/dist/wallet/tx/register.js

@@ -8,7 +8,7 @@ import { resolveWalletRuntimePathsForTesting } from "../runtime.js";
 import { createDefaultWalletSecretProvider, } from "../state/provider.js";
 import { computeRootRegistrationPriceSats, serializeDomainReg } from "../cogop/index.js";
 import { openWalletReadContext } from "../read/index.js";
-import { assertFixedInputPrefixMatches, assertFundingInputsAfterFixedPrefix, assertWalletMutationContextReady, buildWalletMutationTransaction, formatCogAmount, isAlreadyAcceptedError, isBroadcastUnknownError, outpointKey, pauseMiningForWalletMutation, saveWalletStatePreservingUnlock, unlockTemporaryBuilderLocks, updateMutationRecord, } from "./common.js";
+import { assertFixedInputPrefixMatches, assertFundingInputsAfterFixedPrefix, assertWalletMutationContextReady, buildWalletMutationTransactionWithReserveFallback, formatCogAmount, getDecodedInputScriptPubKeyHex, 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";
@@ -402,11 +402,11 @@ function validateFundedDraft(decoded, funded, plan) {
         throw new Error("wallet_register_missing_sender_input");
     }
     assertFixedInputPrefixMatches(inputs, plan.fixedInputs, "wallet_register_sender_input_mismatch");
-    if (inputs[0]?.prevout?.scriptPubKey?.hex !== plan.sender.scriptPubKeyHex) {
+    if (getDecodedInputScriptPubKeyHex(decoded, 0) !== plan.sender.scriptPubKeyHex) {
         throw new Error("wallet_register_sender_input_mismatch");
     }
     assertFundingInputsAfterFixedPrefix({
-        inputs,
+        decoded,
         fixedInputs: plan.fixedInputs,
         allowedFundingScriptPubKeyHex: plan.allowedFundingScriptPubKeyHex,
         eligibleFundingOutpointKeys: plan.eligibleFundingOutpointKeys,
@@ -459,20 +459,11 @@ function buildRegisterPlan(options) {
             anchorValueSats: options.anchorOutpoint === null ? null : options.anchorValueSats,
         });
         if (options.anchorOutpoint === null) {
-            if (fundingUtxos.length === 0) {
-                throw new Error("wallet_register_sender_utxo_unavailable");
-            }
-            const senderInput = fundingUtxos[0];
-            const additionalFunding = fundingUtxos
-                .slice(1)
-                .map((entry) => ({ txid: entry.txid, vout: entry.vout }));
             return {
                 registerKind: "root",
                 sender: options.sender,
                 changeAddress: options.state.funding.address,
-                fixedInputs: [
-                    { txid: senderInput.txid, vout: senderInput.vout },
-                ],
+                fixedInputs: [],
                 outputs: rootOutputs.outputs,
                 changePosition: rootOutputs.changePosition,
                 expectedOpReturnScriptHex: rootOutputs.expectedOpReturnScriptHex,
@@ -483,7 +474,7 @@ function buildRegisterPlan(options) {
                 expectedAnchorScriptHex: null,
                 expectedAnchorValueSats: null,
                 allowedFundingScriptPubKeyHex: options.state.funding.scriptPubKeyHex,
-                eligibleFundingOutpointKeys: new Set(additionalFunding.map((entry) => outpointKey(entry))),
+                eligibleFundingOutpointKeys: new Set(fundingUtxos.map((entry) => outpointKey(entry))),
             };
         }
         const anchorUtxo = options.allUtxos.find((entry) => entry.txid === options.anchorOutpoint?.txid
@@ -550,7 +541,7 @@ function buildRegisterPlan(options) {
     };
 }
 async function buildRegisterTransaction(options) {
-    return buildWalletMutationTransaction({
+    return buildWalletMutationTransactionWithReserveFallback({
         rpc: options.rpc,
         walletName: options.walletName,
         state: options.state,
@@ -558,6 +549,7 @@ async function buildRegisterTransaction(options) {
         validateFundedDraft,
         finalizeErrorCode: "wallet_register_finalize_failed",
         mempoolRejectPrefix: "wallet_register_mempool_rejected",
+        reserveCandidates: options.state.proactiveReserveOutpoints,
     });
 }
 async function reconcilePendingRegisterMutation(options) {

package/dist/wallet/tx/reputation.js

@@ -8,7 +8,7 @@ import { resolveWalletRuntimePathsForTesting } from "../runtime.js";
 import { createDefaultWalletSecretProvider, } from "../state/provider.js";
 import { serializeRepCommit, serializeRepRevoke, validateDomainName, } from "../cogop/index.js";
 import { openWalletReadContext } from "../read/index.js";
-import { assertFixedInputPrefixMatches, assertFundingInputsAfterFixedPrefix, assertWalletMutationContextReady, buildWalletMutationTransaction, formatCogAmount, isAlreadyAcceptedError, isBroadcastUnknownError, outpointKey, pauseMiningForWalletMutation, saveWalletStatePreservingUnlock, unlockTemporaryBuilderLocks, updateMutationRecord, } from "./common.js";
+import { assertFixedInputPrefixMatches, assertFundingInputsAfterFixedPrefix, assertWalletMutationContextReady, buildWalletMutationTransactionWithReserveFallback, formatCogAmount, getDecodedInputScriptPubKeyHex, 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";
@@ -185,11 +185,11 @@ function validateFundedDraft(decoded, funded, plan) {
         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) {
+    if (getDecodedInputScriptPubKeyHex(decoded, 0) !== plan.sender.scriptPubKeyHex) {
         throw new Error(`${plan.errorPrefix}_sender_input_mismatch`);
     }
     assertFundingInputsAfterFixedPrefix({
-        inputs,
+        decoded,
         fixedInputs: plan.fixedInputs,
         allowedFundingScriptPubKeyHex: plan.allowedFundingScriptPubKeyHex,
         eligibleFundingOutpointKeys: plan.eligibleFundingOutpointKeys,
@@ -218,7 +218,7 @@ function validateFundedDraft(decoded, funded, plan) {
     }
 }
 async function buildTransaction(options) {
-    return buildWalletMutationTransaction({
+    return buildWalletMutationTransactionWithReserveFallback({
         rpc: options.rpc,
         walletName: options.walletName,
         state: options.state,
@@ -226,6 +226,7 @@ async function buildTransaction(options) {
         validateFundedDraft,
         finalizeErrorCode: `${options.plan.errorPrefix}_finalize_failed`,
         mempoolRejectPrefix: `${options.plan.errorPrefix}_mempool_rejected`,
+        reserveCandidates: options.state.proactiveReserveOutpoints,
     });
 }
 function createDraftMutation(options) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cogcoin/client",
-  "version": "0.5.13",
+  "version": "0.5.15",
   "description": "Store-backed Cogcoin client with wallet flows, SQLite persistence, and managed Bitcoin Core integration.",
   "license": "MIT",
   "type": "module",