@cogcoin/client 1.1.8 → 1.1.10

package/dist/wallet/tx/cog/variants/claim.js

@@ -0,0 +1,92 @@
+import { confirmClaim } from "../confirm.js";
+import { createClaimCogOpReturnData, createCogIntentFingerprint, resolveClaimSender, ZERO_PREIMAGE_HEX, } from "../intent.js";
+import { createCogDraftMutation } from "../draft.js";
+import { createCogResult, createCogReuseResult, } from "../result.js";
+function createClaimLikeVariant(options, reclaim) {
+    const preimageHex = reclaim ? ZERO_PREIMAGE_HEX : options.preimageHex;
+    const errorPrefix = reclaim ? "wallet_reclaim" : "wallet_claim";
+    return {
+        controlLockPurpose: reclaim ? "wallet-reclaim" : "wallet-claim",
+        preemptionReason: reclaim ? "wallet-reclaim" : "wallet-claim",
+        errorPrefix,
+        repairRequiredErrorCode: `${errorPrefix}_repair_required`,
+        resolveOperation(readContext) {
+            return {
+                ...resolveClaimSender(readContext, options.lockId, preimageHex, reclaim),
+                preimageHex,
+                errorPrefix,
+            };
+        },
+        createIntentFingerprint(operation) {
+            return createCogIntentFingerprint([
+                reclaim ? "reclaim" : "claim",
+                operation.state.walletRootId,
+                operation.sender.scriptPubKeyHex,
+                operation.lockId,
+                operation.preimageHex,
+            ]);
+        },
+        confirm(operation) {
+            return confirmClaim(options.prompter, {
+                kind: reclaim ? "reclaim" : "claim",
+                lockId: operation.lockId,
+                recipientDomainName: operation.recipientDomainName,
+                amountCogtoshi: operation.amountCogtoshi,
+                resolved: operation.resolved,
+                assumeYes: options.assumeYes,
+            });
+        },
+        createDraftMutation({ operation, existingMutation, feeSelection, intentFingerprintHex, nowUnixMs }) {
+            return createCogDraftMutation({
+                kind: "claim",
+                sender: operation.sender,
+                amountCogtoshi: operation.amountCogtoshi,
+                recipientDomainName: operation.recipientDomainName,
+                lockId: operation.lockId,
+                preimageHex: operation.preimageHex,
+                intentFingerprintHex,
+                nowUnixMs,
+                feeSelection,
+                existing: existingMutation,
+            });
+        },
+        createOpReturnData(operation) {
+            return createClaimCogOpReturnData(operation);
+        },
+        createReuseResult({ operation, mutation, resolution, fees }) {
+            return createCogReuseResult({
+                kind: "claim",
+                mutation,
+                resolution,
+                fees,
+                amountCogtoshi: operation.amountCogtoshi,
+                recipientDomainName: operation.recipientDomainName,
+                lockId: operation.lockId,
+                resolved: operation.resolved,
+            });
+        },
+        createResult({ operation, mutation, builtTxid, status, reusedExisting, fees }) {
+            return createCogResult({
+                kind: "claim",
+                mutation,
+                builtTxid,
+                status,
+                reusedExisting,
+                fees,
+                amountCogtoshi: operation.amountCogtoshi,
+                recipientDomainName: operation.recipientDomainName,
+                lockId: operation.lockId,
+                resolved: operation.resolved,
+            });
+        },
+    };
+}
+export function createClaimCogVariant(options) {
+    return createClaimLikeVariant(options, false);
+}
+export function createReclaimCogVariant(options) {
+    return createClaimLikeVariant({
+        ...options,
+        preimageHex: ZERO_PREIMAGE_HEX,
+    }, true);
+}

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

@@ -0,0 +1,2 @@
+import type { CogMutationVariant, LockCogMutationOperation, LockCogToDomainOptions } from "../types.js";
+export declare function createLockCogVariant(options: LockCogToDomainOptions): CogMutationVariant<LockCogMutationOperation>;

package/dist/wallet/tx/cog/variants/lock.js

@@ -0,0 +1,102 @@
+import { lookupDomain } from "@cogcoin/indexer/queries";
+import { confirmLock } from "../confirm.js";
+import { createCogIntentFingerprint, createLockCogOpReturnData, MAX_LOCK_DURATION_BLOCKS, normalizeCogDomainName, normalizePositiveCogAmount, parseHex32, parseTimeoutHeight, resolveIdentitySender, } from "../intent.js";
+import { createCogDraftMutation } from "../draft.js";
+import { createCogResult, createCogReuseResult, } from "../result.js";
+export function createLockCogVariant(options) {
+    const amountCogtoshi = normalizePositiveCogAmount(options.amountCogtoshi, "wallet_lock_invalid_amount");
+    const normalizedRecipientDomainName = normalizeCogDomainName(options.recipientDomainName);
+    const condition = parseHex32(options.conditionHex, "wallet_lock_invalid_condition");
+    if (condition.equals(Buffer.alloc(32))) {
+        throw new Error("wallet_lock_invalid_condition");
+    }
+    return {
+        controlLockPurpose: "wallet-lock-cog",
+        preemptionReason: "wallet-cog-lock",
+        errorPrefix: "wallet_lock",
+        repairRequiredErrorCode: "wallet_lock_repair_required",
+        resolveOperation(readContext) {
+            const currentHeight = readContext.snapshot?.state.history.currentHeight ?? null;
+            if (currentHeight === null) {
+                throw new Error("wallet_lock_current_height_unavailable");
+            }
+            const timeoutHeight = parseTimeoutHeight(currentHeight, options.timeoutBlocksOrDuration, options.timeoutHeight ?? null);
+            if (timeoutHeight <= currentHeight || timeoutHeight > currentHeight + MAX_LOCK_DURATION_BLOCKS) {
+                throw new Error("wallet_lock_invalid_timeout_height");
+            }
+            const recipientDomain = lookupDomain(readContext.snapshot.state, normalizedRecipientDomainName);
+            if (recipientDomain === null) {
+                throw new Error("wallet_lock_domain_not_found");
+            }
+            if (!recipientDomain.anchored) {
+                throw new Error("wallet_lock_domain_not_anchored");
+            }
+            if (readContext.snapshot.state.consensus.nextLockId === 0xffff_ffff) {
+                throw new Error("wallet_lock_id_space_exhausted");
+            }
+            return {
+                ...resolveIdentitySender(readContext, "wallet_lock", amountCogtoshi, options.fromIdentity),
+                amountCogtoshi,
+                normalizedRecipientDomainName,
+                recipientDomain,
+                timeoutHeight,
+                conditionHex: Buffer.from(condition).toString("hex"),
+            };
+        },
+        createIntentFingerprint(operation) {
+            return createCogIntentFingerprint([
+                "lock",
+                operation.state.walletRootId,
+                operation.sender.scriptPubKeyHex,
+                operation.normalizedRecipientDomainName,
+                operation.amountCogtoshi,
+                operation.timeoutHeight,
+                operation.conditionHex,
+            ]);
+        },
+        confirm(operation) {
+            return confirmLock(options.prompter, operation.resolved, operation.amountCogtoshi, operation.normalizedRecipientDomainName, operation.timeoutHeight, options.assumeYes);
+        },
+        createDraftMutation({ operation, existingMutation, feeSelection, intentFingerprintHex, nowUnixMs }) {
+            return createCogDraftMutation({
+                kind: "lock",
+                sender: operation.sender,
+                amountCogtoshi: operation.amountCogtoshi,
+                recipientDomainName: operation.normalizedRecipientDomainName,
+                timeoutHeight: operation.timeoutHeight,
+                conditionHex: operation.conditionHex,
+                intentFingerprintHex,
+                nowUnixMs,
+                feeSelection,
+                existing: existingMutation,
+            });
+        },
+        createOpReturnData(operation) {
+            return createLockCogOpReturnData(operation);
+        },
+        createReuseResult({ operation, mutation, resolution, fees }) {
+            return createCogReuseResult({
+                kind: "lock",
+                mutation,
+                resolution,
+                fees,
+                amountCogtoshi: operation.amountCogtoshi,
+                recipientDomainName: operation.normalizedRecipientDomainName,
+                resolved: operation.resolved,
+            });
+        },
+        createResult({ operation, mutation, builtTxid, status, reusedExisting, fees }) {
+            return createCogResult({
+                kind: "lock",
+                mutation,
+                builtTxid,
+                status,
+                reusedExisting,
+                fees,
+                amountCogtoshi: operation.amountCogtoshi,
+                recipientDomainName: operation.normalizedRecipientDomainName,
+                resolved: operation.resolved,
+            });
+        },
+    };
+}

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

@@ -0,0 +1,2 @@
+import type { CogMutationVariant, SendCogOperation, SendCogOptions } from "../types.js";
+export declare function createSendCogVariant(options: SendCogOptions): CogMutationVariant<SendCogOperation>;

package/dist/wallet/tx/cog/variants/send.js

@@ -0,0 +1,77 @@
+import { normalizeBtcTarget } from "../../targets.js";
+import { confirmSend } from "../confirm.js";
+import { createCogIntentFingerprint, createSendCogOpReturnData, normalizePositiveCogAmount, resolveIdentitySender, } from "../intent.js";
+import { createCogDraftMutation } from "../draft.js";
+import { createCogResult, createCogReuseResult, } from "../result.js";
+export function createSendCogVariant(options) {
+    const amountCogtoshi = normalizePositiveCogAmount(options.amountCogtoshi, "wallet_send_invalid_amount");
+    const recipient = normalizeBtcTarget(options.target);
+    return {
+        controlLockPurpose: "wallet-send",
+        preemptionReason: "wallet-send",
+        errorPrefix: "wallet_send",
+        repairRequiredErrorCode: "wallet_send_repair_required",
+        resolveOperation(readContext) {
+            const operation = resolveIdentitySender(readContext, "wallet_send", amountCogtoshi, options.fromIdentity);
+            if (operation.sender.scriptPubKeyHex === recipient.scriptPubKeyHex) {
+                throw new Error("wallet_send_self_transfer");
+            }
+            return {
+                ...operation,
+                amountCogtoshi,
+                recipient,
+            };
+        },
+        createIntentFingerprint(operation) {
+            return createCogIntentFingerprint([
+                "send",
+                operation.state.walletRootId,
+                operation.sender.scriptPubKeyHex,
+                operation.recipient.scriptPubKeyHex,
+                operation.amountCogtoshi,
+            ]);
+        },
+        confirm(operation) {
+            return confirmSend(options.prompter, operation.resolved, options.target, operation.recipient, operation.amountCogtoshi, options.assumeYes);
+        },
+        createDraftMutation({ operation, existingMutation, feeSelection, intentFingerprintHex, nowUnixMs }) {
+            return createCogDraftMutation({
+                kind: "send",
+                sender: operation.sender,
+                recipientScriptPubKeyHex: operation.recipient.scriptPubKeyHex,
+                amountCogtoshi: operation.amountCogtoshi,
+                intentFingerprintHex,
+                nowUnixMs,
+                feeSelection,
+                existing: existingMutation,
+            });
+        },
+        createOpReturnData(operation) {
+            return createSendCogOpReturnData(operation);
+        },
+        createReuseResult({ operation, mutation, resolution, fees }) {
+            return createCogReuseResult({
+                kind: "send",
+                mutation,
+                resolution,
+                fees,
+                amountCogtoshi: operation.amountCogtoshi,
+                recipientScriptPubKeyHex: operation.recipient.scriptPubKeyHex,
+                resolved: operation.resolved,
+            });
+        },
+        createResult({ operation, mutation, builtTxid, status, reusedExisting, fees }) {
+            return createCogResult({
+                kind: "send",
+                mutation,
+                builtTxid,
+                status,
+                reusedExisting,
+                fees,
+                amountCogtoshi: operation.amountCogtoshi,
+                recipientScriptPubKeyHex: operation.recipient.scriptPubKeyHex,
+                resolved: operation.resolved,
+            });
+        },
+    };
+}

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

@@ -1,96 +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 CogMutationKind = "send" | "lock" | "claim";
-interface WalletCogRpcClient extends WalletMutationRpcClient {
-    getBlockchainInfo(): Promise<{
-        blocks: number;
-    }>;
-    sendRawTransaction(hex: string): Promise<string>;
-    getRawTransaction(txid: string, verbose?: boolean): Promise<RpcTransaction>;
-}
-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 openWalletReadContext;
-    attachService?: typeof attachOrStartManagedBitcoindService;
-    rpcFactory?: (config: Parameters<typeof 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 openWalletReadContext;
-    attachService?: typeof attachOrStartManagedBitcoindService;
-    rpcFactory?: (config: Parameters<typeof 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 openWalletReadContext;
-    attachService?: typeof attachOrStartManagedBitcoindService;
-    rpcFactory?: (config: Parameters<typeof createRpcClient>[0]) => WalletCogRpcClient;
-}
-export interface ReclaimCogLockOptions extends Omit<ClaimCogLockOptions, "preimageHex"> {
-}
-export declare function sendCog(options: SendCogOptions): Promise<CogMutationResult>;
-export declare function lockCogToDomain(options: LockCogToDomainOptions): Promise<CogMutationResult>;
-export declare function claimCogLock(options: ClaimCogLockOptions): Promise<CogMutationResult>;
-export declare function reclaimCogLock(options: ReclaimCogLockOptions): Promise<CogMutationResult>;
-export {};
+export * from "./cog/index.js";