@cogcoin/client 1.1.8 → 1.1.10

package/dist/wallet/tx/domain-market/variants/buy.js

@@ -0,0 +1,103 @@
+import { serializeDomainBuy } from "../../../cogop/index.js";
+import { confirmBuy } from "../confirm.js";
+import { createDomainMarketIntentFingerprint, createResolvedBuyerSummary, createResolvedSellerSummary, normalizeDomainMarketDomainName, resolveBuyOperation, } from "../intent.js";
+import { createDomainMarketDraftMutation, getBuyStatusAfterAcceptance, reserveTransferredDomainRecord, } from "../draft.js";
+import { createBuyResult, createBuyReuseResult, } from "../result.js";
+import { upsertPendingMutation } from "../../journal.js";
+import { updateMutationRecord } from "../../common.js";
+export function createBuyDomainVariant(options) {
+    const normalizedDomainName = normalizeDomainMarketDomainName(options.domainName);
+    return {
+        controlLockPurpose: "wallet-buy",
+        preemptionReason: "wallet-buy",
+        errorPrefix: "wallet_buy",
+        repairRequiredErrorCode: "wallet_buy_repair_required",
+        resolveOperation(readContext) {
+            const operation = resolveBuyOperation(readContext, normalizedDomainName, options.fromIdentity ?? null);
+            const model = readContext.model;
+            const sellerScriptPubKeyHex = Buffer.from(operation.chainDomain.ownerScriptPubKey).toString("hex");
+            const sellerAddress = sellerScriptPubKeyHex === model.walletScriptPubKeyHex ? model.walletAddress : null;
+            return {
+                ...operation,
+                normalizedDomainName,
+                sellerScriptPubKeyHex,
+                resolvedBuyer: createResolvedBuyerSummary(operation.buyerSelector, operation.sender),
+                resolvedSeller: createResolvedSellerSummary(sellerScriptPubKeyHex, sellerAddress),
+            };
+        },
+        createIntentFingerprint(operation) {
+            return createDomainMarketIntentFingerprint([
+                "buy",
+                operation.state.walletRootId,
+                operation.normalizedDomainName,
+                operation.sender.scriptPubKeyHex,
+                operation.listingPriceCogtoshi.toString(),
+            ]);
+        },
+        confirm(operation) {
+            return confirmBuy(options.prompter, operation.normalizedDomainName, operation.buyerSelector, operation.sender, operation.sellerScriptPubKeyHex, operation.resolvedSeller.address, operation.listingPriceCogtoshi, options.assumeYes);
+        },
+        createDraftMutation({ operation, existingMutation, feeSelection, intentFingerprintHex, nowUnixMs }) {
+            return createDomainMarketDraftMutation({
+                kind: "buy",
+                domainName: operation.normalizedDomainName,
+                sender: operation.sender,
+                priceCogtoshi: operation.listingPriceCogtoshi,
+                intentFingerprintHex,
+                nowUnixMs,
+                feeSelection,
+                existing: existingMutation,
+            });
+        },
+        createOpReturnData(operation) {
+            return serializeDomainBuy(operation.chainDomain.domainId, operation.listingPriceCogtoshi).opReturnData;
+        },
+        async beforePublish(operation) {
+            const currentSellerHex = Buffer.from(operation.chainDomain.ownerScriptPubKey).toString("hex");
+            if (currentSellerHex !== operation.sellerScriptPubKeyHex) {
+                throw new Error("wallet_buy_stale_listing_owner");
+            }
+        },
+        async afterAccepted({ operation, acceptedState, broadcastingMutation, built, nowUnixMs, snapshot }) {
+            const finalStatus = getBuyStatusAfterAcceptance({
+                snapshot,
+                domainName: operation.normalizedDomainName,
+                buyerScriptPubKeyHex: operation.sender.scriptPubKeyHex,
+            });
+            const finalMutation = updateMutationRecord(broadcastingMutation, finalStatus, nowUnixMs, {
+                attemptedTxid: built.txid,
+                attemptedWtxid: built.wtxid,
+                temporaryBuilderLockedOutpoints: [],
+            });
+            return {
+                state: reserveTransferredDomainRecord({
+                    state: upsertPendingMutation(acceptedState, finalMutation),
+                    domainName: operation.normalizedDomainName,
+                    domainId: operation.chainDomain.domainId,
+                    currentOwnerScriptPubKeyHex: operation.sender.scriptPubKeyHex,
+                    nowUnixMs,
+                }),
+                mutation: finalMutation,
+                status: finalStatus,
+            };
+        },
+        createReuseResult({ operation, mutation, resolution, fees }) {
+            return createBuyReuseResult({
+                operation,
+                mutation,
+                resolution,
+                fees,
+            });
+        },
+        createResult({ operation, mutation, builtTxid, status, reusedExisting, fees }) {
+            return createBuyResult({
+                operation,
+                mutation,
+                builtTxid,
+                status,
+                reusedExisting,
+                fees,
+            });
+        },
+    };
+}

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

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

package/dist/wallet/tx/domain-market/variants/sell.js

@@ -0,0 +1,91 @@
+import { serializeDomainSell } from "../../../cogop/index.js";
+import { confirmSell } from "../confirm.js";
+import { createDomainMarketIntentFingerprint, createResolvedDomainMarketSenderSummary, createSellEconomicEffectSummary, normalizeDomainMarketDomainName, resolveOwnedDomainOperation, } from "../intent.js";
+import { createDomainMarketDraftMutation, getSellStatusAfterAcceptance, } from "../draft.js";
+import { createSellResult, createSellReuseResult, } from "../result.js";
+import { upsertPendingMutation } from "../../journal.js";
+import { updateMutationRecord } from "../../common.js";
+export function createSellDomainVariant(options) {
+    const normalizedDomainName = normalizeDomainMarketDomainName(options.domainName);
+    return {
+        controlLockPurpose: "wallet-sell",
+        preemptionReason: "wallet-sell",
+        errorPrefix: "wallet_sell",
+        repairRequiredErrorCode: "wallet_sell_repair_required",
+        resolveOperation(readContext) {
+            const operation = resolveOwnedDomainOperation(readContext, normalizedDomainName, "wallet_sell");
+            return {
+                ...operation,
+                normalizedDomainName,
+                listedPriceCogtoshi: options.listedPriceCogtoshi,
+                resolvedSender: createResolvedDomainMarketSenderSummary(operation.sender, operation.senderSelector),
+                resolvedEconomicEffect: createSellEconomicEffectSummary(options.listedPriceCogtoshi),
+            };
+        },
+        createIntentFingerprint(operation) {
+            return createDomainMarketIntentFingerprint([
+                "sell",
+                operation.state.walletRootId,
+                operation.normalizedDomainName,
+                operation.sender.scriptPubKeyHex,
+                operation.listedPriceCogtoshi.toString(),
+            ]);
+        },
+        async confirm(operation) {
+            if (operation.listedPriceCogtoshi > 0n) {
+                await confirmSell(options.prompter, operation.normalizedDomainName, operation.resolvedSender, operation.listedPriceCogtoshi, options.assumeYes);
+            }
+        },
+        createDraftMutation({ operation, existingMutation, feeSelection, intentFingerprintHex, nowUnixMs }) {
+            return createDomainMarketDraftMutation({
+                kind: "sell",
+                domainName: operation.normalizedDomainName,
+                sender: operation.sender,
+                priceCogtoshi: operation.listedPriceCogtoshi,
+                intentFingerprintHex,
+                nowUnixMs,
+                feeSelection,
+                existing: existingMutation,
+            });
+        },
+        createOpReturnData(operation) {
+            return serializeDomainSell(operation.chainDomain.domainId, operation.listedPriceCogtoshi).opReturnData;
+        },
+        async afterAccepted({ operation, acceptedState, broadcastingMutation, built, nowUnixMs, snapshot }) {
+            const finalStatus = getSellStatusAfterAcceptance({
+                snapshot,
+                domainName: operation.normalizedDomainName,
+                senderScriptPubKeyHex: operation.sender.scriptPubKeyHex,
+                listedPriceCogtoshi: operation.listedPriceCogtoshi,
+            });
+            const finalMutation = updateMutationRecord(broadcastingMutation, finalStatus, nowUnixMs, {
+                attemptedTxid: built.txid,
+                attemptedWtxid: built.wtxid,
+                temporaryBuilderLockedOutpoints: [],
+            });
+            return {
+                state: upsertPendingMutation(acceptedState, finalMutation),
+                mutation: finalMutation,
+                status: finalStatus,
+            };
+        },
+        createReuseResult({ operation, mutation, resolution, fees }) {
+            return createSellReuseResult({
+                operation,
+                mutation,
+                resolution,
+                fees,
+            });
+        },
+        createResult({ operation, mutation, builtTxid, status, reusedExisting, fees }) {
+            return createSellResult({
+                operation,
+                mutation,
+                builtTxid,
+                status,
+                reusedExisting,
+                fees,
+            });
+        },
+    };
+}

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

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

package/dist/wallet/tx/domain-market/variants/transfer.js

@@ -0,0 +1,105 @@
+import { getListing } from "@cogcoin/indexer/queries";
+import { serializeDomainTransfer } from "../../../cogop/index.js";
+import { confirmTransfer } from "../confirm.js";
+import { createDomainMarketDraftMutation } from "../draft.js";
+import { createDomainMarketIntentFingerprint, createResolvedDomainMarketRecipientSummary, createResolvedDomainMarketSenderSummary, createTransferEconomicEffectSummary, normalizeDomainMarketDomainName, resolveOwnedDomainOperation, } from "../intent.js";
+import { getTransferStatusAfterAcceptance, reserveTransferredDomainRecord, } from "../draft.js";
+import { createTransferResult, createTransferReuseResult, } from "../result.js";
+import { normalizeBtcTarget } from "../../targets.js";
+import { upsertPendingMutation } from "../../journal.js";
+import { updateMutationRecord } from "../../common.js";
+export function createTransferDomainVariant(options) {
+    const normalizedDomainName = normalizeDomainMarketDomainName(options.domainName);
+    const recipient = normalizeBtcTarget(options.target);
+    return {
+        controlLockPurpose: "wallet-transfer",
+        preemptionReason: "wallet-transfer",
+        errorPrefix: "wallet_transfer",
+        repairRequiredErrorCode: "wallet_transfer_repair_required",
+        resolveOperation(readContext) {
+            const operation = resolveOwnedDomainOperation(readContext, normalizedDomainName, "wallet_transfer");
+            const resolvedSender = createResolvedDomainMarketSenderSummary(operation.sender, operation.senderSelector);
+            const resolvedRecipient = createResolvedDomainMarketRecipientSummary(recipient);
+            const resolvedEconomicEffect = createTransferEconomicEffectSummary(getListing(readContext.snapshot.state, operation.chainDomain.domainId) !== null);
+            if (operation.sender.scriptPubKeyHex === recipient.scriptPubKeyHex) {
+                throw new Error("wallet_transfer_self_transfer");
+            }
+            return {
+                ...operation,
+                normalizedDomainName,
+                recipient,
+                resolvedSender,
+                resolvedRecipient,
+                resolvedEconomicEffect,
+            };
+        },
+        createIntentFingerprint(operation) {
+            return createDomainMarketIntentFingerprint([
+                "transfer",
+                operation.state.walletRootId,
+                operation.normalizedDomainName,
+                operation.sender.scriptPubKeyHex,
+                operation.recipient.scriptPubKeyHex,
+            ]);
+        },
+        confirm(operation) {
+            return confirmTransfer(options.prompter, operation.normalizedDomainName, operation.resolvedSender, operation.resolvedRecipient, operation.resolvedEconomicEffect, options.assumeYes);
+        },
+        createDraftMutation({ operation, existingMutation, feeSelection, intentFingerprintHex, nowUnixMs }) {
+            return createDomainMarketDraftMutation({
+                kind: "transfer",
+                domainName: operation.normalizedDomainName,
+                sender: operation.sender,
+                recipientScriptPubKeyHex: operation.recipient.scriptPubKeyHex,
+                intentFingerprintHex,
+                nowUnixMs,
+                feeSelection,
+                existing: existingMutation,
+            });
+        },
+        createOpReturnData(operation) {
+            return serializeDomainTransfer(operation.chainDomain.domainId, Buffer.from(operation.recipient.scriptPubKeyHex, "hex")).opReturnData;
+        },
+        async afterAccepted({ operation, acceptedState, broadcastingMutation, built, nowUnixMs, snapshot }) {
+            const finalStatus = getTransferStatusAfterAcceptance({
+                snapshot,
+                domainName: operation.normalizedDomainName,
+                recipientScriptPubKeyHex: operation.recipient.scriptPubKeyHex,
+            });
+            const finalMutation = updateMutationRecord(broadcastingMutation, finalStatus, nowUnixMs, {
+                attemptedTxid: built.txid,
+                attemptedWtxid: built.wtxid,
+                temporaryBuilderLockedOutpoints: [],
+            });
+            return {
+                state: reserveTransferredDomainRecord({
+                    state: upsertPendingMutation(acceptedState, finalMutation),
+                    domainName: operation.normalizedDomainName,
+                    domainId: operation.chainDomain.domainId,
+                    currentOwnerScriptPubKeyHex: operation.recipient.scriptPubKeyHex,
+                    nowUnixMs,
+                }),
+                mutation: finalMutation,
+                status: finalStatus,
+            };
+        },
+        createReuseResult({ operation, mutation, resolution, fees }) {
+            return createTransferReuseResult({
+                operation,
+                mutation,
+                resolution,
+                fees,
+            });
+        },
+        createResult({ operation, mutation, builtTxid, status, reusedExisting, fees }) {
+            return createTransferResult({
+                operation,
+                mutation,
+                builtTxid,
+                status,
+                reusedExisting,
+                fees,
+            });
+        },
+    };
+}

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

@@ -1,116 +1 @@
-import { attachOrStartManagedBitcoindService } from "../../bitcoind/service.js";
-import { createRpcClient } from "../../bitcoind/node.js";
-import type { RpcTransaction } from "../../bitcoind/types.js";
-import type { WalletPrompter } from "../lifecycle.js";
-import { type WalletRuntimePaths } from "../runtime.js";
-import { type WalletSecretProvider } from "../state/provider.js";
-import { openWalletReadContext } from "../read/index.js";
-import { type WalletMutationFeeSummary, type WalletMutationRpcClient } from "./common.js";
-type DomainMarketKind = "transfer" | "sell" | "buy";
-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 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 openWalletReadContext;
-    attachService?: typeof attachOrStartManagedBitcoindService;
-    rpcFactory?: (config: Parameters<typeof 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 openWalletReadContext;
-    attachService?: typeof attachOrStartManagedBitcoindService;
-    rpcFactory?: (config: Parameters<typeof 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 openWalletReadContext;
-    attachService?: typeof attachOrStartManagedBitcoindService;
-    rpcFactory?: (config: Parameters<typeof 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 declare function parseCogAmountToCogtoshi(raw: string): bigint;
-export declare function transferDomain(options: TransferDomainOptions): Promise<DomainMarketMutationResult>;
-export declare function sellDomain(options: SellDomainOptions): Promise<DomainMarketMutationResult>;
-export declare function buyDomain(options: BuyDomainOptions): Promise<DomainMarketMutationResult>;
-export {};
+export * from "./domain-market/index.js";