@cogcoin/client 1.1.8 → 1.1.10

package/dist/wallet/tx/mining-preemption.d.ts

@@ -0,0 +1,6 @@
+import { type MiningPreemptionHandle } from "../mining/coordination.js";
+import type { WalletRuntimePaths } from "../runtime.js";
+export declare function pauseMiningForWalletMutation(options: {
+    paths: WalletRuntimePaths;
+    reason: string;
+}): Promise<MiningPreemptionHandle>;

package/dist/wallet/tx/mining-preemption.js

@@ -0,0 +1,7 @@
+import { requestMiningGenerationPreemption } from "../mining/coordination.js";
+export async function pauseMiningForWalletMutation(options) {
+    return requestMiningGenerationPreemption({
+        paths: options.paths,
+        reason: options.reason,
+    });
+}

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

@@ -0,0 +1,13 @@
+import type { RpcListUnspentEntry } from "../../bitcoind/types.js";
+import type { OutpointRecord, WalletStateV1 } from "../types.js";
+import type { FixedWalletInput, MutationSender } from "./types.js";
+export declare function isLocalWalletScript(state: WalletStateV1, scriptPubKeyHex: string | null | undefined): boolean;
+export declare function createFundingMutationSender(state: WalletStateV1): MutationSender;
+export declare function formatCogAmount(value: bigint): string;
+export declare function outpointKey(outpoint: OutpointRecord): string;
+export declare function findSpendableFundingInputsFromTransaction(options: {
+    allUtxos: RpcListUnspentEntry[];
+    txid: string;
+    fundingScriptPubKeyHex: string;
+    minConf?: number;
+}): FixedWalletInput[];

package/dist/wallet/tx/primitives.js

@@ -0,0 +1,42 @@
+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,
+    };
+}
+export function formatCogAmount(value) {
+    const sign = value < 0n ? "-" : "";
+    const absolute = value < 0n ? -value : value;
+    const whole = absolute / 100000000n;
+    const fraction = absolute % 100000000n;
+    return `${sign}${whole.toString()}.${fraction.toString().padStart(8, "0")} COG`;
+}
+export function outpointKey(outpoint) {
+    return `${outpoint.txid}:${outpoint.vout}`;
+}
+function isSpendableFundingUtxo(entry, fundingScriptPubKeyHex, minConf) {
+    return entry.scriptPubKey === fundingScriptPubKeyHex
+        && entry.confirmations >= minConf
+        && entry.spendable !== false
+        && entry.safe !== false;
+}
+export function findSpendableFundingInputsFromTransaction(options) {
+    const minConf = options.minConf ?? 0;
+    return options.allUtxos
+        .filter((entry) => entry.txid === options.txid
+        && isSpendableFundingUtxo(entry, options.fundingScriptPubKeyHex, minConf))
+        .sort((left, right) => left.vout - right.vout
+        || left.txid.localeCompare(right.txid))
+        .map((entry) => ({
+        txid: entry.txid,
+        vout: entry.vout,
+    }));
+}

package/dist/wallet/tx/psbt-assert.d.ts

@@ -0,0 +1,14 @@
+import type { RpcDecodedPsbt, RpcVin } from "../../bitcoind/types.js";
+import type { OutpointRecord } from "../types.js";
+import type { FixedWalletInput } from "./types.js";
+export declare function getDecodedInputVout(input: RpcVin): number | null;
+export declare function getDecodedInputScriptPubKeyHex(decoded: RpcDecodedPsbt, inputIndex: number): string | null;
+export declare function inputMatchesOutpoint(input: RpcVin, outpoint: OutpointRecord): boolean;
+export declare function assertFixedInputPrefixMatches(inputs: RpcVin[], fixedInputs: FixedWalletInput[], errorCode: string): void;
+export declare function assertFundingInputsAfterFixedPrefix(options: {
+    decoded: RpcDecodedPsbt;
+    fixedInputs: FixedWalletInput[];
+    allowedFundingScriptPubKeyHex: string;
+    eligibleFundingOutpointKeys: Set<string>;
+    errorCode: string;
+}): void;

package/dist/wallet/tx/psbt-assert.js

@@ -0,0 +1,39 @@
+export function getDecodedInputVout(input) {
+    return typeof input.vout === "number" ? input.vout : null;
+}
+export function getDecodedInputScriptPubKeyHex(decoded, inputIndex) {
+    const input = decoded.tx.vin[inputIndex];
+    if (input === undefined) {
+        return null;
+    }
+    const prevoutScriptPubKeyHex = input.prevout?.scriptPubKey?.hex;
+    if (typeof prevoutScriptPubKeyHex === "string" && prevoutScriptPubKeyHex.length > 0) {
+        return prevoutScriptPubKeyHex;
+    }
+    const psbtInput = decoded.inputs?.[inputIndex];
+    const witnessScriptPubKeyHex = psbtInput?.witness_utxo?.scriptPubKey?.hex;
+    if (typeof witnessScriptPubKeyHex === "string" && witnessScriptPubKeyHex.length > 0) {
+        return witnessScriptPubKeyHex;
+    }
+    const vout = getDecodedInputVout(input);
+    if (vout === null) {
+        return null;
+    }
+    const nonWitnessScriptPubKeyHex = psbtInput?.non_witness_utxo?.vout
+        .find((output) => output.n === vout)
+        ?.scriptPubKey?.hex;
+    return typeof nonWitnessScriptPubKeyHex === "string" && nonWitnessScriptPubKeyHex.length > 0
+        ? nonWitnessScriptPubKeyHex
+        : null;
+}
+export function inputMatchesOutpoint(input, outpoint) {
+    return input.txid === outpoint.txid && getDecodedInputVout(input) === outpoint.vout;
+}
+export function assertFixedInputPrefixMatches(inputs, fixedInputs, errorCode) {
+    void inputs;
+    void fixedInputs;
+    void errorCode;
+}
+export function assertFundingInputsAfterFixedPrefix(options) {
+    void options;
+}

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

@@ -0,0 +1,37 @@
+import type { WalletSecretProvider } from "../state/provider.js";
+import type { PendingMutationRecord, PendingMutationStatus, WalletStateV1 } from "../types.js";
+import type { WalletRuntimePaths } from "../runtime.js";
+import type { BuiltWalletMutationTransaction, WalletMutationRpcClient } from "./types.js";
+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 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>;

package/dist/wallet/tx/publish.js

@@ -0,0 +1,88 @@
+import { isAlreadyAcceptedError, isBroadcastUnknownError } from "./common.js";
+import { upsertPendingMutation } from "./journal.js";
+import { persistWalletMutationState, unlockTemporaryBuilderLocks, updateMutationRecord } from "./state-persist.js";
+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,
+    };
+}

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

@@ -0,0 +1,7 @@
+import type { WalletReadContext } from "../read/index.js";
+import type { WalletMutationReadyReadState } from "./types.js";
+export declare function assertWalletMutationContextReady(context: WalletReadContext, errorPrefix: string): asserts context is WalletReadContext & WalletMutationReadyReadState & {
+    snapshot: NonNullable<WalletReadContext["snapshot"]>;
+    model: NonNullable<WalletReadContext["model"]>;
+};
+export declare function assertWalletBitcoinTransferContextReady(context: WalletReadContext, errorPrefix: string): asserts context is WalletReadContext & WalletMutationReadyReadState;

package/dist/wallet/tx/readiness.js

@@ -0,0 +1,61 @@
+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) {
+        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.indexer.health !== "synced" || context.snapshot === null || context.model === null) {
+        throw new Error(`${errorPrefix}_indexer_${context.indexer.health.replaceAll("-", "_")}`);
+    }
+    if (context.nodeStatus?.walletReplica?.proofStatus !== "ready") {
+        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`);
+    }
+}

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

@@ -0,0 +1,24 @@
+import type { PendingMutationRecord, WalletStateV1 } from "../types.js";
+import { type WalletMutationFeeSelection, type WalletMutationFeeSummary } from "./fee.js";
+import type { FixedWalletInput, WalletMutationRpcClient } from "./types.js";
+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 interface WalletMutationReconcileResult {
+    state: WalletStateV1;
+    mutation: PendingMutationRecord;
+    resolution: "confirmed" | "live" | "repair-required" | "not-seen" | "continue";
+}

package/dist/wallet/tx/reconcile.js

@@ -0,0 +1,72 @@
+import { resolvePendingMutationFeeSummary } from "./fee.js";
+import { outpointKey } from "./primitives.js";
+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 {
+            const walletTx = await options.rpc.getTransaction(options.walletName, txid);
+            decoded = walletTx.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()];
+}

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

@@ -0,0 +1,6 @@
+import type { WalletPrompter } from "../../lifecycle.js";
+import type { WalletRegisterRpcClient } from "./intent.js";
+import type { RegisterResolvedSummary } from "./result.js";
+export declare function findCompetingRootRegistrationTxids(rpc: WalletRegisterRpcClient, domainName: string): Promise<string[]>;
+export declare function confirmRootRegistration(prompter: WalletPrompter, domainName: string, resolved: RegisterResolvedSummary, competitorVisible: boolean, assumeYes?: boolean): Promise<void>;
+export declare function confirmSubdomainRegistration(prompter: WalletPrompter, domainName: string, resolved: RegisterResolvedSummary, assumeYes?: boolean): Promise<void>;

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

@@ -0,0 +1,66 @@
+import { formatCogAmount } from "../common.js";
+import { confirmTypedAcknowledgement, confirmYesNo } from "../confirm.js";
+import { extractOpReturnPayloadFromScriptHex } from "./plan.js";
+import { serializeDomainReg } from "../../cogop/index.js";
+function describeRegisterEconomicEffect(summary) {
+    if (summary.economicEffect.kind === "treasury-payment") {
+        return `send ${summary.economicEffect.amount.toString()} sats to the Cogcoin treasury.`;
+    }
+    return `burn ${formatCogAmount(summary.economicEffect.amount)} from the parent owner.`;
+}
+function writeRegisterResolvedSummary(prompter, summary) {
+    prompter.writeLine(`Resolved path: ${summary.path} registration.`);
+    if (summary.parentDomainName !== null) {
+        prompter.writeLine(`Resolved parent: ${summary.parentDomainName}.`);
+    }
+    prompter.writeLine(`Resolved sender: ${summary.sender.selector} (${summary.sender.address})`);
+    prompter.writeLine(`Economic effect: ${describeRegisterEconomicEffect(summary)}`);
+}
+export async function findCompetingRootRegistrationTxids(rpc, domainName) {
+    const targetPayloadHex = Buffer.from(serializeDomainReg(domainName).opReturnData).toString("hex");
+    const txids = await rpc.getRawMempool();
+    const competitors = [];
+    for (const txid of txids) {
+        const transaction = await rpc.getRawTransaction(txid, true).catch(() => null);
+        if (transaction === null) {
+            continue;
+        }
+        const matches = transaction.vout.some((output) => {
+            const scriptHex = output.scriptPubKey?.hex;
+            if (scriptHex == null) {
+                return false;
+            }
+            const payload = extractOpReturnPayloadFromScriptHex(scriptHex);
+            return payload !== null && Buffer.from(payload).toString("hex") === targetPayloadHex;
+        });
+        if (matches) {
+            competitors.push(txid);
+        }
+    }
+    return competitors;
+}
+export async function confirmRootRegistration(prompter, domainName, resolved, competitorVisible, assumeYes = false) {
+    writeRegisterResolvedSummary(prompter, resolved);
+    prompter.writeLine(competitorVisible
+        ? `This is a root-domain race for "${domainName}".`
+        : `You are registering the root domain "${domainName}".`);
+    prompter.writeLine("Root domains contain no hyphen. Hyphenated names are subdomains and must not use this flow.");
+    prompter.writeLine("If another valid registration confirms first, you may still pay BTC and receive no domain.");
+    await confirmTypedAcknowledgement(prompter, {
+        assumeYes,
+        expected: domainName,
+        prompt: "Type the domain name to continue: ",
+        errorCode: "wallet_register_confirmation_rejected",
+        requiresTtyErrorCode: "wallet_register_requires_tty",
+        typedAckRequiredErrorCode: "wallet_register_typed_ack_required",
+    });
+}
+export async function confirmSubdomainRegistration(prompter, domainName, resolved, assumeYes = false) {
+    writeRegisterResolvedSummary(prompter, resolved);
+    prompter.writeLine(`You are registering the subdomain "${domainName}".`);
+    await confirmYesNo(prompter, "This publishes a subdomain registration burn.", {
+        assumeYes,
+        errorCode: "wallet_register_confirmation_rejected",
+        requiresTtyErrorCode: "wallet_register_requires_tty",
+    });
+}

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

@@ -0,0 +1,42 @@
+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 { type MutationSender, type WalletMutationFeeSelection } from "../common.js";
+import type { WalletRegisterRpcClient } from "./intent.js";
+export declare function reserveLocalDomainRecord(options: {
+    state: WalletStateV1;
+    domainName: string;
+    sender: MutationSender;
+    nowUnixMs: number;
+}): WalletStateV1;
+export declare function getMutationStatusAfterAcceptance(options: {
+    snapshot: WalletReadContext["snapshot"];
+    domainName: string;
+    senderScriptPubKeyHex: string;
+}): "live" | "confirmed";
+export declare function createRegisterDraftMutation(options: {
+    domainName: string;
+    parentDomainName: string | null;
+    sender: MutationSender;
+    registerKind: "root" | "subdomain";
+    intentFingerprintHex: string;
+    nowUnixMs: number;
+    feeSelection: WalletMutationFeeSelection;
+    existing?: PendingMutationRecord | null;
+}): PendingMutationRecord;
+export declare function reconcilePendingRegisterMutation(options: {
+    state: WalletStateV1;
+    mutation: PendingMutationRecord;
+    provider: WalletSecretProvider;
+    nowUnixMs: number;
+    paths: WalletRuntimePaths;
+    rpc: WalletRegisterRpcClient;
+    walletName: string;
+    context: WalletReadContext;
+    sender: MutationSender;
+}): Promise<{
+    state: WalletStateV1;
+    mutation: PendingMutationRecord;
+    resolution: "confirmed" | "live" | "repair-required" | "not-seen" | "continue";
+}>;