@cogcoin/client 0.5.15 → 1.0.0

package/dist/client/default-client.js

@@ -1,4 +1,5 @@
-import { applyBlockWithScoring, deserializeBlockRecord, rewindBlock, serializeIndexerState, } from "@cogcoin/indexer";
+import { applyBlockWithScoring, createInitialState, deserializeBlockRecord, deserializeIndexerState, rewindBlock, serializeIndexerState, } from "@cogcoin/indexer";
+import { internalHashHexToDisplayHashHex } from "../bitcoind/hash-order.js";
 import { createCheckpoint, createStoredBlockRecord, createTip } from "./persistence.js";
 export class DefaultClient {
     #store;
@@ -78,7 +79,8 @@ export class DefaultClient {
                 const currentRecord = await this.#store.loadBlockRecord(currentHeight);
                 nextTip = {
                     height: currentHeight,
-                    blockHashHex: nextState.history.currentHashHex ?? currentRecord?.blockHashHex ?? "",
+                    blockHashHex: currentRecord?.blockHashHex
+                        ?? (nextState.history.currentHashHex === null ? "" : internalHashHexToDisplayHashHex(nextState.history.currentHashHex)),
                     previousHashHex: currentRecord?.previousHashHex ?? null,
                     stateHashHex: nextState.history.stateHashByHeight.get(currentHeight) ?? null,
                 };
@@ -96,6 +98,47 @@ export class DefaultClient {
             return nextTip === null ? null : { ...nextTip };
         });
     }
+    async restoreCheckpoint(checkpoint) {
+        return this.#enqueue(async () => {
+            this.#assertOpen();
+            const nextState = deserializeIndexerState(checkpoint.stateBytes);
+            if (nextState.history.currentHeight !== checkpoint.height) {
+                throw new Error("client_checkpoint_height_mismatch");
+            }
+            const nextTip = {
+                height: checkpoint.height,
+                blockHashHex: checkpoint.blockHashHex,
+                previousHashHex: null,
+                stateHashHex: nextState.history.stateHashByHeight.get(checkpoint.height) ?? null,
+            };
+            await this.#store.writeAppliedBlock({
+                tip: nextTip,
+                stateBytes: checkpoint.stateBytes,
+                blockRecord: null,
+                checkpoint,
+                deleteAboveHeight: checkpoint.height,
+            });
+            this.#state = nextState;
+            this.#tip = nextTip;
+            return { ...nextTip };
+        });
+    }
+    async resetToInitialState() {
+        return this.#enqueue(async () => {
+            this.#assertOpen();
+            const nextState = createInitialState(this.#genesisParameters);
+            await this.#store.writeAppliedBlock({
+                tip: null,
+                stateBytes: null,
+                blockRecord: null,
+                checkpoint: null,
+                deleteAboveHeight: -1,
+            });
+            this.#state = nextState;
+            this.#tip = null;
+            return null;
+        });
+    }
     async close() {
         await this.#enqueue(async () => {
             if (this.#closed) {

package/dist/client/factory.js

@@ -3,7 +3,7 @@ import { DefaultClient } from "./default-client.js";
 import { initializeState } from "./initialization.js";
 import { createClientStoreAdapter } from "./store-adapter.js";
 const DEFAULT_SNAPSHOT_INTERVAL = 1000;
-const DEFAULT_BLOCK_RECORD_RETENTION = 1000;
+const DEFAULT_BLOCK_RECORD_RETENTION = 100;
 export async function openClient(options) {
     const store = createClientStoreAdapter(options.store);
     const genesisParameters = options.genesisParameters ?? await loadBundledGenesisParameters();

package/dist/client/initialization.js

@@ -1,4 +1,20 @@
 import { createInitialState, deserializeIndexerState, } from "@cogcoin/indexer";
+import { internalHashHexToDisplayHashHex } from "../bitcoind/hash-order.js";
+function createResetEntry() {
+    return {
+        tip: null,
+        stateBytes: null,
+        blockRecord: null,
+        checkpoint: null,
+        deleteAboveHeight: -1,
+    };
+}
+function snapshotUsesLegacyHashOrder(state, snapshotHashHex) {
+    const currentHashHex = state.history.currentHashHex;
+    return currentHashHex !== null
+        && currentHashHex === snapshotHashHex
+        && internalHashHexToDisplayHashHex(currentHashHex) !== snapshotHashHex;
+}
 export async function initializeState(store, genesisParameters) {
     const tip = await store.loadTip();
     const snapshot = await store.loadLatestSnapshot();
@@ -12,6 +28,13 @@ export async function initializeState(store, genesisParameters) {
         };
     }
     const state = deserializeIndexerState(snapshot.stateBytes);
+    if (snapshotUsesLegacyHashOrder(state, snapshot.blockHashHex)) {
+        await store.writeAppliedBlock(createResetEntry());
+        return {
+            state: createInitialState(genesisParameters),
+            tip: null,
+        };
+    }
     if (tip === null) {
         return {
             state,

package/dist/client/persistence.js

@@ -1,18 +1,18 @@
 import { serializeBlockRecord } from "@cogcoin/indexer";
-import { bytesToHex } from "../bytes.js";
+import { internalBytesToDisplayHashHex, internalHashHexToDisplayHashHex } from "../bitcoind/hash-order.js";
 export function createTip(block, stateHashHex) {
     return {
         height: block.height,
-        blockHashHex: bytesToHex(block.hash),
-        previousHashHex: block.previousHash === null ? null : bytesToHex(block.previousHash),
+        blockHashHex: internalBytesToDisplayHashHex(block.hash),
+        previousHashHex: block.previousHash === null ? null : internalBytesToDisplayHashHex(block.previousHash),
         stateHashHex,
     };
 }
 export function createStoredBlockRecord(blockRecord, createdAt) {
     return {
         height: blockRecord.height,
-        blockHashHex: blockRecord.hashHex,
-        previousHashHex: blockRecord.previousHashHex,
+        blockHashHex: internalHashHexToDisplayHashHex(blockRecord.hashHex),
+        previousHashHex: blockRecord.previousHashHex === null ? null : internalHashHexToDisplayHashHex(blockRecord.previousHashHex),
         stateHashHex: blockRecord.stateHashHex,
         recordBytes: serializeBlockRecord(blockRecord),
         createdAt,

package/dist/client/store-adapter.js

@@ -2,6 +2,7 @@ export function assertClientStoreAdapter(store) {
     const requiredMethods = [
         "loadTip",
         "loadLatestSnapshot",
+        "loadLatestCheckpointAtOrBelow",
         "loadBlockRecordsAfter",
         "writeAppliedBlock",
         "deleteBlockRecordsAbove",

package/dist/sqlite/checkpoints.d.ts

@@ -7,5 +7,6 @@ export interface StoredCheckpointRow {
     createdAt: number;
 }
 export declare function loadLatestCheckpoint(database: SqliteDatabase): Promise<StoredCheckpointRow | null>;
+export declare function loadLatestCheckpointAtOrBelow(database: SqliteDatabase, height: number): Promise<StoredCheckpointRow | null>;
 export declare function replaceCheckpoint(database: SqliteDatabase, checkpoint: ClientCheckpoint): Promise<void>;
 export declare function deleteCheckpointsAbove(database: SqliteDatabase, height: number): Promise<void>;

package/dist/sqlite/checkpoints.js

@@ -13,6 +13,13 @@ function decodeCheckpointRow(row) {
 export async function loadLatestCheckpoint(database) {
     return decodeCheckpointRow(await database.get(`SELECT height, block_hash, state_bytes, created_at FROM checkpoints ORDER BY height DESC LIMIT 1`));
 }
+export async function loadLatestCheckpointAtOrBelow(database, height) {
+    return decodeCheckpointRow(await database.get(`SELECT height, block_hash, state_bytes, created_at
+       FROM checkpoints
+       WHERE height <= ?
+       ORDER BY height DESC
+       LIMIT 1`, [height]));
+}
 export async function replaceCheckpoint(database, checkpoint) {
     await database.run(`INSERT OR REPLACE INTO checkpoints (height, block_hash, state_bytes, created_at)
      VALUES (?, ?, ?, ?)`, [

package/dist/sqlite/store.js

@@ -1,5 +1,5 @@
 import { bytesToHex, cloneBytes, hexToBytes, } from "../bytes.js";
-import { deleteCheckpointsAbove, loadLatestCheckpoint, replaceCheckpoint, } from "./checkpoints.js";
+import { deleteCheckpointsAbove, loadLatestCheckpoint, loadLatestCheckpointAtOrBelow, replaceCheckpoint, } from "./checkpoints.js";
 import { loadTipSnapshotMeta, writeTipMeta, } from "./tip-meta.js";
 export function createSqliteStoreAdapter(database) {
     let writeQueue = Promise.resolve();
@@ -42,6 +42,19 @@ export function createSqliteStoreAdapter(database) {
                 createdAt: row.createdAt,
             };
         },
+        async loadLatestCheckpointAtOrBelow(height) {
+            assertOpen();
+            const row = await loadLatestCheckpointAtOrBelow(database, height);
+            if (row === null) {
+                return null;
+            }
+            return {
+                height: row.height,
+                blockHashHex: row.blockHashHex,
+                stateBytes: row.stateBytes,
+                createdAt: row.createdAt,
+            };
+        },
         async loadBlockRecordsAfter(height) {
             assertOpen();
             const rows = await database.all(`SELECT height, block_hash, previous_hash, record_bytes, state_hash_hex, created_at

package/dist/types.d.ts

@@ -30,6 +30,7 @@ export interface WriteAppliedBlockEntry {
 export interface ClientStoreAdapter {
     loadTip(): Promise<ClientTip | null>;
     loadLatestSnapshot(): Promise<ClientCheckpoint | null>;
+    loadLatestCheckpointAtOrBelow(height: number): Promise<ClientCheckpoint | null>;
     loadBlockRecordsAfter(height: number): Promise<StoredBlockRecord[]>;
     writeAppliedBlock(entry: WriteAppliedBlockEntry): Promise<void>;
     deleteBlockRecordsAbove(height: number): Promise<void>;

package/dist/wallet/coin-control.d.ts

@@ -1,18 +1,49 @@
-import type { RpcListUnspentEntry, RpcLockedUnspent, RpcWalletTransaction } from "../bitcoind/types.js";
 import { persistWalletStateUpdate } from "./descriptor-normalization.js";
 import type { WalletRuntimePaths } from "./runtime.js";
-import type { OutpointRecord, PortableWalletArchivePayloadV1, UnlockSessionStateV1, WalletStateV1 } from "./types.js";
-export declare const DEFAULT_PROACTIVE_RESERVE_SATS = 1000;
+import type { OutpointRecord, WalletStateV1 } from "./types.js";
+import type { RpcListUnspentEntry } from "../bitcoind/types.js";
+export declare const DEFAULT_PROACTIVE_RESERVE_SATS = 0;
 export interface WalletCoinControlRpc {
     listUnspent(walletName: string, minConf?: number): Promise<RpcListUnspentEntry[]>;
-    listLockUnspent(walletName: string): Promise<RpcLockedUnspent[]>;
-    lockUnspent(walletName: string, unlock: boolean, outputs: RpcLockedUnspent[]): Promise<boolean>;
-    getTransaction?(walletName: string, txid: string): Promise<RpcWalletTransaction>;
 }
 export declare function outpointKey(outpoint: OutpointRecord): string;
-export declare function normalizeWalletStateRecord(state: WalletStateV1): WalletStateV1;
-export declare function normalizePortableWalletArchivePayload(payload: PortableWalletArchivePayloadV1): PortableWalletArchivePayloadV1;
-export declare function computeDesignatedProactiveReserveOutpoints(state: WalletStateV1, spendableUtxos: readonly RpcListUnspentEntry[]): OutpointRecord[];
+type LegacyManagedCoreWallet = {
+    walletAddress?: string | null;
+    walletScriptPubKeyHex?: string | null;
+    fundingAddress0?: string | null;
+    fundingScriptPubKeyHex0?: string | null;
+    walletName?: string;
+    internalPassphrase?: string;
+    descriptorChecksum?: string | null;
+    proofStatus?: "not-proven" | "ready" | "missing" | "mismatch";
+    lastImportedAtUnixMs?: number | null;
+    lastVerifiedAtUnixMs?: number | null;
+};
+type LegacyWalletStateRecord = Partial<WalletStateV1> & {
+    schemaVersion?: number;
+    hookClientState?: unknown;
+    anchorValueSats?: number;
+    localScriptPubKeyHexes?: string[] | null;
+    funding?: {
+        address?: string | null;
+        scriptPubKeyHex?: string | null;
+    } | null;
+    identities?: Array<{
+        scriptPubKeyHex?: string | null;
+    }> | null;
+    managedCoreWallet?: LegacyManagedCoreWallet | null;
+    domains?: Array<Partial<WalletStateV1["domains"][number]> & {
+        name?: string | null;
+        domainId?: number | null;
+        currentOwnerScriptPubKeyHex?: string | null;
+        canonicalChainStatus?: WalletStateV1["domains"][number]["canonicalChainStatus"];
+        foundingMessageText?: string | null;
+        birthTime?: number | null;
+    }> | null;
+    pendingMutations?: WalletStateV1["pendingMutations"] | null;
+};
+export declare function normalizeWalletStateRecord(rawState: LegacyWalletStateRecord): WalletStateV1;
+export declare function computeDesignatedProactiveReserveOutpoints(_state?: WalletStateV1, _spendableUtxos?: readonly RpcListUnspentEntry[]): OutpointRecord[];
 export declare function reconcilePersistentPolicyLocks(options: {
     rpc: WalletCoinControlRpc;
     walletName: string;
@@ -29,14 +60,12 @@ export declare function reconcilePersistentPolicyLocks(options: {
 export declare function persistWalletCoinControlStateIfNeeded(options: {
     state: WalletStateV1;
     access: Parameters<typeof persistWalletStateUpdate>[0]["access"];
-    session?: UnlockSessionStateV1 | null;
     paths: WalletRuntimePaths;
     nowUnixMs: number;
     replacePrimary?: boolean;
     rpc: WalletCoinControlRpc;
-    cleanupInactiveTemporaryBuilderLocks?: boolean;
 }): Promise<{
     changed: boolean;
-    session: UnlockSessionStateV1 | null;
     state: WalletStateV1;
 }>;
+export {};