@cogcoin/client 0.5.0

package/dist/wallet/cogop/index.js

@@ -0,0 +1,213 @@
+import { COG_OPCODES, COG_PREFIX, FIELD_FORMAT_BYTES, MAX_OP_RETURN_BYTES, MIN_OP_RETURN_BYTES, } from "./constants.js";
+import { writeU8, writeU32BE, writeU64BE } from "./numeric.js";
+import { validateExternalScriptPubKey, writeLenPrefixedSpk } from "./scriptpubkey.js";
+import { validateDomainName, validateFieldName } from "./validate-name.js";
+function concatParts(parts) {
+    const total = parts.reduce((sum, part) => sum + part.length, 0);
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const part of parts) {
+        out.set(part, offset);
+        offset += part.length;
+    }
+    return out;
+}
+function ensureIdentifier(value, errorCode) {
+    if (!Number.isInteger(value) || value <= 0 || value > 0xffffffff) {
+        throw new Error(errorCode);
+    }
+}
+function ensureBytes32(value, errorCode) {
+    if (value.length !== 32) {
+        throw new Error(errorCode);
+    }
+}
+function ensureSentence60(value, errorCode) {
+    if (value.length !== 60) {
+        throw new Error(errorCode);
+    }
+}
+function ensurePayloadLength(payload) {
+    if (payload.length < MIN_OP_RETURN_BYTES || payload.length > MAX_OP_RETURN_BYTES) {
+        throw new Error("wallet_cogop_payload_out_of_range");
+    }
+    return payload;
+}
+function writeAsciiName(name, validator) {
+    validator(name);
+    return new TextEncoder().encode(name);
+}
+function createPayload(opcode, ...parts) {
+    return ensurePayloadLength(concatParts([COG_PREFIX, writeU8(opcode), ...parts]));
+}
+export function computeRootRegistrationPriceSats(rootName) {
+    validateDomainName(rootName);
+    switch (rootName.length) {
+        case 1:
+            return 10000000000n;
+        case 2:
+            return 1000000000n;
+        case 3:
+            return 100000000n;
+        case 4:
+            return 10000000n;
+        case 5:
+            return 1000000n;
+        default:
+            return 100000n;
+    }
+}
+export function serializeMine(domainId, referencedBlockHashInternal, sentence60, minerData) {
+    ensureIdentifier(domainId, "wallet_cogop_invalid_domain_id");
+    ensureBytes32(referencedBlockHashInternal, "wallet_cogop_invalid_block_hash");
+    ensureSentence60(sentence60, "wallet_cogop_invalid_sentence");
+    if (minerData !== undefined && minerData.length > 8) {
+        throw new Error("wallet_cogop_invalid_miner_data_length");
+    }
+    return {
+        opReturnData: createPayload(COG_OPCODES.MINE, writeU32BE(domainId), referencedBlockHashInternal.slice(0, 4), sentence60, minerData ?? new Uint8Array()),
+    };
+}
+export function serializeCogTransfer(amount, recipientSpk) {
+    if (amount <= 0n) {
+        throw new Error("wallet_cogop_invalid_amount");
+    }
+    return {
+        opReturnData: createPayload(COG_OPCODES.COG_TRANSFER, writeU64BE(amount), writeLenPrefixedSpk(recipientSpk)),
+    };
+}
+export function serializeCogLock(amount, timeoutHeight, recipientDomainId, condition32) {
+    if (amount <= 0n) {
+        throw new Error("wallet_cogop_invalid_amount");
+    }
+    ensureIdentifier(recipientDomainId, "wallet_cogop_invalid_domain_id");
+    ensureBytes32(condition32, "wallet_cogop_invalid_condition");
+    return {
+        opReturnData: createPayload(COG_OPCODES.COG_LOCK, writeU64BE(amount), writeU32BE(timeoutHeight), writeU32BE(recipientDomainId), condition32),
+    };
+}
+export function serializeCogClaim(lockId, preimage32) {
+    ensureIdentifier(lockId, "wallet_cogop_invalid_lock_id");
+    ensureBytes32(preimage32, "wallet_cogop_invalid_preimage");
+    return {
+        opReturnData: createPayload(COG_OPCODES.COG_CLAIM, writeU32BE(lockId), preimage32),
+    };
+}
+export function serializeDomainReg(name) {
+    const asciiName = writeAsciiName(name, validateDomainName);
+    return {
+        opReturnData: createPayload(COG_OPCODES.DOMAIN_REG, writeU8(asciiName.length), asciiName),
+    };
+}
+export function serializeDomainTransfer(domainId, recipientSpk) {
+    ensureIdentifier(domainId, "wallet_cogop_invalid_domain_id");
+    return {
+        opReturnData: createPayload(COG_OPCODES.DOMAIN_TRANSFER, writeU32BE(domainId), writeLenPrefixedSpk(recipientSpk)),
+    };
+}
+export function serializeDomainSell(domainId, listedPrice) {
+    ensureIdentifier(domainId, "wallet_cogop_invalid_domain_id");
+    if (listedPrice < 0n) {
+        throw new Error("wallet_cogop_invalid_amount");
+    }
+    return {
+        opReturnData: createPayload(COG_OPCODES.DOMAIN_SELL, writeU32BE(domainId), writeU64BE(listedPrice)),
+    };
+}
+export function serializeDomainBuy(domainId, expectedPrice) {
+    ensureIdentifier(domainId, "wallet_cogop_invalid_domain_id");
+    if (expectedPrice <= 0n) {
+        throw new Error("wallet_cogop_invalid_amount");
+    }
+    return {
+        opReturnData: createPayload(COG_OPCODES.DOMAIN_BUY, writeU32BE(domainId), writeU64BE(expectedPrice)),
+    };
+}
+export function serializeFieldReg(parentDomainId, permanent, fieldName) {
+    ensureIdentifier(parentDomainId, "wallet_cogop_invalid_domain_id");
+    const asciiName = writeAsciiName(fieldName, validateFieldName);
+    return {
+        opReturnData: createPayload(COG_OPCODES.FIELD_REG, writeU32BE(parentDomainId), writeU8(permanent ? 0x01 : 0x00), writeU8(asciiName.length), asciiName),
+    };
+}
+export function serializeDataUpdate(domainId, fieldId, format, value) {
+    ensureIdentifier(domainId, "wallet_cogop_invalid_domain_id");
+    ensureIdentifier(fieldId, "wallet_cogop_invalid_field_id");
+    if (!Number.isInteger(format) || format < 0 || format > 0xff) {
+        throw new Error("wallet_cogop_invalid_format");
+    }
+    if (format === FIELD_FORMAT_BYTES.clear) {
+        return {
+            opReturnData: createPayload(COG_OPCODES.DATA_UPDATE, writeU32BE(domainId), writeU32BE(fieldId), writeU8(format)),
+        };
+    }
+    if (value === undefined || value.length === 0) {
+        throw new Error("wallet_cogop_missing_value");
+    }
+    return {
+        opReturnData: createPayload(COG_OPCODES.DATA_UPDATE, writeU32BE(domainId), writeU32BE(fieldId), writeU8(format), value),
+    };
+}
+export function serializeSetEndpoint(domainId, endpoint) {
+    ensureIdentifier(domainId, "wallet_cogop_invalid_domain_id");
+    return {
+        opReturnData: createPayload(COG_OPCODES.SET_ENDPOINT, writeU32BE(domainId), endpoint ?? new Uint8Array()),
+    };
+}
+export function serializeRepCommit(sourceDomainId, targetDomainId, amount, review60) {
+    ensureIdentifier(sourceDomainId, "wallet_cogop_invalid_domain_id");
+    ensureIdentifier(targetDomainId, "wallet_cogop_invalid_domain_id");
+    if (amount <= 0n) {
+        throw new Error("wallet_cogop_invalid_amount");
+    }
+    if (review60 !== undefined) {
+        ensureSentence60(review60, "wallet_cogop_invalid_review");
+    }
+    return {
+        opReturnData: createPayload(COG_OPCODES.REP_COMMIT, writeU32BE(sourceDomainId), writeU32BE(targetDomainId), writeU64BE(amount), review60 ?? new Uint8Array()),
+    };
+}
+export function serializeRepRevoke(sourceDomainId, targetDomainId, amount, review60) {
+    ensureIdentifier(sourceDomainId, "wallet_cogop_invalid_domain_id");
+    ensureIdentifier(targetDomainId, "wallet_cogop_invalid_domain_id");
+    if (amount <= 0n) {
+        throw new Error("wallet_cogop_invalid_amount");
+    }
+    if (review60 !== undefined) {
+        ensureSentence60(review60, "wallet_cogop_invalid_review");
+    }
+    return {
+        opReturnData: createPayload(COG_OPCODES.REP_REVOKE, writeU32BE(sourceDomainId), writeU32BE(targetDomainId), writeU64BE(amount), review60 ?? new Uint8Array()),
+    };
+}
+export function serializeSetCanonical(domainId) {
+    ensureIdentifier(domainId, "wallet_cogop_invalid_domain_id");
+    return {
+        opReturnData: createPayload(COG_OPCODES.SET_CANONICAL, writeU32BE(domainId)),
+    };
+}
+export function serializeDomainAnchor(domainId, foundingMessage60) {
+    ensureIdentifier(domainId, "wallet_cogop_invalid_domain_id");
+    if (foundingMessage60 === undefined) {
+        return {
+            opReturnData: createPayload(COG_OPCODES.DOMAIN_ANCHOR, writeU32BE(domainId)),
+        };
+    }
+    ensureSentence60(foundingMessage60, "wallet_cogop_invalid_founding_message");
+    return {
+        opReturnData: createPayload(COG_OPCODES.DOMAIN_ANCHOR, writeU32BE(domainId), foundingMessage60, new Uint8Array(12)),
+    };
+}
+export function serializeSetDelegate(domainId, delegateSpk) {
+    ensureIdentifier(domainId, "wallet_cogop_invalid_domain_id");
+    return {
+        opReturnData: createPayload(COG_OPCODES.SET_DELEGATE, writeU32BE(domainId), delegateSpk === undefined ? new Uint8Array() : writeLenPrefixedSpk(delegateSpk)),
+    };
+}
+export function serializeSetMiner(domainId, minerSpk) {
+    ensureIdentifier(domainId, "wallet_cogop_invalid_domain_id");
+    return {
+        opReturnData: createPayload(COG_OPCODES.SET_MINER, writeU32BE(domainId), minerSpk === undefined ? new Uint8Array() : writeLenPrefixedSpk(minerSpk)),
+    };
+}
+export { concatParts, FIELD_FORMAT_BYTES, validateDomainName, validateExternalScriptPubKey, validateFieldName, writeAsciiName, writeLenPrefixedSpk, writeU8, writeU32BE, writeU64BE, };

package/dist/wallet/cogop/numeric.d.ts

@@ -0,0 +1,3 @@
+export declare function writeU8(value: number): Uint8Array;
+export declare function writeU32BE(value: number): Uint8Array;
+export declare function writeU64BE(value: bigint): Uint8Array;

package/dist/wallet/cogop/numeric.js

@@ -0,0 +1,24 @@
+export function writeU8(value) {
+    if (!Number.isInteger(value) || value < 0 || value > 0xff) {
+        throw new Error("wallet_cogop_invalid_u8");
+    }
+    return Uint8Array.of(value);
+}
+export function writeU32BE(value) {
+    if (!Number.isInteger(value) || value < 0 || value > 0xffffffff) {
+        throw new Error("wallet_cogop_invalid_u32");
+    }
+    const bytes = new Uint8Array(4);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    view.setUint32(0, value, false);
+    return bytes;
+}
+export function writeU64BE(value) {
+    if (value < 0n || value > 0xffffffffffffffffn) {
+        throw new Error("wallet_cogop_invalid_u64");
+    }
+    const bytes = new Uint8Array(8);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    view.setBigUint64(0, value, false);
+    return bytes;
+}

package/dist/wallet/cogop/scriptpubkey.d.ts

@@ -0,0 +1,2 @@
+export declare function validateExternalScriptPubKey(spk: Uint8Array): void;
+export declare function writeLenPrefixedSpk(spk: Uint8Array): Uint8Array;

package/dist/wallet/cogop/scriptpubkey.js

@@ -0,0 +1,13 @@
+import { MAX_SCRIPT_PUBKEY_BYTES, MIN_SCRIPT_PUBKEY_BYTES } from "./constants.js";
+export function validateExternalScriptPubKey(spk) {
+    if (spk.length < MIN_SCRIPT_PUBKEY_BYTES || spk.length > MAX_SCRIPT_PUBKEY_BYTES) {
+        throw new Error("wallet_cogop_invalid_scriptpubkey_length");
+    }
+}
+export function writeLenPrefixedSpk(spk) {
+    validateExternalScriptPubKey(spk);
+    const out = new Uint8Array(1 + spk.length);
+    out[0] = spk.length;
+    out.set(spk, 1);
+    return out;
+}

package/dist/wallet/cogop/validate-name.d.ts

@@ -0,0 +1,2 @@
+export declare function validateDomainName(name: string): void;
+export declare function validateFieldName(name: string): void;

package/dist/wallet/cogop/validate-name.js

@@ -0,0 +1,18 @@
+import { MAX_NAME_BYTES, MIN_NAME_BYTES } from "./constants.js";
+function validateNameCommon(name, errorCode) {
+    if (name.length < MIN_NAME_BYTES || name.length > MAX_NAME_BYTES) {
+        throw new Error(errorCode);
+    }
+    if (name.startsWith("-") || name.endsWith("-") || name.includes("--")) {
+        throw new Error(errorCode);
+    }
+    if (!/^[a-z0-9-]+$/.test(name)) {
+        throw new Error(errorCode);
+    }
+}
+export function validateDomainName(name) {
+    validateNameCommon(name, "wallet_cogop_invalid_domain_name");
+}
+export function validateFieldName(name) {
+    validateNameCommon(name, "wallet_cogop_invalid_field_name");
+}

package/dist/wallet/fs/atomic.d.ts

@@ -0,0 +1,6 @@
+export interface AtomicWriteOptions {
+    mode?: number;
+    encoding?: BufferEncoding;
+}
+export declare function writeFileAtomic(filePath: string, data: string | Uint8Array, options?: AtomicWriteOptions): Promise<void>;
+export declare function writeJsonFileAtomic(filePath: string, value: unknown, options?: AtomicWriteOptions): Promise<void>;

package/dist/wallet/fs/atomic.js

@@ -0,0 +1,46 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, open, rename } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+async function fsyncDirectory(directoryPath) {
+    try {
+        const directoryHandle = await open(directoryPath, "r");
+        try {
+            await directoryHandle.sync();
+        }
+        finally {
+            await directoryHandle.close();
+        }
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error) {
+            const code = error.code;
+            if (code === "EINVAL" || code === "EPERM" || code === "EISDIR" || code === "ENOTSUP") {
+                return;
+            }
+        }
+        throw error;
+    }
+}
+export async function writeFileAtomic(filePath, data, options = {}) {
+    const directoryPath = dirname(filePath);
+    const tempPath = join(directoryPath, `${basename(filePath)}.tmp-${randomUUID()}`);
+    await mkdir(directoryPath, { recursive: true });
+    const handle = await open(tempPath, "wx", options.mode ?? 0o600);
+    try {
+        if (typeof data === "string") {
+            await handle.writeFile(data, { encoding: options.encoding ?? "utf8" });
+        }
+        else {
+            await handle.writeFile(data);
+        }
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+    await rename(tempPath, filePath);
+    await fsyncDirectory(directoryPath);
+}
+export async function writeJsonFileAtomic(filePath, value, options = {}) {
+    await writeFileAtomic(filePath, `${JSON.stringify(value, null, 2)}\n`, options);
+}

package/dist/wallet/fs/lock.d.ts

@@ -0,0 +1,19 @@
+export interface FileLockMetadata {
+    processId: number | null;
+    acquiredAtUnixMs: number;
+    purpose: string | null;
+    walletRootId: string | null;
+    [key: string]: unknown;
+}
+export interface FileLockHandle {
+    readonly path: string;
+    readonly metadata: FileLockMetadata;
+    release(): Promise<void>;
+}
+export declare class FileLockBusyError extends Error {
+    readonly lockPath: string;
+    readonly existingMetadata: FileLockMetadata | null;
+    constructor(lockPath: string, existingMetadata: FileLockMetadata | null);
+}
+export declare function readLockMetadata(lockPath: string): Promise<FileLockMetadata | null>;
+export declare function acquireFileLock(lockPath: string, metadata?: Partial<FileLockMetadata>): Promise<FileLockHandle>;

package/dist/wallet/fs/lock.js

@@ -0,0 +1,61 @@
+import { mkdir, open, readFile, rm } from "node:fs/promises";
+import { dirname } from "node:path";
+export class FileLockBusyError extends Error {
+    lockPath;
+    existingMetadata;
+    constructor(lockPath, existingMetadata) {
+        super(`file_lock_busy_${lockPath}`);
+        this.name = "FileLockBusyError";
+        this.lockPath = lockPath;
+        this.existingMetadata = existingMetadata;
+    }
+}
+export async function readLockMetadata(lockPath) {
+    try {
+        const raw = await readFile(lockPath, "utf8");
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    }
+}
+export async function acquireFileLock(lockPath, metadata = {}) {
+    await mkdir(dirname(lockPath), { recursive: true });
+    const fullMetadata = {
+        processId: process.pid ?? null,
+        acquiredAtUnixMs: Date.now(),
+        purpose: metadata.purpose ?? null,
+        walletRootId: metadata.walletRootId ?? null,
+        ...metadata,
+    };
+    let handle;
+    try {
+        handle = await open(lockPath, "wx", 0o600);
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "EEXIST") {
+            throw new FileLockBusyError(lockPath, await readLockMetadata(lockPath));
+        }
+        throw error;
+    }
+    try {
+        await handle.writeFile(`${JSON.stringify(fullMetadata, null, 2)}\n`);
+        await handle.sync();
+    }
+    catch (error) {
+        await handle.close().catch(() => undefined);
+        await rm(lockPath, { force: true }).catch(() => undefined);
+        throw error;
+    }
+    await handle.close();
+    return {
+        path: lockPath,
+        metadata: fullMetadata,
+        async release() {
+            await rm(lockPath, { force: true });
+        },
+    };
+}

package/dist/wallet/fs/status-file.d.ts

@@ -0,0 +1 @@
+export declare function writeRuntimeStatusFile(statusPath: string, snapshot: unknown): Promise<void>;

package/dist/wallet/fs/status-file.js

@@ -0,0 +1,4 @@
+import { writeJsonFileAtomic } from "./atomic.js";
+export async function writeRuntimeStatusFile(statusPath, snapshot) {
+    await writeJsonFileAtomic(statusPath, snapshot, { mode: 0o600 });
+}

package/dist/wallet/lifecycle.d.ts

@@ -0,0 +1,193 @@
+import { attachOrStartIndexerDaemon, probeIndexerDaemon } from "../bitcoind/indexer-daemon.js";
+import { attachOrStartManagedBitcoindService, probeManagedBitcoindService } from "../bitcoind/service.js";
+import { createRpcClient } from "../bitcoind/node.js";
+import type { ManagedCoreWalletReplicaStatus } from "../bitcoind/types.js";
+import { type WalletRuntimePaths } from "./runtime.js";
+import { requestMiningGenerationPreemption } from "./mining/coordination.js";
+import { type WalletSecretProvider } from "./state/provider.js";
+import type { UnlockSessionStateV1, WalletStateV1 } from "./types.js";
+export declare const DEFAULT_UNLOCK_DURATION_MS: number;
+export interface WalletPrompter {
+    readonly isInteractive: boolean;
+    writeLine(message: string): void;
+    prompt(message: string): Promise<string>;
+    clearSensitiveDisplay?(scope: "mnemonic-reveal"): void | Promise<void>;
+}
+export interface WalletInitializationResult {
+    walletRootId: string;
+    fundingAddress: string;
+    unlockUntilUnixMs: number;
+    state: WalletStateV1;
+}
+export interface WalletUnlockResult {
+    unlockUntilUnixMs: number;
+    state: WalletStateV1;
+    source: "primary" | "backup";
+}
+export interface LoadedUnlockedWalletState {
+    session: UnlockSessionStateV1;
+    state: WalletStateV1;
+    source: "primary" | "backup";
+}
+export interface WalletExportResult {
+    archivePath: string;
+    walletRootId: string;
+}
+export interface WalletImportResult {
+    archivePath: string;
+    walletRootId: string;
+    fundingAddress: string;
+    unlockUntilUnixMs: number;
+    state: WalletStateV1;
+}
+export interface WalletRepairResult {
+    walletRootId: string;
+    recoveredFromBackup: boolean;
+    recreatedManagedCoreWallet: boolean;
+    resetIndexerDatabase: boolean;
+    bitcoindServiceAction: "none" | "cleared-stale-artifacts" | "stopped-incompatible-service" | "restarted-compatible-service";
+    bitcoindCompatibilityIssue: "none" | "service-version-mismatch" | "wallet-root-mismatch" | "runtime-mismatch";
+    managedCoreReplicaAction: "none" | "recreated";
+    bitcoindPostRepairHealth: "ready" | "catching-up" | "starting" | "failed" | "unavailable";
+    indexerDaemonAction: "none" | "cleared-stale-artifacts" | "stopped-incompatible-daemon" | "restarted-compatible-daemon";
+    indexerCompatibilityIssue: "none" | "service-version-mismatch" | "wallet-root-mismatch" | "schema-mismatch";
+    indexerPostRepairHealth: "starting" | "catching-up" | "synced" | "failed";
+    miningPreRepairRunMode: "stopped" | "foreground" | "background";
+    miningResumeAction: "none" | "skipped-not-resumable" | "skipped-post-repair-blocked" | "resumed-background" | "resume-failed";
+    miningPostRepairRunMode: "stopped" | "background";
+    miningResumeError: string | null;
+    note: string | null;
+}
+interface WalletLifecycleRpcClient {
+    getDescriptorInfo(descriptor: string): Promise<{
+        descriptor: string;
+        checksum: string;
+    }>;
+    createWallet(walletName: string, options: {
+        blank: boolean;
+        descriptors: boolean;
+        disablePrivateKeys: boolean;
+        loadOnStartup: boolean;
+        passphrase: string;
+    }): Promise<unknown>;
+    walletPassphrase(walletName: string, passphrase: string, timeoutSeconds: number): Promise<null>;
+    importDescriptors(walletName: string, requests: Array<{
+        desc: string;
+        timestamp: string | number;
+        active?: boolean;
+        internal?: boolean;
+        range?: number | [number, number];
+    }>): Promise<Array<{
+        success: boolean;
+    }>>;
+    walletLock(walletName: string): Promise<null>;
+    deriveAddresses(descriptor: string, range?: number | [number, number]): Promise<string[]>;
+    listDescriptors(walletName: string, privateOnly?: boolean): Promise<{
+        descriptors: Array<{
+            desc: string;
+        }>;
+    }>;
+    getWalletInfo(walletName: string): Promise<{
+        walletname: string;
+        private_keys_enabled: boolean;
+        descriptors: boolean;
+    }>;
+    loadWallet(walletName: string, loadOnStartup?: boolean): Promise<{
+        name: string;
+        warning: string;
+    }>;
+    unloadWallet?(walletName: string, loadOnStartup?: boolean): Promise<null>;
+    listWallets(): Promise<string[]>;
+    getBlockchainInfo(): Promise<{
+        blocks: number;
+        headers: number;
+    }>;
+}
+declare function readManagedSnapshotTip(options: {
+    dataDir: string;
+    databasePath: string;
+    walletRootId: string;
+}): Promise<{
+    nodeBestHeight: number | null;
+    snapshotHeight: number | null;
+}>;
+export declare function parseUnlockDurationToMs(raw: string | null | undefined): number;
+export declare function verifyManagedCoreWalletReplica(state: WalletStateV1, dataDir: string, dependencies?: {
+    nodeHandle?: {
+        rpc: Parameters<typeof createRpcClient>[0];
+    };
+    attachService?: typeof attachOrStartManagedBitcoindService;
+    rpcFactory?: (config: Parameters<typeof createRpcClient>[0]) => WalletLifecycleRpcClient;
+}): Promise<ManagedCoreWalletReplicaStatus>;
+export declare function loadUnlockedWalletState(options?: {
+    provider?: WalletSecretProvider;
+    nowUnixMs?: number;
+    paths?: WalletRuntimePaths;
+}): Promise<LoadedUnlockedWalletState | null>;
+export declare function initializeWallet(options: {
+    dataDir: string;
+    provider?: WalletSecretProvider;
+    prompter: WalletPrompter;
+    nowUnixMs?: number;
+    unlockDurationMs?: number;
+    paths?: WalletRuntimePaths;
+    attachService?: typeof attachOrStartManagedBitcoindService;
+    rpcFactory?: (config: Parameters<typeof createRpcClient>[0]) => WalletLifecycleRpcClient;
+}): Promise<WalletInitializationResult>;
+export declare function unlockWallet(options?: {
+    provider?: WalletSecretProvider;
+    nowUnixMs?: number;
+    unlockDurationMs?: number;
+    paths?: WalletRuntimePaths;
+}): Promise<WalletUnlockResult>;
+export declare function lockWallet(options: {
+    dataDir: string;
+    provider?: WalletSecretProvider;
+    paths?: WalletRuntimePaths;
+    attachService?: typeof attachOrStartManagedBitcoindService;
+    rpcFactory?: (config: Parameters<typeof createRpcClient>[0]) => WalletLifecycleRpcClient;
+}): Promise<{
+    walletRootId: string | null;
+    coreLocked: boolean;
+}>;
+export declare function exportWallet(options: {
+    archivePath: string;
+    dataDir: string;
+    databasePath: string;
+    provider?: WalletSecretProvider;
+    prompter: WalletPrompter;
+    nowUnixMs?: number;
+    paths?: WalletRuntimePaths;
+    attachService?: typeof attachOrStartManagedBitcoindService;
+    rpcFactory?: (config: Parameters<typeof createRpcClient>[0]) => WalletLifecycleRpcClient;
+    readSnapshotTip?: typeof readManagedSnapshotTip;
+}): Promise<WalletExportResult>;
+export declare function importWallet(options: {
+    archivePath: string;
+    dataDir: string;
+    databasePath: string;
+    provider?: WalletSecretProvider;
+    prompter: WalletPrompter;
+    nowUnixMs?: number;
+    unlockDurationMs?: number;
+    paths?: WalletRuntimePaths;
+    attachService?: typeof attachOrStartManagedBitcoindService;
+    attachIndexerDaemon?: typeof attachOrStartIndexerDaemon;
+    rpcFactory?: (config: Parameters<typeof createRpcClient>[0]) => WalletLifecycleRpcClient;
+}): Promise<WalletImportResult>;
+export declare function repairWallet(options: {
+    dataDir: string;
+    databasePath: string;
+    provider?: WalletSecretProvider;
+    assumeYes?: boolean;
+    nowUnixMs?: number;
+    paths?: WalletRuntimePaths;
+    attachService?: typeof attachOrStartManagedBitcoindService;
+    probeBitcoindService?: typeof probeManagedBitcoindService;
+    rpcFactory?: (config: Parameters<typeof createRpcClient>[0]) => WalletLifecycleRpcClient;
+    attachIndexerDaemon?: typeof attachOrStartIndexerDaemon;
+    probeIndexerDaemon?: typeof probeIndexerDaemon;
+    requestMiningPreemption?: typeof requestMiningGenerationPreemption;
+    startBackgroundMining?: typeof import("./mining/runner.js").startBackgroundMining;
+}): Promise<WalletRepairResult>;
+export {};