@cogcoin/client 0.5.14 → 1.0.0

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, buildWalletMutationTransactionWithReserveFallback, formatCogAmount, isAlreadyAcceptedError, isBroadcastUnknownError, outpointKey, pauseMiningForWalletMutation, saveWalletStatePreservingUnlock, unlockTemporaryBuilderLocks, updateMutationRecord, } from "./common.js";
+import { assertFixedInputPrefixMatches, assertFundingInputsAfterFixedPrefix, assertWalletMutationContextReady, buildWalletMutationTransactionWithReserveFallback, createBuiltWalletMutationFeeSummary, createFundingMutationSender, createWalletMutationFeeMetadata, formatCogAmount, getDecodedInputScriptPubKeyHex, isLocalWalletScript, isAlreadyAcceptedError, isBroadcastUnknownError, mergeFixedWalletInputs, outpointKey, pauseMiningForWalletMutation, resolvePendingMutationReuseDecision, resolveWalletMutationFeeSelection, 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";
@@ -68,21 +68,6 @@ function parseHex32(value, errorCode) {
 function sha256Hex(value) {
     return createHash("sha256").update(value).digest("hex");
 }
-function resolveAnchorOutpointForSender(state, sender, errorPrefix) {
-    const anchoredDomains = state.domains.filter((domain) => domain.currentOwnerLocalIndex === sender.index
-        && domain.canonicalChainStatus === "anchored");
-    if (anchoredDomains.length === 0) {
-        return null;
-    }
-    const anchoredDomain = anchoredDomains[0];
-    if (anchoredDomain.currentCanonicalAnchorOutpoint === null) {
-        throw new Error(`${errorPrefix}_anchor_outpoint_unavailable`);
-    }
-    return {
-        txid: anchoredDomain.currentCanonicalAnchorOutpoint.txid,
-        vout: anchoredDomain.currentCanonicalAnchorOutpoint.vout,
-    };
-}
 function ensureUsableSender(sender, errorPrefix, amountCogtoshi) {
     if (sender.address === null) {
         throw new Error(`${errorPrefix}_sender_address_unavailable`);
@@ -104,31 +89,11 @@ function createResolvedSenderSummary(identity) {
 }
 function resolveIdentitySender(context, errorPrefix, amountCogtoshi, selector) {
     assertWalletMutationContextReady(context, errorPrefix);
-    const identity = selector == null
-        ? (() => {
-            const eligible = context.model.identities.filter((candidate) => candidate.address !== null
-                && !candidate.readOnly
-                && candidate.observedCogBalance !== null
-                && candidate.observedCogBalance >= amountCogtoshi);
-            if (eligible.length === 0) {
-                throw new Error(`${errorPrefix}_no_eligible_sender`);
-            }
-            if (eligible.length > 1) {
-                throw new Error(`${errorPrefix}_ambiguous_sender`);
-            }
-            return eligible[0];
-        })()
-        : resolveIdentityBySelector(context, selector, errorPrefix);
+    const identity = resolveIdentityBySelector(context, selector ?? context.model.walletAddress ?? "", errorPrefix);
     ensureUsableSender(identity, errorPrefix, amountCogtoshi);
     return {
         state: context.localState.state,
-        unlockUntilUnixMs: context.localState.unlockUntilUnixMs,
-        sender: {
-            localIndex: identity.index,
-            scriptPubKeyHex: identity.scriptPubKeyHex,
-            address: identity.address,
-        },
-        anchorOutpoint: resolveAnchorOutpointForSender(context.localState.state, identity, errorPrefix),
+        sender: createFundingMutationSender(context.localState.state),
         resolved: {
             sender: createResolvedSenderSummary(identity),
             claimPath: null,
@@ -155,20 +120,14 @@ function resolveClaimSender(context, lockId, preimageHex, reclaim) {
             throw new Error("wallet_reclaim_before_timeout");
         }
         const lockerHex = Buffer.from(lock.lockerScriptPubKey).toString("hex");
-        const senderIdentity = context.model.identities.find((identity) => identity.scriptPubKeyHex === lockerHex) ?? null;
-        if (senderIdentity === null) {
+        if (lockerHex !== context.localState.state.funding.scriptPubKeyHex || context.model.walletAddress == null) {
             throw new Error("wallet_reclaim_sender_not_local");
         }
+        const senderIdentity = resolveIdentityBySelector(context, context.model.walletAddress, errorPrefix);
         ensureUsableSender(senderIdentity, errorPrefix, 0n);
         return {
             state: context.localState.state,
-            unlockUntilUnixMs: context.localState.unlockUntilUnixMs,
-            sender: {
-                localIndex: senderIdentity.index,
-                scriptPubKeyHex: senderIdentity.scriptPubKeyHex,
-                address: senderIdentity.address,
-            },
-            anchorOutpoint: resolveAnchorOutpointForSender(context.localState.state, senderIdentity, errorPrefix),
+            sender: createFundingMutationSender(context.localState.state),
             recipientDomainName,
             amountCogtoshi: lock.amount,
             lockId: lock.lockId,
@@ -189,20 +148,14 @@ function resolveClaimSender(context, lockId, preimageHex, reclaim) {
         throw new Error("wallet_claim_recipient_domain_missing");
     }
     const recipientOwnerHex = Buffer.from(recipientDomain.ownerScriptPubKey).toString("hex");
-    const senderIdentity = context.model.identities.find((identity) => identity.scriptPubKeyHex === recipientOwnerHex) ?? null;
-    if (senderIdentity === null) {
+    if (recipientOwnerHex !== context.localState.state.funding.scriptPubKeyHex || context.model.walletAddress == null) {
         throw new Error("wallet_claim_sender_not_local");
     }
+    const senderIdentity = resolveIdentityBySelector(context, context.model.walletAddress, errorPrefix);
     ensureUsableSender(senderIdentity, errorPrefix, 0n);
     return {
         state: context.localState.state,
-        unlockUntilUnixMs: context.localState.unlockUntilUnixMs,
-        sender: {
-            localIndex: senderIdentity.index,
-            scriptPubKeyHex: senderIdentity.scriptPubKeyHex,
-            address: senderIdentity.address,
-        },
-        anchorOutpoint: resolveAnchorOutpointForSender(context.localState.state, senderIdentity, errorPrefix),
+        sender: createFundingMutationSender(context.localState.state),
         recipientDomainName,
         amountCogtoshi: lock.amount,
         lockId: lock.lockId,
@@ -246,45 +199,13 @@ function buildPlanForCogOperation(options) {
         && entry.confirmations >= 1
         && entry.spendable !== false
         && entry.safe !== false);
-    const outputs = [{ data: Buffer.from(options.opReturnData).toString("hex") }];
-    if (options.anchorOutpoint === null) {
-        return {
-            sender: options.sender,
-            changeAddress: options.state.funding.address,
-            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,
-        };
-    }
-    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`);
-    }
-    outputs.push({
-        [options.sender.address]: satsToBtcNumber(options.anchorValueSats),
-    });
     return {
         sender: options.sender,
         changeAddress: options.state.funding.address,
-        fixedInputs: [
-            { txid: anchorUtxo.txid, vout: anchorUtxo.vout },
-        ],
-        outputs,
-        changePosition: 2,
+        fixedInputs: [],
+        outputs: [{ data: Buffer.from(options.opReturnData).toString("hex") }],
+        changePosition: 1,
         expectedOpReturnScriptHex: encodeOpReturnScript(options.opReturnData),
-        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,
@@ -296,29 +217,10 @@ 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`);
-    }
-    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`);
     }
-    if (plan.expectedAnchorScriptHex !== null) {
-        if (outputs[1]?.scriptPubKey?.hex !== plan.expectedAnchorScriptHex) {
-            throw new Error(`${plan.errorPrefix}_anchor_output_mismatch`);
-        }
-        if (valueToSats(outputs[1]?.value ?? 0) !== (plan.expectedAnchorValueSats ?? 0n)) {
-            throw new Error(`${plan.errorPrefix}_anchor_value_mismatch`);
-        }
-    }
-    const expectedWithoutChange = plan.expectedAnchorScriptHex === null ? 1 : 2;
+    const expectedWithoutChange = 1;
     if (funded.changepos === -1) {
         if (outputs.length !== expectedWithoutChange) {
             throw new Error(`${plan.errorPrefix}_unexpected_output_count`);
@@ -341,7 +243,7 @@ async function buildTransaction(options) {
         validateFundedDraft,
         finalizeErrorCode: `${options.plan.errorPrefix}_finalize_failed`,
         mempoolRejectPrefix: `${options.plan.errorPrefix}_mempool_rejected`,
-        reserveCandidates: options.state.proactiveReserveOutpoints,
+        feeRate: options.feeRateSatVb,
     });
 }
 function createDraftMutation(options) {
@@ -363,6 +265,7 @@ function createDraftMutation(options) {
             lastUpdatedAtUnixMs: options.nowUnixMs,
             attemptedTxid: null,
             attemptedWtxid: null,
+            ...createWalletMutationFeeMetadata(options.feeSelection),
             temporaryBuilderLockedOutpoints: [],
         };
     }
@@ -386,6 +289,7 @@ function createDraftMutation(options) {
         lastUpdatedAtUnixMs: options.nowUnixMs,
         attemptedTxid: null,
         attemptedWtxid: null,
+        ...createWalletMutationFeeMetadata(options.feeSelection),
         temporaryBuilderLockedOutpoints: [],
     };
 }
@@ -422,7 +326,6 @@ async function reconcilePendingCogMutation(options) {
             await saveWalletStatePreservingUnlock({
                 state: nextState,
                 provider: options.provider,
-                unlockUntilUnixMs: options.unlockUntilUnixMs,
                 nowUnixMs: options.nowUnixMs,
                 paths: options.paths,
             });
@@ -445,7 +348,6 @@ async function reconcilePendingCogMutation(options) {
         await saveWalletStatePreservingUnlock({
             state: nextState,
             provider: options.provider,
-            unlockUntilUnixMs: options.unlockUntilUnixMs,
             nowUnixMs: options.nowUnixMs,
             paths: options.paths,
         });
@@ -524,7 +426,6 @@ async function sendBuiltTransaction(options) {
     await saveWalletStatePreservingUnlock({
         state: nextState,
         provider: options.provider,
-        unlockUntilUnixMs: options.unlockUntilUnixMs,
         nowUnixMs: options.nowUnixMs,
         paths: options.paths,
     });
@@ -551,7 +452,6 @@ async function sendBuiltTransaction(options) {
                 await saveWalletStatePreservingUnlock({
                     state: nextState,
                     provider: options.provider,
-                    unlockUntilUnixMs: options.unlockUntilUnixMs,
                     nowUnixMs: options.nowUnixMs,
                     paths: options.paths,
                 });
@@ -571,7 +471,6 @@ async function sendBuiltTransaction(options) {
             await saveWalletStatePreservingUnlock({
                 state: nextState,
                 provider: options.provider,
-                unlockUntilUnixMs: options.unlockUntilUnixMs,
                 nowUnixMs: options.nowUnixMs,
                 paths: options.paths,
             });
@@ -592,7 +491,6 @@ async function sendBuiltTransaction(options) {
     await saveWalletStatePreservingUnlock({
         state: nextState,
         provider: options.provider,
-        unlockUntilUnixMs: options.unlockUntilUnixMs,
         nowUnixMs: options.nowUnixMs,
         paths: options.paths,
     });
@@ -640,42 +538,59 @@ export async function sendCog(options) {
             });
             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 reconciled = await reconcilePendingCogMutation({
                     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: "send",
-                        txid: reconciled.mutation.attemptedTxid ?? "unknown",
-                        status: reconciled.resolution,
-                        reusedExisting: true,
-                        amountCogtoshi,
-                        recipientScriptPubKeyHex: recipient.scriptPubKeyHex,
-                        resolved: operation.resolved,
-                    };
+                    const reuse = await resolvePendingMutationReuseDecision({
+                        rpc,
+                        walletName,
+                        mutation: reconciled.mutation,
+                        nextFeeSelection: feeSelection,
+                    });
+                    if (reuse.reuseExisting) {
+                        return {
+                            kind: "send",
+                            txid: reconciled.mutation.attemptedTxid ?? "unknown",
+                            status: reconciled.resolution,
+                            reusedExisting: true,
+                            amountCogtoshi,
+                            recipientScriptPubKeyHex: recipient.scriptPubKeyHex,
+                            resolved: operation.resolved,
+                            fees: reuse.fees,
+                        };
+                    }
+                    replacementFixedInputs = reuse.replacementFixedInputs;
                 }
                 if (reconciled.resolution === "repair-required") {
                     throw new Error("wallet_send_repair_required");
                 }
             }
             await confirmSend(options.prompter, operation.resolved, options.target, recipient, amountCogtoshi, options.assumeYes);
-            let nextState = upsertPendingMutation(operation.state, createDraftMutation({
+            let nextState = upsertPendingMutation(workingState, createDraftMutation({
                 kind: "send",
                 sender: operation.sender,
                 recipientScriptPubKeyHex: recipient.scriptPubKeyHex,
                 amountCogtoshi,
                 intentFingerprintHex,
                 nowUnixMs,
+                feeSelection,
                 existing: existingMutation,
             }));
             nextState = {
@@ -686,23 +601,25 @@ export async function sendCog(options) {
             await saveWalletStatePreservingUnlock({
                 state: nextState,
                 provider,
-                unlockUntilUnixMs: operation.unlockUntilUnixMs,
                 nowUnixMs,
                 paths,
             });
+            const sendPlan = buildPlanForCogOperation({
+                state: nextState,
+                allUtxos: await rpc.listUnspent(walletName, 1),
+                sender: operation.sender,
+                opReturnData: serializeCogTransfer(amountCogtoshi, Buffer.from(recipient.scriptPubKeyHex, "hex")).opReturnData,
+                errorPrefix: "wallet_send",
+            });
             const built = await buildTransaction({
                 rpc,
                 walletName,
                 state: nextState,
-                plan: buildPlanForCogOperation({
-                    state: nextState,
-                    allUtxos: await rpc.listUnspent(walletName, 1),
-                    sender: operation.sender,
-                    anchorOutpoint: operation.anchorOutpoint,
-                    opReturnData: serializeCogTransfer(amountCogtoshi, Buffer.from(recipient.scriptPubKeyHex, "hex")).opReturnData,
-                    anchorValueSats: BigInt(nextState.anchorValueSats),
-                    errorPrefix: "wallet_send",
-                }),
+                plan: {
+                    ...sendPlan,
+                    fixedInputs: mergeFixedWalletInputs(sendPlan.fixedInputs, replacementFixedInputs),
+                },
+                feeRateSatVb: feeSelection.feeRateSatVb,
             });
             const final = await sendBuiltTransaction({
                 rpc,
@@ -712,7 +629,6 @@ export async function sendCog(options) {
                 mutation: nextState.pendingMutations.find((mutation) => mutation.intentFingerprintHex === intentFingerprintHex),
                 state: nextState,
                 provider,
-                unlockUntilUnixMs: operation.unlockUntilUnixMs,
                 nowUnixMs,
                 paths,
                 errorPrefix: "wallet_send",
@@ -725,6 +641,10 @@ export async function sendCog(options) {
                 amountCogtoshi,
                 recipientScriptPubKeyHex: recipient.scriptPubKeyHex,
                 resolved: operation.resolved,
+                fees: createBuiltWalletMutationFeeSummary({
+                    selection: feeSelection,
+                    built,
+                }),
             };
         }
         finally {
@@ -800,36 +720,52 @@ export async function lockCogToDomain(options) {
             });
             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 reconciled = await reconcilePendingCogMutation({
                     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: "lock",
-                        txid: reconciled.mutation.attemptedTxid ?? "unknown",
-                        status: reconciled.resolution,
-                        reusedExisting: true,
-                        amountCogtoshi,
-                        recipientDomainName: normalizedRecipientDomainName,
-                        resolved: operation.resolved,
-                    };
+                    const reuse = await resolvePendingMutationReuseDecision({
+                        rpc,
+                        walletName,
+                        mutation: reconciled.mutation,
+                        nextFeeSelection: feeSelection,
+                    });
+                    if (reuse.reuseExisting) {
+                        return {
+                            kind: "lock",
+                            txid: reconciled.mutation.attemptedTxid ?? "unknown",
+                            status: reconciled.resolution,
+                            reusedExisting: true,
+                            amountCogtoshi,
+                            recipientDomainName: normalizedRecipientDomainName,
+                            resolved: operation.resolved,
+                            fees: reuse.fees,
+                        };
+                    }
+                    replacementFixedInputs = reuse.replacementFixedInputs;
                 }
                 if (reconciled.resolution === "repair-required") {
                     throw new Error("wallet_lock_repair_required");
                 }
             }
             await confirmLock(options.prompter, operation.resolved, amountCogtoshi, normalizedRecipientDomainName, timeoutHeight, options.assumeYes);
-            let nextState = upsertPendingMutation(operation.state, createDraftMutation({
+            let nextState = upsertPendingMutation(workingState, createDraftMutation({
                 kind: "lock",
                 sender: operation.sender,
                 amountCogtoshi,
@@ -838,6 +774,7 @@ export async function lockCogToDomain(options) {
                 conditionHex: Buffer.from(condition).toString("hex"),
                 intentFingerprintHex,
                 nowUnixMs,
+                feeSelection,
                 existing: existingMutation,
             }));
             nextState = {
@@ -848,23 +785,25 @@ export async function lockCogToDomain(options) {
             await saveWalletStatePreservingUnlock({
                 state: nextState,
                 provider,
-                unlockUntilUnixMs: operation.unlockUntilUnixMs,
                 nowUnixMs,
                 paths,
             });
+            const lockPlan = buildPlanForCogOperation({
+                state: nextState,
+                allUtxos: await rpc.listUnspent(walletName, 1),
+                sender: operation.sender,
+                opReturnData: serializeCogLock(amountCogtoshi, timeoutHeight, recipientDomain.domainId, condition).opReturnData,
+                errorPrefix: "wallet_lock",
+            });
             const built = await buildTransaction({
                 rpc,
                 walletName,
                 state: nextState,
-                plan: buildPlanForCogOperation({
-                    state: nextState,
-                    allUtxos: await rpc.listUnspent(walletName, 1),
-                    sender: operation.sender,
-                    anchorOutpoint: operation.anchorOutpoint,
-                    opReturnData: serializeCogLock(amountCogtoshi, timeoutHeight, recipientDomain.domainId, condition).opReturnData,
-                    anchorValueSats: BigInt(nextState.anchorValueSats),
-                    errorPrefix: "wallet_lock",
-                }),
+                plan: {
+                    ...lockPlan,
+                    fixedInputs: mergeFixedWalletInputs(lockPlan.fixedInputs, replacementFixedInputs),
+                },
+                feeRateSatVb: feeSelection.feeRateSatVb,
             });
             const final = await sendBuiltTransaction({
                 rpc,
@@ -874,7 +813,6 @@ export async function lockCogToDomain(options) {
                 mutation: nextState.pendingMutations.find((mutation) => mutation.intentFingerprintHex === intentFingerprintHex),
                 state: nextState,
                 provider,
-                unlockUntilUnixMs: operation.unlockUntilUnixMs,
                 nowUnixMs,
                 paths,
                 errorPrefix: "wallet_lock",
@@ -887,6 +825,10 @@ export async function lockCogToDomain(options) {
                 amountCogtoshi,
                 recipientDomainName: normalizedRecipientDomainName,
                 resolved: operation.resolved,
+                fees: createBuiltWalletMutationFeeSummary({
+                    selection: feeSelection,
+                    built,
+                }),
             };
         }
         finally {
@@ -937,30 +879,46 @@ async function runClaimLikeMutation(options, reclaim) {
             });
             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 reconciled = await reconcilePendingCogMutation({
                     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: "claim",
-                        txid: reconciled.mutation.attemptedTxid ?? "unknown",
-                        status: reconciled.resolution,
-                        reusedExisting: true,
-                        amountCogtoshi: operation.amountCogtoshi,
-                        recipientDomainName: operation.recipientDomainName,
-                        lockId: options.lockId,
-                        resolved: operation.resolved,
-                    };
+                    const reuse = await resolvePendingMutationReuseDecision({
+                        rpc,
+                        walletName,
+                        mutation: reconciled.mutation,
+                        nextFeeSelection: feeSelection,
+                    });
+                    if (reuse.reuseExisting) {
+                        return {
+                            kind: "claim",
+                            txid: reconciled.mutation.attemptedTxid ?? "unknown",
+                            status: reconciled.resolution,
+                            reusedExisting: true,
+                            amountCogtoshi: operation.amountCogtoshi,
+                            recipientDomainName: operation.recipientDomainName,
+                            lockId: options.lockId,
+                            resolved: operation.resolved,
+                            fees: reuse.fees,
+                        };
+                    }
+                    replacementFixedInputs = reuse.replacementFixedInputs;
                 }
                 if (reconciled.resolution === "repair-required") {
                     throw new Error(`${errorPrefix}_repair_required`);
@@ -974,7 +932,7 @@ async function runClaimLikeMutation(options, reclaim) {
                 resolved: operation.resolved,
                 assumeYes: options.assumeYes,
             });
-            let nextState = upsertPendingMutation(operation.state, createDraftMutation({
+            let nextState = upsertPendingMutation(workingState, createDraftMutation({
                 kind: "claim",
                 sender: operation.sender,
                 amountCogtoshi: operation.amountCogtoshi,
@@ -983,6 +941,7 @@ async function runClaimLikeMutation(options, reclaim) {
                 preimageHex,
                 intentFingerprintHex,
                 nowUnixMs,
+                feeSelection,
                 existing: existingMutation,
             }));
             nextState = {
@@ -993,23 +952,25 @@ async function runClaimLikeMutation(options, reclaim) {
             await saveWalletStatePreservingUnlock({
                 state: nextState,
                 provider,
-                unlockUntilUnixMs: operation.unlockUntilUnixMs,
                 nowUnixMs,
                 paths,
             });
+            const claimPlan = buildPlanForCogOperation({
+                state: nextState,
+                allUtxos: await rpc.listUnspent(walletName, 1),
+                sender: operation.sender,
+                opReturnData: serializeCogClaim(options.lockId, Buffer.from(preimageHex, "hex")).opReturnData,
+                errorPrefix,
+            });
             const built = await buildTransaction({
                 rpc,
                 walletName,
                 state: nextState,
-                plan: buildPlanForCogOperation({
-                    state: nextState,
-                    allUtxos: await rpc.listUnspent(walletName, 1),
-                    sender: operation.sender,
-                    anchorOutpoint: operation.anchorOutpoint,
-                    opReturnData: serializeCogClaim(options.lockId, Buffer.from(preimageHex, "hex")).opReturnData,
-                    anchorValueSats: BigInt(nextState.anchorValueSats),
-                    errorPrefix,
-                }),
+                plan: {
+                    ...claimPlan,
+                    fixedInputs: mergeFixedWalletInputs(claimPlan.fixedInputs, replacementFixedInputs),
+                },
+                feeRateSatVb: feeSelection.feeRateSatVb,
             });
             const final = await sendBuiltTransaction({
                 rpc,
@@ -1019,7 +980,6 @@ async function runClaimLikeMutation(options, reclaim) {
                 mutation: nextState.pendingMutations.find((mutation) => mutation.intentFingerprintHex === intentFingerprintHex),
                 state: nextState,
                 provider,
-                unlockUntilUnixMs: operation.unlockUntilUnixMs,
                 nowUnixMs,
                 paths,
                 errorPrefix,
@@ -1033,6 +993,10 @@ async function runClaimLikeMutation(options, reclaim) {
                 recipientDomainName: operation.recipientDomainName,
                 lockId: options.lockId,
                 resolved: operation.resolved,
+                fees: createBuiltWalletMutationFeeSummary({
+                    selection: feeSelection,
+                    built,
+                }),
             };
         }
         finally {