@cogcoin/client 0.5.15 → 1.0.0

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

@@ -1,20 +1,34 @@
-import type { RpcDecodedPsbt, RpcFinalizePsbtResult, RpcListUnspentEntry, RpcLockedUnspent, RpcTestMempoolAcceptResult, RpcTransaction, RpcVin, RpcWalletCreateFundedPsbtResult, RpcWalletTransaction, RpcWalletProcessPsbtResult } from "../../bitcoind/types.js";
+import type { RpcDecodedPsbt, RpcEstimateSmartFeeResult, RpcFinalizePsbtResult, RpcListUnspentEntry, RpcLockedUnspent, RpcMempoolEntry, 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";
 import type { WalletRuntimePaths } from "../runtime.js";
 import { type MiningPreemptionHandle } from "../mining/coordination.js";
 export declare const DEFAULT_WALLET_MUTATION_FEE_RATE_SAT_VB = 10;
+export declare const NEXT_BLOCK_FEE_CONFIRM_TARGET = 1;
+export type WalletMutationFeeSelectionSource = "custom-satvb" | "estimated-next-block-plus-one" | "fallback-default";
+export interface WalletMutationFeeSelection {
+    feeRateSatVb: number;
+    source: WalletMutationFeeSelectionSource;
+}
+export interface WalletMutationFeeSummary extends WalletMutationFeeSelection {
+    feeSats: string | null;
+}
 export interface MutationSender {
     localIndex: number;
     scriptPubKeyHex: string;
     address: string;
 }
+export declare function isLocalWalletScript(state: WalletStateV1, scriptPubKeyHex: string | null | undefined): boolean;
+export declare function createFundingMutationSender(state: WalletStateV1): MutationSender;
 export interface WalletMutationRpcClient {
     listUnspent(walletName: string, minConf?: number): Promise<RpcListUnspentEntry[]>;
-    listLockUnspent(walletName: string): Promise<RpcLockedUnspent[]>;
-    lockUnspent(walletName: string, unlock: boolean, outputs: RpcLockedUnspent[]): Promise<boolean>;
+    listLockUnspent?(walletName: string): Promise<RpcLockedUnspent[]>;
+    lockUnspent?(walletName: string, unlock: boolean, outputs: RpcLockedUnspent[]): Promise<boolean>;
     getTransaction?(walletName: string, txid: string): Promise<RpcWalletTransaction>;
+    getRawTransaction?(txid: string, verbose?: boolean): Promise<RpcTransaction>;
+    getMempoolEntry?(txid: string): Promise<RpcMempoolEntry>;
+    estimateSmartFee?(confirmTarget: number, mode: "conservative" | "economical"): Promise<RpcEstimateSmartFeeResult>;
     walletCreateFundedPsbt(walletName: string, inputs: Array<{
         txid: string;
         vout: number;
@@ -38,11 +52,44 @@ export interface BuiltWalletMutationTransaction {
 }
 export interface FixedWalletInput extends OutpointRecord {
 }
+export declare function formatSatVb(value: number): string;
+export declare function createWalletMutationFeeMetadata(selection: WalletMutationFeeSelection): {
+    selectedFeeRateSatVb: number;
+    feeSelectionSource: WalletMutationFeeSelectionSource;
+};
+export declare function resolveWalletMutationFeeSelection(options: {
+    rpc: Pick<WalletMutationRpcClient, "estimateSmartFee">;
+    feeRateSatVb?: number | null;
+}): Promise<WalletMutationFeeSelection>;
+export declare function createWalletMutationFeeSummary(selection: WalletMutationFeeSelection, feeSats: string | null): WalletMutationFeeSummary;
+export declare function createBuiltWalletMutationFeeSummary(options: {
+    selection: WalletMutationFeeSelection;
+    built: BuiltWalletMutationTransaction;
+}): WalletMutationFeeSummary;
+export declare function resolvePendingMutationFeeSummary(options: {
+    rpc: Pick<WalletMutationRpcClient, "getMempoolEntry">;
+    mutation: PendingMutationRecord;
+}): Promise<WalletMutationFeeSummary>;
+export declare function loadAttemptedMutationFixedInputs(options: {
+    rpc: Pick<WalletMutationRpcClient, "getTransaction" | "getRawTransaction">;
+    walletName: string;
+    mutation: PendingMutationRecord;
+}): Promise<FixedWalletInput[] | null>;
+export declare function resolvePendingMutationReuseDecision(options: {
+    rpc: Pick<WalletMutationRpcClient, "getMempoolEntry" | "getTransaction" | "getRawTransaction">;
+    walletName: string;
+    mutation: PendingMutationRecord;
+    nextFeeSelection: WalletMutationFeeSelection;
+}): Promise<{
+    reuseExisting: boolean;
+    fees: WalletMutationFeeSummary;
+    replacementFixedInputs: FixedWalletInput[] | null;
+}>;
+export declare function mergeFixedWalletInputs(fixedInputs: readonly FixedWalletInput[], replacementInputs: readonly FixedWalletInput[] | null): FixedWalletInput[];
 export declare function saveWalletStatePreservingUnlock(options: {
     state: WalletStateV1;
     provider: WalletSecretProvider;
-    unlockUntilUnixMs: number;
-    nowUnixMs: number;
+    nowUnixMs?: number;
     paths: WalletRuntimePaths;
 }): Promise<void>;
 export declare function formatCogAmount(value: bigint): string;
@@ -57,6 +104,8 @@ export declare function updateMutationRecord(mutation: PendingMutationRecord, st
     attemptedTxid?: string | null;
     attemptedWtxid?: string | null;
     temporaryBuilderLockedOutpoints?: OutpointRecord[];
+    selectedFeeRateSatVb?: number | null;
+    feeSelectionSource?: WalletMutationFeeSelectionSource | null;
 }): PendingMutationRecord;
 export declare function unlockTemporaryBuilderLocks(rpc: Pick<WalletMutationRpcClient, "lockUnspent">, walletName: string, outpoints: OutpointRecord[]): Promise<void>;
 export declare function diffTemporaryLockedOutpoints(before: RpcLockedUnspent[], after: RpcLockedUnspent[]): OutpointRecord[];
@@ -86,11 +135,16 @@ export declare function assertWalletMutationContextReady(context: WalletReadCont
     localState: {
         availability: "ready";
         state: WalletStateV1;
-        unlockUntilUnixMs: number;
     };
     snapshot: NonNullable<WalletReadContext["snapshot"]>;
     model: NonNullable<WalletReadContext["model"]>;
 };
+export declare function assertWalletBitcoinTransferContextReady(context: WalletReadContext, errorPrefix: string): asserts context is WalletReadContext & {
+    localState: {
+        availability: "ready";
+        state: WalletStateV1;
+    };
+};
 export declare function pauseMiningForWalletMutation(options: {
     paths: WalletRuntimePaths;
     reason: string;
@@ -103,7 +157,7 @@ export declare function buildWalletMutationTransaction<TPlan>(options: {
         fixedInputs: FixedWalletInput[];
         outputs: unknown[];
         changeAddress: string;
-        changePosition: number;
+        changePosition?: number | null;
         allowedFundingScriptPubKeyHex: string;
         eligibleFundingOutpointKeys: Set<string>;
     };
@@ -131,5 +185,4 @@ export declare function buildWalletMutationTransactionWithReserveFallback<TPlan>
     mempoolRejectPrefix: string;
     feeRate?: number;
     availableFundingMinConf?: number;
-    reserveCandidates: readonly OutpointRecord[];
 }): Promise<BuiltWalletMutationTransaction>;

package/dist/wallet/tx/common.js

@@ -1,30 +1,194 @@
-import { randomBytes } from "node:crypto";
-import { saveUnlockSession } from "../state/session.js";
 import { saveWalletState } from "../state/storage.js";
 import { createWalletSecretReference, } from "../state/provider.js";
+import { MANAGED_CORE_WALLET_UNLOCK_TIMEOUT_SECONDS, withUnlockedManagedCoreWallet, } from "../managed-core-wallet.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;
+export const NEXT_BLOCK_FEE_CONFIRM_TARGET = 1;
+export function isLocalWalletScript(state, scriptPubKeyHex) {
+    if (typeof scriptPubKeyHex !== "string" || scriptPubKeyHex.length === 0) {
+        return false;
+    }
+    return scriptPubKeyHex === state.funding.scriptPubKeyHex
+        || (state.localScriptPubKeyHexes ?? []).includes(scriptPubKeyHex);
+}
+export function createFundingMutationSender(state) {
+    return {
+        localIndex: 0,
+        scriptPubKeyHex: state.funding.scriptPubKeyHex,
+        address: state.funding.address,
+    };
+}
 function btcNumberToSats(value) {
     return BigInt(Math.round(value * 100_000_000));
 }
+function normalizeSatVb(value) {
+    return Number.parseFloat(value.toFixed(8));
+}
+function satVbFromBtcPerKvB(value) {
+    return normalizeSatVb((value * 100_000_000) / 1_000);
+}
 function valueToSats(value) {
     return typeof value === "string"
         ? BigInt(Math.round(Number(value) * 100_000_000))
         : btcNumberToSats(value);
 }
-function createUnlockSessionState(state, unlockUntilUnixMs, nowUnixMs) {
+function feeRateFromMempoolEntry(entry) {
+    if (!Number.isFinite(entry.vsize) || entry.vsize <= 0) {
+        return null;
+    }
+    const feeSats = Number(btcNumberToSats(entry.fees.base));
+    if (!Number.isFinite(feeSats) || feeSats <= 0) {
+        return null;
+    }
+    return normalizeSatVb(feeSats / entry.vsize);
+}
+export function formatSatVb(value) {
+    return normalizeSatVb(value).toString();
+}
+export function createWalletMutationFeeMetadata(selection) {
     return {
-        schemaVersion: 1,
-        walletRootId: state.walletRootId,
-        sessionId: randomBytes(16).toString("hex"),
-        createdAtUnixMs: nowUnixMs,
-        unlockUntilUnixMs,
-        sourceStateRevision: state.stateRevision,
-        wrappedSessionKeyMaterial: createWalletSecretReference(state.walletRootId).keyId,
+        selectedFeeRateSatVb: selection.feeRateSatVb,
+        feeSelectionSource: selection.source,
     };
 }
+export async function resolveWalletMutationFeeSelection(options) {
+    if (typeof options.feeRateSatVb === "number") {
+        return {
+            feeRateSatVb: normalizeSatVb(options.feeRateSatVb),
+            source: "custom-satvb",
+        };
+    }
+    if (options.rpc.estimateSmartFee !== undefined) {
+        try {
+            const estimate = await options.rpc.estimateSmartFee(NEXT_BLOCK_FEE_CONFIRM_TARGET, "conservative");
+            const estimatedSatVb = typeof estimate.feerate === "number"
+                ? satVbFromBtcPerKvB(estimate.feerate)
+                : null;
+            if (estimatedSatVb !== null && Number.isFinite(estimatedSatVb) && estimatedSatVb > 0) {
+                return {
+                    feeRateSatVb: normalizeSatVb(estimatedSatVb + 1),
+                    source: "estimated-next-block-plus-one",
+                };
+            }
+        }
+        catch {
+            // Fall through to the compatibility default.
+        }
+    }
+    return {
+        feeRateSatVb: DEFAULT_WALLET_MUTATION_FEE_RATE_SAT_VB,
+        source: "fallback-default",
+    };
+}
+export function createWalletMutationFeeSummary(selection, feeSats) {
+    return {
+        feeRateSatVb: selection.feeRateSatVb,
+        feeSats,
+        source: selection.source,
+    };
+}
+export function createBuiltWalletMutationFeeSummary(options) {
+    return createWalletMutationFeeSummary(options.selection, btcNumberToSats(options.built.funded.fee).toString());
+}
+export async function resolvePendingMutationFeeSummary(options) {
+    const source = options.mutation.feeSelectionSource ?? "fallback-default";
+    const selectedFeeRateSatVb = typeof options.mutation.selectedFeeRateSatVb === "number"
+        && Number.isFinite(options.mutation.selectedFeeRateSatVb)
+        && options.mutation.selectedFeeRateSatVb > 0
+        ? normalizeSatVb(options.mutation.selectedFeeRateSatVb)
+        : DEFAULT_WALLET_MUTATION_FEE_RATE_SAT_VB;
+    if (options.mutation.attemptedTxid !== null && options.rpc.getMempoolEntry !== undefined) {
+        try {
+            const entry = await options.rpc.getMempoolEntry(options.mutation.attemptedTxid);
+            const feeRateSatVb = feeRateFromMempoolEntry(entry);
+            if (feeRateSatVb !== null) {
+                return {
+                    feeRateSatVb,
+                    feeSats: btcNumberToSats(entry.fees.base).toString(),
+                    source,
+                };
+            }
+        }
+        catch {
+            // Fall back to stored metadata or the historical default.
+        }
+    }
+    return {
+        feeRateSatVb: selectedFeeRateSatVb,
+        feeSats: null,
+        source,
+    };
+}
+export async function loadAttemptedMutationFixedInputs(options) {
+    if (options.mutation.attemptedTxid === null) {
+        return null;
+    }
+    const txid = options.mutation.attemptedTxid;
+    let decoded = null;
+    if (options.rpc.getTransaction !== undefined) {
+        try {
+            decoded = (await options.rpc.getTransaction(options.walletName, txid)).decoded ?? null;
+        }
+        catch {
+            decoded = null;
+        }
+    }
+    if (decoded === null && options.rpc.getRawTransaction !== undefined) {
+        try {
+            decoded = await options.rpc.getRawTransaction(txid, true);
+        }
+        catch {
+            decoded = null;
+        }
+    }
+    if (decoded === null) {
+        return null;
+    }
+    const fixedInputs = decoded.vin
+        .filter((input) => typeof input.txid === "string" && typeof input.vout === "number")
+        .map((input) => ({
+        txid: input.txid,
+        vout: input.vout,
+    }));
+    return fixedInputs.length > 0 ? fixedInputs : null;
+}
+export async function resolvePendingMutationReuseDecision(options) {
+    const fees = await resolvePendingMutationFeeSummary({
+        rpc: options.rpc,
+        mutation: options.mutation,
+    });
+    if (options.mutation.status === "confirmed"
+        || options.nextFeeSelection.feeRateSatVb <= fees.feeRateSatVb) {
+        return {
+            reuseExisting: true,
+            fees,
+            replacementFixedInputs: null,
+        };
+    }
+    return {
+        reuseExisting: false,
+        fees,
+        replacementFixedInputs: await loadAttemptedMutationFixedInputs({
+            rpc: options.rpc,
+            walletName: options.walletName,
+            mutation: options.mutation,
+        }),
+    };
+}
+export function mergeFixedWalletInputs(fixedInputs, replacementInputs) {
+    if (replacementInputs === null || replacementInputs.length === 0) {
+        return [...fixedInputs];
+    }
+    const merged = new Map();
+    for (const input of fixedInputs) {
+        merged.set(outpointKey(input), { txid: input.txid, vout: input.vout });
+    }
+    for (const input of replacementInputs) {
+        merged.set(outpointKey(input), { txid: input.txid, vout: input.vout });
+    }
+    return [...merged.values()];
+}
 export async function saveWalletStatePreservingUnlock(options) {
     const secretReference = createWalletSecretReference(options.state.walletRootId);
     await saveWalletState({
@@ -34,10 +198,6 @@ export async function saveWalletStatePreservingUnlock(options) {
         provider: options.provider,
         secretReference,
     });
-    await saveUnlockSession(options.paths.walletUnlockSessionPath, createUnlockSessionState(options.state, options.unlockUntilUnixMs, options.nowUnixMs), {
-        provider: options.provider,
-        secretReference,
-    });
 }
 export function formatCogAmount(value) {
     const sign = value < 0n ? "-" : "";
@@ -75,10 +235,12 @@ export function updateMutationRecord(mutation, status, nowUnixMs, options = {})
         attemptedTxid: options.attemptedTxid ?? mutation.attemptedTxid,
         attemptedWtxid: options.attemptedWtxid ?? mutation.attemptedWtxid,
         temporaryBuilderLockedOutpoints: options.temporaryBuilderLockedOutpoints ?? mutation.temporaryBuilderLockedOutpoints,
+        selectedFeeRateSatVb: options.selectedFeeRateSatVb ?? mutation.selectedFeeRateSatVb,
+        feeSelectionSource: options.feeSelectionSource ?? mutation.feeSelectionSource,
     };
 }
 export async function unlockTemporaryBuilderLocks(rpc, walletName, outpoints) {
-    if (outpoints.length === 0) {
+    if (outpoints.length === 0 || rpc.lockUnspent === undefined) {
         return;
     }
     await rpc.lockUnspent(walletName, true, outpoints).catch(() => undefined);
@@ -124,40 +286,18 @@ export function inputMatchesOutpoint(input, outpoint) {
     return input.txid === outpoint.txid && getDecodedInputVout(input) === outpoint.vout;
 }
 export function assertFixedInputPrefixMatches(inputs, fixedInputs, errorCode) {
-    if (inputs.length < fixedInputs.length) {
-        throw new Error(errorCode);
-    }
-    for (const [index, fixedInput] of fixedInputs.entries()) {
-        if (!inputMatchesOutpoint(inputs[index], fixedInput)) {
-            throw new Error(errorCode);
-        }
-    }
+    void inputs;
+    void fixedInputs;
+    void errorCode;
 }
 export function assertFundingInputsAfterFixedPrefix(options) {
-    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);
-        }
-        const key = outpointKey({
-            txid: input.txid,
-            vout,
-        });
-        if (!options.eligibleFundingOutpointKeys.has(key)) {
-            throw new Error(options.errorCode);
-        }
-    }
+    void options;
 }
 export async function reconcilePersistentPolicyLocks(options) {
     await reconcileWalletCoinControlLocks({
         rpc: options.rpc,
         walletName: options.walletName,
         state: options.state,
-        fixedInputs: options.fixedInputs,
-        temporarilyUnlockedOutpoints: options.temporarilyUnlockedOutpoints,
-        cleanupInactiveTemporaryBuilderLocks: options.cleanupInactiveTemporaryBuilderLocks,
     });
 }
 export function isBroadcastUnknownError(error) {
@@ -181,8 +321,8 @@ export function isInsufficientFundsError(error) {
     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");
+    void error;
+    return false;
 }
 function computeRemainingFundingValueSats(options) {
     let remaining = 0n;
@@ -212,11 +352,20 @@ export function assertWalletMutationContextReady(context, errorPrefix) {
     if (context.localState.availability === "uninitialized") {
         throw new Error("wallet_uninitialized");
     }
+    if (context.localState.clientPasswordReadiness === "setup-required") {
+        throw new Error("wallet_client_password_setup_required");
+    }
+    if (context.localState.clientPasswordReadiness === "migration-required") {
+        throw new Error("wallet_client_password_migration_required");
+    }
+    if (context.localState.unlockRequired) {
+        throw new Error("wallet_client_password_locked");
+    }
     if (context.localState.availability === "local-state-corrupt") {
         throw new Error("local-state-corrupt");
     }
-    if (context.localState.availability !== "ready" || context.localState.state === null || context.localState.unlockUntilUnixMs === null) {
-        throw new Error("wallet_locked");
+    if (context.localState.availability !== "ready" || context.localState.state === null) {
+        throw new Error("wallet_secret_provider_unavailable");
     }
     if (context.bitcoind.health !== "ready") {
         throw new Error(`${errorPrefix}_bitcoind_${context.bitcoind.health.replaceAll("-", "_")}`);
@@ -231,6 +380,35 @@ export function assertWalletMutationContextReady(context, errorPrefix) {
         throw new Error(`${errorPrefix}_core_replica_not_ready`);
     }
 }
+export function assertWalletBitcoinTransferContextReady(context, errorPrefix) {
+    if (context.localState.availability === "uninitialized") {
+        throw new Error("wallet_uninitialized");
+    }
+    if (context.localState.clientPasswordReadiness === "setup-required") {
+        throw new Error("wallet_client_password_setup_required");
+    }
+    if (context.localState.clientPasswordReadiness === "migration-required") {
+        throw new Error("wallet_client_password_migration_required");
+    }
+    if (context.localState.unlockRequired) {
+        throw new Error("wallet_client_password_locked");
+    }
+    if (context.localState.availability === "local-state-corrupt") {
+        throw new Error("local-state-corrupt");
+    }
+    if (context.localState.availability !== "ready" || context.localState.state === null) {
+        throw new Error("wallet_secret_provider_unavailable");
+    }
+    if (context.bitcoind.health !== "ready") {
+        throw new Error(`${errorPrefix}_bitcoind_${context.bitcoind.health.replaceAll("-", "_")}`);
+    }
+    if (context.nodeHealth !== "synced") {
+        throw new Error(`${errorPrefix}_node_${context.nodeHealth.replaceAll("-", "_")}`);
+    }
+    if (context.nodeStatus?.walletReplica?.proofStatus !== "ready") {
+        throw new Error(`${errorPrefix}_core_replica_not_ready`);
+    }
+}
 export async function pauseMiningForWalletMutation(options) {
     return requestMiningGenerationPreemption({
         paths: options.paths,
@@ -238,13 +416,6 @@ export async function pauseMiningForWalletMutation(options) {
     });
 }
 export async function buildWalletMutationTransaction(options) {
-    await reconcilePersistentPolicyLocks({
-        rpc: options.rpc,
-        walletName: options.walletName,
-        state: options.state,
-        fixedInputs: options.plan.fixedInputs,
-        temporarilyUnlockedOutpoints: options.temporarilyUnlockedPolicyOutpoints,
-    });
     const availableFundingMinConf = options.availableFundingMinConf ?? 1;
     const availableFundingUtxos = (await options.rpc.listUnspent(options.walletName, availableFundingMinConf))
         .filter((entry) => isSpendableFundingUtxo(entry, options.plan.allowedFundingScriptPubKeyHex, availableFundingMinConf));
@@ -259,67 +430,56 @@ export async function buildWalletMutationTransaction(options) {
             ...availableFundingUtxos.map((entry) => outpointKey({ txid: entry.txid, vout: entry.vout })),
         ]),
     };
-    const lockedBefore = await options.rpc.listLockUnspent(options.walletName);
-    let temporaryBuilderLockedOutpoints = [];
+    const temporaryBuilderLockedOutpoints = [];
     try {
         const funded = await options.rpc.walletCreateFundedPsbt(options.walletName, options.plan.fixedInputs, options.plan.outputs, 0, {
             add_inputs: true,
             include_unsafe: false,
             minconf: 1,
             changeAddress: options.plan.changeAddress,
-            changePosition: options.plan.changePosition,
-            lockUnspents: true,
+            ...(options.plan.changePosition == null ? {} : { changePosition: options.plan.changePosition }),
+            lockUnspents: false,
             fee_rate: options.feeRate ?? DEFAULT_WALLET_MUTATION_FEE_RATE_SAT_VB,
             replaceable: true,
             subtractFeeFromOutputs: [],
         });
-        const lockedAfter = await options.rpc.listLockUnspent(options.walletName);
-        temporaryBuilderLockedOutpoints = diffTemporaryLockedOutpoints(lockedBefore, lockedAfter);
         const decoded = await options.rpc.decodePsbt(funded.psbt);
         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 rawHex;
         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"}`);
-            }
-        }
-        finally {
-            await options.rpc.walletLock(options.walletName).catch(() => undefined);
-        }
-        if ((options.temporarilyUnlockedPolicyOutpoints?.length ?? 0) > 0) {
-            await reconcilePersistentPolicyLocks({
-                rpc: options.rpc,
-                walletName: options.walletName,
-                state: options.state,
-                fixedInputs: options.plan.fixedInputs,
-            });
-        }
+        ({ signed, finalized, rawHex, decodedRaw } = await withUnlockedManagedCoreWallet({
+            rpc: options.rpc,
+            walletName: options.walletName,
+            internalPassphrase: options.state.managedCoreWallet.internalPassphrase,
+            timeoutSeconds: MANAGED_CORE_WALLET_UNLOCK_TIMEOUT_SECONDS,
+            run: async () => {
+                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);
+                }
+                const rawHex = finalized.hex;
+                const decodedRaw = await options.rpc.decodeRawTransaction(rawHex);
+                const mempoolResult = await options.rpc.testMempoolAccept([rawHex]);
+                const accepted = mempoolResult[0];
+                if (accepted == null || !accepted.allowed) {
+                    throw new Error(`${options.mempoolRejectPrefix}_${accepted?.["reject-reason"] ?? "unknown"}`);
+                }
+                return {
+                    signed,
+                    finalized,
+                    rawHex,
+                    decodedRaw,
+                };
+            },
+        }));
         return {
             funded,
             decoded,
             psbt: signed.psbt,
-            rawHex: finalized.hex,
+            rawHex,
             txid: decodedRaw.txid,
             wtxid: decodedRaw.hash ?? null,
             temporaryBuilderLockedOutpoints,
@@ -327,59 +487,19 @@ export async function buildWalletMutationTransaction(options) {
     }
     catch (error) {
         await unlockTemporaryBuilderLocks(options.rpc, options.walletName, temporaryBuilderLockedOutpoints);
-        if ((options.temporarilyUnlockedPolicyOutpoints?.length ?? 0) > 0) {
-            await reconcilePersistentPolicyLocks({
-                rpc: options.rpc,
-                walletName: options.walletName,
-                state: options.state,
-                fixedInputs: options.plan.fixedInputs,
-            });
-        }
         throw error;
     }
 }
 export async function buildWalletMutationTransactionWithReserveFallback(options) {
-    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 <= reserveCandidates.length; attempt += 1) {
-        if (attempt > 0) {
-            unlockedReserveOutpoints = [
-                ...unlockedReserveOutpoints,
-                reserveCandidates[attempt - 1],
-            ];
-        }
-        try {
-            return await buildWalletMutationTransaction({
-                rpc: options.rpc,
-                walletName: options.walletName,
-                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) && !isReserveFloorFundingError(error)) || attempt === reserveCandidates.length) {
-                throw error;
-            }
-        }
-    }
-    throw lastError;
+    return buildWalletMutationTransaction({
+        rpc: options.rpc,
+        walletName: options.walletName,
+        state: options.state,
+        plan: options.plan,
+        validateFundedDraft: options.validateFundedDraft,
+        finalizeErrorCode: options.finalizeErrorCode,
+        mempoolRejectPrefix: options.mempoolRejectPrefix,
+        feeRate: options.feeRate,
+        availableFundingMinConf: options.availableFundingMinConf,
+    });
 }

package/dist/wallet/tx/domain-admin.d.ts

@@ -5,7 +5,7 @@ import type { WalletPrompter } from "../lifecycle.js";
 import { type WalletRuntimePaths } from "../runtime.js";
 import { type WalletSecretProvider } from "../state/provider.js";
 import { openWalletReadContext } from "../read/index.js";
-import { type WalletMutationRpcClient } from "./common.js";
+import { type WalletMutationFeeSummary, type WalletMutationRpcClient } from "./common.js";
 type DomainAdminKind = "endpoint" | "delegate" | "miner" | "canonical";
 interface DomainAdminRpcClient extends WalletMutationRpcClient {
     getBlockchainInfo(): Promise<{
@@ -55,9 +55,11 @@ export interface DomainAdminMutationResult {
     recipientScriptPubKeyHex?: string | null;
     endpointValueHex?: string | null;
     resolved?: DomainAdminResolvedSummary | null;
+    fees: WalletMutationFeeSummary;
 }
 interface DomainAdminBaseOptions {
     domainName: string;
+    feeRateSatVb?: number | null;
     dataDir: string;
     databasePath: string;
     provider?: WalletSecretProvider;