@spirobel/monero-wallet-api 0.5.5 → 0.6.0

package/dist/scanning-syncing/connectionStatus.js

@@ -13,7 +13,42 @@ export function applyWalletScanProgress(cs, progress) {
     if (progress.eta !== undefined) {
         cs.sync.eta = progress.eta;
     }
-    cs.sync.timestamp = new Date().toISOString();
+    const now = new Date().toISOString();
+    cs.sync.timestamp = now;
+    // finished batch is a heartbeat so buffer-full catch-up does not look dead
+    if (cs.last_packet) {
+        cs.last_packet.timestamp = now;
+    }
+}
+// idle tip: ok packet has daemon height but no work item wrote sync yet
+export function applyLastPacket(cs, packet) {
+    cs.last_packet = packet;
+    if (packet.status === "OK" && typeof packet.daemon_height === "number") {
+        cs.sync.daemon_height = packet.daemon_height;
+        if (!cs.sync.current_scan_height) {
+            cs.sync.current_scan_height = packet.daemon_height;
+        }
+    }
+}
+export function isConnectedFromStatus(cs) {
+    if (!cs?.last_packet)
+        return false;
+    const { status, timestamp } = cs.last_packet;
+    // fetch paused on purpose while cpu drains the buffer. not a drop.
+    if (status === "blocks_buffer_full")
+        return true;
+    if (status !== "OK")
+        return false;
+    // catching up: slow get_blocks_bin is not a drop. 10s rule is for tip idle only.
+    const behind = cs.sync.daemon_height > 0 &&
+        cs.sync.current_scan_height > 0 &&
+        cs.sync.daemon_height - cs.sync.current_scan_height > 100;
+    if (behind)
+        return true;
+    if (!timestamp)
+        return false;
+    const age = Date.now() - new Date(timestamp).getTime();
+    return age >= 0 && age <= 10_000;
 }
 export const DEFAULT_CONNECTION_STATUS_PREFIX = "ConnectionStatus-";
 export function msToHHMM(ms) {

package/dist/scanning-syncing/connectionStatusOpened.d.ts

@@ -1,4 +1,4 @@
-import { type ConnectionStatus } from "../api";
+import { type ConnectionStatus } from "./connectionStatus";
 export declare class ConnectionStatusOpened {
     private _onChange?;
     private _timer;

package/dist/scanning-syncing/connectionStatusOpened.js

@@ -1,4 +1,4 @@
-import { readConnectionStatusFile, connectionStatusFilePath, } from "../api";
+import { readConnectionStatusFile, connectionStatusFilePath, isConnectedFromStatus, } from "./connectionStatus";
 export class ConnectionStatusOpened {
     _onChange;
     _timer;
@@ -27,16 +27,7 @@ export class ConnectionStatusOpened {
         return this._cached;
     }
     get isConnected() {
-        const cs = this._cached;
-        if (!cs?.last_packet)
-            return false;
-        const { status, timestamp } = cs.last_packet;
-        if (status !== "OK" && status !== "blocks_buffer_full")
-            return false;
-        if (!timestamp)
-            return false;
-        const age = Date.now() - new Date(timestamp).getTime();
-        return age >= 0 && age <= 10_000;
+        return isConnectedFromStatus(this._cached);
     }
     get daemonHeight() {
         return this._cached?.sync?.daemon_height;

package/dist/scanning-syncing/scanresult/scanCache.d.ts

@@ -20,6 +20,7 @@ export declare function lastRangeThrows(ranges: CacheRange[]): CacheRange;
 export declare function mergeRanges(ranges: CacheRange[]): CacheRange[];
 export declare const findRange: (ranges: CacheRange[], value: number) => CacheRange | null;
 export declare function findRangeThrows(ranges: CacheRange[], value: number): CacheRange;
+export declare function currentScanHeightFromRanges(ranges: CacheRange[], start_height: number): number;
 export type CacheRange = {
     start: number;
     end: number;
@@ -67,6 +68,9 @@ export type TxLog = {
     feeEstimate?: FeeEstimateResponse;
     sendResult?: SendRawTransactionResult;
     error?: string;
+    invocationId?: string;
+    signed_tx?: string;
+    hidden_on_send_plate?: boolean;
 };
 export type ChangeReason = "spent" | "added" | "ownspend" | "reorged" | "reorged_spent" | "burned";
 export type ChangedOutput = {
@@ -95,4 +99,4 @@ export interface HasPrimaryAddress {
     primary_address: string;
 }
 export declare function handleScanError(error: unknown): void;
-export declare function isConnectionError(error: unknown): true | undefined;
+export declare function isConnectionError(error: unknown): boolean;

package/dist/scanning-syncing/scanresult/scanCache.js

@@ -158,6 +158,10 @@ export function findRangeThrows(ranges, value) {
         throw new Error(`range not found for value: ${value}`);
     return range;
 }
+// end of the range that contains start_height. miss means we scan from start
+export function currentScanHeightFromRanges(ranges, start_height) {
+    return findRange(ranges, start_height)?.end ?? start_height ?? 0;
+}
 export function handleScanError(error) {
     // treat errno 0 code "ConnectionRefused" as non fatal outcome, and rethrow,
     // so that UI can be informed after catching it higher up
@@ -185,10 +189,15 @@ export function isConnectionError(error) {
     if (error &&
         typeof error === "object" &&
         (("code" in error && error.code === "ConnectionRefused") ||
-            ("errno" in error && error.errno === 0))) {
+            ("errno" in error && error.errno === 0) ||
+            ("message" in error &&
+                typeof error.message === "string" &&
+                (error.message.includes("Failed to fetch") ||
+                    error.message.includes("ERR_INTERNET_DISCONNECTED") ||
+                    error.message.includes("NetworkError"))))) {
         return true;
     }
     else {
-        false;
+        return false;
     }
 }

package/dist/scanning-syncing/scanresult/scanCacheOpened.d.ts

@@ -1,6 +1,7 @@
 import { ViewPair, type FeeEstimateResponse, type Output, type SendRawTransactionResult } from "../../api";
 import { type Payment } from "../../send-functionality/inputSelection";
 import { ConnectionStatusOpened } from "../connectionStatusOpened";
+import { ActionLogOpened, type ActionLogBackendKind, type ExtensionMessageBus } from "../../actionlog/actionLogOpened";
 import type { LogSetting, PossibleLogs } from "../../io/logging";
 import { type CacheChangedCallback, type CacheChangedCallbackParameters, type ScanCache, type Subaddress, type TxLog } from "./scanCache";
 import { type FoundTransaction, type PrePendingTx } from "./scanStats";
@@ -19,6 +20,7 @@ export type CreateTransactionParams = {
     payments: Payment[];
     inputs?: Output[];
     no_fee_circuit_breaker?: boolean;
+    invocationId?: string;
 };
 export declare class ScanCacheOpened {
     private _scanSettings;
@@ -101,6 +103,23 @@ export declare class ScanCacheOpened {
     get subaddresses(): Subaddress[];
     get tx_logs(): TxLog[];
     makeSignSendTransaction(params: CreateTransactionParams): Promise<SendRawTransactionResult>;
+    private outputsForIndexes;
+    makeSignSend(params: {
+        payments: Payment[];
+        input_indexes: string[];
+    }): Promise<SendRawTransactionResult>;
+    sweepSignSend(params: {
+        address: string;
+        input_indexes: string[];
+    }): Promise<SendRawTransactionResult>;
+    rebroadcastTx(txLogIndex: number): Promise<SendRawTransactionResult>;
+    get failed_txs(): {
+        index: number;
+        txlog: TxLog;
+        inputs: Output[];
+    }[];
+    private recordSend;
+    dismissSendPlate(): Promise<void>;
     /**
      * makeStandardTransaction
      */
@@ -182,9 +201,14 @@ export type ManyScanCachesOpenedCreateOptions = {
     logs?: LogSetting;
     logs_include?: PossibleLogs[];
     logs_exclude?: PossibleLogs[];
+    actionLogPath?: string;
+    actionLogBackend?: ActionLogBackendKind;
+    onActionLogChange?: (() => void) | null;
+    extensionMessageBus?: ExtensionMessageBus;
 };
 export declare class ManyScanCachesOpened {
     readonly connectionStatusOpened: ConnectionStatusOpened;
+    readonly actionLogOpened: ActionLogOpened;
     private _scanSettings;
     private _options;
     get start_height(): number | null;
@@ -195,6 +219,27 @@ export declare class ManyScanCachesOpened {
     stopWorker(): Promise<void>;
     dumpWorkerHeaps(dir?: string): Promise<string[]>;
     changeNodeUrl(node_url: string): Promise<void>;
+    private walletByAddress;
+    makeSignSend(params: {
+        primary_address: string;
+        payments: {
+            address: string;
+            amount: string;
+        }[];
+        input_indexes: string[];
+    }): Promise<SendRawTransactionResult | undefined>;
+    sweepSignSend(params: {
+        primary_address: string;
+        address: string;
+        input_indexes: string[];
+    }): Promise<SendRawTransactionResult | undefined>;
+    rebroadcastTx(params: {
+        primary_address: string;
+        tx_log_index: number;
+    }): Promise<SendRawTransactionResult | undefined>;
+    dismissSendPlate(params: {
+        primary_address: string;
+    }): Promise<void>;
     get merchant_confirmations(): number | null | undefined;
     get cpu_worker_count(): number | undefined;
     get logs(): LogSetting | undefined;
@@ -206,7 +251,7 @@ export declare class ManyScanCachesOpened {
     unwatchConnectionStatus(): void;
     setMerchantConfirmations(merchant_confirmations: number | null): Promise<void>;
     setCpuWorkerCount(cpu_worker_count: number | undefined): Promise<void>;
-    setLogSettings(logs?: LogSetting | null, logs_include?: PossibleLogs[] | null, logs_exclude?: PossibleLogs[] | null): Promise<void>;
+    setLogSettings(logs?: LogSetting | null, logs_include?: string[] | null, logs_exclude?: string[] | null): Promise<void>;
     setWalletName(primary_address: string, name?: string): Promise<void>;
     setWalletSlot(primary_address: string, slot?: number): Promise<void>;
     changeStartHeight(start_height: number | null): Promise<void>;