@cogcoin/client 1.1.8 → 1.1.10

package/dist/wallet/tx/draft-build.d.ts

@@ -0,0 +1,60 @@
+import type { RpcDecodedPsbt, RpcWalletCreateFundedPsbtResult } from "../../bitcoind/types.js";
+import type { OutpointRecord, WalletStateV1 } from "../types.js";
+import type { BuiltWalletMutationTransaction, FixedWalletInput, WalletMutationRpcClient } from "./types.js";
+export declare function fundAndValidateWalletMutationDraft<TPlan>(options: {
+    rpc: WalletMutationRpcClient;
+    walletName: string;
+    plan: TPlan & {
+        fixedInputs: FixedWalletInput[];
+        outputs: unknown[];
+        changeAddress: string;
+        changePosition?: number | null;
+        allowedFundingScriptPubKeyHex: string;
+        eligibleFundingOutpointKeys: Set<string>;
+    };
+    validateFundedDraft(decoded: RpcDecodedPsbt, funded: RpcWalletCreateFundedPsbtResult, plan: TPlan): void;
+    feeRate?: number;
+    availableFundingMinConf?: number;
+}): Promise<{
+    funded: RpcWalletCreateFundedPsbtResult;
+    decoded: RpcDecodedPsbt;
+}>;
+export declare function buildWalletMutationTransaction<TPlan>(options: {
+    rpc: WalletMutationRpcClient;
+    walletName: string;
+    state: WalletStateV1;
+    plan: TPlan & {
+        fixedInputs: FixedWalletInput[];
+        outputs: unknown[];
+        changeAddress: string;
+        changePosition?: number | null;
+        allowedFundingScriptPubKeyHex: string;
+        eligibleFundingOutpointKeys: Set<string>;
+    };
+    validateFundedDraft(decoded: RpcDecodedPsbt, funded: RpcWalletCreateFundedPsbtResult, plan: TPlan): void;
+    finalizeErrorCode: string;
+    mempoolRejectPrefix: string;
+    feeRate?: number;
+    availableFundingMinConf?: number;
+    temporarilyUnlockedPolicyOutpoints?: readonly OutpointRecord[];
+    recoverManagedCoreWalletLockedOnce?: boolean;
+    onManagedCoreWalletLockedRecoveryOutcome?: (outcome: "recovered" | "still-locked") => void;
+}): Promise<BuiltWalletMutationTransaction>;
+export declare function buildWalletMutationTransactionWithReserveFallback<TPlan>(options: {
+    rpc: WalletMutationRpcClient;
+    walletName: string;
+    state: WalletStateV1;
+    plan: TPlan & {
+        fixedInputs: FixedWalletInput[];
+        outputs: unknown[];
+        changeAddress: string;
+        changePosition: number;
+        allowedFundingScriptPubKeyHex: string;
+        eligibleFundingOutpointKeys: Set<string>;
+    };
+    validateFundedDraft(decoded: RpcDecodedPsbt, funded: RpcWalletCreateFundedPsbtResult, plan: TPlan): void;
+    finalizeErrorCode: string;
+    mempoolRejectPrefix: string;
+    feeRate?: number;
+    availableFundingMinConf?: number;
+}): Promise<BuiltWalletMutationTransaction>;

package/dist/wallet/tx/draft-build.js

@@ -0,0 +1,127 @@
+import { DEFAULT_WALLET_MUTATION_FEE_RATE_SAT_VB } from "./fee.js";
+import { getDecodedInputScriptPubKeyHex, getDecodedInputVout } from "./psbt-assert.js";
+import { outpointKey } from "./primitives.js";
+import { unlockTemporaryBuilderLocks } from "./state-persist.js";
+import { signAndFinalizeWalletMutation } from "./signing.js";
+function btcNumberToSats(value) {
+    return BigInt(Math.round(value * 100_000_000));
+}
+function valueToSats(value) {
+    return typeof value === "string"
+        ? BigInt(Math.round(Number(value) * 100_000_000))
+        : btcNumberToSats(value);
+}
+function isSpendableFundingUtxo(entry, fundingScriptPubKeyHex, minConf) {
+    return entry.scriptPubKey === fundingScriptPubKeyHex
+        && entry.confirmations >= minConf
+        && entry.spendable !== false
+        && entry.safe !== false;
+}
+function isReserveFloorFundingError(error) {
+    void error;
+    return false;
+}
+function computeRemainingFundingValueSats(options) {
+    let remaining = 0n;
+    for (const value of options.availableFundingValueByKey.values()) {
+        remaining += value;
+    }
+    for (const [index, input] of options.decoded.tx.vin.entries()) {
+        const scriptPubKeyHex = getDecodedInputScriptPubKeyHex(options.decoded, index);
+        const vout = getDecodedInputVout(input);
+        if (scriptPubKeyHex !== options.fundingScriptPubKeyHex || vout === null || typeof input.txid !== "string") {
+            continue;
+        }
+        remaining -= options.availableFundingValueByKey.get(outpointKey({
+            txid: input.txid,
+            vout,
+        })) ?? 0n;
+    }
+    for (const output of options.decoded.tx.vout) {
+        if (output.scriptPubKey?.hex !== options.fundingScriptPubKeyHex) {
+            continue;
+        }
+        remaining += valueToSats(output.value);
+    }
+    return remaining;
+}
+export async function fundAndValidateWalletMutationDraft(options) {
+    const availableFundingMinConf = options.availableFundingMinConf ?? 1;
+    const availableFundingUtxos = (await options.rpc.listUnspent(options.walletName, availableFundingMinConf))
+        .filter((entry) => isSpendableFundingUtxo(entry, options.plan.allowedFundingScriptPubKeyHex, availableFundingMinConf));
+    const validationPlan = {
+        ...options.plan,
+        eligibleFundingOutpointKeys: new Set([
+            ...options.plan.eligibleFundingOutpointKeys,
+            ...availableFundingUtxos.map((entry) => outpointKey({ txid: entry.txid, vout: entry.vout })),
+        ]),
+    };
+    const funded = await options.rpc.walletCreateFundedPsbt(options.walletName, options.plan.fixedInputs, options.plan.outputs, 0, {
+        add_inputs: true,
+        include_unsafe: false,
+        minconf: availableFundingMinConf,
+        changeAddress: options.plan.changeAddress,
+        ...(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 decoded = await options.rpc.decodePsbt(funded.psbt);
+    options.validateFundedDraft(decoded, funded, validationPlan);
+    return {
+        funded,
+        decoded,
+    };
+}
+export async function buildWalletMutationTransaction(options) {
+    const temporaryBuilderLockedOutpoints = [];
+    try {
+        const { funded, decoded } = await fundAndValidateWalletMutationDraft({
+            rpc: options.rpc,
+            walletName: options.walletName,
+            plan: options.plan,
+            validateFundedDraft: options.validateFundedDraft,
+            feeRate: options.feeRate,
+            availableFundingMinConf: options.availableFundingMinConf,
+        });
+        const { signed, rawHex, decodedRaw } = await signAndFinalizeWalletMutation({
+            rpc: options.rpc,
+            walletName: options.walletName,
+            state: options.state,
+            psbt: funded.psbt,
+            finalizeErrorCode: options.finalizeErrorCode,
+            mempoolRejectPrefix: options.mempoolRejectPrefix,
+            recoverManagedCoreWalletLockedOnce: options.recoverManagedCoreWalletLockedOnce,
+            onManagedCoreWalletLockedRecoveryOutcome: options.onManagedCoreWalletLockedRecoveryOutcome,
+        });
+        return {
+            funded,
+            decoded,
+            psbt: signed.psbt,
+            rawHex,
+            txid: decodedRaw.txid,
+            wtxid: decodedRaw.hash ?? null,
+            temporaryBuilderLockedOutpoints,
+        };
+    }
+    catch (error) {
+        await unlockTemporaryBuilderLocks(options.rpc, options.walletName, temporaryBuilderLockedOutpoints);
+        throw error;
+    }
+}
+export async function buildWalletMutationTransactionWithReserveFallback(options) {
+    void isReserveFloorFundingError;
+    void computeRemainingFundingValueSats;
+    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/executor.d.ts

@@ -4,7 +4,9 @@ import { openWalletReadContext, type WalletReadContext } from "../read/index.js"
 import { type WalletRuntimePaths } from "../runtime.js";
 import { type WalletSecretProvider } from "../state/provider.js";
 import type { PendingMutationRecord, PendingMutationStatus, WalletStateV1 } from "../types.js";
-import { type BuiltWalletMutationTransaction, type FixedWalletInput, type WalletMutationFeeSelection, type WalletMutationFeeSummary, type WalletMutationRpcClient } from "./common.js";
+import { type WalletMutationFeeSelection, type WalletMutationFeeSummary } from "./fee.js";
+import type { WalletMutationPublishResult } from "./publish.js";
+import type { BuiltWalletMutationTransaction, FixedWalletInput, WalletMutationRpcClient } from "./types.js";
 export interface WalletMutationExecutionContext<TRpc extends WalletMutationRpcClient> {
     provider: WalletSecretProvider;
     nowUnixMs: number;
@@ -26,17 +28,6 @@ export interface WalletMutationReconcileResult {
     mutation: PendingMutationRecord;
     resolution: "confirmed" | "live" | "repair-required" | "not-seen" | "continue";
 }
-export interface WalletMutationPublishResult {
-    state: WalletStateV1;
-    mutation: PendingMutationRecord;
-    status: PendingMutationStatus;
-}
-export interface WalletMutationPublishRpcClient extends Pick<WalletMutationRpcClient, "lockUnspent"> {
-    getBlockchainInfo(): Promise<{
-        blocks: number;
-    }>;
-    sendRawTransaction(hex: string): Promise<string>;
-}
 export interface WalletMutationRuntimeOptions<TRpc extends WalletMutationRpcClient> {
     dataDir: string;
     databasePath: string;
@@ -124,12 +115,6 @@ export interface WalletMutationOperationSpec<TOperation extends {
         prepared: TPrepared | null;
     }): TResult;
 }
-export declare function persistWalletMutationState(options: {
-    state: WalletStateV1;
-    provider: WalletSecretProvider;
-    nowUnixMs: number;
-    paths: WalletRuntimePaths;
-}): Promise<WalletStateV1>;
 export declare function resolveExistingWalletMutation<TRpc extends Pick<WalletMutationRpcClient, "getMempoolEntry" | "getTransaction" | "getRawTransaction">, TResult>(options: {
     existingMutation: PendingMutationRecord | null;
     execution: {
@@ -149,28 +134,9 @@ export declare function resolveExistingWalletMutation<TRpc extends Pick<WalletMu
     replacementFixedInputs: FixedWalletInput[] | null;
     result: TResult | null;
 }>;
-export declare function publishWalletMutation<TRpc extends WalletMutationPublishRpcClient>(options: {
-    rpc: TRpc;
-    walletName: string;
-    snapshotHeight: number | null;
-    built: BuiltWalletMutationTransaction;
-    mutation: PendingMutationRecord;
-    state: WalletStateV1;
-    provider: WalletSecretProvider;
-    nowUnixMs: number;
-    paths: WalletRuntimePaths;
-    errorPrefix: string;
-    afterAccepted?(options: {
-        state: WalletStateV1;
-        broadcastingMutation: PendingMutationRecord;
-        built: BuiltWalletMutationTransaction;
-        nowUnixMs: number;
-    }): Promise<{
-        state: WalletStateV1;
-        mutation: PendingMutationRecord;
-        status: PendingMutationStatus;
-    }>;
-}): Promise<WalletMutationPublishResult>;
+export { persistWalletMutationState } from "./state-persist.js";
+export { publishWalletMutation } from "./publish.js";
+export type { WalletMutationPublishResult, WalletMutationPublishRpcClient, } from "./publish.js";
 export declare function executeWalletMutationOperation<TOperation extends {
     state: WalletStateV1;
 }, TRpc extends WalletMutationRpcClient, TPrepared, TBuilt extends BuiltWalletMutationTransaction, TResult>(options: WalletMutationRuntimeOptions<TRpc> & WalletMutationOperationSpec<TOperation, TRpc, TPrepared, TBuilt, TResult>): Promise<WalletMutationExecutionResult<TResult, TBuilt>>;

package/dist/wallet/tx/executor.js

@@ -4,22 +4,11 @@ import { acquireFileLock } from "../fs/lock.js";
 import { openWalletReadContext, } from "../read/index.js";
 import { resolveWalletRuntimePathsForTesting, } from "../runtime.js";
 import { createDefaultWalletSecretProvider, } from "../state/provider.js";
-import { createBuiltWalletMutationFeeSummary, isAlreadyAcceptedError, isBroadcastUnknownError, pauseMiningForWalletMutation, resolvePendingMutationReuseDecision, resolveWalletMutationFeeSelection, saveWalletStatePreservingUnlock, unlockTemporaryBuilderLocks, updateMutationRecord, } from "./common.js";
+import { createBuiltWalletMutationFeeSummary, resolveWalletMutationFeeSelection, } from "./fee.js";
+import { pauseMiningForWalletMutation } from "./mining-preemption.js";
+import { resolvePendingMutationReuseDecision } from "./reconcile.js";
+import { persistWalletMutationState, unlockTemporaryBuilderLocks } from "./state-persist.js";
 import { findPendingMutationByIntent, upsertPendingMutation, } from "./journal.js";
-export async function persistWalletMutationState(options) {
-    const nextState = {
-        ...options.state,
-        stateRevision: options.state.stateRevision + 1,
-        lastWrittenAtUnixMs: options.nowUnixMs,
-    };
-    await saveWalletStatePreservingUnlock({
-        state: nextState,
-        provider: options.provider,
-        nowUnixMs: options.nowUnixMs,
-        paths: options.paths,
-    });
-    return nextState;
-}
 export async function resolveExistingWalletMutation(options) {
     if (options.existingMutation === null) {
         throw new Error("wallet_mutation_existing_required");
@@ -58,91 +47,8 @@ export async function resolveExistingWalletMutation(options) {
         result: null,
     };
 }
-export async function publishWalletMutation(options) {
-    let nextState = options.state;
-    const broadcastingMutation = updateMutationRecord(options.mutation, "broadcasting", options.nowUnixMs, {
-        attemptedTxid: options.built.txid,
-        attemptedWtxid: options.built.wtxid,
-        temporaryBuilderLockedOutpoints: options.built.temporaryBuilderLockedOutpoints,
-    });
-    nextState = await persistWalletMutationState({
-        state: upsertPendingMutation(nextState, broadcastingMutation),
-        provider: options.provider,
-        nowUnixMs: options.nowUnixMs,
-        paths: options.paths,
-    });
-    if (options.snapshotHeight !== null
-        && options.snapshotHeight !== (await options.rpc.getBlockchainInfo()).blocks) {
-        await unlockTemporaryBuilderLocks(options.rpc, options.walletName, options.built.temporaryBuilderLockedOutpoints);
-        throw new Error(`${options.errorPrefix}_tip_mismatch`);
-    }
-    try {
-        await options.rpc.sendRawTransaction(options.built.rawHex);
-    }
-    catch (error) {
-        if (!isAlreadyAcceptedError(error)) {
-            if (isBroadcastUnknownError(error)) {
-                const unknownMutation = updateMutationRecord(broadcastingMutation, "broadcast-unknown", options.nowUnixMs, {
-                    attemptedTxid: options.built.txid,
-                    attemptedWtxid: options.built.wtxid,
-                    temporaryBuilderLockedOutpoints: options.built.temporaryBuilderLockedOutpoints,
-                });
-                nextState = await persistWalletMutationState({
-                    state: upsertPendingMutation(nextState, unknownMutation),
-                    provider: options.provider,
-                    nowUnixMs: options.nowUnixMs,
-                    paths: options.paths,
-                });
-                throw new Error(`${options.errorPrefix}_broadcast_unknown`);
-            }
-            await unlockTemporaryBuilderLocks(options.rpc, options.walletName, options.built.temporaryBuilderLockedOutpoints);
-            const canceledMutation = updateMutationRecord(broadcastingMutation, "canceled", options.nowUnixMs, {
-                attemptedTxid: options.built.txid,
-                attemptedWtxid: options.built.wtxid,
-                temporaryBuilderLockedOutpoints: [],
-            });
-            nextState = await persistWalletMutationState({
-                state: upsertPendingMutation(nextState, canceledMutation),
-                provider: options.provider,
-                nowUnixMs: options.nowUnixMs,
-                paths: options.paths,
-            });
-            throw error;
-        }
-    }
-    await unlockTemporaryBuilderLocks(options.rpc, options.walletName, options.built.temporaryBuilderLockedOutpoints);
-    const accepted = options.afterAccepted === undefined
-        ? {
-            state: upsertPendingMutation(nextState, updateMutationRecord(broadcastingMutation, "live", options.nowUnixMs, {
-                attemptedTxid: options.built.txid,
-                attemptedWtxid: options.built.wtxid,
-                temporaryBuilderLockedOutpoints: [],
-            })),
-            mutation: updateMutationRecord(broadcastingMutation, "live", options.nowUnixMs, {
-                attemptedTxid: options.built.txid,
-                attemptedWtxid: options.built.wtxid,
-                temporaryBuilderLockedOutpoints: [],
-            }),
-            status: "live",
-        }
-        : await options.afterAccepted({
-            state: nextState,
-            broadcastingMutation,
-            built: options.built,
-            nowUnixMs: options.nowUnixMs,
-        });
-    const persistedState = await persistWalletMutationState({
-        state: accepted.state,
-        provider: options.provider,
-        nowUnixMs: options.nowUnixMs,
-        paths: options.paths,
-    });
-    return {
-        state: persistedState,
-        mutation: accepted.mutation,
-        status: accepted.status,
-    };
-}
+export { persistWalletMutationState } from "./state-persist.js";
+export { publishWalletMutation } from "./publish.js";
 export async function executeWalletMutationOperation(options) {
     const provider = options.provider ?? createDefaultWalletSecretProvider();
     const nowUnixMs = options.nowUnixMs ?? Date.now();

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

@@ -0,0 +1,30 @@
+import type { PendingMutationRecord } from "../types.js";
+import type { BuiltWalletMutationTransaction, WalletMutationRpcClient } from "./types.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 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>;

package/dist/wallet/tx/fee.js

@@ -0,0 +1,98 @@
+export const DEFAULT_WALLET_MUTATION_FEE_RATE_SAT_VB = 10;
+export const NEXT_BLOCK_FEE_CONFIRM_TARGET = 1;
+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 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 {
+        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,
+    };
+}

package/dist/wallet/tx/field/confirm.d.ts

@@ -0,0 +1,11 @@
+import type { WalletPrompter } from "../../lifecycle.js";
+declare function confirmYesNo(prompter: WalletPrompter, message: string, errorCode: string, options: {
+    assumeYes?: boolean;
+    requiresTtyErrorCode: string;
+}): Promise<void>;
+declare function confirmTyped(prompter: WalletPrompter, expected: string, prompt: string, errorCode: string, options: {
+    assumeYes?: boolean;
+    requiresTtyErrorCode: string;
+    typedAckRequiredErrorCode: string;
+}): Promise<void>;
+export { confirmTyped, confirmYesNo };

package/dist/wallet/tx/field/confirm.js

@@ -0,0 +1,19 @@
+import { confirmTypedAcknowledgement as confirmSharedTypedAcknowledgement, confirmYesNo as confirmSharedYesNo, } from "../confirm.js";
+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,
+    });
+}
+export { confirmTyped, confirmYesNo };

package/dist/wallet/tx/field/draft.d.ts

@@ -0,0 +1,23 @@
+import type { WalletRuntimePaths } from "../../runtime.js";
+import type { WalletSecretProvider } from "../../state/provider.js";
+import type { PendingMutationRecord, WalletStateV1 } from "../../types.js";
+import type { WalletReadContext } from "../../read/index.js";
+import { findDomainField } from "../../read/index.js";
+import type { FieldDraftMutationOptions, FieldRpcClient } from "./types.js";
+export declare function createStandaloneFieldMutation(options: FieldDraftMutationOptions): PendingMutationRecord;
+export declare function findActiveFieldCreateMutationByDomain(state: WalletStateV1, domainName: string, intentFingerprintHex: string): PendingMutationRecord | null;
+export declare function getObservedFieldState(context: WalletReadContext, domainName: string, fieldName: string): ReturnType<typeof findDomainField>;
+export declare function reconcilePendingFieldMutation(options: {
+    state: WalletStateV1;
+    mutation: PendingMutationRecord;
+    provider: WalletSecretProvider;
+    nowUnixMs: number;
+    paths: WalletRuntimePaths;
+    rpc: FieldRpcClient;
+    walletName: string;
+    context: WalletReadContext;
+}): Promise<{
+    state: WalletStateV1;
+    mutation: PendingMutationRecord;
+    resolution: "confirmed" | "live" | "repair-required" | "not-seen" | "continue";
+}>;