@cogcoin/client 1.1.8 → 1.1.9

package/dist/wallet/tx/reputation.js

@@ -1,556 +1 @@
-import { createHash, randomBytes } from "node:crypto";
-import { encodeSentence } from "@cogcoin/scoring";
-import { getBalance, lookupDomain, } from "@cogcoin/indexer/queries";
-import { attachOrStartManagedBitcoindService } from "../../bitcoind/service.js";
-import { createRpcClient } from "../../bitcoind/node.js";
-import {} from "../runtime.js";
-import {} from "../state/provider.js";
-import { serializeRepCommit, serializeRepRevoke, validateDomainName, } from "../cogop/index.js";
-import { openWalletReadContext } from "../read/index.js";
-import { assertFixedInputPrefixMatches, assertFundingInputsAfterFixedPrefix, assertWalletMutationContextReady, buildWalletMutationTransactionWithReserveFallback, createFundingMutationSender, createWalletMutationFeeMetadata, formatCogAmount, getDecodedInputScriptPubKeyHex, isLocalWalletScript, mergeFixedWalletInputs, outpointKey, unlockTemporaryBuilderLocks, updateMutationRecord, } from "./common.js";
-import { confirmTypedAcknowledgement as confirmSharedTypedAcknowledgement, confirmYesNo as confirmSharedYesNo, } from "./confirm.js";
-import { executeWalletMutationOperation, persistWalletMutationState, publishWalletMutation, resolveExistingWalletMutation, } from "./executor.js";
-import { getCanonicalIdentitySelector } from "./identity-selector.js";
-import { upsertPendingMutation } from "./journal.js";
-function normalizeDomainName(domainName, errorCode) {
-    const normalized = domainName.trim().toLowerCase();
-    if (normalized.length === 0) {
-        throw new Error(errorCode);
-    }
-    validateDomainName(normalized);
-    return normalized;
-}
-function createSupportKey(sourceDomainId, targetDomainId) {
-    return `${sourceDomainId}:${targetDomainId}`;
-}
-function encodeOpReturnScript(payload) {
-    if (payload.length <= 75) {
-        return Buffer.concat([
-            Buffer.from([0x6a, payload.length]),
-            Buffer.from(payload),
-        ]).toString("hex");
-    }
-    return Buffer.concat([
-        Buffer.from([0x6a, 0x4c, payload.length]),
-        Buffer.from(payload),
-    ]).toString("hex");
-}
-function satsToBtcNumber(value) {
-    return Number(value) / 100_000_000;
-}
-function valueToSats(value) {
-    const text = typeof value === "number" ? value.toFixed(8) : value;
-    const match = /^(-?)(\d+)(?:\.(\d{0,8}))?$/.exec(text.trim());
-    if (match == null) {
-        throw new Error(`wallet_reputation_invalid_amount_${text}`);
-    }
-    const sign = match[1] === "-" ? -1n : 1n;
-    const whole = BigInt(match[2] ?? "0");
-    const fraction = BigInt((match[3] ?? "").padEnd(8, "0"));
-    return sign * ((whole * 100000000n) + fraction);
-}
-function createIntentFingerprint(parts) {
-    return createHash("sha256")
-        .update(parts.map((part) => String(part)).join("\n"))
-        .digest("hex");
-}
-function createResolvedReputationSenderSummary(sender, selector) {
-    return {
-        selector,
-        localIndex: sender.localIndex,
-        scriptPubKeyHex: sender.scriptPubKeyHex,
-        address: sender.address,
-    };
-}
-function createResolvedReputationSummary(options) {
-    return {
-        sender: createResolvedReputationSenderSummary(options.sender, options.senderSelector),
-        effect: options.kind === "give"
-            ? {
-                kind: "give-support",
-                burnCogtoshi: options.amountCogtoshi.toString(),
-            }
-            : {
-                kind: "revoke-support",
-                burnCogtoshi: options.amountCogtoshi.toString(),
-            },
-        review: {
-            included: options.review.payloadHex !== null,
-            byteLength: options.review.payload?.length ?? null,
-        },
-        selfStake: options.selfStake,
-    };
-}
-function describeReputationEffect(effect) {
-    if (effect.kind === "give-support") {
-        return `burn ${effect.burnCogtoshi} cogtoshi to publish support`;
-    }
-    return `revoke visible support with no refund of the previously burned ${effect.burnCogtoshi} cogtoshi`;
-}
-function describeReputationReview(review) {
-    if (!review.included || review.byteLength === null) {
-        return "none";
-    }
-    return `included (${review.byteLength} bytes)`;
-}
-function resolveReputationOperation(context, sourceDomainName, targetDomainName, errorPrefix) {
-    assertWalletMutationContextReady(context, errorPrefix);
-    const sourceDomain = lookupDomain(context.snapshot.state, sourceDomainName);
-    if (sourceDomain === null) {
-        throw new Error(`${errorPrefix}_source_domain_not_found`);
-    }
-    if (!sourceDomain.anchored) {
-        throw new Error(`${errorPrefix}_source_domain_not_anchored`);
-    }
-    const targetDomain = lookupDomain(context.snapshot.state, targetDomainName);
-    if (targetDomain === null) {
-        throw new Error(`${errorPrefix}_target_domain_not_found`);
-    }
-    if (!targetDomain.anchored) {
-        throw new Error(`${errorPrefix}_target_domain_not_anchored`);
-    }
-    const ownerHex = Buffer.from(sourceDomain.ownerScriptPubKey).toString("hex");
-    if (ownerHex !== context.localState.state.funding.scriptPubKeyHex || context.model.walletAddress == null) {
-        throw new Error(`${errorPrefix}_source_owner_not_locally_controlled`);
-    }
-    return {
-        readContext: context,
-        state: context.localState.state,
-        sender: createFundingMutationSender(context.localState.state),
-        senderSelector: context.model.walletAddress,
-        sourceDomain,
-        targetDomain,
-        availableBalanceCogtoshi: getBalance(context.snapshot.state, sourceDomain.ownerScriptPubKey),
-        currentNetSupportCogtoshi: context.snapshot.state.consensus.supportByPair.get(createSupportKey(sourceDomain.domainId, targetDomain.domainId)) ?? 0n,
-    };
-}
-function buildPlanForReputationOperation(options) {
-    const fundingUtxos = options.allUtxos.filter((entry) => entry.scriptPubKey === options.state.funding.scriptPubKeyHex
-        && entry.confirmations >= 1
-        && entry.spendable !== false
-        && entry.safe !== false);
-    return {
-        sender: options.sender,
-        changeAddress: options.state.funding.address,
-        fixedInputs: [],
-        outputs: [{ data: Buffer.from(options.opReturnData).toString("hex") }],
-        changePosition: 1,
-        expectedOpReturnScriptHex: encodeOpReturnScript(options.opReturnData),
-        allowedFundingScriptPubKeyHex: options.state.funding.scriptPubKeyHex,
-        eligibleFundingOutpointKeys: new Set(fundingUtxos.map((entry) => outpointKey({ txid: entry.txid, vout: entry.vout }))),
-        errorPrefix: options.errorPrefix,
-    };
-}
-function validateFundedDraft(decoded, funded, plan) {
-    const inputs = decoded.tx.vin;
-    const outputs = decoded.tx.vout;
-    if (inputs.length === 0) {
-        throw new Error(`${plan.errorPrefix}_missing_sender_input`);
-    }
-    if (outputs[0]?.scriptPubKey?.hex !== plan.expectedOpReturnScriptHex) {
-        throw new Error(`${plan.errorPrefix}_opreturn_mismatch`);
-    }
-    if (funded.changepos === -1) {
-        if (outputs.length !== 1) {
-            throw new Error(`${plan.errorPrefix}_unexpected_output_count`);
-        }
-        return;
-    }
-    if (funded.changepos !== plan.changePosition || outputs.length !== 2) {
-        throw new Error(`${plan.errorPrefix}_change_position_mismatch`);
-    }
-    if (outputs[funded.changepos]?.scriptPubKey?.hex !== plan.allowedFundingScriptPubKeyHex) {
-        throw new Error(`${plan.errorPrefix}_change_output_mismatch`);
-    }
-}
-async function buildTransaction(options) {
-    return buildWalletMutationTransactionWithReserveFallback({
-        rpc: options.rpc,
-        walletName: options.walletName,
-        state: options.state,
-        plan: options.plan,
-        validateFundedDraft,
-        finalizeErrorCode: `${options.plan.errorPrefix}_finalize_failed`,
-        mempoolRejectPrefix: `${options.plan.errorPrefix}_mempool_rejected`,
-        feeRate: options.feeRateSatVb,
-    });
-}
-function createDraftMutation(options) {
-    if (options.existing !== null && options.existing !== undefined) {
-        return {
-            ...options.existing,
-            kind: options.kind,
-            domainName: options.sourceDomainName,
-            senderScriptPubKeyHex: options.sender.scriptPubKeyHex,
-            senderLocalIndex: options.sender.localIndex,
-            recipientDomainName: options.targetDomainName,
-            amountCogtoshi: options.amountCogtoshi,
-            reviewPayloadHex: options.reviewPayloadHex,
-            status: "draft",
-            lastUpdatedAtUnixMs: options.nowUnixMs,
-            attemptedTxid: null,
-            attemptedWtxid: null,
-            ...createWalletMutationFeeMetadata(options.feeSelection),
-            temporaryBuilderLockedOutpoints: [],
-        };
-    }
-    return {
-        mutationId: randomBytes(12).toString("hex"),
-        kind: options.kind,
-        domainName: options.sourceDomainName,
-        parentDomainName: null,
-        senderScriptPubKeyHex: options.sender.scriptPubKeyHex,
-        senderLocalIndex: options.sender.localIndex,
-        amountCogtoshi: options.amountCogtoshi,
-        recipientDomainName: options.targetDomainName,
-        reviewPayloadHex: options.reviewPayloadHex,
-        intentFingerprintHex: options.intentFingerprintHex,
-        status: "draft",
-        createdAtUnixMs: options.nowUnixMs,
-        lastUpdatedAtUnixMs: options.nowUnixMs,
-        attemptedTxid: null,
-        attemptedWtxid: null,
-        ...createWalletMutationFeeMetadata(options.feeSelection),
-        temporaryBuilderLockedOutpoints: [],
-    };
-}
-async function saveUpdatedMutationState(options) {
-    return persistWalletMutationState(options);
-}
-function mutationNeedsRepair(mutation, context) {
-    if (context.snapshot === null || mutation.recipientDomainName == null) {
-        return false;
-    }
-    const sourceDomain = lookupDomain(context.snapshot.state, mutation.domainName);
-    const targetDomain = lookupDomain(context.snapshot.state, mutation.recipientDomainName);
-    if (sourceDomain === null || targetDomain === null) {
-        return true;
-    }
-    return !sourceDomain.anchored
-        || !targetDomain.anchored
-        || Buffer.from(sourceDomain.ownerScriptPubKey).toString("hex") !== mutation.senderScriptPubKeyHex;
-}
-async function reconcilePendingReputationMutation(options) {
-    if (options.mutation.status === "confirmed" || options.mutation.status === "live") {
-        return {
-            state: options.state,
-            mutation: options.mutation,
-            resolution: options.mutation.status,
-        };
-    }
-    if (options.mutation.status === "repair-required") {
-        return {
-            state: options.state,
-            mutation: options.mutation,
-            resolution: "repair-required",
-        };
-    }
-    const walletTx = options.mutation.attemptedTxid === null
-        ? null
-        : await options.rpc.getTransaction(options.walletName, options.mutation.attemptedTxid).catch(() => null);
-    if (walletTx !== null) {
-        await unlockTemporaryBuilderLocks(options.rpc, options.walletName, options.mutation.temporaryBuilderLockedOutpoints);
-        const status = walletTx.confirmations > 0 ? "confirmed" : "live";
-        const nextMutation = updateMutationRecord(options.mutation, status, options.nowUnixMs, {
-            temporaryBuilderLockedOutpoints: [],
-        });
-        let nextState = upsertPendingMutation(options.state, nextMutation);
-        nextState = await saveUpdatedMutationState({
-            state: nextState,
-            provider: options.provider,
-            nowUnixMs: options.nowUnixMs,
-            paths: options.paths,
-        });
-        return {
-            state: nextState,
-            mutation: nextMutation,
-            resolution: status,
-        };
-    }
-    if (mutationNeedsRepair(options.mutation, options.context)) {
-        await unlockTemporaryBuilderLocks(options.rpc, options.walletName, options.mutation.temporaryBuilderLockedOutpoints);
-        const repair = updateMutationRecord(options.mutation, "repair-required", options.nowUnixMs, {
-            temporaryBuilderLockedOutpoints: [],
-        });
-        let nextState = upsertPendingMutation(options.state, repair);
-        nextState = await saveUpdatedMutationState({
-            state: nextState,
-            provider: options.provider,
-            nowUnixMs: options.nowUnixMs,
-            paths: options.paths,
-        });
-        return { state: nextState, mutation: repair, resolution: "repair-required" };
-    }
-    if (options.mutation.status === "broadcast-unknown"
-        || options.mutation.status === "draft"
-        || options.mutation.status === "broadcasting") {
-        await unlockTemporaryBuilderLocks(options.rpc, options.walletName, options.mutation.temporaryBuilderLockedOutpoints);
-        const canceled = updateMutationRecord(options.mutation, "canceled", options.nowUnixMs, {
-            temporaryBuilderLockedOutpoints: [],
-        });
-        let nextState = upsertPendingMutation(options.state, canceled);
-        nextState = await saveUpdatedMutationState({
-            state: nextState,
-            provider: options.provider,
-            nowUnixMs: options.nowUnixMs,
-            paths: options.paths,
-        });
-        return { state: nextState, mutation: canceled, resolution: "not-seen" };
-    }
-    return {
-        state: options.state,
-        mutation: options.mutation,
-        resolution: "continue",
-    };
-}
-async function confirmYesNo(prompter, message, errorCode, options) {
-    await confirmSharedYesNo(prompter, message, {
-        assumeYes: options.assumeYes,
-        errorCode,
-        requiresTtyErrorCode: options.requiresTtyErrorCode,
-    });
-}
-async function confirmTyped(prompter, expected, prompt, errorCode, options) {
-    await confirmSharedTypedAcknowledgement(prompter, {
-        assumeYes: options.assumeYes,
-        expected,
-        prompt,
-        errorCode,
-        requiresTtyErrorCode: options.requiresTtyErrorCode,
-        typedAckRequiredErrorCode: options.typedAckRequiredErrorCode,
-    });
-}
-async function confirmReputationMutation(prompter, options) {
-    prompter.writeLine(`${options.kind === "give" ? "Giving" : "Revoking"} reputation from "${options.sourceDomainName}" to "${options.targetDomainName}".`);
-    prompter.writeLine(`Resolved sender: ${options.resolved.sender.selector} (${options.resolved.sender.address})`);
-    prompter.writeLine(`Burn amount: ${formatCogAmount(options.amountCogtoshi)}`);
-    prompter.writeLine(`Effect: ${describeReputationEffect(options.resolved.effect)}.`);
-    prompter.writeLine(`Review: ${describeReputationReview(options.resolved.review)}.`);
-    if (options.reviewText !== null) {
-        prompter.writeLine("Warning: review text will be encoded and published publicly in the mempool and on-chain.");
-    }
-    if (options.kind === "give" && options.resolved.selfStake) {
-        prompter.writeLine("Self-stake: yes.");
-        prompter.writeLine("Warning: this is self-stake.");
-        prompter.writeLine("Self-stake is irrevocable and cannot later be revoked.");
-        await confirmTyped(prompter, options.sourceDomainName, `Type ${options.sourceDomainName} to continue: `, "wallet_rep_give_confirmation_rejected", {
-            assumeYes: options.assumeYes,
-            requiresTtyErrorCode: "wallet_rep_give_requires_tty",
-            typedAckRequiredErrorCode: "wallet_rep_give_typed_ack_required",
-        });
-        return;
-    }
-    await confirmYesNo(prompter, options.kind === "give"
-        ? "This burns COG to publish a reputation commitment."
-        : "This revokes visible support but the burned COG is not refunded.", options.kind === "give"
-        ? "wallet_rep_give_confirmation_rejected"
-        : "wallet_rep_revoke_confirmation_rejected", {
-        assumeYes: options.assumeYes,
-        requiresTtyErrorCode: options.kind === "give"
-            ? "wallet_rep_give_requires_tty"
-            : "wallet_rep_revoke_requires_tty",
-    });
-}
-async function encodeReviewText(reviewText, errorPrefix) {
-    const trimmed = reviewText?.trim() ?? "";
-    if (trimmed === "") {
-        return {
-            text: null,
-            payload: undefined,
-            payloadHex: null,
-        };
-    }
-    return encodeSentence(trimmed)
-        .then((payload) => ({
-        text: trimmed,
-        payload,
-        payloadHex: Buffer.from(payload).toString("hex"),
-    }))
-        .catch((error) => {
-        throw new Error(error instanceof Error ? `${errorPrefix}_invalid_review_${error.message}` : `${errorPrefix}_invalid_review`);
-    });
-}
-async function submitReputationMutation(options) {
-    if (!options.prompter.isInteractive && options.assumeYes !== true) {
-        throw new Error(`${options.errorPrefix}_requires_tty`);
-    }
-    if (options.amountCogtoshi <= 0n) {
-        throw new Error(`${options.errorPrefix}_invalid_amount`);
-    }
-    const execution = await executeWalletMutationOperation({
-        ...options,
-        controlLockPurpose: options.errorPrefix,
-        preemptionReason: options.errorPrefix,
-        async resolveOperation(readContext) {
-            const normalizedSourceDomainName = normalizeDomainName(options.sourceDomainName, `${options.errorPrefix}_missing_source_domain`);
-            const normalizedTargetDomainName = normalizeDomainName(options.targetDomainName, `${options.errorPrefix}_missing_target_domain`);
-            const operation = resolveReputationOperation(readContext, normalizedSourceDomainName, normalizedTargetDomainName, options.errorPrefix);
-            if (operation.availableBalanceCogtoshi < options.amountCogtoshi) {
-                throw new Error(`${options.errorPrefix}_insufficient_cog_balance`);
-            }
-            if (options.kind === "rep-revoke") {
-                if (operation.sourceDomain.domainId === operation.targetDomain.domainId) {
-                    throw new Error(`${options.errorPrefix}_self_revoke_not_allowed`);
-                }
-                if (options.amountCogtoshi > operation.currentNetSupportCogtoshi) {
-                    throw new Error(`${options.errorPrefix}_amount_exceeds_net_support`);
-                }
-            }
-            const review = await encodeReviewText(options.reviewText, options.errorPrefix);
-            const selfStake = operation.sourceDomain.domainId === operation.targetDomain.domainId;
-            return {
-                ...operation,
-                normalizedSourceDomainName,
-                normalizedTargetDomainName,
-                review,
-                resolved: createResolvedReputationSummary({
-                    kind: options.kind === "rep-give" ? "give" : "revoke",
-                    sender: operation.sender,
-                    senderSelector: operation.senderSelector,
-                    amountCogtoshi: options.amountCogtoshi,
-                    review,
-                    selfStake,
-                }),
-            };
-        },
-        createIntentFingerprint(operation) {
-            return createIntentFingerprint([
-                options.kind,
-                operation.state.walletRootId,
-                operation.sourceDomain.name,
-                operation.targetDomain.name,
-                options.amountCogtoshi,
-                operation.review.payloadHex ?? "",
-            ]);
-        },
-        async resolveExistingMutation({ operation, existingMutation, execution }) {
-            if (existingMutation === null) {
-                return {
-                    state: operation.state,
-                    replacementFixedInputs: null,
-                    result: null,
-                };
-            }
-            return resolveExistingWalletMutation({
-                existingMutation,
-                execution,
-                repairRequiredErrorCode: `${options.errorPrefix}_repair_required`,
-                reconcileExistingMutation: (mutation) => reconcilePendingReputationMutation({
-                    state: operation.state,
-                    mutation,
-                    provider: execution.provider,
-                    nowUnixMs: execution.nowUnixMs,
-                    paths: execution.paths,
-                    rpc: execution.rpc,
-                    walletName: execution.walletName,
-                    context: execution.readContext,
-                }),
-                createReuseResult: ({ mutation, resolution, fees }) => ({
-                    kind: options.kind === "rep-give" ? "give" : "revoke",
-                    sourceDomainName: operation.normalizedSourceDomainName,
-                    targetDomainName: operation.normalizedTargetDomainName,
-                    amountCogtoshi: options.amountCogtoshi,
-                    txid: mutation.attemptedTxid ?? "unknown",
-                    status: resolution,
-                    reusedExisting: true,
-                    reviewIncluded: operation.review.payloadHex !== null,
-                    resolved: operation.resolved,
-                    fees,
-                }),
-            });
-        },
-        async confirm({ operation }) {
-            await confirmReputationMutation(options.prompter, {
-                kind: options.kind === "rep-give" ? "give" : "revoke",
-                sourceDomainName: operation.normalizedSourceDomainName,
-                targetDomainName: operation.normalizedTargetDomainName,
-                amountCogtoshi: options.amountCogtoshi,
-                reviewText: operation.review.text,
-                resolved: operation.resolved,
-                assumeYes: options.assumeYes,
-            });
-        },
-        createDraftMutation({ operation, existingMutation, execution, intentFingerprintHex }) {
-            return {
-                mutation: createDraftMutation({
-                    kind: options.kind,
-                    sourceDomainName: operation.normalizedSourceDomainName,
-                    targetDomainName: operation.normalizedTargetDomainName,
-                    amountCogtoshi: options.amountCogtoshi,
-                    sender: operation.sender,
-                    intentFingerprintHex,
-                    nowUnixMs: execution.nowUnixMs,
-                    reviewPayloadHex: operation.review.payloadHex,
-                    feeSelection: execution.feeSelection,
-                    existing: existingMutation,
-                }),
-                prepared: null,
-            };
-        },
-        async build({ operation, state, execution, replacementFixedInputs }) {
-            const opReturnData = options.kind === "rep-give"
-                ? serializeRepCommit(operation.sourceDomain.domainId, operation.targetDomain.domainId, options.amountCogtoshi, operation.review.payload).opReturnData
-                : serializeRepRevoke(operation.sourceDomain.domainId, operation.targetDomain.domainId, options.amountCogtoshi, operation.review.payload).opReturnData;
-            const reputationPlan = buildPlanForReputationOperation({
-                state,
-                allUtxos: await execution.rpc.listUnspent(execution.walletName, 1),
-                sender: operation.sender,
-                opReturnData,
-                errorPrefix: options.errorPrefix,
-            });
-            return buildTransaction({
-                rpc: execution.rpc,
-                walletName: execution.walletName,
-                state,
-                plan: {
-                    ...reputationPlan,
-                    fixedInputs: mergeFixedWalletInputs(reputationPlan.fixedInputs, replacementFixedInputs),
-                },
-                feeRateSatVb: execution.feeSelection.feeRateSatVb,
-            });
-        },
-        publish({ state, execution, built, mutation }) {
-            return publishWalletMutation({
-                rpc: execution.rpc,
-                walletName: execution.walletName,
-                snapshotHeight: execution.readContext.snapshot?.tip?.height ?? null,
-                built,
-                mutation,
-                state,
-                provider: execution.provider,
-                nowUnixMs: execution.nowUnixMs,
-                paths: execution.paths,
-                errorPrefix: options.errorPrefix,
-            });
-        },
-        createResult({ operation, mutation, built, status, reusedExisting, fees }) {
-            return {
-                kind: options.kind === "rep-give" ? "give" : "revoke",
-                sourceDomainName: operation.normalizedSourceDomainName,
-                targetDomainName: operation.normalizedTargetDomainName,
-                amountCogtoshi: options.amountCogtoshi,
-                txid: mutation.attemptedTxid ?? built?.txid ?? "unknown",
-                status: status,
-                reusedExisting,
-                reviewIncluded: operation.review.payloadHex !== null,
-                resolved: operation.resolved,
-                fees,
-            };
-        },
-    });
-    return execution.result;
-}
-export async function giveReputation(options) {
-    return submitReputationMutation({
-        ...options,
-        kind: "rep-give",
-        errorPrefix: "wallet_rep_give",
-    });
-}
-export async function revokeReputation(options) {
-    return submitReputationMutation({
-        ...options,
-        kind: "rep-revoke",
-        errorPrefix: "wallet_rep_revoke",
-    });
-}
+export * from "./reputation/index.js";

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

@@ -0,0 +1,18 @@
+import type { RpcFinalizePsbtResult, RpcTransaction, RpcWalletProcessPsbtResult } from "../../bitcoind/types.js";
+import type { WalletStateV1 } from "../types.js";
+import type { WalletMutationRpcClient } from "./types.js";
+export declare function signAndFinalizeWalletMutation(options: {
+    rpc: WalletMutationRpcClient;
+    walletName: string;
+    state: WalletStateV1;
+    psbt: string;
+    finalizeErrorCode: string;
+    mempoolRejectPrefix: string;
+    recoverManagedCoreWalletLockedOnce?: boolean;
+    onManagedCoreWalletLockedRecoveryOutcome?: (outcome: "recovered" | "still-locked") => void;
+}): Promise<{
+    signed: RpcWalletProcessPsbtResult;
+    finalized: RpcFinalizePsbtResult;
+    rawHex: string;
+    decodedRaw: RpcTransaction;
+}>;

package/dist/wallet/tx/signing.js

@@ -0,0 +1,31 @@
+import { MANAGED_CORE_WALLET_UNLOCK_TIMEOUT_SECONDS, withUnlockedManagedCoreWallet, } from "../managed-core-wallet.js";
+export async function signAndFinalizeWalletMutation(options) {
+    return withUnlockedManagedCoreWallet({
+        rpc: options.rpc,
+        walletName: options.walletName,
+        internalPassphrase: options.state.managedCoreWallet.internalPassphrase,
+        timeoutSeconds: MANAGED_CORE_WALLET_UNLOCK_TIMEOUT_SECONDS,
+        recoverLockedWalletOnce: options.recoverManagedCoreWalletLockedOnce,
+        onLockedWalletRecoveryOutcome: options.onManagedCoreWalletLockedRecoveryOutcome,
+        run: async () => {
+            const signed = await options.rpc.walletProcessPsbt(options.walletName, options.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,
+            };
+        },
+    });
+}

package/dist/wallet/tx/state-persist.d.ts

@@ -0,0 +1,27 @@
+import type { RpcLockedUnspent } from "../../bitcoind/types.js";
+import { type WalletSecretProvider } from "../state/provider.js";
+import type { OutpointRecord, PendingMutationRecord, PendingMutationStatus, WalletStateV1 } from "../types.js";
+import type { WalletRuntimePaths } from "../runtime.js";
+import type { WalletMutationFeeSelectionSource } from "./fee.js";
+import type { WalletMutationRpcClient } from "./types.js";
+export declare function saveWalletStatePreservingUnlock(options: {
+    state: WalletStateV1;
+    provider: WalletSecretProvider;
+    nowUnixMs?: number;
+    paths: WalletRuntimePaths;
+}): Promise<void>;
+export declare function updateMutationRecord(mutation: PendingMutationRecord, status: PendingMutationStatus, nowUnixMs: number, options?: {
+    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[];
+export declare function persistWalletMutationState(options: {
+    state: WalletStateV1;
+    provider: WalletSecretProvider;
+    nowUnixMs: number;
+    paths: WalletRuntimePaths;
+}): Promise<WalletStateV1>;