dexbot 1.3.3 → 1.4.1

package/dist/modules/dexbot_class.d.ts

@@ -112,7 +112,6 @@ declare class DEXBot {
     _credentialRecoveryDeferredTimer: any;
     _structuralGridResyncTimer: any;
     _structuralGridResyncRunning: boolean;
-    _ghostOrderCancelAttempted: Set<string> | null;
     _dustHealthCheckTimer: any;
     _lastBroadcastHeartbeatAt: number | undefined;
     _lastDeferredDustCount: number;
@@ -140,7 +139,7 @@ declare class DEXBot {
      * @param {string} [level='info'] - The log level ('debug', 'info', 'warn', 'error').
      * @private
      */
-    _log(msg: any, level?: string): void;
+    _log(msg: any, level?: any): void;
     /**
      * Log a warning message to the console with the bot's prefix.
      * @param {string} msg - The message to log.
@@ -152,7 +151,7 @@ declare class DEXBot {
      * Used during startup to ensure bot begins in a stable state.
      * @private
      */
-    _persistAndRecoverIfNeeded(): Promise<any>;
+    _persistAndRecoverIfNeeded(): Promise<void>;
     /**
      * Snapshot the recently queued fill keys as a plain object for crash-durable persistence.
      * Merges with any existing snapshot to avoid losing keys that were evicted from the
@@ -160,30 +159,36 @@ declare class DEXBot {
      * Only includes entries within the dedup window to avoid writing stale keys.
      * @returns {Record<string, number>}
      */
-    _getRecentFillKeysSnapshot(): any;
+    _getRecentFillKeysSnapshot(): Record<string, number>;
     /**
      * Get current pipeline signal state for congestion checks.
      * @returns {{incomingFillQueueLength: number, shadowLocks: number, batchInFlight: boolean, recoveryInFlight: boolean, broadcasting: boolean}}
      */
-    _getPipelineSignals(): any;
+    _getPipelineSignals(): {
+        incomingFillQueueLength: any;
+        shadowLocks: any;
+        batchInFlight: any;
+        recoveryInFlight: any;
+        broadcasting: any;
+    };
     /**
      * Mark that grid activity occurred (updates idle timer).
      * @param {string} [reason='activity'] - Reason for activity
      * @returns {void}
      */
-    _markGridActivity(reason?: string): any;
+    _markGridActivity(reason?: any): void;
     /**
      * Trigger a full state recovery sync (fetch chain + sync from open orders + persist).
      * @param {string} [reason='state recovery sync'] - Reason for recovery
      * @returns {Promise<void>}
      */
-    _triggerStateRecoverySync(reason?: string): Promise<any>;
+    _triggerStateRecoverySync(reason?: any): Promise<void>;
     /**
      * Abort the current flow if an illegal state signal was raised.
      * @param {string} flowContext - Description of the flow being aborted
      * @returns {Promise<boolean>} True if flow was aborted
      */
-    _abortFlowIfIllegalState(flowContext: any): Promise<any>;
+    _abortFlowIfIllegalState(flowContext: any): Promise<boolean>;
     /**
      * Handle a hard abort from batch processing due to illegal state or accounting failure.
      * @param {Error} err - The error that triggered the abort
@@ -191,34 +196,57 @@ declare class DEXBot {
      * @param {number} [opsCount=0] - Number of operations in the batch
      * @returns {Promise<Object>} Abort result object
      */
-    _handleBatchHardAbort(err: any, phase?: string, opsCount?: number): Promise<any>;
+    _handleBatchHardAbort(err: any, phase?: any, opsCount?: any): Promise<{
+        abortedForIllegalState: boolean;
+        executed: boolean;
+        hadRotation: boolean;
+    } | {
+        abortedForAccountingFailure: boolean;
+        executed: boolean;
+        hadRotation: boolean;
+    } | null>;
     /**
      * Apply recoverable grid updates (order virtualisation) after a batch failure.
      * @param {Array<Object>} updates - Array of order update objects
      * @param {string} [context='recoverable-grid-update'] - Context label for logging
      * @returns {Promise<number>} Number of updates applied
      */
-    _applyRecoverableGridUpdates(updates: any, context?: string): Promise<any>;
+    _applyRecoverableGridUpdates(updates: any, context?: any): Promise<number>;
     /**
      * Recover from explicit stale order errors by virtualizing affected grid slots.
      * @param {Set<string>|string[]} staleOrderIds - Set or array of stale chain order IDs
      * @param {string} [reason='stale order cleanup'] - Reason for cleanup
      * @returns {Promise<{executed: boolean, hadRotation: boolean, stale: boolean, recoveredByVirtualization?: boolean}>}
      */
-    _recoverExplicitStaleOrders(staleOrderIds: any, reason?: string): Promise<any>;
+    _recoverExplicitStaleOrders(staleOrderIds: any, reason?: any): Promise<{
+        executed: boolean;
+        hadRotation: boolean;
+        stale: boolean;
+        recoveredByVirtualization?: undefined;
+    } | {
+        executed: boolean;
+        hadRotation: boolean;
+        stale: boolean;
+        recoveredByVirtualization: boolean;
+    }>;
     /**
      * Recover from on-chain size drift detected during batch broadcast.
      * @param {Error} err - The size drift error
      * @returns {Promise<{executed: boolean, hadRotation: boolean, recoveredBySync: boolean, reason: string}>}
      */
-    _recoverBatchSizeDrift(err: any, opContexts?: any[]): Promise<any>;
+    _recoverBatchSizeDrift(err: any, opContexts?: any): Promise<{
+        executed: boolean;
+        hadRotation: boolean;
+        recoveredBySync: boolean;
+        reason: string;
+    }>;
     /**
      * Extract chain order IDs from opContexts for operations that could
      * trigger a size-drift error (size-update and rotation update).
      * @param {Array<Object>} opContexts
      * @returns {string[]} Unique chain order IDs
      */
-    _extractSizeDriftOrderIds(opContexts: any): any;
+    _extractSizeDriftOrderIds(opContexts: any): unknown[];
     /**
      * Reload the entire grid from the persisted on-disk snapshot and reconcile
      * with current chain state. Mirrors the startup recovery path.
@@ -229,7 +257,13 @@ declare class DEXBot {
      *
      * @returns {Promise<{success: boolean, reason?: string}>}
      */
-    _recoverFromPersistedGrid(): Promise<any>;
+    _recoverFromPersistedGrid(): Promise<{
+        success: boolean;
+        reason: string;
+    } | {
+        success: boolean;
+        reason?: undefined;
+    }>;
     /**
      * Reject a corrupted grid snapshot when catastrophic fund drift is detected.
      * Shared between startup and recovery paths to avoid duplicating the
@@ -238,7 +272,7 @@ declare class DEXBot {
      * @param {'startup'|'recovery'} context - Controls log prefix.
      * @returns {Promise<boolean>} True if the snapshot was rejected (cleared).
      */
-    _rejectCorruptedGridSnapshot(context: any): Promise<any>;
+    _rejectCorruptedGridSnapshot(context: any): Promise<boolean>;
     /**
      * Attempt to repair size-drift for specific order IDs by reading their
      * current on-chain state and correcting the local grid directly.
@@ -246,26 +280,32 @@ declare class DEXBot {
      * @param {string[]} orderIds
      * @returns {Promise<boolean>} True if all affected orders were repaired
      */
-    _targetedOrderRepair(orderIds: any): Promise<any>;
+    _targetedOrderRepair(orderIds: any): Promise<boolean>;
     /**
      * Initialize bot state from storage and blockchain.
      * Consolidates common initialization logic for start() and startWithPrivateKey().
      * @returns {{persistedGrid: Object, persistedBtsFeesOwed: number, persistedBoundaryIdx: number, persistedBtsBalance: number, persistedRecentFillKeys: Object}}
      * @private
      */
-    _initializeStartupState(): Promise<any>;
+    _initializeStartupState(): Promise<{
+        persistedGrid: any;
+        persistedBtsFeesOwed: any;
+        persistedBoundaryIdx: any;
+        persistedBtsBalance: any;
+        persistedRecentFillKeys: any;
+    }>;
     /**
      * Wire processed fill tracking into the manager.
      * @returns {void}
      */
-    _wireProcessedFillTracking(): any;
+    _wireProcessedFillTracking(): void;
     /**
      * Flush pending processed fill persistence to disk.
      * @param {string} [reason='manual'] - Reason for flushing
      * @param {Object} [options={}] - Flush options
      * @returns {Promise<void>}
      */
-    _flushProcessedFillPersistence(reason?: string, options?: {}): Promise<any>;
+    _flushProcessedFillPersistence(reason?: any, options?: any): Promise<void>;
     /**
      * Flush persistence for specific fill keys.
      * @param {Set<string>|string[]} fillKeys - Fill keys to persist
@@ -273,20 +313,20 @@ declare class DEXBot {
      * @param {Object} [options={}] - Flush options
      * @returns {Promise<void>}
      */
-    _flushProcessedFillPersistenceForKeys(fillKeys: any, reason?: string, options?: {}): Promise<any>;
+    _flushProcessedFillPersistenceForKeys(fillKeys: any, reason?: any, options?: any): Promise<void>;
     /**
      * Discard pending persistence for specific fill keys.
      * @param {string[]|Set<string>} fillKeys - Fill keys to discard
      * @returns {void}
      */
-    _discardPendingProcessedFillPersistence(fillKeys: any): any;
+    _discardPendingProcessedFillPersistence(fillKeys: any): void;
     /**
      * Build a fallback deduplication key for an orphan fill (when standard keys are unavailable).
      * @param {Object} fill - Fill event object
      * @returns {string|null} Fallback key or null
      */
-    _buildOrphanFillFallbackKey(fill: any): any;
-    _isNewFillKey(fillKey: any, processedFillKeys: any, label?: string, orderId?: string): boolean;
+    _buildOrphanFillFallbackKey(fill: any): string | null;
+    _isNewFillKey(fillKey: any, processedFillKeys: any, label?: any, orderId?: any): boolean;
     /**
      * Apply replay-safe fill accounting using a provided fill key.
      * @param {Object} fill - Fill event object
@@ -315,7 +355,22 @@ declare class DEXBot {
         replayLevel?: string;
         persistenceMode?: any;
         allowOrphanFallbackKey?: boolean;
-    }): Promise<any>;
+    }): Promise<{
+        status: string;
+        fillKey: any;
+        usedFallbackKey?: undefined;
+        error?: undefined;
+    } | {
+        status: string;
+        fillKey: any;
+        usedFallbackKey: boolean;
+        error?: undefined;
+    } | {
+        status: string;
+        fillKey: any;
+        error: any;
+        usedFallbackKey?: undefined;
+    }>;
     /**
      * Apply replay-safe fill accounting for tracked fills (those with a valid grid order).
      * @param {Object} fill - Fill event object
@@ -332,7 +387,22 @@ declare class DEXBot {
         logger?: any;
         replayMessage?: any;
         persistenceMode?: any;
-    }): Promise<any>;
+    }): Promise<{
+        status: string;
+        fillKey: any;
+        usedFallbackKey?: undefined;
+        error?: undefined;
+    } | {
+        status: string;
+        fillKey: any;
+        usedFallbackKey: boolean;
+        error?: undefined;
+    } | {
+        status: string;
+        fillKey: any;
+        error: any;
+        usedFallbackKey?: undefined;
+    }>;
     /**
      * Apply replay-safe fill accounting for orphan fills (grid order not found).
      * @param {Object} fill - Fill event object
@@ -349,20 +419,45 @@ declare class DEXBot {
         logger?: any;
         replayMessage?: any;
         persistenceMode?: any;
-    }): Promise<any>;
+    }): Promise<{
+        status: string;
+        fillKey: any;
+        usedFallbackKey?: undefined;
+        error?: undefined;
+    } | {
+        status: string;
+        fillKey: any;
+        usedFallbackKey: boolean;
+        error?: undefined;
+    } | {
+        status: string;
+        fillKey: any;
+        error: any;
+        usedFallbackKey?: undefined;
+    }>;
     /**
      * Refresh dynamic weight distribution from market adapter.
      * @param {string} [context='runtime'] - Context label for logging
      * @returns {import('./types').DynamicWeightRefreshResult|null}
      */
-    _refreshDynamicWeightDistribution(context?: string): any;
+    _refreshDynamicWeightDistribution(context?: any): {
+        applied: boolean;
+        source: string;
+        weightDistribution: any;
+        snapshotUpdatedAt?: undefined;
+    } | {
+        applied: boolean;
+        source: string;
+        weightDistribution: any;
+        snapshotUpdatedAt: any;
+    };
     /**
      * Finalize the bot startup after account and initial grid sync are complete.
      * Consolidates common logic for start() and startWithPrivateKey().
      * @param {Object} startupState - The startup state from _initializeStartupState.
      * @private
      */
-    _finishStartupSequence(startupState: any): Promise<any>;
+    _finishStartupSequence(startupState: any): Promise<void>;
     /**
      * Create the fill callback for listenForFills.
      * Separated from start() to allow deferred activation after startup completes.
@@ -370,14 +465,19 @@ declare class DEXBot {
      * @returns {Function} Async callback for processing fills
      * @private
      */
-    _createFillCallback(chainOrders: any): any;
+    _createFillCallback(chainOrders: any): (fills: any) => Promise<void>;
     /**
      * Read open orders from chain, sync with local state, and process any fills found.
      * Shared helper used by post-reset spread check and targeted drift reconciliation.
      * @param {string} tag - Context label for logging
      * @returns {Promise<{syncResult: Object|null, aborted: boolean, hasUnmatched: number, openOrders: Array|null}>}
      */
-    _syncOpenOrdersAndProcessFills(tag: any): Promise<any>;
+    _syncOpenOrdersAndProcessFills(tag: any): Promise<{
+        syncResult: any;
+        aborted: boolean;
+        hasUnmatched: any;
+        openOrders: any;
+    }>;
     _maxConsecutiveFillConsumerFailures(): any;
     /**
      * Compute the backoff delay for fill-consumer retries after the failure
@@ -388,7 +488,7 @@ declare class DEXBot {
      * @returns {number} Delay in milliseconds before the next retry.
      * @private
      */
-    _computeFillConsumerBackoffMs(failures: any): any;
+    _computeFillConsumerBackoffMs(failures: any): number;
     _scheduleFillConsumerRestart(chainOrders: any): void;
     /**
      * Consume queued fills from incomingFillQueue and rebalance.
@@ -403,7 +503,7 @@ declare class DEXBot {
      * @param {Object} chainOrders - Chain orders module for blockchain operations
      * @private
      */
-    _consumeFillQueue(chainOrders: any): Promise<any>;
+    _consumeFillQueue(chainOrders: any): Promise<void>;
     /**
      * Process fills during bootstrap phase using the standard fill pipeline.
      *
@@ -421,7 +521,7 @@ declare class DEXBot {
      * @param {Object} chainOrders - Chain orders instance for broadcasting
      * @returns {Promise<void>}
      */
-    _processFillsWithBootstrapMode(chainOrders: any): Promise<any>;
+    _processFillsWithBootstrapMode(chainOrders: any): Promise<void>;
     /**
      * Set up account identifier and configure global context.
      * @param {string} accountName - The name of the account to set up
@@ -439,7 +539,7 @@ declare class DEXBot {
      * Places initial orders on the blockchain.
      * @returns {Promise<void>}
      */
-    placeInitialOrders(): Promise<any>;
+    placeInitialOrders(): Promise<void>;
     /**
      * Build outside-in pair groups for initial order placement.
      * @param {Array<Object>} orders - Array of order objects
@@ -463,7 +563,7 @@ declare class DEXBot {
      * @param {string} [warnContext=''] - Context for warning messages
      * @returns {Array} Array of operation result entries
      */
-    _extractOperationResults(result: any, warnContext?: string): any;
+    _extractOperationResults(result: any, warnContext?: any): any[];
     /**
      * Find CREATE operation contexts whose broadcast result did not include a chain order id.
      *
@@ -471,7 +571,10 @@ declare class DEXBot {
      * @param {Array<Object>} opContexts - Operation context metadata aligned with operations.
      * @returns {Array<{index:number, ctx:Object}>} Missing create result contexts.
      */
-    _findMissingCreateResultContexts(operationResults: any, opContexts: any): any;
+    _findMissingCreateResultContexts(operationResults: any, opContexts: any): {
+        index: number;
+        ctx: any;
+    }[];
     /**
      * Run an immediate chain sync after a successful CREATE broadcast returned incomplete ids.
      *
@@ -483,7 +586,7 @@ declare class DEXBot {
      * @param {string} [reason] - Human-readable recovery context for logs.
      * @returns {Promise<void>}
      */
-    _recoverAfterMissingCreateResults(reason?: string): Promise<any>;
+    _recoverAfterMissingCreateResults(reason?: any): Promise<void>;
     /**
      * Restore unresolved missing-create blockers after recovery if sync did not adopt them.
      *
@@ -491,7 +594,7 @@ declare class DEXBot {
      * @param {Object} recoveryResult - Result returned by manager.syncFromOpenOrders.
      * @returns {void}
      */
-    _preserveMissingCreateBlockersAfterRecovery(blockers: any, recoveryResult: any): any;
+    _preserveMissingCreateBlockersAfterRecovery(blockers: any, recoveryResult: any): void;
     /**
      * Merge missing CREATE result contexts into manager._lastUnmatchedChainOrders.
      *
@@ -503,7 +606,7 @@ declare class DEXBot {
      * @param {Array<{index:number, ctx:Object}>} missingCreateResults - Missing CREATE results.
      * @returns {void}
      */
-    _markMissingCreateResultsAsStructuralBlocker(missingCreateResults: any): any;
+    _markMissingCreateResultsAsStructuralBlocker(missingCreateResults: any): void;
     /**
      * Format an unmatched chain order/blocker for COW logs.
      *
@@ -531,7 +634,7 @@ declare class DEXBot {
      * @param {Object} entry.finalInts - { amountToSell, minToReceive, ... } blockchain integers
      * @returns {void}
      */
-    _recordPendingBroadcast(entry: any): any;
+    _recordPendingBroadcast(entry: any): void;
     /**
      * Clear the pending-broadcast cache.
      *
@@ -540,7 +643,7 @@ declare class DEXBot {
      * recovery adoption (matched entries are explicitly removed by
      * _reconcileAfterUncertainBroadcast before calling this).
      */
-    _clearPendingBroadcasts(): any;
+    _clearPendingBroadcasts(): void;
     /**
      * Build a fingerprint for an on-chain order so it can be matched against
      * the pending-broadcast cache.
@@ -561,7 +664,13 @@ declare class DEXBot {
      * @param {Object} chainOrder
      * @returns {{side: string, assetA: string, assetB: string, sellInt: number, receiveInt: number}|null}
      */
-    _normalizeChainOrderForPendingMatch(chainOrder: any): any;
+    _normalizeChainOrderForPendingMatch(chainOrder: any): {
+        side: any;
+        assetA: any;
+        assetB: any;
+        sellInt: number;
+        receiveInt: number;
+    } | null;
     /**
      * Find a chain order that matches a planned slot using price+size proximity.
      *
@@ -605,7 +714,19 @@ declare class DEXBot {
      * @returns {Promise<Object>} Result object compatible with batch return shape
      */
     _reconcileAfterUncertainBroadcast(err: any, opContexts: any, options?: Record<string, any>): Promise<any>;
-    _reconcileAfterUncertainBroadcastImpl(err: any, opContexts: any, options: any): Promise<any>;
+    _reconcileAfterUncertainBroadcastImpl(err: any, opContexts: any, options: any): Promise<{
+        executed: boolean;
+        hadRotation: boolean;
+        uncertain: boolean;
+        adoptedCount?: undefined;
+        discardedCount?: undefined;
+    } | {
+        executed: boolean;
+        hadRotation: boolean;
+        uncertain: boolean;
+        adoptedCount: number;
+        discardedCount: number;
+    }>;
     /**
      * Auto-cancel a price-drift orphan from the unmatched-order snapshot.
      *
@@ -631,13 +752,48 @@ declare class DEXBot {
      *
      * @returns {Promise<{cancelled: boolean, orderId?: string, reason?: string}>}
      */
-    _autoCancelOneUnmatchedOrphan(): Promise<any>;
+    _autoCancelOneUnmatchedOrphan(): Promise<{
+        cancelled: boolean;
+        reason: string;
+        subCount: any;
+        message?: undefined;
+        orderId?: undefined;
+        error?: undefined;
+    } | {
+        cancelled: boolean;
+        reason: string;
+        subCount?: undefined;
+        message?: undefined;
+        orderId?: undefined;
+        error?: undefined;
+    } | {
+        cancelled: boolean;
+        reason: string;
+        message: string;
+        subCount?: undefined;
+        orderId?: undefined;
+        error?: undefined;
+    } | {
+        cancelled: boolean;
+        orderId: any;
+        reason?: undefined;
+        subCount?: undefined;
+        message?: undefined;
+        error?: undefined;
+    } | {
+        cancelled: boolean;
+        reason: string;
+        error: any;
+        subCount?: undefined;
+        message?: undefined;
+        orderId?: undefined;
+    }>;
     /**
      * Check whether to execute creates in outside-in pair mode (mixed BUY/SELL operations).
      * @param {Array<Object>} opContexts - Operation contexts array
      * @returns {boolean} True if pair mode should be used
      */
-    _shouldExecuteCreatePairMode(opContexts: any): any;
+    _shouldExecuteCreatePairMode(opContexts: any): boolean;
     /**
      * Execute operations with retry on BroadcastUncertainError.
      * The daemon already retries internally against a 25s deadline.
@@ -647,14 +803,20 @@ declare class DEXBot {
      * execution where earlier groups already committed). Re-broadcasting
      * the full operations array would duplicate those creates on chain.
      */
-    _executeWithRetryOnUncertain(operations: any, opContexts: any): Promise<any>;
+    _executeWithRetryOnUncertain(operations: any, opContexts: any): Promise<{
+        result: any;
+        opContexts: any;
+    }>;
     /**
      * Execute blockchain operations with appropriate strategy (single batch or pair mode).
      * @param {Array<import('./types').CreatedOperation>} operations - Array of operation objects
      * @param {Array<Object>} opContexts - Array of operation context metadata (1:1 with operations)
      * @returns {Promise<{result: Object, opContexts: Array}>} Execution result with contexts
      */
-    _executeOperationsWithStrategy(operations: any, opContexts: any): Promise<any>;
+    _executeOperationsWithStrategy(operations: any, opContexts: any): Promise<{
+        result: any;
+        opContexts: any;
+    }>;
     /**
      * Validate that operations can be executed with available funds before broadcasting.
      * Checks sufficient available funds for all operations.
@@ -664,14 +826,22 @@ declare class DEXBot {
      * @returns {Object} { isValid: boolean, summary: string }
      * @private
      */
-    _validateOperationFunds(operations: any, assetA: any, assetB: any): any;
+    _validateOperationFunds(operations: any, assetA: any, assetB: any): {
+        isValid: boolean;
+        summary: string;
+        violations?: undefined;
+    } | {
+        isValid: boolean;
+        summary: string;
+        violations: any[];
+    };
     /**
      * Resolve the ideal size from an order-like object with fallback.
      * @param {Object|null} orderLike - Order-like object with optional idealSize/size nested properties
      * @param {number|null} [fallbackSize=null] - Fallback size if none found
      * @returns {number|null} Resolved size or null
      */
-    _resolveIdealSizeForValidation(orderLike: any, fallbackSize?: any): any;
+    _resolveIdealSizeForValidation(orderLike: any, fallbackSize?: any): number | null;
     /**
      * Validate that an order size is safe to execute (above minimum dust thresholds).
      * @param {number} size - Order size to validate
@@ -687,7 +857,7 @@ declare class DEXBot {
      * @param {string} [contextLabel='rebalance'] - Context label for logging
      * @returns {Promise<Object>} Batch execution result
      */
-    _executeBatchIfNeeded(rebalanceResult: any, contextLabel?: string): Promise<any>;
+    _executeBatchIfNeeded(rebalanceResult: any, contextLabel?: any): Promise<any>;
     /**
      * Process filled orders in capped batches per FILL_PROCESSING.MAX_FILL_BATCH_SIZE.
      * Each chunk triggers its own processFilledOrders → COW plan → broadcast cycle.
@@ -698,7 +868,7 @@ declare class DEXBot {
      * @param {Object} [options={}] - Passed through to processFilledOrders
      * @returns {{aborted: boolean}}
      */
-    _processFillsWithBatching(fills: any, excl: any, contextLabel: any, options?: {}): Promise<{
+    _processFillsWithBatching(fills: any, excl: any, contextLabel: any, options?: any): Promise<{
         aborted: boolean;
     }>;
     /**
@@ -724,7 +894,7 @@ declare class DEXBot {
      * @returns {Promise<void>}
      * @throws {Error} With code CREDENTIAL_DAEMON_UNAVAILABLE if daemon is down
      */
-    _ensureCredentialDaemonWritable(contextLabel?: string): Promise<void>;
+    _ensureCredentialDaemonWritable(contextLabel?: any): Promise<void>;
     /**
      * Check if an error is related to credential daemon unavailability.
      * @param {Error|*} err - Error to check
@@ -765,13 +935,18 @@ declare class DEXBot {
      * @param {Object|Array} plan - Plan object with ordersToPlace/ordersToRotate/ordersToUpdate/ordersToCancel, or array of ordersToPlace
      * @returns {Array<{type: string, id: string, order?: Object, orderId?: string, newSize?: number, newPrice?: number, newGridId?: string}>}
      */
-    _buildActionsFromPlan(plan: any): any;
+    _buildActionsFromPlan(plan: any): any[];
     /**
      * Build a COW result object (workingGrid + actions) from a simple plan.
      * @param {Object|Array} plan - Plan object or array of ordersToPlace
      * @returns {{workingGrid: import('./types').WorkingGrid, workingIndexes: Object, workingBoundary: number, actions: Array}}
      */
-    _buildCowResultFromPlan(plan: any): any;
+    _buildCowResultFromPlan(plan: any): {
+        workingGrid: any;
+        workingIndexes: any;
+        workingBoundary: any;
+        actions: any[];
+    };
     /**
      * Restore skipped update slots in the working grid to master state.
      * @param {import('./types').WorkingGrid} workingGrid - Working grid to restore slots into
@@ -779,7 +954,7 @@ declare class DEXBot {
      * @param {number} [skippedCount=0] - Count of skipped actions for logging
      * @returns {void}
      */
-    _restoreSkippedUpdateSlotsInWorkingGrid(workingGrid: any, skippedSlotIds: any, skippedCount?: number): any;
+    _restoreSkippedUpdateSlotsInWorkingGrid(workingGrid: any, skippedSlotIds: any, skippedCount?: any): void;
     /**
      * COW broadcast: Execute blockchain operations and commit working grid on success.
      * Master grid is ONLY updated after successful blockchain confirmation.
@@ -788,7 +963,11 @@ declare class DEXBot {
      * @private
      */
     _updateOrdersOnChainBatchCOW(cowResult: any): Promise<any>;
-    _processBatchResults(result: any, opContexts: any): Promise<any>;
+    _processBatchResults(result: any, opContexts: any): Promise<{
+        executed: boolean;
+        hadRotation: boolean;
+        updateOperationCount: number;
+    }>;
     /**
      * Perform grid recalculation triggered by trigger file.
      * Reloads config from disk, recalculates grid, resets funds, and removes trigger file.
@@ -797,20 +976,20 @@ declare class DEXBot {
      * @returns {Promise<boolean>} True if resync succeeded
      * @private
      */
-    _performGridResync(options?: {}): Promise<any>;
+    _performGridResync(options?: any): Promise<boolean>;
     /**
      * Handle any pending trigger file reset at startup.
      * This is called FIRST during startup before any grid operations.
      * @returns {Promise<boolean>} True if trigger reset completed successfully, false otherwise
      * @private
      */
-    _handlePendingTriggerReset(): Promise<any>;
+    _handlePendingTriggerReset(): Promise<boolean>;
     /**
      * Setup trigger file detection for grid reset.
      * Monitors the trigger file and performs grid resync when it's created.
      * @private
      */
-    _setupTriggerFileDetection(): Promise<any>;
+    _setupTriggerFileDetection(): Promise<void>;
     /**
      * Starts the bot's operation.
      * @param {string|Object|Buffer} [vaultSecret=null] - The unlock secret.
@@ -839,31 +1018,31 @@ declare class DEXBot {
      *
      * @private
      */
-    _performPeriodicGridChecks(): Promise<any>;
-    _isOpenOrdersSyncLoopEnabled(): any;
+    _performPeriodicGridChecks(): Promise<void>;
+    _isOpenOrdersSyncLoopEnabled(): boolean;
     /**
      * Start the open-orders watchdog sync loop.
      * Uses fill lock contention checks to avoid competing with fill processing.
      * @private
      */
-    _startOpenOrdersSyncLoop(): any;
+    _startOpenOrdersSyncLoop(): void;
     /**
      * Stop the open-orders watchdog sync loop.
      * @private
      */
-    _stopOpenOrdersSyncLoop(): Promise<any>;
+    _stopOpenOrdersSyncLoop(): Promise<void>;
     /**
      * Set up periodic blockchain account balance fetch interval.
      * Fetches available funds at regular intervals to keep blockchain variables up-to-date.
      * @private
      */
-    _setupBlockchainFetchInterval(): any;
+    _setupBlockchainFetchInterval(): void;
     /**
      * Stop the periodic blockchain fetch interval.
      * @private
      */
-    _stopBlockchainFetchInterval(): any;
-    _releaseMarketAdapterRuntime(context?: string): Promise<any>;
+    _stopBlockchainFetchInterval(): void;
+    _releaseMarketAdapterRuntime(context?: any): Promise<any>;
     /**
      * Get or create the credit runtime for debt policy management.
      * @returns {import('./credit_runtime').CreditRuntime|null}
@@ -885,7 +1064,7 @@ declare class DEXBot {
      * @param {Object} [options={}] - Maintenance options
      * @returns {Promise<*>} Maintenance result from runtime
      */
-    _runCreditRuntimeMaintenance(context?: string, options?: {}): Promise<any>;
+    _runCreditRuntimeMaintenance(context?: any, options?: any): Promise<any>;
     /**
      * Start the credit deal watchdog interval.
      * @returns {void}
@@ -896,11 +1075,11 @@ declare class DEXBot {
      * @returns {void}
      */
     _stopCreditWatchdogInterval(): void;
-    requestGridReset(reason?: string, options?: {
+    requestGridReset(reason?: any, options?: {
         refreshCenterPrice?: boolean;
         [key: string]: any;
     }): Promise<any>;
-    _wireStructuralGridResyncRequest(): any;
+    _wireStructuralGridResyncRequest(): void;
     /**
      * Get current metrics for monitoring and debugging.
      * @returns {Object} Metrics snapshot
@@ -937,7 +1116,7 @@ declare class DEXBot {
      * @param {Object} context - Maintenance context for logging.
      * @private
      */
-    _executeMaintenanceLogic(context: any): Promise<any>;
+    _executeMaintenanceLogic(context: any): Promise<void>;
     /**
      * Cancel dust partial orders immediately — no maps, no timers, no delay.
      * Each dust order is cancelled on chain and its slot rotated through the
@@ -946,10 +1125,15 @@ declare class DEXBot {
      * @returns {Promise<{cancelledCount: number, batchResult: {aborted: boolean}|null}>}
      * @private
      */
-    _cancelDustOrders({ buy: buyDust, sell: sellDust }?: {
-        buy?: any[];
-        sell?: any[];
-    }): Promise<any>;
+    _cancelDustOrders({ buy: buyDust, sell: sellDust }?: any): Promise<{
+        cancelledCount: number;
+        batchResult: null;
+    } | {
+        cancelledCount: number;
+        batchResult: {
+            aborted: any;
+        };
+    }>;
     /**
      * Run a single dust health check cycle: inspect grid for partials below the
      * configured dust threshold and cancel them immediately inside the fill-
@@ -957,7 +1141,7 @@ declare class DEXBot {
      * once at startup.
      * @private
      */
-    _runDustHealthCheck(): Promise<any>;
+    _runDustHealthCheck(): Promise<void>;
     /**
      * Set up the periodic dust health check interval.
      * Catches partials below the dust threshold that were missed by the post-fill
@@ -965,7 +1149,7 @@ declare class DEXBot {
      * Calls _runDustHealthCheck on each tick.
      * @private
      */
-    _setupDustHealthCheckInterval(): any;
+    _setupDustHealthCheckInterval(): void;
     /**
      * Perform grid maintenance: fund thresholds, spread condition, grid health, divergence.
      * Consolidates maintenance checks used during startup, periodic updates, and post-fill.
@@ -990,7 +1174,7 @@ declare class DEXBot {
      * @param {Object} options - Maintenance options
      * @private
      */
-    _runGridMaintenance(context?: string, options?: {}): Promise<any>;
+    _runGridMaintenance(context?: any, options?: any): Promise<void>;
     /**
      * Gracefully shutdown the bot.
      * Waits for current fill processing to complete, persists state, and stops intervals.
@@ -1001,8 +1185,5 @@ declare class DEXBot {
     shutdown(): Promise<void>;
     _shutdownImpl(): Promise<void>;
 }
-declare const _default: typeof DEXBot & {
-    normalizeBotEntry: any;
-};
-export = _default;
+export default DEXBot;
 //# sourceMappingURL=dexbot_class.d.ts.map