@cogcoin/client 1.1.8 → 1.1.9

package/dist/wallet/tx/register/draft.js

@@ -0,0 +1,181 @@
+import { randomBytes } from "node:crypto";
+import { lookupDomain } from "@cogcoin/indexer/queries";
+import { createWalletMutationFeeMetadata, saveWalletStatePreservingUnlock, unlockTemporaryBuilderLocks, updateMutationRecord, } from "../common.js";
+import { upsertPendingMutation } from "../journal.js";
+export function reserveLocalDomainRecord(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,
+                currentOwnerScriptPubKeyHex: options.sender.scriptPubKeyHex,
+                birthTime: domain.birthTime ?? Math.floor(options.nowUnixMs / 1000),
+            };
+        })
+        : [
+            ...options.state.domains,
+            {
+                name: options.domainName,
+                domainId: null,
+                currentOwnerScriptPubKeyHex: options.sender.scriptPubKeyHex,
+                canonicalChainStatus: "unknown",
+                foundingMessageText: existing?.foundingMessageText ?? null,
+                birthTime: Math.floor(options.nowUnixMs / 1000),
+            },
+        ];
+    return {
+        ...options.state,
+        domains,
+    };
+}
+export function getMutationStatusAfterAcceptance(options) {
+    const chainRecord = options.snapshot === null ? null : lookupDomain(options.snapshot.state, options.domainName);
+    if (chainRecord === null) {
+        return "live";
+    }
+    return Buffer.from(chainRecord.ownerScriptPubKey).toString("hex") === options.senderScriptPubKeyHex
+        ? "confirmed"
+        : "live";
+}
+export function createRegisterDraftMutation(options) {
+    if (options.existing !== null && options.existing !== undefined) {
+        return {
+            ...options.existing,
+            registerKind: options.registerKind,
+            parentDomainName: options.parentDomainName,
+            senderScriptPubKeyHex: options.sender.scriptPubKeyHex,
+            senderLocalIndex: options.sender.localIndex,
+            status: "draft",
+            lastUpdatedAtUnixMs: options.nowUnixMs,
+            attemptedTxid: null,
+            attemptedWtxid: null,
+            ...createWalletMutationFeeMetadata(options.feeSelection),
+            temporaryBuilderLockedOutpoints: [],
+        };
+    }
+    return {
+        mutationId: randomBytes(12).toString("hex"),
+        kind: "register",
+        registerKind: options.registerKind,
+        domainName: options.domainName,
+        parentDomainName: options.parentDomainName,
+        senderScriptPubKeyHex: options.sender.scriptPubKeyHex,
+        senderLocalIndex: options.sender.localIndex,
+        intentFingerprintHex: options.intentFingerprintHex,
+        status: "draft",
+        createdAtUnixMs: options.nowUnixMs,
+        lastUpdatedAtUnixMs: options.nowUnixMs,
+        attemptedTxid: null,
+        attemptedWtxid: null,
+        ...createWalletMutationFeeMetadata(options.feeSelection),
+        temporaryBuilderLockedOutpoints: [],
+    };
+}
+export async function reconcilePendingRegisterMutation(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 chainOwnerHex = Buffer.from(chainDomain.ownerScriptPubKey).toString("hex");
+        if (chainOwnerHex !== options.sender.scriptPubKeyHex) {
+            const repairMutation = updateMutationRecord(options.mutation, "repair-required", options.nowUnixMs, {
+                temporaryBuilderLockedOutpoints: [],
+            });
+            const nextState = upsertPendingMutation(options.state, repairMutation);
+            await saveWalletStatePreservingUnlock({
+                state: nextState,
+                provider: options.provider,
+                nowUnixMs: options.nowUnixMs,
+                paths: options.paths,
+            });
+            return {
+                state: nextState,
+                mutation: repairMutation,
+                resolution: "repair-required",
+            };
+        }
+        await unlockTemporaryBuilderLocks(options.rpc, options.walletName, options.mutation.temporaryBuilderLockedOutpoints);
+        const confirmedMutation = updateMutationRecord(options.mutation, "confirmed", options.nowUnixMs, {
+            temporaryBuilderLockedOutpoints: [],
+        });
+        const nextState = reserveLocalDomainRecord({
+            state: upsertPendingMutation(options.state, confirmedMutation),
+            domainName: options.mutation.domainName,
+            sender: options.sender,
+            nowUnixMs: options.nowUnixMs,
+        });
+        await saveWalletStatePreservingUnlock({
+            state: nextState,
+            provider: options.provider,
+            nowUnixMs: options.nowUnixMs,
+            paths: options.paths,
+        });
+        return {
+            state: nextState,
+            mutation: confirmedMutation,
+            resolution: "confirmed",
+        };
+    }
+    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 liveMutation = updateMutationRecord(options.mutation, "live", options.nowUnixMs, {
+                temporaryBuilderLockedOutpoints: [],
+            });
+            const nextState = reserveLocalDomainRecord({
+                state: upsertPendingMutation(options.state, liveMutation),
+                domainName: options.mutation.domainName,
+                sender: options.sender,
+                nowUnixMs: options.nowUnixMs,
+            });
+            await saveWalletStatePreservingUnlock({
+                state: nextState,
+                provider: options.provider,
+                nowUnixMs: options.nowUnixMs,
+                paths: options.paths,
+            });
+            return {
+                state: nextState,
+                mutation: liveMutation,
+                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 canceledMutation = updateMutationRecord(options.mutation, "canceled", options.nowUnixMs, {
+            temporaryBuilderLockedOutpoints: [],
+        });
+        const nextState = upsertPendingMutation(options.state, canceledMutation);
+        await saveWalletStatePreservingUnlock({
+            state: nextState,
+            provider: options.provider,
+            nowUnixMs: options.nowUnixMs,
+            paths: options.paths,
+        });
+        return {
+            state: nextState,
+            mutation: canceledMutation,
+            resolution: "not-seen",
+        };
+    }
+    return {
+        state: options.state,
+        mutation: options.mutation,
+        resolution: "continue",
+    };
+}

package/dist/wallet/tx/register/index.d.ts

@@ -0,0 +1,6 @@
+import { type RegisterDomainOptions } from "./intent.js";
+import { type RegisterDomainResult } from "./result.js";
+export { extractOpReturnPayloadFromScriptHex } from "./plan.js";
+export type { RegisterDomainOptions } from "./intent.js";
+export type { RegisterDomainResult } from "./result.js";
+export declare function registerDomain(options: RegisterDomainOptions): Promise<RegisterDomainResult>;

package/dist/wallet/tx/register/index.js

@@ -0,0 +1,158 @@
+import { loadBundledGenesisParameters } from "@cogcoin/indexer";
+import { buildWalletMutationTransactionWithReserveFallback, mergeFixedWalletInputs, updateMutationRecord, } from "../common.js";
+import { executeWalletMutationOperation, publishWalletMutation, resolveExistingWalletMutation, } from "../executor.js";
+import { upsertPendingMutation } from "../journal.js";
+import { confirmRootRegistration, confirmSubdomainRegistration, findCompetingRootRegistrationTxids, } from "./confirm.js";
+import { createRegisterDraftMutation, getMutationStatusAfterAcceptance, reconcilePendingRegisterMutation, reserveLocalDomainRecord, } from "./draft.js";
+import { createRegisterOperationFingerprint, normalizeRegisterDomainName, resolveRegisterOperation, } from "./intent.js";
+import { buildRegisterPlan, buildRegisterTransaction, extractOpReturnPayloadFromScriptHex, } from "./plan.js";
+import { createRegisterResult, createRegisterReuseResult, } from "./result.js";
+import { serializeDomainReg } from "../../cogop/index.js";
+export { extractOpReturnPayloadFromScriptHex } from "./plan.js";
+export async function registerDomain(options) {
+    if (!options.prompter.isInteractive && options.assumeYes !== true) {
+        throw new Error("wallet_register_requires_tty");
+    }
+    const normalizedDomainName = normalizeRegisterDomainName(options.domainName);
+    const execution = await executeWalletMutationOperation({
+        ...options,
+        controlLockPurpose: "wallet-register",
+        preemptionReason: "wallet-register",
+        async resolveOperation(readContext) {
+            return resolveRegisterOperation({
+                readContext,
+                normalizedDomainName,
+                fromIdentity: options.fromIdentity,
+                loadGenesisParameters: options.loadGenesisParameters ?? loadBundledGenesisParameters,
+            });
+        },
+        createIntentFingerprint(operation) {
+            return createRegisterOperationFingerprint(operation);
+        },
+        async resolveExistingMutation({ operation, existingMutation, execution }) {
+            if (existingMutation === null) {
+                return { state: operation.state, replacementFixedInputs: null, result: null };
+            }
+            return resolveExistingWalletMutation({
+                existingMutation,
+                execution,
+                repairRequiredErrorCode: "wallet_register_repair_required",
+                reconcileExistingMutation: (mutation) => reconcilePendingRegisterMutation({
+                    state: operation.state,
+                    mutation,
+                    provider: execution.provider,
+                    nowUnixMs: execution.nowUnixMs,
+                    paths: execution.paths,
+                    rpc: execution.rpc,
+                    walletName: execution.walletName,
+                    context: execution.readContext,
+                    sender: operation.senderResolution.sender,
+                }),
+                createReuseResult: ({ mutation, resolution, fees }) => createRegisterReuseResult({
+                    operation,
+                    mutation,
+                    resolution,
+                    fees,
+                }),
+            });
+        },
+        async confirm({ operation, execution }) {
+            if (operation.senderResolution.registerKind === "root") {
+                const competingRootTxids = await findCompetingRootRegistrationTxids(execution.rpc, operation.normalizedDomainName);
+                if (competingRootTxids.length > 0 && !options.forceRace) {
+                    throw new Error("wallet_register_root_race_detected");
+                }
+                await confirmRootRegistration(options.prompter, operation.normalizedDomainName, operation.resolvedSummary, competingRootTxids.length > 0, options.assumeYes);
+                return;
+            }
+            await confirmSubdomainRegistration(options.prompter, operation.normalizedDomainName, operation.resolvedSummary, options.assumeYes);
+        },
+        createDraftMutation({ operation, existingMutation, execution, intentFingerprintHex }) {
+            return {
+                mutation: createRegisterDraftMutation({
+                    domainName: operation.normalizedDomainName,
+                    parentDomainName: operation.senderResolution.parentDomainName,
+                    sender: operation.senderResolution.sender,
+                    registerKind: operation.senderResolution.registerKind,
+                    intentFingerprintHex,
+                    nowUnixMs: execution.nowUnixMs,
+                    feeSelection: execution.feeSelection,
+                    existing: existingMutation,
+                }),
+                prepared: null,
+            };
+        },
+        async build({ operation, state, execution, replacementFixedInputs }) {
+            const plan = buildRegisterPlan({
+                context: execution.readContext,
+                state,
+                allUtxos: await execution.rpc.listUnspent(execution.walletName, 1),
+                sender: operation.senderResolution.sender,
+                registerKind: operation.senderResolution.registerKind,
+                domainName: operation.normalizedDomainName,
+                parentDomainName: operation.senderResolution.parentDomainName,
+                treasuryAddress: operation.genesis.treasuryAddress,
+                treasuryScriptPubKeyHex: Buffer.from(operation.genesis.treasuryScriptPubKey).toString("hex"),
+                rootPriceSats: operation.rootPriceSats,
+                serializeDomainReg: (domainName) => serializeDomainReg(domainName),
+            });
+            return buildRegisterTransaction({
+                rpc: execution.rpc,
+                walletName: execution.walletName,
+                state,
+                plan: {
+                    ...plan,
+                    fixedInputs: mergeFixedWalletInputs(plan.fixedInputs, replacementFixedInputs),
+                },
+                feeRateSatVb: execution.feeSelection.feeRateSatVb,
+            });
+        },
+        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: "wallet_register",
+                async afterAccepted({ state: acceptedState, broadcastingMutation, built, nowUnixMs }) {
+                    const finalStatus = getMutationStatusAfterAcceptance({
+                        snapshot: execution.readContext.snapshot,
+                        domainName: operation.normalizedDomainName,
+                        senderScriptPubKeyHex: operation.senderResolution.sender.scriptPubKeyHex,
+                    });
+                    const finalMutation = updateMutationRecord(broadcastingMutation, finalStatus, nowUnixMs, {
+                        attemptedTxid: built.txid,
+                        attemptedWtxid: built.wtxid,
+                        temporaryBuilderLockedOutpoints: [],
+                    });
+                    return {
+                        state: reserveLocalDomainRecord({
+                            state: upsertPendingMutation(acceptedState, finalMutation),
+                            domainName: operation.normalizedDomainName,
+                            sender: operation.senderResolution.sender,
+                            nowUnixMs,
+                        }),
+                        mutation: finalMutation,
+                        status: finalStatus,
+                    };
+                },
+            });
+        },
+        createResult({ operation, mutation, built, status, reusedExisting, fees }) {
+            return createRegisterResult({
+                operation,
+                mutation,
+                builtTxid: built?.txid ?? null,
+                status: status,
+                reusedExisting,
+                fees,
+            });
+        },
+    });
+    return execution.result;
+}

package/dist/wallet/tx/register/intent.d.ts

@@ -0,0 +1,74 @@
+import { loadBundledGenesisParameters } from "@cogcoin/indexer";
+import { attachOrStartManagedBitcoindService } from "../../../bitcoind/service.js";
+import { createRpcClient } from "../../../bitcoind/node.js";
+import type { WalletPrompter } from "../../lifecycle.js";
+import { openWalletReadContext, type WalletReadContext } from "../../read/index.js";
+import type { WalletRuntimePaths } from "../../runtime.js";
+import type { WalletSecretProvider } from "../../state/provider.js";
+import type { WalletStateV1 } from "../../types.js";
+import { type BuiltWalletMutationTransaction, type MutationSender, type WalletMutationRpcClient } from "../common.js";
+import { type RegisterResolvedSummary } from "./result.js";
+export interface WalletRegisterRpcClient extends WalletMutationRpcClient {
+    getBlockchainInfo(): Promise<{
+        blocks: number;
+    }>;
+    sendRawTransaction(hex: string): Promise<string>;
+    getRawMempool(): Promise<string[]>;
+    getRawTransaction(txid: string, verbose?: boolean): Promise<import("../../../bitcoind/types.js").RpcTransaction>;
+}
+export type BuiltRegisterTransaction = BuiltWalletMutationTransaction;
+export interface RegisterDomainOptions {
+    domainName: string;
+    fromIdentity?: string | null;
+    feeRateSatVb?: number | null;
+    dataDir: string;
+    databasePath: string;
+    forceRace?: boolean;
+    provider?: WalletSecretProvider;
+    prompter: WalletPrompter;
+    assumeYes?: boolean;
+    nowUnixMs?: number;
+    paths?: WalletRuntimePaths;
+    openReadContext?: typeof openWalletReadContext;
+    attachService?: typeof attachOrStartManagedBitcoindService;
+    rpcFactory?: (config: Parameters<typeof createRpcClient>[0]) => WalletRegisterRpcClient;
+    loadGenesisParameters?: typeof loadBundledGenesisParameters;
+}
+export interface ResolvedRegisterSender {
+    registerKind: "root" | "subdomain";
+    parentDomainName: string | null;
+    sender: MutationSender;
+    senderSelector: string;
+}
+export interface RegisterMutationOperation {
+    state: WalletStateV1;
+    normalizedDomainName: string;
+    senderResolution: ResolvedRegisterSender;
+    rootPriceSats: bigint;
+    resolvedSummary: RegisterResolvedSummary;
+    genesis: Awaited<ReturnType<typeof loadBundledGenesisParameters>>;
+}
+export declare function normalizeRegisterDomainName(domainName: string): string;
+export declare function resolveRegisterSender(context: WalletReadContext & {
+    localState: {
+        availability: "ready";
+        state: WalletStateV1;
+    };
+    snapshot: NonNullable<WalletReadContext["snapshot"]>;
+    model: NonNullable<WalletReadContext["model"]>;
+}, domainName: string, fromIdentity: string | null | undefined): ResolvedRegisterSender;
+export declare function createRegisterResolvedSummary(options: {
+    registerKind: "root" | "subdomain";
+    parentDomainName: string | null;
+    senderSelector: string;
+    sender: MutationSender;
+    economicEffectKind: "treasury-payment" | "cog-burn";
+    economicEffectAmount: bigint;
+}): RegisterResolvedSummary;
+export declare function resolveRegisterOperation(options: {
+    readContext: WalletReadContext;
+    normalizedDomainName: string;
+    fromIdentity?: string | null;
+    loadGenesisParameters?: typeof loadBundledGenesisParameters;
+}): Promise<RegisterMutationOperation>;
+export declare function createRegisterOperationFingerprint(operation: RegisterMutationOperation): string;

package/dist/wallet/tx/register/intent.js

@@ -0,0 +1,119 @@
+import { createHash } from "node:crypto";
+import { loadBundledGenesisParameters } from "@cogcoin/indexer";
+import { getBalance, getParent, lookupDomain } from "@cogcoin/indexer/queries";
+import { attachOrStartManagedBitcoindService } from "../../../bitcoind/service.js";
+import { createRpcClient } from "../../../bitcoind/node.js";
+import { openWalletReadContext } from "../../read/index.js";
+import { computeRootRegistrationPriceSats, serializeDomainReg } from "../../cogop/index.js";
+import { assertWalletMutationContextReady, createFundingMutationSender, isLocalWalletScript, } from "../common.js";
+import { SUBDOMAIN_REGISTRATION_FEE_COGTOSHI, } from "./result.js";
+function normalizeDomainName(domainName) {
+    const normalized = domainName.trim().toLowerCase();
+    if (normalized.length === 0) {
+        throw new Error("wallet_register_missing_domain");
+    }
+    serializeDomainReg(normalized);
+    return normalized;
+}
+function createRegisterIntentFingerprint(options) {
+    return createHash("sha256")
+        .update([
+        "register",
+        options.walletRootId,
+        options.domainName,
+        options.registerKind,
+        options.senderScriptPubKeyHex,
+    ].join("\n"))
+        .digest("hex");
+}
+export function normalizeRegisterDomainName(domainName) {
+    return normalizeDomainName(domainName);
+}
+export function resolveRegisterSender(context, domainName, fromIdentity) {
+    const state = context.localState.state;
+    if (context.model.walletAddress === null) {
+        throw new Error("wallet_register_funding_identity_unavailable");
+    }
+    void fromIdentity;
+    if (!domainName.includes("-")) {
+        return {
+            registerKind: "root",
+            parentDomainName: null,
+            senderSelector: context.model.walletAddress,
+            sender: createFundingMutationSender(state),
+        };
+    }
+    const parent = getParent(context.snapshot.state, domainName);
+    if (parent === null) {
+        throw new Error("wallet_register_parent_not_found");
+    }
+    if (!parent.domain.anchored) {
+        throw new Error("wallet_register_parent_not_anchored");
+    }
+    const parentDomain = context.model.domains.find((domain) => domain.name === parent.parentName) ?? null;
+    if (!isLocalWalletScript(state, parentDomain?.ownerScriptPubKeyHex)) {
+        throw new Error("wallet_register_parent_not_locally_controlled");
+    }
+    if (getBalance(context.snapshot.state, state.funding.scriptPubKeyHex) < SUBDOMAIN_REGISTRATION_FEE_COGTOSHI) {
+        throw new Error("wallet_register_insufficient_cog_balance");
+    }
+    return {
+        registerKind: "subdomain",
+        parentDomainName: parent.parentName,
+        senderSelector: context.model.walletAddress,
+        sender: createFundingMutationSender(state),
+    };
+}
+export function createRegisterResolvedSummary(options) {
+    return {
+        path: options.registerKind,
+        parentDomainName: options.parentDomainName,
+        sender: {
+            selector: options.senderSelector,
+            localIndex: options.sender.localIndex,
+            scriptPubKeyHex: options.sender.scriptPubKeyHex,
+            address: options.sender.address,
+        },
+        economicEffect: {
+            kind: options.economicEffectKind,
+            amount: options.economicEffectAmount,
+        },
+    };
+}
+export async function resolveRegisterOperation(options) {
+    assertWalletMutationContextReady(options.readContext, "wallet_register");
+    const state = options.readContext.localState.state;
+    const senderResolution = resolveRegisterSender(options.readContext, options.normalizedDomainName, options.fromIdentity);
+    if (lookupDomain(options.readContext.snapshot.state, options.normalizedDomainName) !== null) {
+        throw new Error("wallet_register_domain_already_registered");
+    }
+    if (options.readContext.snapshot.state.consensus.nextDomainId === 0xffff_ffff) {
+        throw new Error("wallet_register_next_domain_id_exhausted");
+    }
+    const rootPriceSats = computeRootRegistrationPriceSats(options.normalizedDomainName);
+    const resolvedSummary = createRegisterResolvedSummary({
+        registerKind: senderResolution.registerKind,
+        parentDomainName: senderResolution.parentDomainName,
+        senderSelector: senderResolution.senderSelector,
+        sender: senderResolution.sender,
+        economicEffectKind: senderResolution.registerKind === "root" ? "treasury-payment" : "cog-burn",
+        economicEffectAmount: senderResolution.registerKind === "root" ? rootPriceSats : SUBDOMAIN_REGISTRATION_FEE_COGTOSHI,
+    });
+    const genesis = await (options.loadGenesisParameters ?? loadBundledGenesisParameters)();
+    return {
+        state,
+        normalizedDomainName: options.normalizedDomainName,
+        senderResolution,
+        rootPriceSats,
+        resolvedSummary,
+        genesis,
+    };
+}
+export function createRegisterOperationFingerprint(operation) {
+    return createRegisterIntentFingerprint({
+        walletRootId: operation.state.walletRootId,
+        domainName: operation.normalizedDomainName,
+        registerKind: operation.senderResolution.registerKind,
+        senderScriptPubKeyHex: operation.senderResolution.sender.scriptPubKeyHex,
+    });
+}

package/dist/wallet/tx/register/plan.d.ts

@@ -0,0 +1,43 @@
+import type { RpcDecodedPsbt, RpcListUnspentEntry, RpcWalletCreateFundedPsbtResult } from "../../../bitcoind/types.js";
+import type { WalletReadContext } from "../../read/index.js";
+import type { WalletStateV1 } from "../../types.js";
+import { type FixedWalletInput, type MutationSender } from "../common.js";
+import type { BuiltRegisterTransaction, WalletRegisterRpcClient } from "./intent.js";
+export interface RegisterTransactionPlan {
+    registerKind: "root" | "subdomain";
+    sender: MutationSender;
+    changeAddress: string;
+    fixedInputs: FixedWalletInput[];
+    outputs: unknown[];
+    changePosition: number;
+    expectedOpReturnScriptHex: string;
+    expectedTreasuryOutputIndex: number | null;
+    expectedTreasuryScriptHex: string | null;
+    expectedTreasuryValueSats: bigint | null;
+    allowedFundingScriptPubKeyHex: string;
+    eligibleFundingOutpointKeys: Set<string>;
+}
+export declare function extractOpReturnPayloadFromScriptHex(scriptHex: string): Uint8Array | null;
+export declare function validateFundedDraft(decoded: RpcDecodedPsbt, funded: RpcWalletCreateFundedPsbtResult, plan: RegisterTransactionPlan): void;
+export declare function buildRegisterPlan(options: {
+    context: WalletReadContext;
+    state: WalletStateV1;
+    allUtxos: RpcListUnspentEntry[];
+    sender: MutationSender;
+    registerKind: "root" | "subdomain";
+    domainName: string;
+    parentDomainName: string | null;
+    treasuryAddress: string;
+    treasuryScriptPubKeyHex: string;
+    rootPriceSats: bigint;
+    serializeDomainReg(domainName: string): {
+        opReturnData: Uint8Array;
+    };
+}): RegisterTransactionPlan;
+export declare function buildRegisterTransaction(options: {
+    rpc: WalletRegisterRpcClient;
+    walletName: string;
+    state: WalletStateV1;
+    plan: RegisterTransactionPlan;
+    feeRateSatVb: number;
+}): Promise<BuiltRegisterTransaction>;