@cogcoin/client 1.1.8 → 1.1.10

package/dist/wallet/tx/domain-market/confirm.d.ts

@@ -0,0 +1,6 @@
+import type { WalletPrompter } from "../../lifecycle.js";
+import type { DomainMarketResolvedEconomicEffect, DomainMarketResolvedRecipientSummary, DomainMarketResolvedSenderSummary } from "./types.js";
+import type { MutationSender } from "../common.js";
+export declare function confirmTransfer(prompter: WalletPrompter, domainName: string, sender: DomainMarketResolvedSenderSummary, recipient: DomainMarketResolvedRecipientSummary, economicEffect: DomainMarketResolvedEconomicEffect, assumeYes?: boolean): Promise<void>;
+export declare function confirmSell(prompter: WalletPrompter, domainName: string, sender: DomainMarketResolvedSenderSummary, listedPriceCogtoshi: bigint, assumeYes?: boolean): Promise<void>;
+export declare function confirmBuy(prompter: WalletPrompter, domainName: string, buyerSelector: string, buyer: MutationSender, sellerScriptPubKeyHex: string, sellerAddress: string | null, listedPriceCogtoshi: bigint, assumeYes?: boolean): Promise<void>;

package/dist/wallet/tx/domain-market/confirm.js

@@ -0,0 +1,52 @@
+import { confirmTypedAcknowledgement, confirmYesNo, } from "../confirm.js";
+export async function confirmTransfer(prompter, domainName, sender, recipient, economicEffect, assumeYes = false) {
+    prompter.writeLine(`You are transferring "${domainName}".`);
+    prompter.writeLine(`Resolved sender: ${sender.selector} (${sender.address})`);
+    prompter.writeLine(`Resolved recipient: ${recipient.address ?? `spk:${recipient.scriptPubKeyHex}`}`);
+    prompter.writeLine(`Economic effect: ${economicEffect.kind === "ownership-transfer" && economicEffect.clearsListing
+        ? "transfer domain ownership and clear any active listing."
+        : "transfer domain ownership."}`);
+    if (recipient.opaque) {
+        prompter.writeLine(`Target script length: ${recipient.scriptPubKeyHex.length / 2} bytes`);
+        prompter.writeLine("Cogcoin identity is exact raw-script equality. Different script templates are different identities.");
+        const acknowledgement = `RAW-SCRIPT:${recipient.scriptPubKeyHex.slice(0, 16)}`;
+        await confirmTypedAcknowledgement(prompter, {
+            assumeYes,
+            expected: acknowledgement,
+            prompt: `Type ${acknowledgement} to continue: `,
+            errorCode: "wallet_transfer_confirmation_rejected",
+            requiresTtyErrorCode: "wallet_transfer_requires_tty",
+            typedAckRequiredErrorCode: "wallet_transfer_typed_ack_required",
+        });
+        return;
+    }
+    await confirmYesNo(prompter, "This publishes a standalone DOMAIN_TRANSFER.", {
+        assumeYes,
+        errorCode: "wallet_transfer_confirmation_rejected",
+        requiresTtyErrorCode: "wallet_transfer_requires_tty",
+    });
+}
+export async function confirmSell(prompter, domainName, sender, listedPriceCogtoshi, assumeYes = false) {
+    prompter.writeLine(`You are listing "${domainName}".`);
+    prompter.writeLine(`Resolved sender: ${sender.selector} (${sender.address})`);
+    prompter.writeLine(`Exact listing price: ${listedPriceCogtoshi.toString()} cogtoshi.`);
+    prompter.writeLine(`Economic effect: set the listing price to ${listedPriceCogtoshi.toString()} cogtoshi in COG state.`);
+    prompter.writeLine("Settlement: entirely in COG state. No BTC payment output will be added.");
+    await confirmYesNo(prompter, "This publishes a standalone DOMAIN_SELL mutation.", {
+        assumeYes,
+        errorCode: "wallet_sell_confirmation_rejected",
+        requiresTtyErrorCode: "wallet_sell_requires_tty",
+    });
+}
+export async function confirmBuy(prompter, domainName, buyerSelector, buyer, sellerScriptPubKeyHex, sellerAddress, listedPriceCogtoshi, assumeYes = false) {
+    prompter.writeLine(`You are buying "${domainName}".`);
+    prompter.writeLine(`Exact listing price: ${listedPriceCogtoshi.toString()} cogtoshi.`);
+    prompter.writeLine(`Resolved buyer: ${buyerSelector} (${buyer.address})`);
+    prompter.writeLine(`Resolved seller: ${sellerAddress ?? `spk:${sellerScriptPubKeyHex}`}`);
+    prompter.writeLine("Settlement: entirely in COG state. No BTC payment output will be added.");
+    await confirmYesNo(prompter, "This publishes a standalone DOMAIN_BUY mutation.", {
+        assumeYes,
+        errorCode: "wallet_buy_confirmation_rejected",
+        requiresTtyErrorCode: "wallet_buy_requires_tty",
+    });
+}

package/dist/wallet/tx/domain-market/draft.d.ts

@@ -0,0 +1,43 @@
+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 { DomainMarketDraftMutationOptions, DomainMarketRpcClient } from "./types.js";
+export declare function reserveTransferredDomainRecord(options: {
+    state: WalletStateV1;
+    domainName: string;
+    domainId: number | null;
+    currentOwnerScriptPubKeyHex: string;
+    nowUnixMs: number;
+}): WalletStateV1;
+export declare function createDomainMarketDraftMutation(options: DomainMarketDraftMutationOptions): PendingMutationRecord;
+export declare function getTransferStatusAfterAcceptance(options: {
+    snapshot: WalletReadContext["snapshot"];
+    domainName: string;
+    recipientScriptPubKeyHex: string;
+}): "live" | "confirmed";
+export declare function getSellStatusAfterAcceptance(options: {
+    snapshot: WalletReadContext["snapshot"];
+    domainName: string;
+    senderScriptPubKeyHex: string;
+    listedPriceCogtoshi: bigint;
+}): "live" | "confirmed";
+export declare function getBuyStatusAfterAcceptance(options: {
+    snapshot: WalletReadContext["snapshot"];
+    domainName: string;
+    buyerScriptPubKeyHex: string;
+}): "live" | "confirmed";
+export declare function reconcilePendingDomainMarketMutation(options: {
+    state: WalletStateV1;
+    mutation: PendingMutationRecord;
+    provider: WalletSecretProvider;
+    nowUnixMs: number;
+    paths: WalletRuntimePaths;
+    rpc: DomainMarketRpcClient;
+    walletName: string;
+    context: WalletReadContext;
+}): Promise<{
+    state: WalletStateV1;
+    mutation: PendingMutationRecord;
+    resolution: "confirmed" | "live" | "repair-required" | "not-seen" | "continue";
+}>;

package/dist/wallet/tx/domain-market/draft.js

@@ -0,0 +1,286 @@
+import { randomBytes } from "node:crypto";
+import { getListing, lookupDomain } from "@cogcoin/indexer/queries";
+import { createWalletMutationFeeMetadata, saveWalletStatePreservingUnlock, unlockTemporaryBuilderLocks, updateMutationRecord, } from "../common.js";
+import { upsertPendingMutation } from "../journal.js";
+export function reserveTransferredDomainRecord(options) {
+    const existing = options.state.domains.find((domain) => domain.name === options.domainName) ?? null;
+    const domains = options.state.domains.some((domain) => domain.name === options.domainName)
+        ? options.state.domains.map((domain) => {
+            if (domain.name !== options.domainName) {
+                return domain;
+            }
+            return {
+                ...domain,
+                domainId: options.domainId ?? domain.domainId,
+                currentOwnerScriptPubKeyHex: options.currentOwnerScriptPubKeyHex,
+                canonicalChainStatus: "registered-unanchored",
+                birthTime: domain.birthTime ?? Math.floor(options.nowUnixMs / 1000),
+            };
+        })
+        : [
+            ...options.state.domains,
+            {
+                name: options.domainName,
+                domainId: options.domainId,
+                currentOwnerScriptPubKeyHex: options.currentOwnerScriptPubKeyHex,
+                canonicalChainStatus: "registered-unanchored",
+                foundingMessageText: existing?.foundingMessageText ?? null,
+                birthTime: Math.floor(options.nowUnixMs / 1000),
+            },
+        ];
+    return {
+        ...options.state,
+        domains,
+    };
+}
+export function createDomainMarketDraftMutation(options) {
+    if (options.existing !== null && options.existing !== undefined) {
+        return {
+            ...options.existing,
+            kind: options.kind,
+            parentDomainName: options.parentDomainName ?? null,
+            senderScriptPubKeyHex: options.sender.scriptPubKeyHex,
+            senderLocalIndex: options.sender.localIndex,
+            recipientScriptPubKeyHex: options.recipientScriptPubKeyHex ?? null,
+            priceCogtoshi: options.priceCogtoshi ?? 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: options.parentDomainName ?? null,
+        senderScriptPubKeyHex: options.sender.scriptPubKeyHex,
+        senderLocalIndex: options.sender.localIndex,
+        recipientScriptPubKeyHex: options.recipientScriptPubKeyHex ?? null,
+        priceCogtoshi: options.priceCogtoshi ?? null,
+        intentFingerprintHex: options.intentFingerprintHex,
+        status: "draft",
+        createdAtUnixMs: options.nowUnixMs,
+        lastUpdatedAtUnixMs: options.nowUnixMs,
+        attemptedTxid: null,
+        attemptedWtxid: null,
+        ...createWalletMutationFeeMetadata(options.feeSelection),
+        temporaryBuilderLockedOutpoints: [],
+    };
+}
+export function getTransferStatusAfterAcceptance(options) {
+    const chainDomain = options.snapshot === null ? null : lookupDomain(options.snapshot.state, options.domainName);
+    if (chainDomain === null) {
+        return "live";
+    }
+    return Buffer.from(chainDomain.ownerScriptPubKey).toString("hex") === options.recipientScriptPubKeyHex
+        ? "confirmed"
+        : "live";
+}
+export function getSellStatusAfterAcceptance(options) {
+    const chainDomain = options.snapshot === null ? null : lookupDomain(options.snapshot.state, options.domainName);
+    if (chainDomain === null) {
+        return "live";
+    }
+    const ownerHex = Buffer.from(chainDomain.ownerScriptPubKey).toString("hex");
+    const listing = getListing(options.snapshot.state, chainDomain.domainId);
+    if (options.listedPriceCogtoshi === 0n) {
+        return ownerHex === options.senderScriptPubKeyHex && listing === null ? "confirmed" : "live";
+    }
+    return ownerHex === options.senderScriptPubKeyHex && listing?.priceCogtoshi === options.listedPriceCogtoshi
+        ? "confirmed"
+        : "live";
+}
+export function getBuyStatusAfterAcceptance(options) {
+    const chainDomain = options.snapshot === null ? null : lookupDomain(options.snapshot.state, options.domainName);
+    if (chainDomain === null) {
+        return "live";
+    }
+    return Buffer.from(chainDomain.ownerScriptPubKey).toString("hex") === options.buyerScriptPubKeyHex
+        ? "confirmed"
+        : "live";
+}
+export async function reconcilePendingDomainMarketMutation(options) {
+    if (options.mutation.status === "repair-required") {
+        return {
+            state: options.state,
+            mutation: options.mutation,
+            resolution: "repair-required",
+        };
+    }
+    const chainDomain = options.context.snapshot === null
+        ? null
+        : lookupDomain(options.context.snapshot.state, options.mutation.domainName);
+    if (chainDomain !== null) {
+        const ownerHex = Buffer.from(chainDomain.ownerScriptPubKey).toString("hex");
+        const listing = getListing(options.context.snapshot.state, chainDomain.domainId);
+        if (options.mutation.kind === "transfer") {
+            if (ownerHex === options.mutation.recipientScriptPubKeyHex) {
+                await unlockTemporaryBuilderLocks(options.rpc, options.walletName, options.mutation.temporaryBuilderLockedOutpoints);
+                const confirmed = updateMutationRecord(options.mutation, "confirmed", options.nowUnixMs, {
+                    temporaryBuilderLockedOutpoints: [],
+                });
+                const nextState = reserveTransferredDomainRecord({
+                    state: upsertPendingMutation(options.state, confirmed),
+                    domainName: options.mutation.domainName,
+                    domainId: chainDomain.domainId,
+                    currentOwnerScriptPubKeyHex: ownerHex,
+                    nowUnixMs: options.nowUnixMs,
+                });
+                await saveWalletStatePreservingUnlock({
+                    state: nextState,
+                    provider: options.provider,
+                    nowUnixMs: options.nowUnixMs,
+                    paths: options.paths,
+                });
+                return { state: nextState, mutation: confirmed, resolution: "confirmed" };
+            }
+            if (ownerHex !== options.mutation.senderScriptPubKeyHex) {
+                const repair = updateMutationRecord(options.mutation, "repair-required", options.nowUnixMs, {
+                    temporaryBuilderLockedOutpoints: [],
+                });
+                const nextState = upsertPendingMutation(options.state, repair);
+                await saveWalletStatePreservingUnlock({
+                    state: nextState,
+                    provider: options.provider,
+                    nowUnixMs: options.nowUnixMs,
+                    paths: options.paths,
+                });
+                return { state: nextState, mutation: repair, resolution: "repair-required" };
+            }
+        }
+        if (options.mutation.kind === "sell") {
+            const targetPrice = options.mutation.priceCogtoshi ?? 0n;
+            if (ownerHex === options.mutation.senderScriptPubKeyHex) {
+                if (targetPrice === 0n && listing === null) {
+                    await unlockTemporaryBuilderLocks(options.rpc, options.walletName, options.mutation.temporaryBuilderLockedOutpoints);
+                    const confirmed = updateMutationRecord(options.mutation, "confirmed", options.nowUnixMs, {
+                        temporaryBuilderLockedOutpoints: [],
+                    });
+                    const nextState = upsertPendingMutation(options.state, confirmed);
+                    await saveWalletStatePreservingUnlock({
+                        state: nextState,
+                        provider: options.provider,
+                        nowUnixMs: options.nowUnixMs,
+                        paths: options.paths,
+                    });
+                    return { state: nextState, mutation: confirmed, resolution: "confirmed" };
+                }
+                if (targetPrice > 0n && listing?.priceCogtoshi === targetPrice) {
+                    await unlockTemporaryBuilderLocks(options.rpc, options.walletName, options.mutation.temporaryBuilderLockedOutpoints);
+                    const confirmed = updateMutationRecord(options.mutation, "confirmed", options.nowUnixMs, {
+                        temporaryBuilderLockedOutpoints: [],
+                    });
+                    const nextState = upsertPendingMutation(options.state, confirmed);
+                    await saveWalletStatePreservingUnlock({
+                        state: nextState,
+                        provider: options.provider,
+                        nowUnixMs: options.nowUnixMs,
+                        paths: options.paths,
+                    });
+                    return { state: nextState, mutation: confirmed, resolution: "confirmed" };
+                }
+            }
+            else {
+                const repair = updateMutationRecord(options.mutation, "repair-required", options.nowUnixMs, {
+                    temporaryBuilderLockedOutpoints: [],
+                });
+                const nextState = upsertPendingMutation(options.state, repair);
+                await saveWalletStatePreservingUnlock({
+                    state: nextState,
+                    provider: options.provider,
+                    nowUnixMs: options.nowUnixMs,
+                    paths: options.paths,
+                });
+                return { state: nextState, mutation: repair, resolution: "repair-required" };
+            }
+        }
+        if (options.mutation.kind === "buy") {
+            if (ownerHex === options.mutation.senderScriptPubKeyHex) {
+                await unlockTemporaryBuilderLocks(options.rpc, options.walletName, options.mutation.temporaryBuilderLockedOutpoints);
+                const confirmed = updateMutationRecord(options.mutation, "confirmed", options.nowUnixMs, {
+                    temporaryBuilderLockedOutpoints: [],
+                });
+                const nextState = reserveTransferredDomainRecord({
+                    state: upsertPendingMutation(options.state, confirmed),
+                    domainName: options.mutation.domainName,
+                    domainId: chainDomain.domainId,
+                    currentOwnerScriptPubKeyHex: ownerHex,
+                    nowUnixMs: options.nowUnixMs,
+                });
+                await saveWalletStatePreservingUnlock({
+                    state: nextState,
+                    provider: options.provider,
+                    nowUnixMs: options.nowUnixMs,
+                    paths: options.paths,
+                });
+                return { state: nextState, mutation: confirmed, resolution: "confirmed" };
+            }
+            if (listing === null) {
+                const repair = updateMutationRecord(options.mutation, "repair-required", options.nowUnixMs, {
+                    temporaryBuilderLockedOutpoints: [],
+                });
+                const nextState = upsertPendingMutation(options.state, repair);
+                await saveWalletStatePreservingUnlock({
+                    state: nextState,
+                    provider: options.provider,
+                    nowUnixMs: options.nowUnixMs,
+                    paths: options.paths,
+                });
+                return { state: nextState, mutation: repair, resolution: "repair-required" };
+            }
+        }
+    }
+    if (options.mutation.attemptedTxid !== null) {
+        const mempool = await options.rpc.getRawMempool().catch(() => []);
+        if (mempool.includes(options.mutation.attemptedTxid)) {
+            await unlockTemporaryBuilderLocks(options.rpc, options.walletName, options.mutation.temporaryBuilderLockedOutpoints);
+            const live = updateMutationRecord(options.mutation, "live", options.nowUnixMs, {
+                temporaryBuilderLockedOutpoints: [],
+            });
+            let nextState = upsertPendingMutation(options.state, live);
+            if (live.kind === "transfer" || live.kind === "buy") {
+                nextState = reserveTransferredDomainRecord({
+                    state: nextState,
+                    domainName: live.domainName,
+                    domainId: chainDomain?.domainId ?? null,
+                    currentOwnerScriptPubKeyHex: live.kind === "transfer"
+                        ? (live.recipientScriptPubKeyHex ?? live.senderScriptPubKeyHex)
+                        : live.senderScriptPubKeyHex,
+                    nowUnixMs: options.nowUnixMs,
+                });
+            }
+            await saveWalletStatePreservingUnlock({
+                state: nextState,
+                provider: options.provider,
+                nowUnixMs: options.nowUnixMs,
+                paths: options.paths,
+            });
+            return { state: nextState, mutation: live, resolution: "live" };
+        }
+    }
+    if (options.mutation.status === "broadcast-unknown"
+        || options.mutation.status === "live"
+        || options.mutation.status === "draft"
+        || options.mutation.status === "broadcasting") {
+        await unlockTemporaryBuilderLocks(options.rpc, options.walletName, options.mutation.temporaryBuilderLockedOutpoints);
+        const canceled = updateMutationRecord(options.mutation, "canceled", options.nowUnixMs, {
+            temporaryBuilderLockedOutpoints: [],
+        });
+        const nextState = upsertPendingMutation(options.state, canceled);
+        await saveWalletStatePreservingUnlock({
+            state: nextState,
+            provider: options.provider,
+            nowUnixMs: options.nowUnixMs,
+            paths: options.paths,
+        });
+        return { state: nextState, mutation: canceled, resolution: "not-seen" };
+    }
+    return {
+        state: options.state,
+        mutation: options.mutation,
+        resolution: "continue",
+    };
+}

package/dist/wallet/tx/domain-market/index.d.ts

@@ -0,0 +1,6 @@
+import type { BuyDomainOptions, DomainMarketMutationResult, SellDomainOptions, TransferDomainOptions } from "./types.js";
+export { parseCogAmountToCogtoshi } from "./intent.js";
+export type { BuyDomainOptions, DomainMarketMutationResult, DomainMarketResolvedBuyerSummary, DomainMarketResolvedEconomicEffect, DomainMarketResolvedRecipientSummary, DomainMarketResolvedSellerSummary, DomainMarketResolvedSenderSummary, DomainMarketResolvedSummary, SellDomainOptions, TransferDomainOptions, } from "./types.js";
+export declare function transferDomain(options: TransferDomainOptions): Promise<DomainMarketMutationResult>;
+export declare function sellDomain(options: SellDomainOptions): Promise<DomainMarketMutationResult>;
+export declare function buyDomain(options: BuyDomainOptions): Promise<DomainMarketMutationResult>;

package/dist/wallet/tx/domain-market/index.js

@@ -0,0 +1,145 @@
+import { mergeFixedWalletInputs } from "../common.js";
+import { executeWalletMutationOperation, publishWalletMutation, resolveExistingWalletMutation, } from "../executor.js";
+import { reconcilePendingDomainMarketMutation } from "./draft.js";
+import { prepareDomainMarketBuildState, buildPlanForDomainOperation, buildDomainMarketTransaction, } from "./plan.js";
+import { parseCogAmountToCogtoshi } from "./intent.js";
+import { createBuyDomainVariant } from "./variants/buy.js";
+import { createSellDomainVariant } from "./variants/sell.js";
+import { createTransferDomainVariant } from "./variants/transfer.js";
+export { parseCogAmountToCogtoshi } from "./intent.js";
+async function executeDomainMarketMutation(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) => reconcilePendingDomainMarketMutation({
+                    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 prepareBuildState({ state, execution }) {
+            return (await prepareDomainMarketBuildState({
+                rpc: execution.rpc,
+                walletName: execution.walletName,
+                state,
+                provider: execution.provider,
+                nowUnixMs: execution.nowUnixMs,
+                paths: execution.paths,
+                preflightCoinControl: false,
+            })).state;
+        },
+        async build({ operation, state, execution, replacementFixedInputs }) {
+            const domainPlan = buildPlanForDomainOperation({
+                state,
+                allUtxos: await execution.rpc.listUnspent(execution.walletName, 1),
+                sender: operation.sender,
+                opReturnData: variant.createOpReturnData(operation),
+                errorPrefix: variant.errorPrefix,
+            });
+            return buildDomainMarketTransaction({
+                rpc: execution.rpc,
+                walletName: execution.walletName,
+                state,
+                plan: {
+                    ...domainPlan,
+                    fixedInputs: mergeFixedWalletInputs(domainPlan.fixedInputs, replacementFixedInputs),
+                },
+                feeRateSatVb: execution.feeSelection.feeRateSatVb,
+            });
+        },
+        async beforePublish({ operation }) {
+            if (variant.beforePublish !== undefined) {
+                await variant.beforePublish(operation);
+            }
+        },
+        publish({ operation, 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,
+                async afterAccepted({ state: acceptedState, broadcastingMutation, built, nowUnixMs }) {
+                    return variant.afterAccepted({
+                        operation,
+                        acceptedState,
+                        broadcastingMutation,
+                        built,
+                        nowUnixMs,
+                        snapshot: execution.readContext.snapshot,
+                    });
+                },
+            });
+        },
+        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 transferDomain(options) {
+    return executeDomainMarketMutation(options, createTransferDomainVariant(options));
+}
+export async function sellDomain(options) {
+    if (options.listedPriceCogtoshi < 0n) {
+        throw new Error("wallet_sell_invalid_amount");
+    }
+    return executeDomainMarketMutation(options, createSellDomainVariant(options));
+}
+export async function buyDomain(options) {
+    return executeDomainMarketMutation(options, createBuyDomainVariant(options));
+}

package/dist/wallet/tx/domain-market/intent.d.ts

@@ -0,0 +1,15 @@
+import { normalizeBtcTarget } from "../targets.js";
+import type { BuyOperationContext, DomainMarketResolvedBuyerSummary, DomainMarketResolvedEconomicEffect, DomainMarketResolvedRecipientSummary, DomainMarketResolvedSellerSummary, DomainMarketResolvedSenderSummary, DomainOperationContext } from "./types.js";
+export declare function normalizeDomainMarketDomainName(domainName: string): string;
+export declare function parseCogAmountToCogtoshi(raw: string): bigint;
+export declare function createDomainMarketIntentFingerprint(parts: string[]): string;
+export declare function createResolvedDomainMarketSenderSummary(sender: MutationSender, selector: string): DomainMarketResolvedSenderSummary;
+export declare function createResolvedDomainMarketRecipientSummary(recipient: ReturnType<typeof normalizeBtcTarget>): DomainMarketResolvedRecipientSummary;
+export declare function createTransferEconomicEffectSummary(clearsListing: boolean): DomainMarketResolvedEconomicEffect;
+export declare function createSellEconomicEffectSummary(listedPriceCogtoshi: bigint): DomainMarketResolvedEconomicEffect;
+export declare function resolveOwnedDomainOperation(context: WalletReadContext, domainName: string, errorPrefix: string): DomainOperationContext;
+export declare function resolveBuyOperation(context: WalletReadContext, domainName: string, fromIdentity?: string | null): BuyOperationContext;
+export declare function createResolvedBuyerSummary(selector: string, sender: MutationSender): DomainMarketResolvedBuyerSummary;
+export declare function createResolvedSellerSummary(scriptPubKeyHex: string, address: string | null): DomainMarketResolvedSellerSummary;
+import type { WalletReadContext } from "../../read/index.js";
+import type { MutationSender } from "../common.js";