@cogcoin/client 1.1.8 → 1.1.10

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

@@ -0,0 +1,131 @@
+import { createHash } from "node:crypto";
+import { getBalance, getListing, lookupDomain, } from "@cogcoin/indexer/queries";
+import { validateDomainName } from "../../cogop/index.js";
+import { assertWalletMutationContextReady, createFundingMutationSender, } from "../common.js";
+import { getCanonicalIdentitySelector, } from "../identity-selector.js";
+import { normalizeBtcTarget } from "../targets.js";
+export function normalizeDomainMarketDomainName(domainName) {
+    const normalized = domainName.trim().toLowerCase();
+    if (normalized.length === 0) {
+        throw new Error("wallet_domain_missing_domain");
+    }
+    validateDomainName(normalized);
+    return normalized;
+}
+export function parseCogAmountToCogtoshi(raw) {
+    const match = /^(-?)(\d+)(?:\.(\d{0,8}))?$/.exec(raw.trim());
+    if (match == null) {
+        throw new Error(`wallet_sell_invalid_amount_${raw}`);
+    }
+    const sign = match[1] === "-" ? -1n : 1n;
+    const whole = BigInt(match[2] ?? "0");
+    const fraction = BigInt((match[3] ?? "").padEnd(8, "0"));
+    return sign * ((whole * 100000000n) + fraction);
+}
+export function createDomainMarketIntentFingerprint(parts) {
+    return createHash("sha256")
+        .update(parts.join("\n"))
+        .digest("hex");
+}
+export function createResolvedDomainMarketSenderSummary(sender, selector) {
+    return {
+        selector,
+        localIndex: sender.localIndex,
+        scriptPubKeyHex: sender.scriptPubKeyHex,
+        address: sender.address,
+    };
+}
+export function createResolvedDomainMarketRecipientSummary(recipient) {
+    return {
+        scriptPubKeyHex: recipient.scriptPubKeyHex,
+        address: recipient.address,
+        opaque: recipient.opaque,
+    };
+}
+export function createTransferEconomicEffectSummary(clearsListing) {
+    return {
+        kind: "ownership-transfer",
+        clearsListing,
+    };
+}
+export function createSellEconomicEffectSummary(listedPriceCogtoshi) {
+    if (listedPriceCogtoshi === 0n) {
+        return {
+            kind: "listing-clear",
+            listedPriceCogtoshi: "0",
+        };
+    }
+    return {
+        kind: "listing-set",
+        listedPriceCogtoshi: listedPriceCogtoshi.toString(),
+    };
+}
+export function resolveOwnedDomainOperation(context, domainName, errorPrefix) {
+    assertWalletMutationContextReady(context, errorPrefix);
+    const chainDomain = lookupDomain(context.snapshot.state, domainName);
+    if (chainDomain === null) {
+        throw new Error(`${errorPrefix}_domain_not_found`);
+    }
+    if (chainDomain.anchored) {
+        throw new Error(`${errorPrefix}_domain_anchored`);
+    }
+    const ownerHex = Buffer.from(chainDomain.ownerScriptPubKey).toString("hex");
+    if (ownerHex !== context.localState.state.funding.scriptPubKeyHex || context.model.walletAddress == null) {
+        throw new Error(`${errorPrefix}_owner_not_locally_controlled`);
+    }
+    return {
+        readContext: context,
+        state: context.localState.state,
+        sender: createFundingMutationSender(context.localState.state),
+        senderSelector: context.model.walletAddress,
+        chainDomain,
+    };
+}
+export function resolveBuyOperation(context, domainName, fromIdentity = null) {
+    void fromIdentity;
+    assertWalletMutationContextReady(context, "wallet_buy");
+    const chainDomain = lookupDomain(context.snapshot.state, domainName);
+    if (chainDomain === null) {
+        throw new Error("wallet_buy_domain_not_found");
+    }
+    if (chainDomain.anchored) {
+        throw new Error("wallet_buy_domain_anchored");
+    }
+    const listing = getListing(context.snapshot.state, chainDomain.domainId);
+    if (listing === null) {
+        throw new Error("wallet_buy_domain_not_listed");
+    }
+    if (context.model.walletAddress === null) {
+        throw new Error("wallet_buy_funding_identity_unavailable");
+    }
+    const ownerHex = Buffer.from(chainDomain.ownerScriptPubKey).toString("hex");
+    if (ownerHex === context.localState.state.funding.scriptPubKeyHex) {
+        throw new Error("wallet_buy_already_owner");
+    }
+    if (getBalance(context.snapshot.state, context.localState.state.funding.scriptPubKeyHex) < listing.priceCogtoshi) {
+        throw new Error("wallet_buy_insufficient_cog_balance");
+    }
+    return {
+        readContext: context,
+        state: context.localState.state,
+        sender: createFundingMutationSender(context.localState.state),
+        senderSelector: context.model.walletAddress,
+        chainDomain,
+        listingPriceCogtoshi: listing.priceCogtoshi,
+        buyerSelector: context.model.walletAddress,
+    };
+}
+export function createResolvedBuyerSummary(selector, sender) {
+    return {
+        selector,
+        localIndex: sender.localIndex,
+        scriptPubKeyHex: sender.scriptPubKeyHex,
+        address: sender.address,
+    };
+}
+export function createResolvedSellerSummary(scriptPubKeyHex, address) {
+    return {
+        scriptPubKeyHex,
+        address,
+    };
+}

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

@@ -0,0 +1,31 @@
+import type { RpcListUnspentEntry } from "../../../bitcoind/types.js";
+import type { WalletRuntimePaths } from "../../runtime.js";
+import type { WalletSecretProvider } from "../../state/provider.js";
+import type { WalletStateV1 } from "../../types.js";
+import { type MutationSender } from "../common.js";
+import type { BuiltDomainMarketTransaction, DomainMarketBuildState, DomainMarketPlan, DomainMarketRpcClient } from "./types.js";
+import type { RpcDecodedPsbt } from "../../../bitcoind/types.js";
+export declare function prepareDomainMarketBuildState(options: {
+    rpc: DomainMarketRpcClient;
+    walletName: string;
+    state: WalletStateV1;
+    provider: WalletSecretProvider;
+    nowUnixMs: number;
+    paths: WalletRuntimePaths;
+    preflightCoinControl: boolean;
+}): Promise<DomainMarketBuildState>;
+export declare function buildPlanForDomainOperation(options: {
+    state: WalletStateV1;
+    allUtxos: RpcListUnspentEntry[];
+    sender: MutationSender;
+    opReturnData: Uint8Array;
+    errorPrefix: string;
+}): DomainMarketPlan;
+export declare function validateFundedDomainMarketDraft(decoded: RpcDecodedPsbt, funded: BuiltDomainMarketTransaction["funded"], plan: DomainMarketPlan): void;
+export declare function buildDomainMarketTransaction(options: {
+    rpc: DomainMarketRpcClient;
+    walletName: string;
+    state: WalletStateV1;
+    plan: DomainMarketPlan;
+    feeRateSatVb: number;
+}): Promise<BuiltDomainMarketTransaction>;

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

@@ -0,0 +1,98 @@
+import { reconcilePersistentPolicyLocks as reconcileWalletCoinControlLocks } from "../../coin-control.js";
+import { buildWalletMutationTransactionWithReserveFallback, outpointKey, saveWalletStatePreservingUnlock, } 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 async function prepareDomainMarketBuildState(options) {
+    if (!options.preflightCoinControl) {
+        return {
+            state: options.state,
+            allUtxos: (await options.rpc.listUnspent(options.walletName, 1)).slice(),
+        };
+    }
+    const reconciled = await reconcileWalletCoinControlLocks({
+        rpc: options.rpc,
+        walletName: options.walletName,
+        state: options.state,
+    });
+    const nextState = reconciled.changed
+        ? {
+            ...reconciled.state,
+            stateRevision: reconciled.state.stateRevision + 1,
+            lastWrittenAtUnixMs: options.nowUnixMs,
+        }
+        : reconciled.state;
+    if (reconciled.changed) {
+        await saveWalletStatePreservingUnlock({
+            state: nextState,
+            provider: options.provider,
+            nowUnixMs: options.nowUnixMs,
+            paths: options.paths,
+        });
+    }
+    return {
+        state: nextState,
+        allUtxos: (await options.rpc.listUnspent(options.walletName, 1)).slice(),
+    };
+}
+export function buildPlanForDomainOperation(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 validateFundedDomainMarketDraft(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 buildDomainMarketTransaction(options) {
+    return buildWalletMutationTransactionWithReserveFallback({
+        rpc: options.rpc,
+        walletName: options.walletName,
+        state: options.state,
+        plan: options.plan,
+        validateFundedDraft: validateFundedDomainMarketDraft,
+        finalizeErrorCode: `${options.plan.errorPrefix}_finalize_failed`,
+        mempoolRejectPrefix: `${options.plan.errorPrefix}_mempool_rejected`,
+        feeRate: options.feeRateSatVb,
+    });
+}

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

@@ -0,0 +1,45 @@
+import type { PendingMutationRecord } from "../../types.js";
+import type { WalletMutationFeeSummary } from "../common.js";
+import type { BuyDomainMutationOperation, DomainMarketMutationResult, SellDomainMutationOperation, TransferDomainMutationOperation } from "./types.js";
+export declare function createTransferReuseResult(options: {
+    operation: TransferDomainMutationOperation;
+    mutation: PendingMutationRecord;
+    resolution: "confirmed" | "live";
+    fees: WalletMutationFeeSummary;
+}): DomainMarketMutationResult;
+export declare function createTransferResult(options: {
+    operation: TransferDomainMutationOperation;
+    mutation: PendingMutationRecord;
+    builtTxid: string | null;
+    status: "live" | "confirmed";
+    reusedExisting: boolean;
+    fees: WalletMutationFeeSummary;
+}): DomainMarketMutationResult;
+export declare function createSellReuseResult(options: {
+    operation: SellDomainMutationOperation;
+    mutation: PendingMutationRecord;
+    resolution: "confirmed" | "live";
+    fees: WalletMutationFeeSummary;
+}): DomainMarketMutationResult;
+export declare function createSellResult(options: {
+    operation: SellDomainMutationOperation;
+    mutation: PendingMutationRecord;
+    builtTxid: string | null;
+    status: "live" | "confirmed";
+    reusedExisting: boolean;
+    fees: WalletMutationFeeSummary;
+}): DomainMarketMutationResult;
+export declare function createBuyReuseResult(options: {
+    operation: BuyDomainMutationOperation;
+    mutation: PendingMutationRecord;
+    resolution: "confirmed" | "live";
+    fees: WalletMutationFeeSummary;
+}): DomainMarketMutationResult;
+export declare function createBuyResult(options: {
+    operation: BuyDomainMutationOperation;
+    mutation: PendingMutationRecord;
+    builtTxid: string | null;
+    status: "live" | "confirmed";
+    reusedExisting: boolean;
+    fees: WalletMutationFeeSummary;
+}): DomainMarketMutationResult;

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

@@ -0,0 +1,88 @@
+export function createTransferReuseResult(options) {
+    return {
+        kind: "transfer",
+        domainName: options.operation.normalizedDomainName,
+        txid: options.mutation.attemptedTxid ?? "unknown",
+        status: options.resolution,
+        reusedExisting: true,
+        recipientScriptPubKeyHex: options.operation.recipient.scriptPubKeyHex,
+        resolved: {
+            sender: options.operation.resolvedSender,
+            recipient: options.operation.resolvedRecipient,
+            economicEffect: options.operation.resolvedEconomicEffect,
+        },
+        fees: options.fees,
+    };
+}
+export function createTransferResult(options) {
+    return {
+        kind: "transfer",
+        domainName: options.operation.normalizedDomainName,
+        txid: options.mutation.attemptedTxid ?? options.builtTxid ?? "unknown",
+        status: options.status,
+        reusedExisting: options.reusedExisting,
+        recipientScriptPubKeyHex: options.operation.recipient.scriptPubKeyHex,
+        resolved: {
+            sender: options.operation.resolvedSender,
+            recipient: options.operation.resolvedRecipient,
+            economicEffect: options.operation.resolvedEconomicEffect,
+        },
+        fees: options.fees,
+    };
+}
+export function createSellReuseResult(options) {
+    return {
+        kind: "sell",
+        domainName: options.operation.normalizedDomainName,
+        txid: options.mutation.attemptedTxid ?? "unknown",
+        status: options.resolution,
+        reusedExisting: true,
+        listedPriceCogtoshi: options.operation.listedPriceCogtoshi,
+        resolved: {
+            sender: options.operation.resolvedSender,
+            economicEffect: options.operation.resolvedEconomicEffect,
+        },
+        fees: options.fees,
+    };
+}
+export function createSellResult(options) {
+    return {
+        kind: "sell",
+        domainName: options.operation.normalizedDomainName,
+        txid: options.mutation.attemptedTxid ?? options.builtTxid ?? "unknown",
+        status: options.status,
+        reusedExisting: options.reusedExisting,
+        listedPriceCogtoshi: options.operation.listedPriceCogtoshi,
+        resolved: {
+            sender: options.operation.resolvedSender,
+            economicEffect: options.operation.resolvedEconomicEffect,
+        },
+        fees: options.fees,
+    };
+}
+export function createBuyReuseResult(options) {
+    return {
+        kind: "buy",
+        domainName: options.operation.normalizedDomainName,
+        txid: options.mutation.attemptedTxid ?? "unknown",
+        status: options.resolution,
+        reusedExisting: true,
+        listedPriceCogtoshi: options.operation.listingPriceCogtoshi,
+        resolvedBuyer: options.operation.resolvedBuyer,
+        resolvedSeller: options.operation.resolvedSeller,
+        fees: options.fees,
+    };
+}
+export function createBuyResult(options) {
+    return {
+        kind: "buy",
+        domainName: options.operation.normalizedDomainName,
+        txid: options.mutation.attemptedTxid ?? options.builtTxid ?? "unknown",
+        status: options.status,
+        reusedExisting: options.reusedExisting,
+        listedPriceCogtoshi: options.operation.listingPriceCogtoshi,
+        resolvedBuyer: options.operation.resolvedBuyer,
+        resolvedSeller: options.operation.resolvedSeller,
+        fees: options.fees,
+    };
+}

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

@@ -0,0 +1,221 @@
+import type { lookupDomain } from "@cogcoin/indexer/queries";
+import type { RpcListUnspentEntry, 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 type DomainMarketKind = "transfer" | "sell" | "buy";
+export interface DomainMarketRpcClient extends WalletMutationRpcClient {
+    getBlockchainInfo(): Promise<{
+        blocks: number;
+    }>;
+    sendRawTransaction(hex: string): Promise<string>;
+    getRawMempool(): Promise<string[]>;
+    getRawTransaction(txid: string, verbose?: boolean): Promise<RpcTransaction>;
+}
+export interface DomainMarketPlan {
+    sender: MutationSender;
+    changeAddress: string;
+    fixedInputs: FixedWalletInput[];
+    outputs: unknown[];
+    changePosition: number;
+    expectedOpReturnScriptHex: string;
+    allowedFundingScriptPubKeyHex: string;
+    eligibleFundingOutpointKeys: Set<string>;
+    errorPrefix: string;
+}
+export interface BuiltDomainMarketTransaction extends BuiltWalletMutationTransaction {
+}
+export interface DomainOperationContext {
+    readContext: WalletReadContext;
+    state: WalletStateV1;
+    sender: MutationSender;
+    senderSelector: string;
+    chainDomain: NonNullable<ReturnType<typeof lookupDomain>>;
+}
+export interface BuyOperationContext extends DomainOperationContext {
+    listingPriceCogtoshi: bigint;
+    buyerSelector: string;
+}
+export interface TransferDomainMutationOperation extends DomainOperationContext {
+    normalizedDomainName: string;
+    recipient: ReturnType<typeof import("../targets.js").normalizeBtcTarget>;
+    resolvedSender: DomainMarketResolvedSenderSummary;
+    resolvedRecipient: DomainMarketResolvedRecipientSummary;
+    resolvedEconomicEffect: DomainMarketResolvedEconomicEffect;
+}
+export interface SellDomainMutationOperation extends DomainOperationContext {
+    normalizedDomainName: string;
+    listedPriceCogtoshi: bigint;
+    resolvedSender: DomainMarketResolvedSenderSummary;
+    resolvedEconomicEffect: DomainMarketResolvedEconomicEffect;
+}
+export interface BuyDomainMutationOperation extends BuyOperationContext {
+    normalizedDomainName: string;
+    sellerScriptPubKeyHex: string;
+    resolvedBuyer: DomainMarketResolvedBuyerSummary;
+    resolvedSeller: DomainMarketResolvedSellerSummary;
+}
+export type DomainMarketOperation = TransferDomainMutationOperation | SellDomainMutationOperation | BuyDomainMutationOperation;
+export interface DomainMarketResolvedSenderSummary {
+    selector: string;
+    localIndex: number;
+    scriptPubKeyHex: string;
+    address: string;
+}
+export interface DomainMarketResolvedRecipientSummary {
+    scriptPubKeyHex: string;
+    address: string | null;
+    opaque: boolean;
+}
+export interface DomainMarketResolvedBuyerSummary {
+    selector: string;
+    localIndex: number;
+    scriptPubKeyHex: string;
+    address: string;
+}
+export interface DomainMarketResolvedSellerSummary {
+    scriptPubKeyHex: string;
+    address: string | null;
+}
+export type DomainMarketResolvedEconomicEffect = {
+    kind: "ownership-transfer";
+    clearsListing: boolean;
+} | {
+    kind: "listing-set";
+    listedPriceCogtoshi: string;
+} | {
+    kind: "listing-clear";
+    listedPriceCogtoshi: "0";
+};
+export interface DomainMarketResolvedSummary {
+    sender: DomainMarketResolvedSenderSummary;
+    recipient?: DomainMarketResolvedRecipientSummary | null;
+    economicEffect: DomainMarketResolvedEconomicEffect;
+}
+export interface TransferDomainOptions {
+    domainName: string;
+    target: 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]) => DomainMarketRpcClient;
+}
+export interface SellDomainOptions {
+    domainName: string;
+    listedPriceCogtoshi: bigint;
+    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]) => DomainMarketRpcClient;
+}
+export interface BuyDomainOptions {
+    domainName: 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]) => DomainMarketRpcClient;
+}
+export interface DomainMarketMutationResult {
+    kind: DomainMarketKind;
+    domainName: string;
+    txid: string;
+    status: "live" | "confirmed";
+    reusedExisting: boolean;
+    listedPriceCogtoshi?: bigint;
+    recipientScriptPubKeyHex?: string | null;
+    resolved?: DomainMarketResolvedSummary | null;
+    resolvedBuyer?: DomainMarketResolvedBuyerSummary | null;
+    resolvedSeller?: DomainMarketResolvedSellerSummary | null;
+    fees: WalletMutationFeeSummary;
+}
+export interface DomainMarketDraftMutationOptions {
+    kind: DomainMarketKind;
+    domainName: string;
+    sender: MutationSender;
+    intentFingerprintHex: string;
+    nowUnixMs: number;
+    feeSelection: {
+        feeRateSatVb: number;
+        source: "custom-satvb" | "estimated-next-block-plus-one" | "fallback-default";
+    };
+    parentDomainName?: string | null;
+    recipientScriptPubKeyHex?: string | null;
+    priceCogtoshi?: bigint | null;
+    existing?: PendingMutationRecord | null;
+}
+export interface DomainMarketBuildState {
+    state: WalletStateV1;
+    allUtxos: RpcListUnspentEntry[];
+}
+export interface DomainMarketMutationVariant<TOperation extends DomainMarketOperation> {
+    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;
+    beforePublish?(operation: TOperation): Promise<void>;
+    afterAccepted(options: {
+        operation: TOperation;
+        acceptedState: WalletStateV1;
+        broadcastingMutation: PendingMutationRecord;
+        built: BuiltDomainMarketTransaction;
+        nowUnixMs: number;
+        snapshot: WalletReadContext["snapshot"];
+    }): Promise<{
+        state: WalletStateV1;
+        mutation: PendingMutationRecord;
+        status: "live" | "confirmed";
+    }>;
+    createReuseResult(options: {
+        operation: TOperation;
+        mutation: PendingMutationRecord;
+        resolution: "confirmed" | "live";
+        fees: WalletMutationFeeSummary;
+    }): DomainMarketMutationResult;
+    createResult(options: {
+        operation: TOperation;
+        mutation: PendingMutationRecord;
+        builtTxid: string | null;
+        status: "live" | "confirmed";
+        reusedExisting: boolean;
+        fees: WalletMutationFeeSummary;
+    }): DomainMarketMutationResult;
+}

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

@@ -0,0 +1 @@
+export {};

package/dist/wallet/tx/domain-market/variants/buy.d.ts

@@ -0,0 +1,2 @@
+import type { BuyDomainMutationOperation, BuyDomainOptions, DomainMarketMutationVariant } from "../types.js";
+export declare function createBuyDomainVariant(options: BuyDomainOptions): DomainMarketMutationVariant<BuyDomainMutationOperation>;