@cogcoin/client 1.1.8 → 1.1.10

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

@@ -0,0 +1,117 @@
+import { mergeFixedWalletInputs } from "../common.js";
+import { executeWalletMutationOperation, publishWalletMutation, resolveExistingWalletMutation, } from "../executor.js";
+import { reconcilePendingCogMutation } from "./draft.js";
+import { buildPlanForCogOperation, buildCogTransaction, } from "./plan.js";
+import { createClaimCogVariant, createReclaimCogVariant } from "./variants/claim.js";
+import { createLockCogVariant } from "./variants/lock.js";
+import { createSendCogVariant } from "./variants/send.js";
+async function executeCogMutation(options, variant) {
+    const execution = await executeWalletMutationOperation({
+        ...options,
+        controlLockPurpose: variant.controlLockPurpose,
+        preemptionReason: variant.preemptionReason,
+        resolveOperation(readContext) {
+            return variant.resolveOperation(readContext);
+        },
+        createIntentFingerprint(operation) {
+            return variant.createIntentFingerprint(operation);
+        },
+        async resolveExistingMutation({ operation, existingMutation, execution }) {
+            if (existingMutation === null) {
+                return { state: operation.state, replacementFixedInputs: null, result: null };
+            }
+            return resolveExistingWalletMutation({
+                existingMutation,
+                execution,
+                repairRequiredErrorCode: variant.repairRequiredErrorCode,
+                reconcileExistingMutation: (mutation) => reconcilePendingCogMutation({
+                    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 }) => variant.createReuseResult({
+                    operation,
+                    mutation,
+                    resolution,
+                    fees,
+                }),
+            });
+        },
+        confirm({ operation }) {
+            return variant.confirm(operation);
+        },
+        createDraftMutation({ operation, existingMutation, execution, intentFingerprintHex }) {
+            return {
+                mutation: variant.createDraftMutation({
+                    operation,
+                    existingMutation,
+                    feeSelection: execution.feeSelection,
+                    intentFingerprintHex,
+                    nowUnixMs: execution.nowUnixMs,
+                }),
+                prepared: null,
+            };
+        },
+        async build({ operation, state, execution, replacementFixedInputs }) {
+            const plan = buildPlanForCogOperation({
+                state,
+                allUtxos: await execution.rpc.listUnspent(execution.walletName, 1),
+                sender: operation.sender,
+                opReturnData: variant.createOpReturnData(operation),
+                errorPrefix: variant.errorPrefix,
+            });
+            return buildCogTransaction({
+                rpc: execution.rpc,
+                walletName: execution.walletName,
+                state,
+                plan: {
+                    ...plan,
+                    fixedInputs: mergeFixedWalletInputs(plan.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: variant.errorPrefix,
+            });
+        },
+        createResult({ operation, mutation, built, status, reusedExisting, fees }) {
+            return variant.createResult({
+                operation,
+                mutation,
+                builtTxid: built?.txid ?? null,
+                status: status,
+                reusedExisting,
+                fees,
+            });
+        },
+    });
+    return execution.result;
+}
+export async function sendCog(options) {
+    return executeCogMutation(options, createSendCogVariant(options));
+}
+export async function lockCogToDomain(options) {
+    return executeCogMutation(options, createLockCogVariant(options));
+}
+export async function claimCogLock(options) {
+    return executeCogMutation(options, createClaimCogVariant(options));
+}
+export async function reclaimCogLock(options) {
+    return executeCogMutation(options, createReclaimCogVariant(options));
+}

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

@@ -0,0 +1,30 @@
+import { resolveIdentityBySelector } from "../identity-selector.js";
+import type { ClaimCogMutationOperation, CogResolvedSenderSummary, CogResolvedSummary, LockCogMutationOperation, SendCogOperation } from "./types.js";
+import { MAX_LOCK_DURATION_BLOCKS, ZERO_PREIMAGE_HEX } from "./types.js";
+export declare function normalizeCogDomainName(value: string): string;
+export declare function normalizePositiveCogAmount(amountCogtoshi: bigint, errorCode: string): bigint;
+export declare function createCogIntentFingerprint(parts: Array<string | number | bigint>): string;
+export declare function parseHex32(value: string, errorCode: string): Buffer;
+export declare function sha256Hex(value: Uint8Array): string;
+export declare function createResolvedSenderSummary(identity: ReturnType<typeof resolveIdentityBySelector>): CogResolvedSenderSummary;
+export declare function resolveIdentitySender(context: WalletReadContext, errorPrefix: string, amountCogtoshi: bigint, selector: string | null | undefined): {
+    state: WalletStateV1;
+    sender: MutationSender;
+    resolved: CogResolvedSummary;
+};
+export declare function resolveClaimSender(context: WalletReadContext, lockId: number, preimageHex: string, reclaim: boolean): {
+    state: WalletStateV1;
+    sender: MutationSender;
+    recipientDomainName: string | null;
+    amountCogtoshi: bigint;
+    lockId: number;
+    resolved: CogResolvedSummary;
+};
+export declare function parseTimeoutHeight(currentHeight: number, rawRelative: string | null | undefined, rawAbsolute: number | null | undefined): number;
+export declare function createSendCogOpReturnData(operation: SendCogOperation): Uint8Array;
+export declare function createLockCogOpReturnData(operation: LockCogMutationOperation): Uint8Array;
+export declare function createClaimCogOpReturnData(operation: ClaimCogMutationOperation): Uint8Array;
+export { MAX_LOCK_DURATION_BLOCKS, ZERO_PREIMAGE_HEX, };
+import type { WalletReadContext } from "../../read/index.js";
+import type { WalletStateV1 } from "../../types.js";
+import type { MutationSender } from "../common.js";

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

@@ -0,0 +1,169 @@
+import { createHash } from "node:crypto";
+import { getLock, lookupDomain, } from "@cogcoin/indexer/queries";
+import { serializeCogClaim, serializeCogLock, serializeCogTransfer, } from "../../cogop/index.js";
+import { assertWalletMutationContextReady, createFundingMutationSender, } from "../common.js";
+import { getCanonicalIdentitySelector, resolveIdentityBySelector, } from "../identity-selector.js";
+import { MAX_LOCK_DURATION_BLOCKS, ZERO_PREIMAGE_HEX, } from "./types.js";
+export function normalizeCogDomainName(value) {
+    const normalized = value.trim().toLowerCase();
+    if (normalized.length === 0) {
+        throw new Error("wallet_cog_missing_domain");
+    }
+    return normalized;
+}
+export function normalizePositiveCogAmount(amountCogtoshi, errorCode) {
+    if (amountCogtoshi <= 0n) {
+        throw new Error(errorCode);
+    }
+    return amountCogtoshi;
+}
+export function createCogIntentFingerprint(parts) {
+    return createHash("sha256")
+        .update(parts.map((part) => String(part)).join("\n"))
+        .digest("hex");
+}
+export function parseHex32(value, errorCode) {
+    const normalized = value.trim().toLowerCase();
+    if (!/^[0-9a-f]{64}$/.test(normalized)) {
+        throw new Error(errorCode);
+    }
+    return Buffer.from(normalized, "hex");
+}
+export function sha256Hex(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+function ensureUsableSender(sender, errorPrefix, amountCogtoshi) {
+    if (sender.address === null) {
+        throw new Error(`${errorPrefix}_sender_address_unavailable`);
+    }
+    if (sender.readOnly) {
+        throw new Error(`${errorPrefix}_sender_read_only`);
+    }
+    if (sender.observedCogBalance === null || sender.observedCogBalance < amountCogtoshi) {
+        throw new Error(`${errorPrefix}_insufficient_cog_balance`);
+    }
+}
+export function createResolvedSenderSummary(identity) {
+    return {
+        selector: getCanonicalIdentitySelector(identity),
+        localIndex: identity.index,
+        scriptPubKeyHex: identity.scriptPubKeyHex,
+        address: identity.address,
+    };
+}
+export function resolveIdentitySender(context, errorPrefix, amountCogtoshi, selector) {
+    assertWalletMutationContextReady(context, errorPrefix);
+    const identity = resolveIdentityBySelector(context, selector ?? context.model.walletAddress ?? "", errorPrefix);
+    ensureUsableSender(identity, errorPrefix, amountCogtoshi);
+    return {
+        state: context.localState.state,
+        sender: createFundingMutationSender(context.localState.state),
+        resolved: {
+            sender: createResolvedSenderSummary(identity),
+            claimPath: null,
+        },
+    };
+}
+export function resolveClaimSender(context, lockId, preimageHex, reclaim) {
+    const errorPrefix = reclaim ? "wallet_reclaim" : "wallet_claim";
+    assertWalletMutationContextReady(context, errorPrefix);
+    const currentHeight = context.snapshot.state.history.currentHeight;
+    if (currentHeight === null) {
+        throw new Error(`${errorPrefix}_current_height_unavailable`);
+    }
+    const lock = getLock(context.snapshot.state, lockId);
+    if (lock === null || lock.status !== "active") {
+        throw new Error(`${errorPrefix}_lock_not_found`);
+    }
+    const recipientDomain = lookupDomain(context.snapshot.state, context.model.domains.find((domain) => domain.domainId === lock.recipientDomainId)?.name ?? "") ?? [...context.snapshot.state.consensus.domainsById.values()].find((entry) => entry.domainId === lock.recipientDomainId)
+        ?? null;
+    const recipientDomainName = recipientDomain?.name ?? null;
+    if (reclaim) {
+        if (currentHeight < lock.timeoutHeight) {
+            throw new Error("wallet_reclaim_before_timeout");
+        }
+        const lockerHex = Buffer.from(lock.lockerScriptPubKey).toString("hex");
+        if (lockerHex !== context.localState.state.funding.scriptPubKeyHex || context.model.walletAddress == null) {
+            throw new Error("wallet_reclaim_sender_not_local");
+        }
+        const senderIdentity = resolveIdentityBySelector(context, context.model.walletAddress, errorPrefix);
+        ensureUsableSender(senderIdentity, errorPrefix, 0n);
+        return {
+            state: context.localState.state,
+            sender: createFundingMutationSender(context.localState.state),
+            recipientDomainName,
+            amountCogtoshi: lock.amount,
+            lockId: lock.lockId,
+            resolved: {
+                sender: createResolvedSenderSummary(senderIdentity),
+                claimPath: "timeout-reclaim",
+            },
+        };
+    }
+    if (currentHeight >= lock.timeoutHeight) {
+        throw new Error("wallet_claim_lock_expired");
+    }
+    const preimage = parseHex32(preimageHex, "wallet_claim_invalid_preimage");
+    if (sha256Hex(preimage) !== Buffer.from(lock.condition).toString("hex")) {
+        throw new Error("wallet_claim_preimage_mismatch");
+    }
+    if (recipientDomain === null) {
+        throw new Error("wallet_claim_recipient_domain_missing");
+    }
+    const recipientOwnerHex = Buffer.from(recipientDomain.ownerScriptPubKey).toString("hex");
+    if (recipientOwnerHex !== context.localState.state.funding.scriptPubKeyHex || context.model.walletAddress == null) {
+        throw new Error("wallet_claim_sender_not_local");
+    }
+    const senderIdentity = resolveIdentityBySelector(context, context.model.walletAddress, errorPrefix);
+    ensureUsableSender(senderIdentity, errorPrefix, 0n);
+    return {
+        state: context.localState.state,
+        sender: createFundingMutationSender(context.localState.state),
+        recipientDomainName,
+        amountCogtoshi: lock.amount,
+        lockId: lock.lockId,
+        resolved: {
+            sender: createResolvedSenderSummary(senderIdentity),
+            claimPath: "recipient-claim",
+        },
+    };
+}
+export function parseTimeoutHeight(currentHeight, rawRelative, rawAbsolute) {
+    if ((rawRelative == null) === (rawAbsolute == null)) {
+        throw new Error("wallet_lock_timeout_requires_exactly_one_mode");
+    }
+    if (rawAbsolute != null) {
+        if (!Number.isInteger(rawAbsolute)) {
+            throw new Error("wallet_lock_invalid_timeout_height");
+        }
+        return rawAbsolute;
+    }
+    const trimmed = rawRelative.trim().toLowerCase();
+    let blocks;
+    if (/^[1-9]\d*$/.test(trimmed)) {
+        blocks = Number.parseInt(trimmed, 10);
+    }
+    else {
+        const match = /^(\d+)(m|h|d|w)$/.exec(trimmed);
+        if (match == null) {
+            throw new Error("wallet_lock_invalid_timeout_duration");
+        }
+        const value = Number.parseInt(match[1], 10);
+        const minutesPerUnit = match[2] === "m" ? 1
+            : match[2] === "h" ? 60
+                : match[2] === "d" ? 24 * 60
+                    : 7 * 24 * 60;
+        blocks = Math.ceil((value * minutesPerUnit) / 10);
+    }
+    return currentHeight + blocks;
+}
+export function createSendCogOpReturnData(operation) {
+    return serializeCogTransfer(operation.amountCogtoshi, Buffer.from(operation.recipient.scriptPubKeyHex, "hex")).opReturnData;
+}
+export function createLockCogOpReturnData(operation) {
+    return serializeCogLock(operation.amountCogtoshi, operation.timeoutHeight, operation.recipientDomain.domainId, Buffer.from(operation.conditionHex, "hex")).opReturnData;
+}
+export function createClaimCogOpReturnData(operation) {
+    return serializeCogClaim(operation.lockId, Buffer.from(operation.preimageHex, "hex")).opReturnData;
+}
+export { MAX_LOCK_DURATION_BLOCKS, ZERO_PREIMAGE_HEX, };

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

@@ -0,0 +1,19 @@
+import type { RpcDecodedPsbt, RpcListUnspentEntry } from "../../../bitcoind/types.js";
+import { type MutationSender } from "../common.js";
+import type { BuiltCogMutationTransaction, CogMutationPlan, WalletCogRpcClient } from "./types.js";
+import type { WalletStateV1 } from "../../types.js";
+export declare function buildPlanForCogOperation(options: {
+    state: WalletStateV1;
+    allUtxos: RpcListUnspentEntry[];
+    sender: MutationSender;
+    opReturnData: Uint8Array;
+    errorPrefix: string;
+}): CogMutationPlan;
+export declare function validateFundedCogDraft(decoded: RpcDecodedPsbt, funded: BuiltCogMutationTransaction["funded"], plan: CogMutationPlan): void;
+export declare function buildCogTransaction(options: {
+    rpc: WalletCogRpcClient;
+    walletName: string;
+    state: WalletStateV1;
+    plan: CogMutationPlan;
+    feeRateSatVb: number;
+}): Promise<BuiltCogMutationTransaction>;

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

@@ -0,0 +1,65 @@
+import { buildWalletMutationTransactionWithReserveFallback, outpointKey, } from "../common.js";
+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");
+}
+export function buildPlanForCogOperation(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,
+    };
+}
+export function validateFundedCogDraft(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`);
+    }
+    const expectedWithoutChange = 1;
+    if (funded.changepos === -1) {
+        if (outputs.length !== expectedWithoutChange) {
+            throw new Error(`${plan.errorPrefix}_unexpected_output_count`);
+        }
+        return;
+    }
+    if (funded.changepos !== plan.changePosition || outputs.length !== expectedWithoutChange + 1) {
+        throw new Error(`${plan.errorPrefix}_change_position_mismatch`);
+    }
+    if (outputs[funded.changepos]?.scriptPubKey?.hex !== plan.allowedFundingScriptPubKeyHex) {
+        throw new Error(`${plan.errorPrefix}_change_output_mismatch`);
+    }
+}
+export async function buildCogTransaction(options) {
+    return buildWalletMutationTransactionWithReserveFallback({
+        rpc: options.rpc,
+        walletName: options.walletName,
+        state: options.state,
+        plan: options.plan,
+        validateFundedDraft: validateFundedCogDraft,
+        finalizeErrorCode: `${options.plan.errorPrefix}_finalize_failed`,
+        mempoolRejectPrefix: `${options.plan.errorPrefix}_mempool_rejected`,
+        feeRate: options.feeRateSatVb,
+    });
+}

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

@@ -0,0 +1,27 @@
+import type { PendingMutationRecord } from "../../types.js";
+import type { WalletMutationFeeSummary } from "../common.js";
+import type { CogMutationResult, CogResolvedSummary } from "./types.js";
+export declare function createCogReuseResult(options: {
+    kind: CogMutationResult["kind"];
+    mutation: PendingMutationRecord;
+    resolution: "confirmed" | "live";
+    fees: WalletMutationFeeSummary;
+    amountCogtoshi?: bigint;
+    recipientScriptPubKeyHex?: string | null;
+    recipientDomainName?: string | null;
+    lockId?: number | null;
+    resolved: CogResolvedSummary;
+}): CogMutationResult;
+export declare function createCogResult(options: {
+    kind: CogMutationResult["kind"];
+    mutation: PendingMutationRecord;
+    builtTxid: string | null;
+    status: "live" | "confirmed";
+    reusedExisting: boolean;
+    fees: WalletMutationFeeSummary;
+    amountCogtoshi?: bigint;
+    recipientScriptPubKeyHex?: string | null;
+    recipientDomainName?: string | null;
+    lockId?: number | null;
+    resolved: CogResolvedSummary;
+}): CogMutationResult;

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

@@ -0,0 +1,28 @@
+export function createCogReuseResult(options) {
+    return {
+        kind: options.kind,
+        txid: options.mutation.attemptedTxid ?? "unknown",
+        status: options.resolution,
+        reusedExisting: true,
+        amountCogtoshi: options.amountCogtoshi,
+        recipientScriptPubKeyHex: options.recipientScriptPubKeyHex,
+        recipientDomainName: options.recipientDomainName,
+        lockId: options.lockId,
+        resolved: options.resolved,
+        fees: options.fees,
+    };
+}
+export function createCogResult(options) {
+    return {
+        kind: options.kind,
+        txid: options.mutation.attemptedTxid ?? options.builtTxid ?? "unknown",
+        status: options.status,
+        reusedExisting: options.reusedExisting,
+        amountCogtoshi: options.amountCogtoshi,
+        recipientScriptPubKeyHex: options.recipientScriptPubKeyHex,
+        recipientDomainName: options.recipientDomainName,
+        lockId: options.lockId,
+        resolved: options.resolved,
+        fees: options.fees,
+    };
+}

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

@@ -0,0 +1,186 @@
+import type { lookupDomain } from "@cogcoin/indexer/queries";
+import type { RpcTransaction } from "../../../bitcoind/types.js";
+import type { WalletPrompter } from "../../lifecycle.js";
+import type { WalletReadContext } from "../../read/index.js";
+import type { WalletRuntimePaths } from "../../runtime.js";
+import type { WalletSecretProvider } from "../../state/provider.js";
+import type { PendingMutationRecord, WalletStateV1 } from "../../types.js";
+import type { BuiltWalletMutationTransaction, FixedWalletInput, MutationSender, WalletMutationFeeSummary, WalletMutationRpcClient } from "../common.js";
+export declare const MAX_LOCK_DURATION_BLOCKS = 262800;
+export declare const ZERO_PREIMAGE_HEX: string;
+export type CogMutationKind = "send" | "lock" | "claim";
+export interface WalletCogRpcClient extends WalletMutationRpcClient {
+    getBlockchainInfo(): Promise<{
+        blocks: number;
+    }>;
+    sendRawTransaction(hex: string): Promise<string>;
+    getRawTransaction(txid: string, verbose?: boolean): Promise<RpcTransaction>;
+}
+export interface CogMutationPlan {
+    sender: MutationSender;
+    changeAddress: string;
+    fixedInputs: FixedWalletInput[];
+    outputs: unknown[];
+    changePosition: number;
+    expectedOpReturnScriptHex: string;
+    allowedFundingScriptPubKeyHex: string;
+    eligibleFundingOutpointKeys: Set<string>;
+    errorPrefix: string;
+}
+export type BuiltCogMutationTransaction = BuiltWalletMutationTransaction;
+export interface SendCogOperation {
+    state: WalletStateV1;
+    sender: MutationSender;
+    resolved: CogResolvedSummary;
+    amountCogtoshi: bigint;
+    recipient: ReturnType<typeof import("../targets.js").normalizeBtcTarget>;
+}
+export interface LockCogMutationOperation {
+    state: WalletStateV1;
+    sender: MutationSender;
+    resolved: CogResolvedSummary;
+    amountCogtoshi: bigint;
+    normalizedRecipientDomainName: string;
+    recipientDomain: NonNullable<ReturnType<typeof lookupDomain>>;
+    timeoutHeight: number;
+    conditionHex: string;
+}
+export interface ClaimCogMutationOperation {
+    state: WalletStateV1;
+    sender: MutationSender;
+    resolved: CogResolvedSummary;
+    amountCogtoshi: bigint;
+    recipientDomainName: string | null;
+    lockId: number;
+    preimageHex: string;
+    errorPrefix: string;
+}
+export type CogMutationOperation = SendCogOperation | LockCogMutationOperation | ClaimCogMutationOperation;
+export type CogResolvedClaimPath = "recipient-claim" | "timeout-reclaim";
+export interface CogResolvedSenderSummary {
+    selector: string;
+    localIndex: number;
+    scriptPubKeyHex: string;
+    address: string;
+}
+export interface CogResolvedSummary {
+    sender: CogResolvedSenderSummary;
+    claimPath: CogResolvedClaimPath | null;
+}
+export interface CogMutationResult {
+    kind: CogMutationKind;
+    txid: string;
+    status: "live" | "confirmed";
+    reusedExisting: boolean;
+    amountCogtoshi?: bigint;
+    recipientScriptPubKeyHex?: string | null;
+    recipientDomainName?: string | null;
+    lockId?: number | null;
+    resolved: CogResolvedSummary;
+    fees: WalletMutationFeeSummary;
+}
+export interface SendCogOptions {
+    amountCogtoshi: bigint;
+    target: string;
+    fromIdentity?: string | null;
+    feeRateSatVb?: number | null;
+    dataDir: string;
+    databasePath: string;
+    provider?: WalletSecretProvider;
+    prompter: WalletPrompter;
+    assumeYes?: boolean;
+    nowUnixMs?: number;
+    paths?: WalletRuntimePaths;
+    openReadContext?: typeof import("../../read/index.js").openWalletReadContext;
+    attachService?: typeof import("../../../bitcoind/service.js").attachOrStartManagedBitcoindService;
+    rpcFactory?: (config: Parameters<typeof import("../../../bitcoind/node.js").createRpcClient>[0]) => WalletCogRpcClient;
+}
+export interface LockCogToDomainOptions {
+    amountCogtoshi: bigint;
+    recipientDomainName: string;
+    fromIdentity?: string | null;
+    feeRateSatVb?: number | null;
+    timeoutHeight?: number | null;
+    timeoutBlocksOrDuration?: string | null;
+    conditionHex: string;
+    dataDir: string;
+    databasePath: string;
+    provider?: WalletSecretProvider;
+    prompter: WalletPrompter;
+    assumeYes?: boolean;
+    nowUnixMs?: number;
+    paths?: WalletRuntimePaths;
+    openReadContext?: typeof import("../../read/index.js").openWalletReadContext;
+    attachService?: typeof import("../../../bitcoind/service.js").attachOrStartManagedBitcoindService;
+    rpcFactory?: (config: Parameters<typeof import("../../../bitcoind/node.js").createRpcClient>[0]) => WalletCogRpcClient;
+}
+export interface ClaimCogLockOptions {
+    lockId: number;
+    preimageHex: string;
+    feeRateSatVb?: number | null;
+    dataDir: string;
+    databasePath: string;
+    provider?: WalletSecretProvider;
+    prompter: WalletPrompter;
+    assumeYes?: boolean;
+    nowUnixMs?: number;
+    paths?: WalletRuntimePaths;
+    openReadContext?: typeof import("../../read/index.js").openWalletReadContext;
+    attachService?: typeof import("../../../bitcoind/service.js").attachOrStartManagedBitcoindService;
+    rpcFactory?: (config: Parameters<typeof import("../../../bitcoind/node.js").createRpcClient>[0]) => WalletCogRpcClient;
+}
+export interface ReclaimCogLockOptions extends Omit<ClaimCogLockOptions, "preimageHex"> {
+}
+export interface CogDraftMutationOptions {
+    kind: CogMutationKind;
+    sender: MutationSender;
+    intentFingerprintHex: string;
+    nowUnixMs: number;
+    feeSelection: {
+        feeRateSatVb: number;
+        source: "custom-satvb" | "estimated-next-block-plus-one" | "fallback-default";
+    };
+    domainName?: string | null;
+    recipientScriptPubKeyHex?: string | null;
+    recipientDomainName?: string | null;
+    amountCogtoshi?: bigint | null;
+    timeoutHeight?: number | null;
+    conditionHex?: string | null;
+    lockId?: number | null;
+    preimageHex?: string | null;
+    existing?: PendingMutationRecord | null;
+}
+export interface CogMutationVariant<TOperation extends CogMutationOperation> {
+    controlLockPurpose: string;
+    preemptionReason: string;
+    errorPrefix: string;
+    repairRequiredErrorCode: string;
+    resolveOperation(readContext: WalletReadContext): TOperation;
+    createIntentFingerprint(operation: TOperation): string;
+    confirm(operation: TOperation): Promise<void>;
+    createDraftMutation(options: {
+        operation: TOperation;
+        existingMutation: PendingMutationRecord | null;
+        feeSelection: {
+            feeRateSatVb: number;
+            source: "custom-satvb" | "estimated-next-block-plus-one" | "fallback-default";
+        };
+        intentFingerprintHex: string;
+        nowUnixMs: number;
+    }): PendingMutationRecord;
+    createOpReturnData(operation: TOperation): Uint8Array;
+    createReuseResult(options: {
+        operation: TOperation;
+        mutation: PendingMutationRecord;
+        resolution: "confirmed" | "live";
+        fees: WalletMutationFeeSummary;
+    }): CogMutationResult;
+    createResult(options: {
+        operation: TOperation;
+        mutation: PendingMutationRecord;
+        builtTxid: string | null;
+        status: "live" | "confirmed";
+        reusedExisting: boolean;
+        fees: WalletMutationFeeSummary;
+    }): CogMutationResult;
+}

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

@@ -0,0 +1,2 @@
+export const MAX_LOCK_DURATION_BLOCKS = 262_800;
+export const ZERO_PREIMAGE_HEX = "00".repeat(32);

package/dist/wallet/tx/cog/variants/claim.d.ts

@@ -0,0 +1,3 @@
+import type { ClaimCogLockOptions, ClaimCogMutationOperation, CogMutationVariant, ReclaimCogLockOptions } from "../types.js";
+export declare function createClaimCogVariant(options: ClaimCogLockOptions): CogMutationVariant<ClaimCogMutationOperation>;
+export declare function createReclaimCogVariant(options: ReclaimCogLockOptions): CogMutationVariant<ClaimCogMutationOperation>;