@cogcoin/client 0.5.13 → 0.5.15

package/dist/wallet/mining/runner.d.ts

@@ -1,12 +1,12 @@
 import { attachOrStartManagedBitcoindService } from "../../bitcoind/service.js";
 import { createRpcClient } from "../../bitcoind/node.js";
 import type { ProgressOutputMode } from "../../bitcoind/types.js";
-import { type MutationSender, type WalletMutationRpcClient } from "../tx/common.js";
+import { type FixedWalletInput, type MutationSender, type WalletMutationRpcClient } from "../tx/common.js";
 import { type WalletPrompter } from "../lifecycle.js";
 import { openWalletReadContext } from "../read/index.js";
 import { type WalletRuntimePaths } from "../runtime.js";
 import { type WalletSecretProvider } from "../state/provider.js";
-import type { MiningStateRecord } from "../types.js";
+import type { MiningStateRecord, OutpointRecord, WalletStateV1 } from "../types.js";
 import type { MiningRuntimeStatusV1 } from "./types.js";
 type MiningRpcClient = WalletMutationRpcClient & {
     getBlockchainInfo(): Promise<{
@@ -64,6 +64,21 @@ type MiningRpcClient = WalletMutationRpcClient & {
     sendRawTransaction(hex: string): Promise<string>;
     saveMempool?(): Promise<null>;
 };
+interface MiningCandidate {
+    domainId: number;
+    domainName: string;
+    localIndex: number;
+    sender: MutationSender;
+    anchorOutpoint: OutpointRecord;
+    sentence: string;
+    encodedSentenceBytes: Uint8Array;
+    bip39WordIndices: number[];
+    bip39Words: readonly string[];
+    canonicalBlend: bigint;
+    referencedBlockHashDisplay: string;
+    referencedBlockHashInternal: Uint8Array;
+    targetBlockHeight: number;
+}
 interface RunnerDependencies {
     openReadContext?: typeof openWalletReadContext;
     attachService?: typeof attachOrStartManagedBitcoindService;
@@ -104,6 +119,61 @@ export interface MiningStartResult {
     started: boolean;
     snapshot: MiningRuntimeStatusV1 | null;
 }
+declare function createMiningPlan(options: {
+    state: WalletStateV1;
+    candidate: MiningCandidate;
+    conflictOutpoint: OutpointRecord;
+    allUtxos: Awaited<ReturnType<MiningRpcClient["listUnspent"]>>;
+    feeRateSatVb: number;
+}): {
+    sender: MutationSender;
+    fixedInputs: FixedWalletInput[];
+    outputs: unknown[];
+    changeAddress: string;
+    changePosition: number;
+    expectedOpReturnScriptHex: string;
+    expectedAnchorScriptHex: string;
+    expectedAnchorValueSats: bigint;
+    allowedFundingScriptPubKeyHex: string;
+    eligibleFundingOutpointKeys: Set<string>;
+    expectedConflictOutpoint: OutpointRecord;
+    feeRateSatVb: number;
+};
+export declare function createMiningPlanForTesting(options: {
+    state: WalletStateV1;
+    candidate: {
+        domainId: number;
+        domainName: string;
+        localIndex: number;
+        sender: MutationSender;
+        anchorOutpoint: OutpointRecord;
+        sentence: string;
+        encodedSentenceBytes: Uint8Array;
+        bip39WordIndices: number[];
+        bip39Words: readonly string[];
+        canonicalBlend: bigint;
+        referencedBlockHashDisplay: string;
+        referencedBlockHashInternal: Uint8Array;
+        targetBlockHeight: number;
+    };
+    conflictOutpoint: OutpointRecord;
+    allUtxos: Awaited<ReturnType<MiningRpcClient["listUnspent"]>>;
+    feeRateSatVb: number;
+}): {
+    sender: MutationSender;
+    fixedInputs: FixedWalletInput[];
+    outputs: unknown[];
+    changeAddress: string;
+    changePosition: number;
+    expectedOpReturnScriptHex: string;
+    expectedAnchorScriptHex: string;
+    expectedAnchorValueSats: bigint;
+    allowedFundingScriptPubKeyHex: string;
+    eligibleFundingOutpointKeys: Set<string>;
+    expectedConflictOutpoint: OutpointRecord;
+    feeRateSatVb: number;
+};
+export declare function validateMiningDraftForTesting(decoded: Awaited<ReturnType<MiningRpcClient["decodePsbt"]>>, funded: Awaited<ReturnType<MiningRpcClient["walletCreateFundedPsbt"]>>, plan: ReturnType<typeof createMiningPlan>): void;
 export declare function runForegroundMining(options: RunForegroundMiningOptions): Promise<void>;
 export declare function startBackgroundMining(options: StartBackgroundMiningOptions): Promise<MiningStartResult>;
 export declare function stopBackgroundMining(options: StopBackgroundMiningOptions): Promise<MiningRuntimeStatusV1 | null>;

package/dist/wallet/mining/runner.js

@@ -8,7 +8,7 @@ import { attachOrStartManagedBitcoindService } from "../../bitcoind/service.js";
 import { createRpcClient } from "../../bitcoind/node.js";
 import { COG_OPCODES, COG_PREFIX } from "../cogop/constants.js";
 import { extractOpReturnPayloadFromScriptHex } from "../tx/register.js";
-import { DEFAULT_WALLET_MUTATION_FEE_RATE_SAT_VB, assertFixedInputPrefixMatches, assertFundingInputsAfterFixedPrefix, buildWalletMutationTransaction, outpointKey as walletMutationOutpointKey, isAlreadyAcceptedError, isBroadcastUnknownError, reconcilePersistentPolicyLocks, saveWalletStatePreservingUnlock, } from "../tx/common.js";
+import { DEFAULT_WALLET_MUTATION_FEE_RATE_SAT_VB, assertFixedInputPrefixMatches, assertFundingInputsAfterFixedPrefix, buildWalletMutationTransaction, getDecodedInputScriptPubKeyHex, outpointKey as walletMutationOutpointKey, isAlreadyAcceptedError, isBroadcastUnknownError, reconcilePersistentPolicyLocks, saveWalletStatePreservingUnlock, } from "../tx/common.js";
 import { acquireFileLock } from "../fs/lock.js";
 import { loadOrAutoUnlockWalletState } from "../lifecycle.js";
 import { isMineableWalletDomain, openWalletReadContext, } from "../read/index.js";
@@ -610,16 +610,16 @@ function validateMiningDraft(decoded, funded, plan) {
         throw new Error("wallet_mining_missing_inputs");
     }
     assertFixedInputPrefixMatches(inputs, plan.fixedInputs, "wallet_mining_missing_inputs");
-    if (inputs[0]?.prevout?.scriptPubKey?.hex !== plan.sender.scriptPubKeyHex) {
+    if (getDecodedInputScriptPubKeyHex(decoded, 0) !== plan.sender.scriptPubKeyHex) {
         throw new Error("wallet_mining_sender_input_mismatch");
     }
-    if (inputs[1]?.prevout?.scriptPubKey?.hex !== plan.allowedFundingScriptPubKeyHex
+    if (getDecodedInputScriptPubKeyHex(decoded, 1) !== plan.allowedFundingScriptPubKeyHex
         || inputs[1]?.txid !== plan.expectedConflictOutpoint.txid
-        || inputs[1].vout !== plan.expectedConflictOutpoint.vout) {
+        || inputs[1]?.vout !== plan.expectedConflictOutpoint.vout) {
         throw new Error("wallet_mining_conflict_input_mismatch");
     }
     assertFundingInputsAfterFixedPrefix({
-        inputs,
+        decoded,
         fixedInputs: plan.fixedInputs,
         allowedFundingScriptPubKeyHex: plan.allowedFundingScriptPubKeyHex,
         eligibleFundingOutpointKeys: plan.eligibleFundingOutpointKeys,
@@ -650,6 +650,12 @@ async function buildMiningTransaction(options) {
         feeRate: options.plan.feeRateSatVb,
     });
 }
+export function createMiningPlanForTesting(options) {
+    return createMiningPlan(options);
+}
+export function validateMiningDraftForTesting(decoded, funded, plan) {
+    validateMiningDraft(decoded, funded, plan);
+}
 function resolveEligibleAnchoredRoots(context) {
     const state = context.localState.state;
     const model = context.model;

package/dist/wallet/tx/anchor.d.ts

@@ -18,6 +18,7 @@ interface WalletAnchorRpcClient extends WalletMutationRpcClient {
 export interface AnchorDomainOptions {
     domainName: string;
     foundingMessageText?: string | null;
+    promptForFoundingMessageWhenMissing?: boolean;
     dataDir: string;
     databasePath: string;
     provider?: WalletSecretProvider;
@@ -36,6 +37,7 @@ export interface AnchorDomainResult {
     dedicatedIndex: number;
     status: "live" | "confirmed";
     reusedExisting: boolean;
+    foundingMessageText?: string | null;
 }
 export interface ClearPendingAnchorOptions {
     domainName: string;

package/dist/wallet/tx/anchor.js

@@ -5,12 +5,11 @@ import { attachOrStartManagedBitcoindService } from "../../bitcoind/service.js";
 import { createRpcClient } from "../../bitcoind/node.js";
 import { acquireFileLock } from "../fs/lock.js";
 import { deriveWalletIdentityMaterial, } from "../material.js";
-import { computeDesignatedProactiveReserveOutpoints } from "../coin-control.js";
 import { resolveWalletRuntimePathsForTesting } from "../runtime.js";
 import { createDefaultWalletSecretProvider, } from "../state/provider.js";
 import { serializeDomainAnchor, serializeDomainTransfer, validateDomainName, } from "../cogop/index.js";
 import { openWalletReadContext } from "../read/index.js";
-import { assertFixedInputPrefixMatches, assertFundingInputsAfterFixedPrefix, assertWalletMutationContextReady, buildWalletMutationTransactionWithReserveFallback, getDecodedInputScriptPubKeyHex, isAlreadyAcceptedError, isBroadcastUnknownError, outpointKey, pauseMiningForWalletMutation, saveWalletStatePreservingUnlock, unlockTemporaryBuilderLocks, inputMatchesOutpoint, } from "./common.js";
+import { assertFixedInputPrefixMatches, assertFundingInputsAfterFixedPrefix, assertWalletMutationContextReady, buildWalletMutationTransactionWithReserveFallback, findSpendableFundingInputsFromTransaction, getDecodedInputScriptPubKeyHex, isAlreadyAcceptedError, isBroadcastUnknownError, outpointKey, pauseMiningForWalletMutation, saveWalletStatePreservingUnlock, unlockTemporaryBuilderLocks, inputMatchesOutpoint, } from "./common.js";
 import { confirmYesNo } from "./confirm.js";
 const ACTIVE_FAMILY_STATUSES = new Set([
     "draft",
@@ -116,6 +115,11 @@ function findActiveAnchorFamilyByDomain(state, domainName) {
         && family.domainName === domainName
         && ACTIVE_FAMILY_STATUSES.has(family.status)) ?? null;
 }
+function isClearableReservedAnchorFamily(family) {
+    return family?.type === "anchor"
+        && family.status === "draft"
+        && family.currentStep === "reserved";
+}
 function findAnchorFamilyById(state, familyId) {
     return state.proactiveFamilies.find((family) => family.familyId === familyId) ?? null;
 }
@@ -216,6 +220,35 @@ function encodeFoundingMessage(foundingMessageText) {
         throw new Error(error instanceof Error ? `wallet_anchor_invalid_message_${error.message}` : "wallet_anchor_invalid_message");
     });
 }
+function extractAnchorInvalidMessageReason(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message === "wallet_anchor_invalid_message") {
+        return null;
+    }
+    if (!message.startsWith("wallet_anchor_invalid_message_")) {
+        return null;
+    }
+    const reason = message.slice("wallet_anchor_invalid_message_".length).trim();
+    return reason === "" ? null : reason;
+}
+async function resolveFoundingMessage(options) {
+    if (!options.promptForFoundingMessageWhenMissing || options.foundingMessageText != null) {
+        return encodeFoundingMessage(options.foundingMessageText ?? null);
+    }
+    for (;;) {
+        const answer = await options.prompter.prompt("Founding message (optional, press Enter to skip): ");
+        try {
+            return await encodeFoundingMessage(answer);
+        }
+        catch (error) {
+            const reason = extractAnchorInvalidMessageReason(error);
+            options.prompter.writeLine("Founding message cannot be encoded in canonical Coglex.");
+            if (reason !== null) {
+                options.prompter.writeLine(`Reason: ${reason}`);
+            }
+        }
+    }
+}
 function resolveAnchorOutpointForSender(state, senderIndex) {
     const anchoredDomain = state.domains.find((domain) => domain.currentOwnerLocalIndex === senderIndex
         && domain.canonicalChainStatus === "anchored"
@@ -457,14 +490,10 @@ function buildTx1Plan(options) {
         { [options.operation.targetIdentity.address]: satsToBtcNumber(BigInt(options.state.anchorValueSats)) },
     ];
     if (options.operation.sourceAnchorOutpoint === null) {
-        if (fundingUtxos.length === 0) {
-            throw new Error("wallet_anchor_sender_utxo_unavailable");
-        }
-        const senderInput = fundingUtxos[0];
         return {
             sender: options.operation.sourceSender,
             changeAddress: options.state.funding.address,
-            fixedInputs: [{ txid: senderInput.txid, vout: senderInput.vout }],
+            fixedInputs: [],
             outputs,
             changePosition: 2,
             expectedOpReturnScriptHex: encodeOpReturnScript(serializeDomainTransfer(options.operation.chainDomain.domainId, Buffer.from(options.operation.targetIdentity.scriptPubKeyHex, "hex")).opReturnData),
@@ -473,9 +502,7 @@ function buildTx1Plan(options) {
             expectedReplacementAnchorScriptHex: null,
             expectedReplacementAnchorValueSats: null,
             allowedFundingScriptPubKeyHex: options.state.funding.scriptPubKeyHex,
-            eligibleFundingOutpointKeys: new Set(fundingUtxos
-                .filter((entry) => !(entry.txid === senderInput.txid && entry.vout === senderInput.vout))
-                .map((entry) => outpointKey({ txid: entry.txid, vout: entry.vout }))),
+            eligibleFundingOutpointKeys: new Set(fundingUtxos.map((entry) => outpointKey({ txid: entry.txid, vout: entry.vout }))),
             requiredSenderOutpoint: null,
             requiredProvisionalOutpoint: null,
             errorPrefix: "wallet_anchor_tx1",
@@ -524,6 +551,12 @@ function buildTx2Plan(options) {
     }
     const fundingUtxos = sortUtxos(options.allUtxos.filter((entry) => entry.scriptPubKey === options.state.funding.scriptPubKeyHex
         && isSpendableConfirmedUtxo(entry)));
+    const tx1FundingChangeInputs = findSpendableFundingInputsFromTransaction({
+        allUtxos: options.allUtxos,
+        txid: tx1Txid,
+        fundingScriptPubKeyHex: options.state.funding.scriptPubKeyHex,
+        minConf: 0,
+    });
     const foundingPayload = options.operation.foundingMessagePayloadHex === null
         ? undefined
         : Buffer.from(options.operation.foundingMessagePayloadHex, "hex");
@@ -535,7 +568,10 @@ function buildTx2Plan(options) {
             address: options.operation.targetIdentity.address,
         },
         changeAddress: options.state.funding.address,
-        fixedInputs: [{ txid: provisional.txid, vout: provisional.vout }],
+        fixedInputs: [
+            { txid: provisional.txid, vout: provisional.vout },
+            ...tx1FundingChangeInputs,
+        ],
         outputs: [
             { data: Buffer.from(opReturnData).toString("hex") },
             { [options.operation.targetIdentity.address]: satsToBtcNumber(BigInt(options.state.anchorValueSats)) },
@@ -563,7 +599,7 @@ function validateTx1Draft(decoded, funded, plan) {
         throw new Error(`${plan.errorPrefix}_sender_input_mismatch`);
     }
     assertFixedInputPrefixMatches(inputs, plan.fixedInputs, `${plan.errorPrefix}_sender_input_mismatch`);
-    const firstInputScriptPubKeyHex = getDecodedInputScriptPubKeyHex(inputs[0]);
+    const firstInputScriptPubKeyHex = getDecodedInputScriptPubKeyHex(decoded, 0);
     if (firstInputScriptPubKeyHex !== plan.sender.scriptPubKeyHex) {
         throw new Error(`${plan.errorPrefix}_sender_input_mismatch`);
     }
@@ -573,7 +609,7 @@ function validateTx1Draft(decoded, funded, plan) {
         }
     }
     assertFundingInputsAfterFixedPrefix({
-        inputs,
+        decoded,
         fixedInputs: plan.fixedInputs,
         allowedFundingScriptPubKeyHex: plan.allowedFundingScriptPubKeyHex,
         eligibleFundingOutpointKeys: plan.eligibleFundingOutpointKeys,
@@ -617,13 +653,13 @@ function validateTx2Draft(decoded, funded, plan) {
         throw new Error(`${plan.errorPrefix}_provisional_input_mismatch`);
     }
     assertFixedInputPrefixMatches(inputs, plan.fixedInputs, `${plan.errorPrefix}_provisional_input_mismatch`);
-    const firstInputScriptPubKeyHex = getDecodedInputScriptPubKeyHex(inputs[0]);
+    const firstInputScriptPubKeyHex = getDecodedInputScriptPubKeyHex(decoded, 0);
     if (firstInputScriptPubKeyHex !== plan.sender.scriptPubKeyHex
         || !inputMatchesOutpoint(inputs[0], plan.requiredProvisionalOutpoint)) {
         throw new Error(`${plan.errorPrefix}_provisional_input_mismatch`);
     }
     assertFundingInputsAfterFixedPrefix({
-        inputs,
+        decoded,
         fixedInputs: plan.fixedInputs,
         allowedFundingScriptPubKeyHex: plan.allowedFundingScriptPubKeyHex,
         eligibleFundingOutpointKeys: plan.eligibleFundingOutpointKeys,
@@ -653,7 +689,6 @@ function validateTx2Draft(decoded, funded, plan) {
     }
 }
 async function buildTx1(options) {
-    const reserveCandidates = computeDesignatedProactiveReserveOutpoints(options.state, await options.rpc.listUnspent(options.walletName, 1));
     return buildWalletMutationTransactionWithReserveFallback({
         rpc: options.rpc,
         walletName: options.walletName,
@@ -662,11 +697,10 @@ async function buildTx1(options) {
         validateFundedDraft: validateTx1Draft,
         finalizeErrorCode: "wallet_anchor_tx1_finalize_failed",
         mempoolRejectPrefix: "wallet_anchor_tx1_mempool_rejected",
-        reserveCandidates,
+        reserveCandidates: options.state.proactiveReserveOutpoints,
     });
 }
 async function buildTx2(options) {
-    const reserveCandidates = computeDesignatedProactiveReserveOutpoints(options.state, await options.rpc.listUnspent(options.walletName, 1));
     return buildWalletMutationTransactionWithReserveFallback({
         rpc: options.rpc,
         walletName: options.walletName,
@@ -675,7 +709,8 @@ async function buildTx2(options) {
         validateFundedDraft: validateTx2Draft,
         finalizeErrorCode: "wallet_anchor_tx2_finalize_failed",
         mempoolRejectPrefix: "wallet_anchor_tx2_mempool_rejected",
-        reserveCandidates,
+        availableFundingMinConf: 0,
+        reserveCandidates: options.state.proactiveReserveOutpoints,
     });
 }
 async function relockAnchorOutpoint(rpc, walletName, outpoint) {
@@ -1107,6 +1142,7 @@ async function submitTx2(options) {
         dedicatedIndex: options.operation.targetIdentity.localIndex,
         status: finalStatus,
         reusedExisting: false,
+        foundingMessageText: options.operation.foundingMessageText,
     };
 }
 function ensureSameTipHeight(context, bestHeight, errorCode) {
@@ -1131,7 +1167,11 @@ export async function anchorDomain(options) {
             paths,
             reason: "wallet-anchor",
         });
-        const message = await encodeFoundingMessage(options.foundingMessageText ?? null);
+        const message = await resolveFoundingMessage({
+            foundingMessageText: options.foundingMessageText,
+            promptForFoundingMessageWhenMissing: options.promptForFoundingMessageWhenMissing,
+            prompter: options.prompter,
+        });
         const readContext = await (options.openReadContext ?? openWalletReadContext)({
             dataDir: options.dataDir,
             databasePath: options.databasePath,
@@ -1144,6 +1184,9 @@ export async function anchorDomain(options) {
             const initialFamily = createDraftAnchorFamily(operation, nowUnixMs);
             const existingFamily = findAnchorFamilyByIntent(operation.state, initialFamily.intentFingerprintHex);
             const conflictingFamily = findActiveAnchorFamilyByDomain(operation.state, normalizedDomainName);
+            if (existingFamily === null && isClearableReservedAnchorFamily(conflictingFamily)) {
+                throw new Error(`wallet_anchor_clear_pending_first_${conflictingFamily.domainName}`);
+            }
             if (existingFamily === null && conflictingFamily !== null) {
                 throw new Error("wallet_anchor_prior_family_unresolved");
             }
@@ -1185,6 +1228,7 @@ export async function anchorDomain(options) {
                         dedicatedIndex: reconciled.family.reservedDedicatedIndex ?? existingTargetIdentity.localIndex,
                         status: reconciled.resolution,
                         reusedExisting: true,
+                        foundingMessageText: reconciled.family.foundingMessageText,
                     };
                 }
                 if (reconciled.resolution === "repair-required") {
@@ -1336,6 +1380,7 @@ export async function anchorDomain(options) {
             return {
                 ...result,
                 reusedExisting: resumedExisting,
+                foundingMessageText: result.foundingMessageText ?? operation.foundingMessageText,
             };
         }
         finally {

package/dist/wallet/tx/cog.js

@@ -7,7 +7,7 @@ import { resolveWalletRuntimePathsForTesting } from "../runtime.js";
 import { createDefaultWalletSecretProvider, } from "../state/provider.js";
 import { serializeCogClaim, serializeCogLock, serializeCogTransfer, } 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";
@@ -248,28 +248,17 @@ function buildPlanForCogOperation(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/common.d.ts

@@ -1,4 +1,4 @@
-import type { RpcDecodedPsbt, RpcFinalizePsbtResult, RpcListUnspentEntry, RpcLockedUnspent, RpcTestMempoolAcceptResult, RpcTransaction, RpcVin, RpcWalletCreateFundedPsbtResult, RpcWalletProcessPsbtResult } from "../../bitcoind/types.js";
+import type { RpcDecodedPsbt, RpcFinalizePsbtResult, RpcListUnspentEntry, RpcLockedUnspent, RpcTestMempoolAcceptResult, RpcTransaction, RpcVin, RpcWalletCreateFundedPsbtResult, RpcWalletTransaction, RpcWalletProcessPsbtResult } from "../../bitcoind/types.js";
 import { type WalletSecretProvider } from "../state/provider.js";
 import type { OutpointRecord, PendingMutationRecord, PendingMutationStatus, WalletStateV1 } from "../types.js";
 import type { WalletReadContext } from "../read/index.js";
@@ -14,12 +14,15 @@ export interface WalletMutationRpcClient {
     listUnspent(walletName: string, minConf?: number): Promise<RpcListUnspentEntry[]>;
     listLockUnspent(walletName: string): Promise<RpcLockedUnspent[]>;
     lockUnspent(walletName: string, unlock: boolean, outputs: RpcLockedUnspent[]): Promise<boolean>;
+    getTransaction?(walletName: string, txid: string): Promise<RpcWalletTransaction>;
     walletCreateFundedPsbt(walletName: string, inputs: Array<{
         txid: string;
         vout: number;
     }>, outputs: unknown[], locktime: number, options: Record<string, unknown>, bip32Derivs?: boolean): Promise<RpcWalletCreateFundedPsbtResult>;
     decodePsbt(psbt: string): Promise<RpcDecodedPsbt>;
+    walletPassphrase(walletName: string, passphrase: string, timeoutSeconds: number): Promise<null>;
     walletProcessPsbt(walletName: string, psbt: string, sign?: boolean, sighashType?: string): Promise<RpcWalletProcessPsbtResult>;
+    walletLock(walletName: string): Promise<null>;
     finalizePsbt(psbt: string, extract?: boolean): Promise<RpcFinalizePsbtResult>;
     decodeRawTransaction(hex: string): Promise<RpcTransaction>;
     testMempoolAccept(rawTransactions: string[]): Promise<RpcTestMempoolAcceptResult[]>;
@@ -44,6 +47,12 @@ export declare function saveWalletStatePreservingUnlock(options: {
 }): Promise<void>;
 export declare function formatCogAmount(value: bigint): string;
 export declare function outpointKey(outpoint: OutpointRecord): string;
+export declare function findSpendableFundingInputsFromTransaction(options: {
+    allUtxos: RpcListUnspentEntry[];
+    txid: string;
+    fundingScriptPubKeyHex: string;
+    minConf?: number;
+}): FixedWalletInput[];
 export declare function updateMutationRecord(mutation: PendingMutationRecord, status: PendingMutationStatus, nowUnixMs: number, options?: {
     attemptedTxid?: string | null;
     attemptedWtxid?: string | null;
@@ -51,12 +60,12 @@ export declare function updateMutationRecord(mutation: PendingMutationRecord, st
 }): PendingMutationRecord;
 export declare function unlockTemporaryBuilderLocks(rpc: Pick<WalletMutationRpcClient, "lockUnspent">, walletName: string, outpoints: OutpointRecord[]): Promise<void>;
 export declare function diffTemporaryLockedOutpoints(before: RpcLockedUnspent[], after: RpcLockedUnspent[]): OutpointRecord[];
-export declare function getDecodedInputScriptPubKeyHex(input: RpcVin): string | null;
 export declare function getDecodedInputVout(input: RpcVin): number | null;
+export declare function getDecodedInputScriptPubKeyHex(decoded: RpcDecodedPsbt, inputIndex: number): string | null;
 export declare function inputMatchesOutpoint(input: RpcVin, outpoint: OutpointRecord): boolean;
 export declare function assertFixedInputPrefixMatches(inputs: RpcVin[], fixedInputs: FixedWalletInput[], errorCode: string): void;
 export declare function assertFundingInputsAfterFixedPrefix(options: {
-    inputs: RpcVin[];
+    decoded: RpcDecodedPsbt;
     fixedInputs: FixedWalletInput[];
     allowedFundingScriptPubKeyHex: string;
     eligibleFundingOutpointKeys: Set<string>;
@@ -95,11 +104,14 @@ export declare function buildWalletMutationTransaction<TPlan>(options: {
         outputs: unknown[];
         changeAddress: string;
         changePosition: number;
+        allowedFundingScriptPubKeyHex: string;
+        eligibleFundingOutpointKeys: Set<string>;
     };
     validateFundedDraft(decoded: RpcDecodedPsbt, funded: RpcWalletCreateFundedPsbtResult, plan: TPlan): void;
     finalizeErrorCode: string;
     mempoolRejectPrefix: string;
     feeRate?: number;
+    availableFundingMinConf?: number;
     temporarilyUnlockedPolicyOutpoints?: readonly OutpointRecord[];
 }): Promise<BuiltWalletMutationTransaction>;
 export declare function buildWalletMutationTransactionWithReserveFallback<TPlan>(options: {
@@ -111,10 +123,13 @@ export declare function buildWalletMutationTransactionWithReserveFallback<TPlan>
         outputs: unknown[];
         changeAddress: string;
         changePosition: number;
+        allowedFundingScriptPubKeyHex: string;
+        eligibleFundingOutpointKeys: Set<string>;
     };
     validateFundedDraft(decoded: RpcDecodedPsbt, funded: RpcWalletCreateFundedPsbtResult, plan: TPlan): void;
     finalizeErrorCode: string;
     mempoolRejectPrefix: string;
     feeRate?: number;
+    availableFundingMinConf?: number;
     reserveCandidates: readonly OutpointRecord[];
 }): Promise<BuiltWalletMutationTransaction>;