@cogcoin/client 0.5.14 → 1.0.0

package/dist/wallet/coin-control.js

@@ -1,367 +1,126 @@
-import { saveUnlockSession } from "./state/session.js";
 import { persistWalletStateUpdate } from "./descriptor-normalization.js";
-import { miningFamilyMayStillExist } from "./mining/state.js";
-export const DEFAULT_PROACTIVE_RESERVE_SATS = 1_000;
-function btcNumberToSats(value) {
-    return BigInt(Math.round(value * 100_000_000));
-}
+import { normalizeMiningStateRecord } from "./mining/state.js";
+export const DEFAULT_PROACTIVE_RESERVE_SATS = 0;
 export function outpointKey(outpoint) {
     return `${outpoint.txid}:${outpoint.vout}`;
 }
-function normalizeOutpointRecordList(outpoints) {
-    const normalized = [];
+function uniqueStrings(values) {
+    return values.filter((value, index, entries) => typeof value === "string" && value.length > 0 && entries.indexOf(value) === index);
+}
+function uniqueOutpoints(values) {
     const seen = new Set();
-    for (const outpoint of outpoints ?? []) {
-        if (outpoint == null
-            || typeof outpoint.txid !== "string"
-            || outpoint.txid.length === 0
-            || typeof outpoint.vout !== "number"
-            || !Number.isInteger(outpoint.vout)
-            || outpoint.vout < 0) {
+    const normalized = [];
+    for (const value of values ?? []) {
+        if (value == null
+            || typeof value.txid !== "string"
+            || value.txid.length === 0
+            || typeof value.vout !== "number"
+            || !Number.isInteger(value.vout)
+            || value.vout < 0) {
             continue;
         }
-        const key = outpointKey(outpoint);
+        const key = outpointKey(value);
         if (seen.has(key)) {
             continue;
         }
         seen.add(key);
-        normalized.push({ txid: outpoint.txid, vout: outpoint.vout });
+        normalized.push({ txid: value.txid, vout: value.vout });
     }
     return normalized;
 }
-function normalizeReserveSats(raw) {
-    if (typeof raw !== "number" || !Number.isFinite(raw)) {
-        return DEFAULT_PROACTIVE_RESERVE_SATS;
-    }
-    const normalized = Math.max(0, Math.trunc(raw));
-    if (normalized === 0) {
-        return 0;
-    }
-    return DEFAULT_PROACTIVE_RESERVE_SATS;
-}
-function sameOutpointList(left, right) {
-    if (left.length !== (right?.length ?? 0)) {
-        return false;
-    }
-    return left.every((outpoint, index) => outpoint.txid === right?.[index]?.txid && outpoint.vout === right?.[index]?.vout);
-}
-export function normalizeWalletStateRecord(state) {
-    const rawProactiveReserveSats = state.proactiveReserveSats;
-    const proactiveReserveSats = normalizeReserveSats(rawProactiveReserveSats);
-    const reserveValueChanged = proactiveReserveSats !== rawProactiveReserveSats;
-    const proactiveReserveOutpoints = normalizeOutpointRecordList(proactiveReserveSats <= 0 || reserveValueChanged
-        ? []
-        : state.proactiveReserveOutpoints);
-    const pendingMutations = state.pendingMutations ?? [];
-    if (proactiveReserveSats === state.proactiveReserveSats
-        && sameOutpointList(proactiveReserveOutpoints, state.proactiveReserveOutpoints)
-        && pendingMutations === state.pendingMutations) {
-        return state;
-    }
-    return {
-        ...state,
-        proactiveReserveSats,
-        proactiveReserveOutpoints,
-        pendingMutations,
-    };
-}
-export function normalizePortableWalletArchivePayload(payload) {
-    const rawProactiveReserveSats = payload.proactiveReserveSats;
-    const proactiveReserveSats = normalizeReserveSats(rawProactiveReserveSats);
-    const reserveValueChanged = proactiveReserveSats !== rawProactiveReserveSats;
-    const proactiveReserveOutpoints = normalizeOutpointRecordList(proactiveReserveSats <= 0 || reserveValueChanged
-        ? []
-        : payload.proactiveReserveOutpoints);
-    if (proactiveReserveSats === payload.proactiveReserveSats
-        && sameOutpointList(proactiveReserveOutpoints, payload.proactiveReserveOutpoints)) {
-        return payload;
-    }
-    return {
-        ...payload,
-        proactiveReserveSats,
-        proactiveReserveOutpoints,
-    };
-}
-function isSpendableUtxo(entry) {
-    return entry.spendable !== false && entry.safe !== false;
-}
-function isConfirmedFundingUtxo(state, entry) {
-    return entry.scriptPubKey === state.funding.scriptPubKeyHex
-        && entry.confirmations >= 1
-        && isSpendableUtxo(entry);
-}
-function sortFundingEntriesForReserve(entries) {
-    return entries.slice().sort((left, right) => {
-        const amount = btcNumberToSats(right.amount) - btcNumberToSats(left.amount);
-        if (amount !== 0n) {
-            return amount > 0n ? 1 : -1;
-        }
-        const txid = left.txid.localeCompare(right.txid);
-        if (txid !== 0) {
-            return txid;
-        }
-        return left.vout - right.vout;
-    });
-}
-function isActiveTrackedTransaction(record) {
-    if (record == null) {
-        return false;
-    }
-    return record.status === "broadcasting"
-        || record.status === "broadcast-unknown"
-        || record.status === "live";
-}
-function isActiveTrackedStatus(status) {
-    return status === "broadcasting"
-        || status === "broadcast-unknown"
-        || status === "live";
-}
-function deriveLiveProvisionalOutpointKeys(state) {
-    const keys = new Set();
-    for (const family of state.proactiveFamilies) {
-        if ((family.type !== "anchor" && family.type !== "field") || family.tx1?.attemptedTxid == null) {
-            continue;
-        }
-        if (isActiveTrackedStatus(family.status)) {
-            keys.add(outpointKey({ txid: family.tx1.attemptedTxid, vout: 1 }));
-        }
-    }
-    return keys;
-}
-function deriveAuxiliaryDedicatedOutpoints(state, spendableUtxos) {
-    const canonicalAnchorKeys = new Set(state.domains
-        .map((domain) => domain.currentCanonicalAnchorOutpoint)
-        .filter((outpoint) => outpoint !== null)
-        .map((outpoint) => outpointKey(outpoint)));
-    const dedicatedScriptSet = new Set(state.identities
-        .filter((identity) => identity.status === "dedicated")
-        .map((identity) => identity.scriptPubKeyHex));
-    const liveProvisionalKeys = deriveLiveProvisionalOutpointKeys(state);
-    const auxiliary = [];
-    const seen = new Set();
-    for (const entry of spendableUtxos) {
-        if (!isSpendableUtxo(entry) || !dedicatedScriptSet.has(entry.scriptPubKey)) {
-            continue;
-        }
-        const outpoint = { txid: entry.txid, vout: entry.vout };
-        const key = outpointKey(outpoint);
-        if (canonicalAnchorKeys.has(key) || liveProvisionalKeys.has(key) || seen.has(key)) {
-            continue;
-        }
-        seen.add(key);
-        auxiliary.push(outpoint);
-    }
-    return auxiliary;
-}
-export function computeDesignatedProactiveReserveOutpoints(state, spendableUtxos) {
-    const normalizedState = normalizeWalletStateRecord(state);
-    if (normalizedState.proactiveReserveSats <= 0) {
-        return [];
-    }
-    const conflictKey = normalizedState.miningState.sharedMiningConflictOutpoint === null
-        ? null
-        : outpointKey(normalizedState.miningState.sharedMiningConflictOutpoint);
-    const eligible = sortFundingEntriesForReserve(spendableUtxos.filter((entry) => isConfirmedFundingUtxo(normalizedState, entry)
-        && outpointKey({ txid: entry.txid, vout: entry.vout }) !== conflictKey));
-    const selected = [];
-    let total = 0n;
-    const target = BigInt(normalizedState.proactiveReserveSats);
-    for (const entry of eligible) {
-        selected.push({ txid: entry.txid, vout: entry.vout });
-        total += btcNumberToSats(entry.amount);
-        if (total >= target) {
-            break;
-        }
-    }
-    if (total < target) {
-        return [];
-    }
-    return selected;
+function uniqueLocalScriptPubKeyHexes(state) {
+    return uniqueStrings([
+        state.funding?.scriptPubKeyHex ?? "",
+        ...(state.localScriptPubKeyHexes ?? []),
+        ...((state.identities ?? []).map((identity) => identity?.scriptPubKeyHex ?? "")),
+    ]);
 }
-function syncStateWithComputedReserve(state, spendableUtxos) {
-    const normalizedState = normalizeWalletStateRecord(state);
-    const proactiveReserveOutpoints = computeDesignatedProactiveReserveOutpoints(normalizedState, spendableUtxos);
-    const sameLength = proactiveReserveOutpoints.length === normalizedState.proactiveReserveOutpoints.length;
-    const sameKeys = sameLength && proactiveReserveOutpoints.every((outpoint, index) => outpointKey(outpoint) === outpointKey(normalizedState.proactiveReserveOutpoints[index]));
-    if (sameKeys && normalizedState === state) {
-        return {
-            state,
-            changed: false,
-        };
-    }
-    if (sameKeys) {
-        return {
-            state: normalizedState,
-            changed: true,
-        };
-    }
+function normalizeDomains(rawDomains) {
+    return (rawDomains ?? [])
+        .filter((domain) => typeof domain?.name === "string" && domain.name.trim().length > 0)
+        .map((domain) => ({
+        name: domain.name.trim().toLowerCase(),
+        domainId: domain.domainId ?? null,
+        currentOwnerScriptPubKeyHex: domain.currentOwnerScriptPubKeyHex ?? null,
+        canonicalChainStatus: domain.canonicalChainStatus ?? "unknown",
+        foundingMessageText: domain.foundingMessageText ?? null,
+        birthTime: domain.birthTime ?? null,
+    }))
+        .sort((left, right) => left.name.localeCompare(right.name));
+}
+export function normalizeWalletStateRecord(rawState) {
+    const fundingAddress = rawState.funding?.address
+        ?? rawState.managedCoreWallet?.walletAddress
+        ?? rawState.managedCoreWallet?.fundingAddress0
+        ?? "";
+    const fundingScriptPubKeyHex = rawState.funding?.scriptPubKeyHex
+        ?? rawState.managedCoreWallet?.walletScriptPubKeyHex
+        ?? rawState.managedCoreWallet?.fundingScriptPubKeyHex0
+        ?? "";
+    const localScriptPubKeyHexes = uniqueLocalScriptPubKeyHexes(rawState);
+    const pendingMutations = (rawState.pendingMutations ?? [])
+        .filter((mutation) => mutation.status === "confirmed" || mutation.status === "canceled")
+        .map((mutation) => ({
+        ...mutation,
+        senderLocalIndex: mutation.senderScriptPubKeyHex === fundingScriptPubKeyHex ? 0 : null,
+        senderScriptPubKeyHex: mutation.senderScriptPubKeyHex === ""
+            ? fundingScriptPubKeyHex
+            : mutation.senderScriptPubKeyHex,
+        temporaryBuilderLockedOutpoints: [],
+    }));
     return {
-        state: {
-            ...normalizedState,
-            proactiveReserveOutpoints,
+        schemaVersion: 5,
+        stateRevision: rawState.stateRevision ?? 1,
+        lastWrittenAtUnixMs: rawState.lastWrittenAtUnixMs ?? 0,
+        walletRootId: rawState.walletRootId ?? "",
+        network: rawState.network ?? "mainnet",
+        localScriptPubKeyHexes,
+        mnemonic: {
+            phrase: rawState.mnemonic?.phrase ?? "",
+            language: rawState.mnemonic?.language ?? "english",
         },
-        changed: true,
+        keys: {
+            masterFingerprintHex: rawState.keys?.masterFingerprintHex ?? "",
+            accountPath: rawState.keys?.accountPath ?? "",
+            accountXprv: rawState.keys?.accountXprv ?? "",
+            accountXpub: rawState.keys?.accountXpub ?? "",
+        },
+        descriptor: {
+            privateExternal: rawState.descriptor?.privateExternal ?? "",
+            publicExternal: rawState.descriptor?.publicExternal ?? "",
+            checksum: rawState.descriptor?.checksum ?? null,
+            rangeEnd: rawState.descriptor?.rangeEnd ?? 0,
+            safetyMargin: rawState.descriptor?.safetyMargin ?? 0,
+        },
+        funding: {
+            address: fundingAddress,
+            scriptPubKeyHex: fundingScriptPubKeyHex,
+        },
+        walletBirthTime: rawState.walletBirthTime ?? 0,
+        managedCoreWallet: {
+            walletName: rawState.managedCoreWallet?.walletName ?? "",
+            internalPassphrase: rawState.managedCoreWallet?.internalPassphrase ?? "",
+            descriptorChecksum: rawState.managedCoreWallet?.descriptorChecksum ?? null,
+            walletAddress: rawState.managedCoreWallet?.walletAddress ?? fundingAddress,
+            walletScriptPubKeyHex: rawState.managedCoreWallet?.walletScriptPubKeyHex ?? fundingScriptPubKeyHex,
+            proofStatus: rawState.managedCoreWallet?.proofStatus ?? "not-proven",
+            lastImportedAtUnixMs: rawState.managedCoreWallet?.lastImportedAtUnixMs ?? null,
+            lastVerifiedAtUnixMs: rawState.managedCoreWallet?.lastVerifiedAtUnixMs ?? null,
+        },
+        domains: normalizeDomains(rawState.domains),
+        miningState: normalizeMiningStateRecord(rawState.miningState),
+        pendingMutations,
     };
 }
-function collectInactiveTemporaryBuilderLockCleanup(state) {
-    const normalizedState = normalizeWalletStateRecord(state);
-    const stale = new Map();
-    let familiesChanged = false;
-    let mutationsChanged = false;
-    const proactiveFamilies = normalizedState.proactiveFamilies.map((family) => {
-        let nextFamily = family;
-        for (const key of ["tx1", "tx2"]) {
-            const record = nextFamily[key];
-            if (record == null || isActiveTrackedTransaction(record) || record.temporaryBuilderLockedOutpoints.length === 0) {
-                continue;
-            }
-            for (const outpoint of record.temporaryBuilderLockedOutpoints) {
-                stale.set(outpointKey(outpoint), outpoint);
-            }
-            nextFamily = {
-                ...nextFamily,
-                [key]: {
-                    ...record,
-                    temporaryBuilderLockedOutpoints: [],
-                },
-            };
-            familiesChanged = true;
-        }
-        return nextFamily;
-    });
-    const pendingMutations = (normalizedState.pendingMutations ?? []).map((mutation) => {
-        if (isActiveTrackedStatus(mutation.status) || mutation.temporaryBuilderLockedOutpoints.length === 0) {
-            return mutation;
-        }
-        for (const outpoint of mutation.temporaryBuilderLockedOutpoints) {
-            stale.set(outpointKey(outpoint), outpoint);
-        }
-        mutationsChanged = true;
-        return {
-            ...mutation,
-            temporaryBuilderLockedOutpoints: [],
-        };
-    });
-    if (!familiesChanged && !mutationsChanged && normalizedState === state) {
-        return {
-            state,
-            staleOutpoints: [],
-            changed: false,
-        };
-    }
-    return {
-        state: familiesChanged || mutationsChanged
-            ? {
-                ...normalizedState,
-                proactiveFamilies,
-                pendingMutations,
-            }
-            : normalizedState,
-        staleOutpoints: [...stale.values()],
-        changed: familiesChanged || mutationsChanged || normalizedState !== state,
-    };
-}
-function collectPersistentPolicyLockedOutpoints(state, spendableUtxos) {
-    const outpoints = [];
-    const seen = new Set();
-    const pushUnique = (outpoint) => {
-        if (outpoint === null) {
-            return;
-        }
-        const key = outpointKey(outpoint);
-        if (seen.has(key)) {
-            return;
-        }
-        seen.add(key);
-        outpoints.push(outpoint);
-    };
-    for (const domain of state.domains) {
-        pushUnique(domain.currentCanonicalAnchorOutpoint);
-    }
-    for (const outpoint of deriveAuxiliaryDedicatedOutpoints(state, spendableUtxos)) {
-        pushUnique(outpoint);
-    }
-    for (const outpoint of state.proactiveReserveOutpoints) {
-        pushUnique(outpoint);
-    }
-    if (!miningFamilyMayStillExist(state.miningState)) {
-        pushUnique(state.miningState.sharedMiningConflictOutpoint);
-    }
-    return outpoints;
+export function computeDesignatedProactiveReserveOutpoints(_state, _spendableUtxos) {
+    return [];
 }
 export async function reconcilePersistentPolicyLocks(options) {
-    const rawReserveOutpoints = normalizeOutpointRecordList(options.state.proactiveReserveOutpoints);
-    let state = normalizeWalletStateRecord(options.state);
-    let changed = state !== options.state;
-    const fixedInputKeys = new Set((options.fixedInputs ?? []).map((outpoint) => outpointKey(outpoint)));
-    const temporarilyUnlockedKeys = new Set((options.temporarilyUnlockedOutpoints ?? []).map((outpoint) => outpointKey(outpoint)));
-    if (options.cleanupInactiveTemporaryBuilderLocks === true) {
-        const cleaned = collectInactiveTemporaryBuilderLockCleanup(state);
-        state = cleaned.state;
-        changed ||= cleaned.changed;
-        if (cleaned.staleOutpoints.length > 0) {
-            await options.rpc.lockUnspent(options.walletName, true, cleaned.staleOutpoints).catch(() => undefined);
-        }
-    }
-    const lockedBeforeReserveInspection = await options.rpc.listLockUnspent(options.walletName).catch(() => []);
-    const lockedBeforeReserveInspectionKeys = new Set(lockedBeforeReserveInspection.map((outpoint) => outpointKey(outpoint)));
-    const reserveInspectionUnlocks = rawReserveOutpoints.filter((outpoint) => {
-        const key = outpointKey(outpoint);
-        return lockedBeforeReserveInspectionKeys.has(key) && !fixedInputKeys.has(key);
-    });
-    if (reserveInspectionUnlocks.length > 0) {
-        await options.rpc.lockUnspent(options.walletName, true, reserveInspectionUnlocks).catch(() => undefined);
-    }
-    const spendableUtxos = reserveInspectionUnlocks.length > 0 || options.spendableUtxos === undefined
-        ? await options.rpc.listUnspent(options.walletName, 0).catch(() => [])
-        : options.spendableUtxos;
-    const previouslyProtectedUniverse = collectPersistentPolicyLockedOutpoints(state, spendableUtxos);
-    const reserveSynced = syncStateWithComputedReserve(state, spendableUtxos);
-    state = reserveSynced.state;
-    changed ||= reserveSynced.changed;
-    const protectedUniverse = collectPersistentPolicyLockedOutpoints(state, spendableUtxos);
-    if (protectedUniverse.length === 0 && previouslyProtectedUniverse.length === 0) {
-        return {
-            state,
-            changed,
-            spendableUtxos,
-        };
-    }
-    const protectedUniverseKeys = new Set(protectedUniverse.map((outpoint) => outpointKey(outpoint)));
-    const previouslyProtectedUniverseKeys = new Set(previouslyProtectedUniverse.map((outpoint) => outpointKey(outpoint)));
-    const managedProtectedKeys = new Set([
-        ...protectedUniverseKeys,
-        ...previouslyProtectedUniverseKeys,
-    ]);
-    const locked = await options.rpc.listLockUnspent(options.walletName).catch(() => []);
-    const spendableKeys = new Set(spendableUtxos.map((entry) => outpointKey(entry)));
-    const lockedKeys = new Set(locked.map((outpoint) => outpointKey(outpoint)));
-    const expectedLocked = protectedUniverse.filter((outpoint) => {
-        const key = outpointKey(outpoint);
-        return (spendableKeys.has(key) || lockedKeys.has(key))
-            && !fixedInputKeys.has(key)
-            && !temporarilyUnlockedKeys.has(key);
-    });
-    const expectedLockedKeys = new Set(expectedLocked.map((outpoint) => outpointKey(outpoint)));
-    const lockedManaged = locked.filter((outpoint) => managedProtectedKeys.has(outpointKey(outpoint)));
-    const staleLocked = lockedManaged.filter((outpoint) => !expectedLockedKeys.has(outpointKey(outpoint)));
-    const missingLocked = protectedUniverse.filter((outpoint) => {
-        const key = outpointKey(outpoint);
-        return spendableKeys.has(key)
-            && !fixedInputKeys.has(key)
-            && !temporarilyUnlockedKeys.has(key)
-            && !lockedKeys.has(key);
-    });
-    if (staleLocked.length > 0) {
-        await options.rpc.lockUnspent(options.walletName, true, staleLocked).catch(() => undefined);
-    }
-    if (missingLocked.length > 0) {
-        await options.rpc.lockUnspent(options.walletName, false, missingLocked).catch(() => undefined);
-    }
+    const state = normalizeWalletStateRecord(options.state);
     return {
         state,
-        changed,
-        spendableUtxos,
+        changed: state !== options.state,
+        spendableUtxos: options.spendableUtxos ?? await options.rpc.listUnspent(options.walletName, 0).catch(() => []),
     };
 }
 export async function persistWalletCoinControlStateIfNeeded(options) {
@@ -369,12 +128,10 @@ export async function persistWalletCoinControlStateIfNeeded(options) {
         rpc: options.rpc,
         walletName: options.state.managedCoreWallet.walletName,
         state: options.state,
-        cleanupInactiveTemporaryBuilderLocks: options.cleanupInactiveTemporaryBuilderLocks ?? true,
     });
     if (!reconciled.changed) {
         return {
             changed: false,
-            session: options.session ?? null,
             state: reconciled.state,
         };
     }
@@ -385,22 +142,8 @@ export async function persistWalletCoinControlStateIfNeeded(options) {
         nowUnixMs: options.nowUnixMs,
         replacePrimary: options.replacePrimary,
     });
-    if (options.session == null) {
-        return {
-            changed: true,
-            session: null,
-            state: nextState,
-        };
-    }
-    const nextSession = {
-        ...options.session,
-        walletRootId: nextState.walletRootId,
-        sourceStateRevision: nextState.stateRevision,
-    };
-    await saveUnlockSession(options.paths.walletUnlockSessionPath, nextSession, options.access);
     return {
         changed: true,
-        session: nextSession,
         state: nextState,
     };
 }

package/dist/wallet/descriptor-normalization.d.ts

@@ -1,6 +1,6 @@
 import { type WalletStateSaveAccess } from "./state/storage.js";
 import type { WalletRuntimePaths } from "./runtime.js";
-import type { UnlockSessionStateV1, WalletStateV1 } from "./types.js";
+import type { WalletStateV1 } from "./types.js";
 export interface WalletDescriptorInfoRpc {
     getDescriptorInfo(descriptor: string): Promise<{
         descriptor: string;
@@ -30,13 +30,11 @@ export declare function persistWalletStateUpdate(options: {
 export declare function persistNormalizedWalletDescriptorStateIfNeeded(options: {
     state: WalletStateV1;
     access: WalletStateSaveAccess;
-    session?: UnlockSessionStateV1 | null;
     paths: WalletRuntimePaths;
     nowUnixMs: number;
     replacePrimary?: boolean;
     rpc: WalletDescriptorInfoRpc;
 }): Promise<{
     changed: boolean;
-    session: UnlockSessionStateV1 | null;
     state: WalletStateV1;
 }>;

package/dist/wallet/descriptor-normalization.js

@@ -1,6 +1,5 @@
 import { rm } from "node:fs/promises";
 import { deriveWalletMaterialFromMnemonic } from "./material.js";
-import { saveUnlockSession } from "./state/session.js";
 import { saveWalletState } from "./state/storage.js";
 export function stripDescriptorChecksum(descriptor) {
     return descriptor.replace(/#[A-Za-z0-9]+$/, "");
@@ -76,7 +75,6 @@ export async function persistNormalizedWalletDescriptorStateIfNeeded(options) {
     if (!normalized.changed) {
         return {
             changed: false,
-            session: options.session ?? null,
             state: options.state,
         };
     }
@@ -87,22 +85,8 @@ export async function persistNormalizedWalletDescriptorStateIfNeeded(options) {
         nowUnixMs: options.nowUnixMs,
         replacePrimary: options.replacePrimary,
     });
-    if (options.session === undefined || options.session === null) {
-        return {
-            changed: true,
-            session: options.session ?? null,
-            state: nextState,
-        };
-    }
-    const nextSession = {
-        ...options.session,
-        walletRootId: nextState.walletRootId,
-        sourceStateRevision: nextState.stateRevision,
-    };
-    await saveUnlockSession(options.paths.walletUnlockSessionPath, nextSession, options.access);
     return {
         changed: true,
-        session: nextSession,
         state: nextState,
     };
 }