@cogcoin/client 0.5.15 → 1.0.0

package/dist/wallet/state/storage.js

@@ -1,11 +1,46 @@
 import { readFile } from "node:fs/promises";
 import { writeJsonFileAtomic } from "../fs/atomic.js";
 import { normalizeWalletStateRecord } from "../coin-control.js";
-import { decryptJsonWithPassphrase, decryptJsonWithSecretProvider, encryptJsonWithPassphrase, encryptJsonWithSecretProvider, } from "./crypto.js";
+import { decryptJsonWithSecretProvider, encryptJsonWithSecretProvider, } from "./crypto.js";
 async function readEnvelope(path) {
     const raw = await readFile(path, "utf8");
     return JSON.parse(raw);
 }
+function serializeWalletState(state) {
+    return {
+        schemaVersion: 5,
+        stateRevision: state.stateRevision,
+        lastWrittenAtUnixMs: state.lastWrittenAtUnixMs,
+        walletRootId: state.walletRootId,
+        network: state.network,
+        localScriptPubKeyHexes: state.localScriptPubKeyHexes,
+        mnemonic: state.mnemonic,
+        keys: state.keys,
+        descriptor: state.descriptor,
+        funding: state.funding,
+        walletBirthTime: state.walletBirthTime,
+        managedCoreWallet: {
+            walletName: state.managedCoreWallet.walletName,
+            internalPassphrase: state.managedCoreWallet.internalPassphrase,
+            descriptorChecksum: state.managedCoreWallet.descriptorChecksum,
+            walletAddress: state.managedCoreWallet.walletAddress,
+            walletScriptPubKeyHex: state.managedCoreWallet.walletScriptPubKeyHex,
+            proofStatus: state.managedCoreWallet.proofStatus,
+            lastImportedAtUnixMs: state.managedCoreWallet.lastImportedAtUnixMs,
+            lastVerifiedAtUnixMs: state.managedCoreWallet.lastVerifiedAtUnixMs,
+        },
+        domains: state.domains.map((domain) => ({
+            name: domain.name,
+            domainId: domain.domainId,
+            currentOwnerScriptPubKeyHex: domain.currentOwnerScriptPubKeyHex,
+            canonicalChainStatus: domain.canonicalChainStatus,
+            foundingMessageText: domain.foundingMessageText,
+            birthTime: domain.birthTime,
+        })),
+        miningState: state.miningState,
+        pendingMutations: state.pendingMutations,
+    };
+}
 export async function loadRawWalletStateEnvelope(paths) {
     try {
         return {
@@ -43,6 +78,12 @@ export function extractWalletRootIdHintFromWalletStateEnvelope(envelope) {
     }
     return keyId.slice(prefix.length);
 }
+async function loadWalletStateEnvelope(envelope, access) {
+    if (envelope.secretProvider == null) {
+        throw new Error("wallet_state_legacy_envelope_unsupported");
+    }
+    return normalizeWalletStateRecord(await decryptJsonWithSecretProvider(envelope, access.provider));
+}
 export async function saveWalletState(paths, state, access) {
     let previousPrimary = null;
     try {
@@ -56,15 +97,10 @@ export async function saveWalletState(paths, state, access) {
             throw error;
         }
     }
-    const envelope = typeof access === "string" || access instanceof Uint8Array
-        ? await encryptJsonWithPassphrase(state, access, {
-            format: "cogcoin-local-wallet-state",
-            walletRootIdHint: state.walletRootId,
-        })
-        : await encryptJsonWithSecretProvider(state, access.provider, access.secretReference, {
-            format: "cogcoin-local-wallet-state",
-            walletRootIdHint: state.walletRootId,
-        });
+    const envelope = await encryptJsonWithSecretProvider(serializeWalletState(state), access.provider, access.secretReference, {
+        format: "cogcoin-local-wallet-state",
+        walletRootIdHint: state.walletRootId,
+    });
     await writeJsonFileAtomic(paths.primaryPath, envelope, { mode: 0o600 });
     if (previousPrimary !== null) {
         await writeJsonFileAtomic(paths.backupPath, previousPrimary, { mode: 0o600 });
@@ -74,18 +110,14 @@ export async function loadWalletState(paths, access) {
     try {
         return {
             source: "primary",
-            state: normalizeWalletStateRecord(typeof access === "string" || access instanceof Uint8Array
-                ? await decryptJsonWithPassphrase(await readEnvelope(paths.primaryPath), access)
-                : await decryptJsonWithSecretProvider(await readEnvelope(paths.primaryPath), access.provider)),
+            state: await loadWalletStateEnvelope(await readEnvelope(paths.primaryPath), access),
         };
     }
     catch (primaryError) {
         try {
             return {
                 source: "backup",
-                state: normalizeWalletStateRecord(typeof access === "string" || access instanceof Uint8Array
-                    ? await decryptJsonWithPassphrase(await readEnvelope(paths.backupPath), access)
-                    : await decryptJsonWithSecretProvider(await readEnvelope(paths.backupPath), access.provider)),
+                state: await loadWalletStateEnvelope(await readEnvelope(paths.backupPath), access),
             };
         }
         catch {

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

@@ -1,24 +1,22 @@
 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 type { ProactiveFamilyStateRecord } from "../types.js";
 import { openWalletReadContext } from "../read/index.js";
-import { type WalletMutationRpcClient } from "./common.js";
+import { type WalletMutationFeeSummary, type WalletMutationRpcClient } from "./common.js";
 interface WalletAnchorRpcClient extends WalletMutationRpcClient {
     getBlockchainInfo(): Promise<{
         blocks: number;
     }>;
     sendRawTransaction(hex: string): Promise<string>;
     getRawMempool(): Promise<string[]>;
-    getRawTransaction(txid: string, verbose?: boolean): Promise<RpcTransaction>;
 }
 export interface AnchorDomainOptions {
     domainName: string;
     foundingMessageText?: string | null;
     promptForFoundingMessageWhenMissing?: boolean;
+    feeRateSatVb?: number | null;
     dataDir: string;
     databasePath: string;
     provider?: WalletSecretProvider;
@@ -32,33 +30,10 @@ export interface AnchorDomainOptions {
 export interface AnchorDomainResult {
     domainName: string;
     txid: string;
-    tx1Txid: string;
-    tx2Txid: string;
-    dedicatedIndex: number;
     status: "live" | "confirmed";
     reusedExisting: boolean;
     foundingMessageText?: string | null;
-}
-export interface ClearPendingAnchorOptions {
-    domainName: 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]) => WalletAnchorRpcClient;
-}
-export interface ClearPendingAnchorResult {
-    domainName: string;
-    cleared: boolean;
-    previousFamilyStatus: ProactiveFamilyStateRecord["status"] | null;
-    previousFamilyStep: ProactiveFamilyStateRecord["currentStep"] | null;
-    releasedDedicatedIndex: number | null;
+    fees: WalletMutationFeeSummary;
 }
 export declare function anchorDomain(options: AnchorDomainOptions): Promise<AnchorDomainResult>;
-export declare function clearPendingAnchor(options: ClearPendingAnchorOptions): Promise<ClearPendingAnchorResult>;
 export {};