@cogcoin/client 1.1.8 → 1.1.10

package/dist/wallet/tx/bitcoin-transfer/intent.js

@@ -0,0 +1,74 @@
+import { attachOrStartManagedBitcoindService } from "../../../bitcoind/service.js";
+import { createRpcClient } from "../../../bitcoind/node.js";
+import { openWalletReadContext } from "../../read/index.js";
+import { normalizeBtcTarget } from "../targets.js";
+function parsePositiveSats(value) {
+    const trimmed = value.trim();
+    if (!/^[1-9]\d*$/.test(trimmed)) {
+        throw new Error("wallet_bitcoin_transfer_invalid_amount");
+    }
+    return BigInt(trimmed);
+}
+function normalizeRecipientAddress(target) {
+    const trimmed = target.trim();
+    try {
+        const normalized = normalizeBtcTarget(trimmed);
+        if (trimmed.startsWith("spk:") || normalized.opaque || normalized.address === null) {
+            throw new Error("wallet_bitcoin_transfer_address_required");
+        }
+        return {
+            address: normalized.address,
+            scriptPubKeyHex: normalized.scriptPubKeyHex,
+        };
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === "wallet_bitcoin_transfer_address_required") {
+            throw error;
+        }
+        if (trimmed.startsWith("spk:")) {
+            throw new Error("wallet_bitcoin_transfer_address_required", { cause: error });
+        }
+        if (error instanceof Error
+            && (error.message === "wallet_target_missing"
+                || error.message === "wallet_target_invalid_address"
+                || error.message === "wallet_target_invalid_script")) {
+            throw new Error("wallet_bitcoin_transfer_invalid_address", { cause: error });
+        }
+        throw error;
+    }
+}
+function satsToBtcNumber(value) {
+    return Number(value) / 100_000_000;
+}
+function isSpendableFundingUtxo(entry, fundingScriptPubKeyHex) {
+    return entry.scriptPubKey === fundingScriptPubKeyHex
+        && entry.confirmations >= 1
+        && entry.spendable !== false
+        && entry.safe !== false;
+}
+export function resolveBitcoinTransferIntent(options) {
+    const amountSats = parsePositiveSats(options.amountSatsText);
+    const recipient = normalizeRecipientAddress(options.target);
+    return {
+        amountSats,
+        recipientAddress: recipient.address,
+        recipientScriptPubKeyHex: recipient.scriptPubKeyHex,
+    };
+}
+export function buildPlanForBitcoinTransfer(options) {
+    const fundingUtxos = options.allUtxos.filter((entry) => isSpendableFundingUtxo(entry, options.state.funding.scriptPubKeyHex));
+    return {
+        fixedInputs: [],
+        outputs: [
+            {
+                [options.recipientAddress]: satsToBtcNumber(options.amountSats),
+            },
+        ],
+        changeAddress: options.state.funding.address,
+        changePosition: null,
+        allowedFundingScriptPubKeyHex: options.state.funding.scriptPubKeyHex,
+        eligibleFundingOutpointKeys: new Set(fundingUtxos.map((entry) => options.outpointKey({ txid: entry.txid, vout: entry.vout }))),
+        recipientScriptPubKeyHex: options.recipientScriptPubKeyHex,
+        amountSats: options.amountSats,
+    };
+}

package/dist/wallet/tx/bitcoin-transfer/plan.d.ts

@@ -0,0 +1,5 @@
+import type { RpcDecodedPsbt } from "../../../bitcoind/types.js";
+import type { BitcoinTransferPlan } from "./intent.js";
+export declare function validateFundedBitcoinTransfer(decoded: RpcDecodedPsbt, _funded: {
+    fee: number;
+}, plan: BitcoinTransferPlan): void;

package/dist/wallet/tx/bitcoin-transfer/plan.js

@@ -0,0 +1,21 @@
+function btcValueToSats(value) {
+    const numeric = typeof value === "string" ? Number(value) : value;
+    return BigInt(Math.round(numeric * 100_000_000));
+}
+export function validateFundedBitcoinTransfer(decoded, _funded, plan) {
+    if (decoded.tx.vin.length === 0) {
+        throw new Error("wallet_bitcoin_transfer_missing_sender_input");
+    }
+    const recipientOutputs = decoded.tx.vout.filter((output) => output.scriptPubKey?.hex === plan.recipientScriptPubKeyHex);
+    if (recipientOutputs.length !== 1) {
+        throw new Error("wallet_bitcoin_transfer_missing_recipient_output");
+    }
+    if (btcValueToSats(recipientOutputs[0].value) !== plan.amountSats) {
+        throw new Error("wallet_bitcoin_transfer_recipient_amount_mismatch");
+    }
+    const hasUnexpectedOutput = decoded.tx.vout.some((output) => output.scriptPubKey?.hex !== plan.recipientScriptPubKeyHex
+        && output.scriptPubKey?.hex !== plan.allowedFundingScriptPubKeyHex);
+    if (hasUnexpectedOutput) {
+        throw new Error("wallet_bitcoin_transfer_unexpected_output");
+    }
+}

package/dist/wallet/tx/bitcoin-transfer/result.d.ts

@@ -0,0 +1,19 @@
+import type { WalletStateV1 } from "../../types.js";
+import type { BuiltWalletMutationTransaction } from "../common.js";
+export interface BitcoinTransferResult {
+    amountSats: bigint;
+    feeSats: bigint;
+    senderAddress: string;
+    recipientAddress: string;
+    recipientScriptPubKeyHex: string;
+    changeAddress: string;
+    txid: string;
+    wtxid: string | null;
+}
+export declare function createBitcoinTransferResult(options: {
+    state: WalletStateV1;
+    built: BuiltWalletMutationTransaction;
+    amountSats: bigint;
+    recipientAddress: string;
+    recipientScriptPubKeyHex: string;
+}): BitcoinTransferResult;

package/dist/wallet/tx/bitcoin-transfer/result.js

@@ -0,0 +1,16 @@
+function btcValueToSats(value) {
+    const numeric = typeof value === "string" ? Number(value) : value;
+    return BigInt(Math.round(numeric * 100_000_000));
+}
+export function createBitcoinTransferResult(options) {
+    return {
+        amountSats: options.amountSats,
+        feeSats: btcValueToSats(options.built.funded.fee),
+        senderAddress: options.state.funding.address,
+        recipientAddress: options.recipientAddress,
+        recipientScriptPubKeyHex: options.recipientScriptPubKeyHex,
+        changeAddress: options.state.funding.address,
+        txid: options.built.txid,
+        wtxid: options.built.wtxid,
+    };
+}

package/dist/wallet/tx/bitcoin-transfer.d.ts

@@ -1,35 +1 @@
-import { attachOrStartManagedBitcoindService } from "../../bitcoind/service.js";
-import { createRpcClient } from "../../bitcoind/node.js";
-import type { WalletPrompter } from "../lifecycle.js";
-import { openWalletReadContext } from "../read/index.js";
-import { type WalletRuntimePaths } from "../runtime.js";
-import { type WalletSecretProvider } from "../state/provider.js";
-import { type WalletMutationRpcClient } from "./common.js";
-interface WalletBitcoinTransferRpcClient extends WalletMutationRpcClient {
-    sendRawTransaction(hex: string): Promise<string>;
-}
-export interface BitcoinTransferResult {
-    amountSats: bigint;
-    feeSats: bigint;
-    senderAddress: string;
-    recipientAddress: string;
-    recipientScriptPubKeyHex: string;
-    changeAddress: string;
-    txid: string;
-    wtxid: string | null;
-}
-export interface TransferBitcoinOptions {
-    amountSatsText: string;
-    target: string;
-    dataDir: string;
-    databasePath: string;
-    provider?: WalletSecretProvider;
-    prompter: WalletPrompter;
-    assumeYes?: boolean;
-    paths?: WalletRuntimePaths;
-    openReadContext?: typeof openWalletReadContext;
-    attachService?: typeof attachOrStartManagedBitcoindService;
-    rpcFactory?: (config: Parameters<typeof createRpcClient>[0]) => WalletBitcoinTransferRpcClient;
-}
-export declare function transferBitcoin(options: TransferBitcoinOptions): Promise<BitcoinTransferResult>;
-export {};
+export * from "./bitcoin-transfer/index.js";

package/dist/wallet/tx/bitcoin-transfer.js

@@ -1,200 +1 @@
-import { attachOrStartManagedBitcoindService } from "../../bitcoind/service.js";
-import { createRpcClient } from "../../bitcoind/node.js";
-import { acquireFileLock } from "../fs/lock.js";
-import { openWalletReadContext } from "../read/index.js";
-import { resolveWalletRuntimePathsForTesting } from "../runtime.js";
-import { createDefaultWalletSecretProvider, } from "../state/provider.js";
-import { confirmYesNo } from "./confirm.js";
-import { assertWalletBitcoinTransferContextReady, buildWalletMutationTransaction, isAlreadyAcceptedError, isBroadcastUnknownError, isInsufficientFundsError, outpointKey, pauseMiningForWalletMutation, unlockTemporaryBuilderLocks, } from "./common.js";
-import { normalizeBtcTarget } from "./targets.js";
-function parsePositiveSats(value) {
-    const trimmed = value.trim();
-    if (!/^[1-9]\d*$/.test(trimmed)) {
-        throw new Error("wallet_bitcoin_transfer_invalid_amount");
-    }
-    return BigInt(trimmed);
-}
-function satsToBtcNumber(value) {
-    return Number(value) / 100_000_000;
-}
-function btcValueToSats(value) {
-    const numeric = typeof value === "string" ? Number(value) : value;
-    return BigInt(Math.round(numeric * 100_000_000));
-}
-function normalizeRecipientAddress(target) {
-    const trimmed = target.trim();
-    try {
-        const normalized = normalizeBtcTarget(trimmed);
-        if (trimmed.startsWith("spk:") || normalized.opaque || normalized.address === null) {
-            throw new Error("wallet_bitcoin_transfer_address_required");
-        }
-        return {
-            address: normalized.address,
-            scriptPubKeyHex: normalized.scriptPubKeyHex,
-        };
-    }
-    catch (error) {
-        if (error instanceof Error && error.message === "wallet_bitcoin_transfer_address_required") {
-            throw error;
-        }
-        if (trimmed.startsWith("spk:")) {
-            throw new Error("wallet_bitcoin_transfer_address_required", { cause: error });
-        }
-        if (error instanceof Error
-            && (error.message === "wallet_target_missing"
-                || error.message === "wallet_target_invalid_address"
-                || error.message === "wallet_target_invalid_script")) {
-            throw new Error("wallet_bitcoin_transfer_invalid_address", { cause: error });
-        }
-        throw error;
-    }
-}
-function isSpendableFundingUtxo(entry, fundingScriptPubKeyHex) {
-    return entry.scriptPubKey === fundingScriptPubKeyHex
-        && entry.confirmations >= 1
-        && entry.spendable !== false
-        && entry.safe !== false;
-}
-function buildPlanForBitcoinTransfer(options) {
-    const fundingUtxos = options.allUtxos.filter((entry) => isSpendableFundingUtxo(entry, options.state.funding.scriptPubKeyHex));
-    return {
-        fixedInputs: [],
-        outputs: [
-            {
-                [options.recipientAddress]: satsToBtcNumber(options.amountSats),
-            },
-        ],
-        changeAddress: options.state.funding.address,
-        changePosition: null,
-        allowedFundingScriptPubKeyHex: options.state.funding.scriptPubKeyHex,
-        eligibleFundingOutpointKeys: new Set(fundingUtxos.map((entry) => outpointKey({ txid: entry.txid, vout: entry.vout }))),
-        recipientScriptPubKeyHex: options.recipientScriptPubKeyHex,
-        amountSats: options.amountSats,
-    };
-}
-function validateFundedBitcoinTransfer(decoded, _funded, plan) {
-    if (decoded.tx.vin.length === 0) {
-        throw new Error("wallet_bitcoin_transfer_missing_sender_input");
-    }
-    const recipientOutputs = decoded.tx.vout.filter((output) => output.scriptPubKey?.hex === plan.recipientScriptPubKeyHex);
-    if (recipientOutputs.length !== 1) {
-        throw new Error("wallet_bitcoin_transfer_missing_recipient_output");
-    }
-    if (btcValueToSats(recipientOutputs[0].value) !== plan.amountSats) {
-        throw new Error("wallet_bitcoin_transfer_recipient_amount_mismatch");
-    }
-    const hasUnexpectedOutput = decoded.tx.vout.some((output) => output.scriptPubKey?.hex !== plan.recipientScriptPubKeyHex
-        && output.scriptPubKey?.hex !== plan.allowedFundingScriptPubKeyHex);
-    if (hasUnexpectedOutput) {
-        throw new Error("wallet_bitcoin_transfer_unexpected_output");
-    }
-}
-async function confirmBitcoinTransfer(prompter, senderAddress, recipientAddress, amountSats, assumeYes = false) {
-    prompter.writeLine(`You are sending ${amountSats.toString()} sats.`);
-    prompter.writeLine(`Wallet address: ${senderAddress}`);
-    prompter.writeLine(`Recipient: ${recipientAddress}`);
-    await confirmYesNo(prompter, "This will publish a standard Bitcoin payment from the wallet address.", {
-        assumeYes,
-        errorCode: "wallet_bitcoin_transfer_confirmation_rejected",
-        requiresTtyErrorCode: "wallet_bitcoin_transfer_requires_tty",
-    });
-}
-export async function transferBitcoin(options) {
-    const amountSats = parsePositiveSats(options.amountSatsText);
-    const recipient = normalizeRecipientAddress(options.target);
-    const provider = options.provider ?? createDefaultWalletSecretProvider();
-    const paths = options.paths ?? resolveWalletRuntimePathsForTesting();
-    const controlLock = await acquireFileLock(paths.walletControlLockPath, {
-        purpose: "wallet-bitcoin-transfer",
-        walletRootId: null,
-    });
-    try {
-        const miningPreemption = await pauseMiningForWalletMutation({
-            paths,
-            reason: "wallet-bitcoin-transfer",
-        });
-        const readContext = await (options.openReadContext ?? openWalletReadContext)({
-            dataDir: options.dataDir,
-            databasePath: options.databasePath,
-            secretProvider: provider,
-            walletControlLockHeld: true,
-            paths,
-        });
-        try {
-            assertWalletBitcoinTransferContextReady(readContext, "wallet_bitcoin_transfer");
-            const state = readContext.localState.state;
-            if (state.funding.scriptPubKeyHex === recipient.scriptPubKeyHex) {
-                throw new Error("wallet_bitcoin_transfer_self_transfer");
-            }
-            await confirmBitcoinTransfer(options.prompter, state.funding.address, recipient.address, amountSats, options.assumeYes);
-            const node = await (options.attachService ?? attachOrStartManagedBitcoindService)({
-                dataDir: options.dataDir,
-                chain: "main",
-                startHeight: 0,
-                walletRootId: state.walletRootId,
-            });
-            const rpc = (options.rpcFactory ?? createRpcClient)(node.rpc);
-            const walletName = state.managedCoreWallet.walletName;
-            const allUtxos = await rpc.listUnspent(walletName, 1);
-            const plan = buildPlanForBitcoinTransfer({
-                state,
-                allUtxos,
-                recipientAddress: recipient.address,
-                recipientScriptPubKeyHex: recipient.scriptPubKeyHex,
-                amountSats,
-            });
-            let built;
-            try {
-                built = await buildWalletMutationTransaction({
-                    rpc,
-                    walletName,
-                    state,
-                    plan,
-                    validateFundedDraft: validateFundedBitcoinTransfer,
-                    finalizeErrorCode: "wallet_bitcoin_transfer_finalize_failed",
-                    mempoolRejectPrefix: "wallet_bitcoin_transfer_mempool_reject",
-                });
-            }
-            catch (error) {
-                if (isInsufficientFundsError(error)) {
-                    throw new Error("wallet_bitcoin_transfer_insufficient_funds", { cause: error });
-                }
-                throw error;
-            }
-            try {
-                await rpc.sendRawTransaction(built.rawHex);
-            }
-            catch (error) {
-                if (!isAlreadyAcceptedError(error)) {
-                    if (isInsufficientFundsError(error)) {
-                        throw new Error("wallet_bitcoin_transfer_insufficient_funds", { cause: error });
-                    }
-                    if (isBroadcastUnknownError(error)) {
-                        throw new Error("wallet_bitcoin_transfer_broadcast_unknown", { cause: error });
-                    }
-                    throw error;
-                }
-            }
-            finally {
-                await unlockTemporaryBuilderLocks(rpc, walletName, built.temporaryBuilderLockedOutpoints);
-            }
-            return {
-                amountSats,
-                feeSats: btcValueToSats(built.funded.fee),
-                senderAddress: state.funding.address,
-                recipientAddress: recipient.address,
-                recipientScriptPubKeyHex: recipient.scriptPubKeyHex,
-                changeAddress: state.funding.address,
-                txid: built.txid,
-                wtxid: built.wtxid,
-            };
-        }
-        finally {
-            await readContext.close();
-            await miningPreemption.release();
-        }
-    }
-    finally {
-        await controlLock.release();
-    }
-}
+export * from "./bitcoin-transfer/index.js";

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

@@ -0,0 +1,13 @@
+import type { WalletPrompter } from "../../lifecycle.js";
+import type { CogResolvedSummary } from "./types.js";
+import { normalizeBtcTarget } from "../targets.js";
+export declare function confirmSend(prompter: WalletPrompter, resolved: CogResolvedSummary, target: string, normalizedRecipient: ReturnType<typeof normalizeBtcTarget>, amountCogtoshi: bigint, assumeYes?: boolean): Promise<void>;
+export declare function confirmLock(prompter: WalletPrompter, resolved: CogResolvedSummary, amountCogtoshi: bigint, recipientDomainName: string, timeoutHeight: number, assumeYes?: boolean): Promise<void>;
+export declare function confirmClaim(prompter: WalletPrompter, options: {
+    kind: "claim" | "reclaim";
+    lockId: number;
+    recipientDomainName: string | null;
+    amountCogtoshi: bigint;
+    resolved: CogResolvedSummary;
+    assumeYes?: boolean;
+}): Promise<void>;

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

@@ -0,0 +1,59 @@
+import { formatCogAmount } from "../common.js";
+import { confirmTypedAcknowledgement, confirmYesNo, } from "../confirm.js";
+import { normalizeBtcTarget } from "../targets.js";
+export async function confirmSend(prompter, resolved, target, normalizedRecipient, amountCogtoshi, assumeYes = false) {
+    prompter.writeLine(`You are sending ${formatCogAmount(amountCogtoshi)}.`);
+    prompter.writeLine(`Resolved sender: ${resolved.sender.selector} (${resolved.sender.address})`);
+    prompter.writeLine(`Recipient: ${normalizedRecipient.address ?? `spk:${normalizedRecipient.scriptPubKeyHex}`}`);
+    if (normalizedRecipient.opaque) {
+        await confirmTypedAcknowledgement(prompter, {
+            assumeYes,
+            expected: target.trim(),
+            prompt: "Type the exact target to continue: ",
+            errorCode: "wallet_send_confirmation_rejected",
+            requiresTtyErrorCode: "wallet_send_requires_tty",
+            typedAckRequiredErrorCode: "wallet_send_typed_ack_required",
+        });
+        return;
+    }
+    await confirmYesNo(prompter, "This will publish an on-chain COG transfer.", {
+        assumeYes,
+        errorCode: "wallet_send_confirmation_rejected",
+        requiresTtyErrorCode: "wallet_send_requires_tty",
+    });
+}
+export async function confirmLock(prompter, resolved, amountCogtoshi, recipientDomainName, timeoutHeight, assumeYes = false) {
+    prompter.writeLine(`You are locking ${formatCogAmount(amountCogtoshi)}.`);
+    prompter.writeLine(`Resolved sender: ${resolved.sender.selector} (${resolved.sender.address})`);
+    prompter.writeLine(`Recipient domain: ${recipientDomainName}`);
+    prompter.writeLine(`Resolved timeout height: ${timeoutHeight}`);
+    await confirmYesNo(prompter, "This creates an escrowed COG lock and the funds cannot be spent until claimed or reclaimed.", {
+        assumeYes,
+        errorCode: "wallet_mutation_confirmation_rejected",
+        requiresTtyErrorCode: "wallet_lock_requires_tty",
+    });
+}
+export async function confirmClaim(prompter, options) {
+    prompter.writeLine(`${options.kind === "claim" ? "Claiming" : "Reclaiming"} lock:${options.lockId} for ${formatCogAmount(options.amountCogtoshi)}.`);
+    prompter.writeLine(`Resolved sender: ${options.resolved.sender.selector} (${options.resolved.sender.address})`);
+    if (options.resolved.claimPath !== null) {
+        prompter.writeLine(`Resolved path: ${options.resolved.claimPath}.`);
+    }
+    if (options.recipientDomainName !== null) {
+        prompter.writeLine(`Recipient domain: ${options.recipientDomainName}`);
+    }
+    if (options.kind === "claim") {
+        prompter.writeLine("Warning: the claim preimage becomes public in the mempool and on-chain.");
+    }
+    await confirmYesNo(prompter, options.kind === "claim"
+        ? "This spends the lock via the recipient claim path."
+        : "This spends the lock via the timeout reclaim path.", {
+        assumeYes: options.assumeYes,
+        errorCode: options.kind === "claim"
+            ? "wallet_claim_confirmation_rejected"
+            : "wallet_reclaim_confirmation_rejected",
+        requiresTtyErrorCode: options.kind === "claim"
+            ? "wallet_claim_requires_tty"
+            : "wallet_reclaim_requires_tty",
+    });
+}

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

@@ -0,0 +1,20 @@
+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 { CogDraftMutationOptions, WalletCogRpcClient } from "./types.js";
+export declare function createCogDraftMutation(options: CogDraftMutationOptions): PendingMutationRecord;
+export declare function reconcilePendingCogMutation(options: {
+    state: WalletStateV1;
+    mutation: PendingMutationRecord;
+    provider: WalletSecretProvider;
+    nowUnixMs: number;
+    paths: WalletRuntimePaths;
+    rpc: WalletCogRpcClient;
+    walletName: string;
+    context: WalletReadContext;
+}): Promise<{
+    state: WalletStateV1;
+    mutation: PendingMutationRecord;
+    resolution: "confirmed" | "live" | "repair-required" | "continue";
+}>;

package/dist/wallet/tx/cog/draft.js

@@ -0,0 +1,114 @@
+import { randomBytes } from "node:crypto";
+import { getLock } from "@cogcoin/indexer/queries";
+import { createWalletMutationFeeMetadata, saveWalletStatePreservingUnlock, unlockTemporaryBuilderLocks, updateMutationRecord, } from "../common.js";
+import { upsertPendingMutation } from "../journal.js";
+import { ZERO_PREIMAGE_HEX } from "./types.js";
+export function createCogDraftMutation(options) {
+    if (options.existing !== null && options.existing !== undefined) {
+        return {
+            ...options.existing,
+            kind: options.kind,
+            domainName: options.domainName ?? "",
+            senderScriptPubKeyHex: options.sender.scriptPubKeyHex,
+            senderLocalIndex: options.sender.localIndex,
+            recipientScriptPubKeyHex: options.recipientScriptPubKeyHex ?? null,
+            recipientDomainName: options.recipientDomainName ?? null,
+            amountCogtoshi: options.amountCogtoshi ?? null,
+            timeoutHeight: options.timeoutHeight ?? null,
+            conditionHex: options.conditionHex ?? null,
+            lockId: options.lockId ?? null,
+            preimageHex: options.preimageHex ?? null,
+            status: "draft",
+            lastUpdatedAtUnixMs: options.nowUnixMs,
+            attemptedTxid: null,
+            attemptedWtxid: null,
+            ...createWalletMutationFeeMetadata(options.feeSelection),
+            temporaryBuilderLockedOutpoints: [],
+        };
+    }
+    return {
+        mutationId: randomBytes(12).toString("hex"),
+        kind: options.kind,
+        domainName: options.domainName ?? "",
+        parentDomainName: null,
+        senderScriptPubKeyHex: options.sender.scriptPubKeyHex,
+        senderLocalIndex: options.sender.localIndex,
+        recipientScriptPubKeyHex: options.recipientScriptPubKeyHex ?? null,
+        recipientDomainName: options.recipientDomainName ?? null,
+        amountCogtoshi: options.amountCogtoshi ?? null,
+        timeoutHeight: options.timeoutHeight ?? null,
+        conditionHex: options.conditionHex ?? null,
+        lockId: options.lockId ?? null,
+        preimageHex: options.preimageHex ?? null,
+        intentFingerprintHex: options.intentFingerprintHex,
+        status: "draft",
+        createdAtUnixMs: options.nowUnixMs,
+        lastUpdatedAtUnixMs: options.nowUnixMs,
+        attemptedTxid: null,
+        attemptedWtxid: null,
+        ...createWalletMutationFeeMetadata(options.feeSelection),
+        temporaryBuilderLockedOutpoints: [],
+    };
+}
+export async function reconcilePendingCogMutation(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",
+        };
+    }
+    if (options.mutation.kind === "claim" && options.context.snapshot !== null && options.mutation.lockId != null) {
+        const lock = getLock(options.context.snapshot.state, options.mutation.lockId);
+        const expectedStatus = options.mutation.preimageHex === ZERO_PREIMAGE_HEX ? "reclaimed" : "claimed";
+        if (lock !== null
+            && lock.status === expectedStatus
+            && Buffer.from(lock.resolverScriptPubKey ?? new Uint8Array()).toString("hex") === options.mutation.senderScriptPubKeyHex) {
+            await unlockTemporaryBuilderLocks(options.rpc, options.walletName, options.mutation.temporaryBuilderLockedOutpoints);
+            const confirmed = updateMutationRecord(options.mutation, "confirmed", options.nowUnixMs, {
+                temporaryBuilderLockedOutpoints: [],
+            });
+            const nextState = {
+                ...upsertPendingMutation(options.state, confirmed),
+                stateRevision: options.state.stateRevision + 1,
+                lastWrittenAtUnixMs: options.nowUnixMs,
+            };
+            await saveWalletStatePreservingUnlock({
+                state: nextState,
+                provider: options.provider,
+                nowUnixMs: options.nowUnixMs,
+                paths: options.paths,
+            });
+            return { state: nextState, mutation: confirmed, resolution: "confirmed" };
+        }
+    }
+    const known = options.mutation.attemptedTxid === null
+        ? false
+        : await options.rpc.getRawTransaction(options.mutation.attemptedTxid, true).then(() => true).catch(() => false);
+    if (known) {
+        await unlockTemporaryBuilderLocks(options.rpc, options.walletName, options.mutation.temporaryBuilderLockedOutpoints);
+        const live = updateMutationRecord(options.mutation, "live", options.nowUnixMs, {
+            temporaryBuilderLockedOutpoints: [],
+        });
+        const nextState = {
+            ...upsertPendingMutation(options.state, live),
+            stateRevision: options.state.stateRevision + 1,
+            lastWrittenAtUnixMs: options.nowUnixMs,
+        };
+        await saveWalletStatePreservingUnlock({
+            state: nextState,
+            provider: options.provider,
+            nowUnixMs: options.nowUnixMs,
+            paths: options.paths,
+        });
+        return { state: nextState, mutation: live, resolution: "live" };
+    }
+    return { state: options.state, mutation: options.mutation, resolution: "continue" };
+}

package/dist/wallet/tx/cog/index.d.ts

@@ -0,0 +1,6 @@
+import type { ClaimCogLockOptions, CogMutationResult, LockCogToDomainOptions, ReclaimCogLockOptions, SendCogOptions } from "./types.js";
+export type { ClaimCogLockOptions, CogMutationResult, CogResolvedClaimPath, CogResolvedSenderSummary, CogResolvedSummary, LockCogToDomainOptions, ReclaimCogLockOptions, SendCogOptions, } from "./types.js";
+export declare function sendCog(options: SendCogOptions): Promise<CogMutationResult>;
+export declare function lockCogToDomain(options: LockCogToDomainOptions): Promise<CogMutationResult>;
+export declare function claimCogLock(options: ClaimCogLockOptions): Promise<CogMutationResult>;
+export declare function reclaimCogLock(options: ReclaimCogLockOptions): Promise<CogMutationResult>;