@cogcoin/client 1.1.8 → 1.1.10

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

@@ -0,0 +1,162 @@
+import type { lookupDomain } from "@cogcoin/indexer/queries";
+import type { RpcTransaction } from "../../../bitcoind/types.js";
+import type { WalletPrompter } from "../../lifecycle.js";
+import type { WalletReadContext } from "../../read/index.js";
+import type { WalletRuntimePaths } from "../../runtime.js";
+import type { WalletSecretProvider } from "../../state/provider.js";
+import type { PendingMutationRecord, WalletStateV1 } from "../../types.js";
+import type { BuiltWalletMutationTransaction, FixedWalletInput, MutationSender, WalletMutationFeeSummary, WalletMutationRpcClient } from "../common.js";
+export type DomainAdminKind = "endpoint" | "delegate" | "miner" | "canonical";
+export interface DomainAdminRpcClient extends WalletMutationRpcClient {
+    getBlockchainInfo(): Promise<{
+        blocks: number;
+    }>;
+    sendRawTransaction(hex: string): Promise<string>;
+    getRawTransaction(txid: string, verbose?: boolean): Promise<RpcTransaction>;
+}
+export interface DomainAdminPlan {
+    sender: MutationSender;
+    changeAddress: string;
+    fixedInputs: FixedWalletInput[];
+    outputs: unknown[];
+    changePosition: number;
+    expectedOpReturnScriptHex: string;
+    allowedFundingScriptPubKeyHex: string;
+    eligibleFundingOutpointKeys: Set<string>;
+    errorPrefix: string;
+}
+export type ReadyWalletReadContext = WalletReadContext & {
+    localState: {
+        availability: "ready";
+        state: WalletStateV1;
+    };
+    snapshot: NonNullable<WalletReadContext["snapshot"]>;
+    model: NonNullable<WalletReadContext["model"]>;
+};
+export interface DomainAdminOperation {
+    readContext: ReadyWalletReadContext;
+    state: WalletStateV1;
+    sender: MutationSender;
+    senderSelector: string;
+    chainDomain: NonNullable<ReturnType<typeof lookupDomain>>;
+}
+export interface StandaloneDomainAdminOperation extends DomainAdminOperation {
+    normalizedDomainName: string;
+    resolvedSender: DomainAdminResolvedSenderSummary;
+    payload: PreparedDomainAdminPayload;
+}
+export interface BuiltDomainAdminTransaction extends BuiltWalletMutationTransaction {
+}
+export interface DomainAdminResolvedSenderSummary {
+    selector: string;
+    localIndex: number;
+    scriptPubKeyHex: string;
+    address: string;
+}
+export interface DomainAdminResolvedTargetSummary {
+    scriptPubKeyHex: string;
+    address: string | null;
+    opaque: boolean;
+}
+export type DomainAdminResolvedEffect = {
+    kind: "endpoint-set";
+    byteLength: number;
+} | {
+    kind: "endpoint-clear";
+} | {
+    kind: "delegate-set";
+} | {
+    kind: "delegate-clear";
+} | {
+    kind: "miner-set";
+} | {
+    kind: "miner-clear";
+} | {
+    kind: "canonicalize-owner";
+};
+export interface DomainAdminResolvedSummary {
+    sender: DomainAdminResolvedSenderSummary;
+    target: DomainAdminResolvedTargetSummary | null;
+    effect: DomainAdminResolvedEffect;
+}
+export interface DomainAdminMutationResult {
+    kind: DomainAdminKind;
+    domainName: string;
+    txid: string;
+    status: "live" | "confirmed";
+    reusedExisting: boolean;
+    recipientScriptPubKeyHex?: string | null;
+    endpointValueHex?: string | null;
+    resolved?: DomainAdminResolvedSummary | null;
+    fees: WalletMutationFeeSummary;
+}
+export interface PreparedDomainAdminPayload {
+    opReturnData: Uint8Array;
+    recipientScriptPubKeyHex?: string | null;
+    endpointValueHex?: string | null;
+    resolvedTarget: DomainAdminResolvedTargetSummary | null;
+    resolvedEffect: DomainAdminResolvedEffect;
+}
+interface DomainAdminBaseOptions {
+    domainName: 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]) => DomainAdminRpcClient;
+}
+export interface SetDomainEndpointOptions extends DomainAdminBaseOptions {
+    source: {
+        kind: "text";
+        value: string;
+    } | {
+        kind: "json";
+        value: string;
+    } | {
+        kind: "bytes";
+        value: string;
+    };
+}
+export interface ClearDomainEndpointOptions extends DomainAdminBaseOptions {
+}
+export interface SetDomainDelegateOptions extends DomainAdminBaseOptions {
+    target: string;
+}
+export interface ClearDomainDelegateOptions extends DomainAdminBaseOptions {
+}
+export interface SetDomainMinerOptions extends DomainAdminBaseOptions {
+    target: string;
+}
+export interface ClearDomainMinerOptions extends DomainAdminBaseOptions {
+}
+export interface SetDomainCanonicalOptions extends DomainAdminBaseOptions {
+}
+export interface DomainAdminDraftMutationOptions {
+    kind: DomainAdminKind;
+    domainName: string;
+    sender: MutationSender;
+    intentFingerprintHex: string;
+    nowUnixMs: number;
+    feeSelection: {
+        feeRateSatVb: number;
+        source: "custom-satvb" | "estimated-next-block-plus-one" | "fallback-default";
+    };
+    recipientScriptPubKeyHex?: string | null;
+    endpointValueHex?: string | null;
+    existing?: PendingMutationRecord | null;
+}
+export interface DomainAdminVariant {
+    kind: DomainAdminKind;
+    errorPrefix: string;
+    requireRoot?: boolean;
+    intentParts(operation: DomainAdminOperation): Array<string | number | bigint>;
+    createPayload(operation: DomainAdminOperation): Promise<PreparedDomainAdminPayload>;
+    confirm(operation: DomainAdminOperation): Promise<void>;
+}
+export {};

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

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

package/dist/wallet/tx/domain-admin/variants/canonical.d.ts

@@ -0,0 +1,2 @@
+import type { DomainAdminVariant, SetDomainCanonicalOptions } from "../types.js";
+export declare function createCanonicalVariant(options: SetDomainCanonicalOptions): DomainAdminVariant;

package/dist/wallet/tx/domain-admin/variants/canonical.js

@@ -0,0 +1,22 @@
+import { serializeSetCanonical } from "../../../cogop/index.js";
+import { confirmCanonicalMutation } from "../confirm.js";
+import { createResolvedDomainAdminSenderSummary } from "../intent.js";
+export function createCanonicalVariant(options) {
+    return {
+        kind: "canonical",
+        errorPrefix: "wallet_domain_canonical",
+        intentParts(operation) {
+            return [operation.chainDomain.name, operation.sender.scriptPubKeyHex];
+        },
+        async createPayload(operation) {
+            return {
+                opReturnData: serializeSetCanonical(operation.chainDomain.domainId).opReturnData,
+                resolvedTarget: null,
+                resolvedEffect: { kind: "canonicalize-owner" },
+            };
+        },
+        async confirm(operation) {
+            await confirmCanonicalMutation(options.prompter, operation.chainDomain.name, createResolvedDomainAdminSenderSummary(operation.sender, operation.senderSelector), options.assumeYes);
+        },
+    };
+}

package/dist/wallet/tx/domain-admin/variants/delegate.d.ts

@@ -0,0 +1,3 @@
+import type { ClearDomainDelegateOptions, DomainAdminVariant, SetDomainDelegateOptions } from "../types.js";
+export declare function createSetDelegateVariant(options: SetDomainDelegateOptions): DomainAdminVariant;
+export declare function createClearDelegateVariant(options: ClearDomainDelegateOptions): DomainAdminVariant;

package/dist/wallet/tx/domain-admin/variants/delegate.js

@@ -0,0 +1,60 @@
+import { serializeSetDelegate } from "../../../cogop/index.js";
+import { confirmTargetMutation } from "../confirm.js";
+import { createResolvedDomainAdminSenderSummary, createResolvedDomainAdminTargetSummary, } from "../intent.js";
+import { normalizeBtcTarget } from "../../targets.js";
+export function createSetDelegateVariant(options) {
+    const target = normalizeBtcTarget(options.target);
+    return {
+        kind: "delegate",
+        errorPrefix: "wallet_domain_delegate",
+        intentParts(operation) {
+            return [operation.chainDomain.name, target.scriptPubKeyHex];
+        },
+        async createPayload(operation) {
+            if (target.scriptPubKeyHex === operation.sender.scriptPubKeyHex) {
+                throw new Error("wallet_domain_delegate_self_target");
+            }
+            return {
+                opReturnData: serializeSetDelegate(operation.chainDomain.domainId, Buffer.from(target.scriptPubKeyHex, "hex")).opReturnData,
+                recipientScriptPubKeyHex: target.scriptPubKeyHex,
+                resolvedTarget: createResolvedDomainAdminTargetSummary(target),
+                resolvedEffect: { kind: "delegate-set" },
+            };
+        },
+        async confirm(operation) {
+            await confirmTargetMutation(options.prompter, {
+                kind: "delegate",
+                domainName: operation.chainDomain.name,
+                target,
+                sender: createResolvedDomainAdminSenderSummary(operation.sender, operation.senderSelector),
+                assumeYes: options.assumeYes,
+            });
+        },
+    };
+}
+export function createClearDelegateVariant(options) {
+    return {
+        kind: "delegate",
+        errorPrefix: "wallet_domain_delegate",
+        intentParts(operation) {
+            return [operation.chainDomain.name, "clear"];
+        },
+        async createPayload(operation) {
+            return {
+                opReturnData: serializeSetDelegate(operation.chainDomain.domainId).opReturnData,
+                recipientScriptPubKeyHex: null,
+                resolvedTarget: null,
+                resolvedEffect: { kind: "delegate-clear" },
+            };
+        },
+        async confirm(operation) {
+            await confirmTargetMutation(options.prompter, {
+                kind: "delegate",
+                domainName: operation.chainDomain.name,
+                target: null,
+                sender: createResolvedDomainAdminSenderSummary(operation.sender, operation.senderSelector),
+                assumeYes: options.assumeYes,
+            });
+        },
+    };
+}

package/dist/wallet/tx/domain-admin/variants/endpoint.d.ts

@@ -0,0 +1,3 @@
+import type { ClearDomainEndpointOptions, DomainAdminVariant, SetDomainEndpointOptions } from "../types.js";
+export declare function createSetEndpointVariant(options: SetDomainEndpointOptions): Promise<DomainAdminVariant>;
+export declare function createClearEndpointVariant(options: ClearDomainEndpointOptions): DomainAdminVariant;

package/dist/wallet/tx/domain-admin/variants/endpoint.js

@@ -0,0 +1,102 @@
+import { readFile } from "node:fs/promises";
+import { resolve as resolvePath } from "node:path";
+import { serializeSetEndpoint } from "../../../cogop/index.js";
+import { confirmEndpointMutation, } from "../confirm.js";
+import { createResolvedDomainAdminSenderSummary, } from "../intent.js";
+async function loadEndpointPayload(source) {
+    if (source.kind === "text") {
+        const value = source.value;
+        if (value.length === 0) {
+            throw new Error("wallet_domain_endpoint_payload_missing");
+        }
+        return new TextEncoder().encode(value);
+    }
+    if (source.kind === "json") {
+        const value = source.value.trim();
+        if (value.length === 0) {
+            throw new Error("wallet_domain_endpoint_payload_missing");
+        }
+        try {
+            JSON.parse(value);
+        }
+        catch {
+            throw new Error("wallet_domain_endpoint_invalid_json");
+        }
+        return new TextEncoder().encode(value);
+    }
+    if (source.value.startsWith("hex:")) {
+        const hex = source.value.slice(4);
+        if (!/^[0-9a-f]+$/.test(hex) || hex.length % 2 !== 0) {
+            throw new Error("wallet_domain_endpoint_invalid_bytes");
+        }
+        if (hex.length === 0) {
+            throw new Error("wallet_domain_endpoint_payload_missing");
+        }
+        return Buffer.from(hex, "hex");
+    }
+    if (!source.value.startsWith("@")) {
+        throw new Error("wallet_domain_endpoint_invalid_bytes");
+    }
+    const filePath = source.value.slice(1);
+    if (filePath.trim() === "") {
+        throw new Error("wallet_domain_endpoint_invalid_bytes");
+    }
+    const payload = await readFile(resolvePath(process.cwd(), filePath));
+    if (payload.length === 0) {
+        throw new Error("wallet_domain_endpoint_payload_missing");
+    }
+    return payload;
+}
+export async function createSetEndpointVariant(options) {
+    const payloadBytes = await loadEndpointPayload(options.source);
+    return {
+        kind: "endpoint",
+        errorPrefix: "wallet_domain_endpoint",
+        intentParts(operation) {
+            return [operation.chainDomain.name, Buffer.from(payloadBytes).toString("hex")];
+        },
+        async createPayload(operation) {
+            return {
+                opReturnData: serializeSetEndpoint(operation.chainDomain.domainId, payloadBytes).opReturnData,
+                endpointValueHex: Buffer.from(payloadBytes).toString("hex"),
+                resolvedTarget: null,
+                resolvedEffect: {
+                    kind: "endpoint-set",
+                    byteLength: payloadBytes.length,
+                },
+            };
+        },
+        async confirm(operation) {
+            await confirmEndpointMutation(options.prompter, operation.chainDomain.name, payloadBytes, {
+                clear: false,
+                sender: createResolvedDomainAdminSenderSummary(operation.sender, operation.senderSelector),
+                sourceKind: options.source.kind,
+                assumeYes: options.assumeYes,
+            });
+        },
+    };
+}
+export function createClearEndpointVariant(options) {
+    return {
+        kind: "endpoint",
+        errorPrefix: "wallet_domain_endpoint",
+        intentParts(operation) {
+            return [operation.chainDomain.name, "clear"];
+        },
+        async createPayload(operation) {
+            return {
+                opReturnData: serializeSetEndpoint(operation.chainDomain.domainId).opReturnData,
+                endpointValueHex: "",
+                resolvedTarget: null,
+                resolvedEffect: { kind: "endpoint-clear" },
+            };
+        },
+        async confirm(operation) {
+            await confirmEndpointMutation(options.prompter, operation.chainDomain.name, new Uint8Array(), {
+                clear: true,
+                sender: createResolvedDomainAdminSenderSummary(operation.sender, operation.senderSelector),
+                assumeYes: options.assumeYes,
+            });
+        },
+    };
+}

package/dist/wallet/tx/domain-admin/variants/miner.d.ts

@@ -0,0 +1,3 @@
+import type { ClearDomainMinerOptions, DomainAdminVariant, SetDomainMinerOptions } from "../types.js";
+export declare function createSetMinerVariant(options: SetDomainMinerOptions): DomainAdminVariant;
+export declare function createClearMinerVariant(options: ClearDomainMinerOptions): DomainAdminVariant;

package/dist/wallet/tx/domain-admin/variants/miner.js

@@ -0,0 +1,59 @@
+import { serializeSetMiner } from "../../../cogop/index.js";
+import { confirmTargetMutation } from "../confirm.js";
+import { createResolvedDomainAdminSenderSummary, createResolvedDomainAdminTargetSummary, } from "../intent.js";
+import { normalizeBtcTarget } from "../../targets.js";
+export function createSetMinerVariant(options) {
+    const target = normalizeBtcTarget(options.target);
+    return {
+        kind: "miner",
+        errorPrefix: "wallet_domain_miner",
+        requireRoot: true,
+        intentParts(operation) {
+            return [operation.chainDomain.name, target.scriptPubKeyHex];
+        },
+        async createPayload(operation) {
+            return {
+                opReturnData: serializeSetMiner(operation.chainDomain.domainId, Buffer.from(target.scriptPubKeyHex, "hex")).opReturnData,
+                recipientScriptPubKeyHex: target.scriptPubKeyHex,
+                resolvedTarget: createResolvedDomainAdminTargetSummary(target),
+                resolvedEffect: { kind: "miner-set" },
+            };
+        },
+        async confirm(operation) {
+            await confirmTargetMutation(options.prompter, {
+                kind: "miner",
+                domainName: operation.chainDomain.name,
+                target,
+                sender: createResolvedDomainAdminSenderSummary(operation.sender, operation.senderSelector),
+                assumeYes: options.assumeYes,
+            });
+        },
+    };
+}
+export function createClearMinerVariant(options) {
+    return {
+        kind: "miner",
+        errorPrefix: "wallet_domain_miner",
+        requireRoot: true,
+        intentParts(operation) {
+            return [operation.chainDomain.name, "clear"];
+        },
+        async createPayload(operation) {
+            return {
+                opReturnData: serializeSetMiner(operation.chainDomain.domainId).opReturnData,
+                recipientScriptPubKeyHex: null,
+                resolvedTarget: null,
+                resolvedEffect: { kind: "miner-clear" },
+            };
+        },
+        async confirm(operation) {
+            await confirmTargetMutation(options.prompter, {
+                kind: "miner",
+                domainName: operation.chainDomain.name,
+                target: null,
+                sender: createResolvedDomainAdminSenderSummary(operation.sender, operation.senderSelector),
+                assumeYes: options.assumeYes,
+            });
+        },
+    };
+}

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

@@ -1,107 +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 DomainAdminKind = "endpoint" | "delegate" | "miner" | "canonical";
-interface DomainAdminRpcClient extends WalletMutationRpcClient {
-    getBlockchainInfo(): Promise<{
-        blocks: number;
-    }>;
-    sendRawTransaction(hex: string): Promise<string>;
-    getRawTransaction(txid: string, verbose?: boolean): Promise<RpcTransaction>;
-}
-export interface DomainAdminResolvedSenderSummary {
-    selector: string;
-    localIndex: number;
-    scriptPubKeyHex: string;
-    address: string;
-}
-export interface DomainAdminResolvedTargetSummary {
-    scriptPubKeyHex: string;
-    address: string | null;
-    opaque: boolean;
-}
-export type DomainAdminResolvedEffect = {
-    kind: "endpoint-set";
-    byteLength: number;
-} | {
-    kind: "endpoint-clear";
-} | {
-    kind: "delegate-set";
-} | {
-    kind: "delegate-clear";
-} | {
-    kind: "miner-set";
-} | {
-    kind: "miner-clear";
-} | {
-    kind: "canonicalize-owner";
-};
-export interface DomainAdminResolvedSummary {
-    sender: DomainAdminResolvedSenderSummary;
-    target: DomainAdminResolvedTargetSummary | null;
-    effect: DomainAdminResolvedEffect;
-}
-export interface DomainAdminMutationResult {
-    kind: DomainAdminKind;
-    domainName: string;
-    txid: string;
-    status: "live" | "confirmed";
-    reusedExisting: boolean;
-    recipientScriptPubKeyHex?: string | null;
-    endpointValueHex?: string | null;
-    resolved?: DomainAdminResolvedSummary | null;
-    fees: WalletMutationFeeSummary;
-}
-interface DomainAdminBaseOptions {
-    domainName: 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]) => DomainAdminRpcClient;
-}
-export interface SetDomainEndpointOptions extends DomainAdminBaseOptions {
-    source: {
-        kind: "text";
-        value: string;
-    } | {
-        kind: "json";
-        value: string;
-    } | {
-        kind: "bytes";
-        value: string;
-    };
-}
-export interface ClearDomainEndpointOptions extends DomainAdminBaseOptions {
-}
-export interface SetDomainDelegateOptions extends DomainAdminBaseOptions {
-    target: string;
-}
-export interface ClearDomainDelegateOptions extends DomainAdminBaseOptions {
-}
-export interface SetDomainMinerOptions extends DomainAdminBaseOptions {
-    target: string;
-}
-export interface ClearDomainMinerOptions extends DomainAdminBaseOptions {
-}
-export interface SetDomainCanonicalOptions extends DomainAdminBaseOptions {
-}
-export declare function setDomainEndpoint(options: SetDomainEndpointOptions): Promise<DomainAdminMutationResult>;
-export declare function clearDomainEndpoint(options: ClearDomainEndpointOptions): Promise<DomainAdminMutationResult>;
-export declare function setDomainDelegate(options: SetDomainDelegateOptions): Promise<DomainAdminMutationResult>;
-export declare function clearDomainDelegate(options: ClearDomainDelegateOptions): Promise<DomainAdminMutationResult>;
-export declare function setDomainMiner(options: SetDomainMinerOptions): Promise<DomainAdminMutationResult>;
-export declare function clearDomainMiner(options: ClearDomainMinerOptions): Promise<DomainAdminMutationResult>;
-export declare function setDomainCanonical(options: SetDomainCanonicalOptions): Promise<DomainAdminMutationResult>;
-export {};
+export * from "./domain-admin/index.js";