dexbot 1.3.2 → 1.3.3

package/dist/modules/dexbot_cow_runtime.d.ts

@@ -0,0 +1,319 @@
+/**
+ * modules/dexbot_cow_runtime.ts - COW (Copy-on-Write) Batch Execution Runtime
+ *
+ * Handles on-chain order execution with Copy-on-Write working grid semantics,
+ * broadcast uncertainty recovery, and result processing.
+ *
+ * Each function takes the DEXBot instance as its first parameter, following
+ * the same pattern as dexbot_fill_runtime.ts.
+ */
+/**
+ * Group orders into outside-in pairs for atomic create execution.
+ * @param {Array} orders
+ * @returns {Array<Array>}
+ */
+declare function buildOutsideInPairGroupsForOrders(orders: any): any;
+/**
+ * Build outside-in pair groups for create entry contexts.
+ * @param {Array} createEntries
+ * @returns {Array<Array>}
+ */
+declare function buildOutsideInPairGroupsForCreateEntries(createEntries: any): any;
+/**
+ * Extract operation results from a batch transaction result.
+ * @param {Object|Array|null} result
+ * @param {string} [warnContext='']
+ * @param {Function} [logFn] - Optional logger function, called with (msg, level) on unrecognized shape
+ * @returns {Array}
+ */
+declare function extractOperationResults(result: any, warnContext?: string, logFn?: any): any[];
+/**
+ * Find CREATE operation contexts whose broadcast result did not include a chain order id.
+ * @param {Array} operationResults
+ * @param {Array} opContexts
+ * @returns {Array<{index:number, ctx:Object}>}
+ */
+declare function findMissingCreateResultContexts(operationResults: any, opContexts: any): any[];
+/**
+ * Run an immediate chain sync after a successful CREATE broadcast returned incomplete ids.
+ * @param {import('./dexbot_class').DEXBot} bot
+ * @param {string} [reason]
+ * @returns {Promise<void>}
+ */
+declare function recoverAfterMissingCreateResults(bot: any, reason?: string): Promise<void>;
+/**
+ * Restore unresolved missing-create blockers after recovery if sync did not adopt them.
+ * @param {import('./dexbot_class').DEXBot} bot
+ * @param {Array} blockers
+ * @param {Object} recoveryResult
+ */
+declare function preserveMissingCreateBlockersAfterRecovery(bot: any, blockers: any, recoveryResult: any): void;
+/**
+ * Merge missing CREATE result contexts into manager._lastUnmatchedChainOrders.
+ * @param {import('./dexbot_class').DEXBot} bot
+ * @param {Array<{index:number, ctx:Object}>} missingCreateResults
+ */
+declare function markMissingCreateResultsAsStructuralBlocker(bot: any, missingCreateResults: any): void;
+/**
+ * Format an unmatched chain order for COW logs.
+ * @param {Object} order
+ * @returns {string}
+ */
+declare function formatUnmatchedChainOrderForLog(order: any): any;
+/**
+ * Record a pending CREATE broadcast on the manager.
+ * @param {import('./dexbot_class').DEXBot} bot
+ * @param {Object} entry
+ */
+declare function recordPendingBroadcast(bot: any, entry: any): void;
+/**
+ * Clear the pending-broadcast cache.
+ * @param {Map} pendingBroadcasts
+ */
+declare function clearPendingBroadcasts(pendingBroadcasts: any): void;
+/**
+ * Build a fingerprint for an on-chain order so it can be matched against
+ * the pending-broadcast cache.
+ * @param {import('./dexbot_class').DEXBot} bot
+ * @param {Object} chainOrder
+ * @param {string} slotId
+ * @returns {string|null}
+ */
+declare function buildChainOrderFingerprint(bot: any, chainOrder: any, slotId: any): any;
+/**
+ * Normalize raw BitShares limit_order_object data into the integer tuple
+ * used by pending-broadcast recovery.
+ * @param {import('./dexbot_class').DEXBot} bot
+ * @param {Object} chainOrder
+ * @returns {{side: string, assetA: string, assetB: string, sellInt: number, receiveInt: number}|null}
+ */
+declare function normalizeChainOrderForPendingMatch(bot: any, chainOrder: any): {
+    side: any;
+    assetA: any;
+    assetB: any;
+    sellInt: number;
+    receiveInt: number;
+};
+/**
+ * Find a chain order that matches a planned slot using price+size proximity.
+ * @param {import('./dexbot_class').DEXBot} bot
+ * @param {Array} chainOrders - Open chain orders for the account
+ * @param {string} slotId - Planned grid slot id
+ * @param {Object} planned - { sell, receive, orderType } integers from the planned op
+ * @returns {Object|null} Matching chain order, or null
+ */
+declare function findChainOrderForSlot(bot: any, chainOrders: any, slotId: any, planned: any): any;
+/**
+ * Reconcile a broadcast whose chain state is unknown.
+ * Thin wrapper that optionally acquires _fillProcessingLock before delegating.
+ * @param {import('./dexbot_class').DEXBot} bot
+ * @param {BroadcastUncertainError} err
+ * @param {Array<Object>} opContexts
+ * @param {Object} [options]
+ * @returns {Promise<Object>}
+ */
+declare function reconcileAfterUncertainBroadcast(bot: any, err: any, opContexts: any, options?: Record<string, any>): Promise<any>;
+/**
+ * Reconcile a broadcast whose chain state is unknown (implementation).
+ * @param {import('./dexbot_class').DEXBot} bot
+ * @param {BroadcastUncertainError} err
+ * @param {Array<Object>} opContexts
+ * @param {Object} options
+ * @returns {Promise<Object>}
+ */
+declare function reconcileAfterUncertainBroadcastImpl(bot: any, 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 one unmatched orphan (price-drift orphan) per cycle.
+ * @param {import('./dexbot_class').DEXBot} bot
+ * @returns {Promise<{cancelled: boolean, reason?: string, orderId?: string}>}
+ */
+declare function autoCancelOneUnmatchedOrphan(bot: any): 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.
+ * @param {import('./dexbot_class').DEXBot} bot
+ * @param {Array} opContexts
+ * @returns {boolean}
+ */
+declare function shouldExecuteCreatePairMode(bot: any, opContexts: any): boolean;
+/**
+ * Execute operations with retry on BroadcastUncertainError.
+ * @param {import('./dexbot_class').DEXBot} bot
+ * @param {Array} operations
+ * @param {Array} opContexts
+ * @returns {Promise<{result: Object, opContexts: Array}>}
+ */
+declare function executeWithRetryOnUncertain(bot: any, operations: any, opContexts: any): Promise<{
+    result: any;
+    opContexts: any;
+}>;
+/**
+ * Execute blockchain operations with appropriate strategy (single batch or pair mode).
+ * @param {import('./dexbot_class').DEXBot} bot
+ * @param {Array} operations
+ * @param {Array} opContexts
+ * @returns {Promise<{result: Object, opContexts: Array}>}
+ */
+declare function executeOperationsWithStrategy(bot: any, operations: any, opContexts: any): Promise<{
+    result: any;
+    opContexts: any;
+}>;
+/**
+ * Validate that operations can be executed with available funds before broadcasting.
+ * @param {import('./dexbot_class').DEXBot} bot
+ * @param {Array} operations
+ * @param {Object} assetA
+ * @param {Object} assetB
+ * @returns {Object} { isValid: boolean, summary: string }
+ */
+declare function validateOperationFunds(bot: any, 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 {import('./dexbot_class').DEXBot} bot
+ * @param {Object|null} orderLike
+ * @param {number|null} [fallbackSize=null]
+ * @returns {number|null}
+ */
+declare function resolveIdealSizeForValidation(bot: any, orderLike: any, fallbackSize?: any): number;
+/**
+ * Validate that an order size is safe to execute.
+ * @param {import('./dexbot_class').DEXBot} bot
+ * @param {number} size
+ * @param {string} type
+ * @param {Object|null} [orderLike=null]
+ * @param {number|null} [fallbackSize=null]
+ * @returns {import('./types').OrderValidationResult}
+ */
+declare function validateOrderSizeForExecution(bot: any, size: any, type: any, orderLike?: any, fallbackSize?: any): any;
+/**
+ * Build COW actions array from a simple plan object.
+ * @param {import('./dexbot_class').DEXBot} bot
+ * @param {Object|Array} plan
+ * @returns {Array}
+ */
+declare function buildActionsFromPlan(bot: any, plan: any): any[];
+/**
+ * Build a COW result object (workingGrid + actions) from a simple plan.
+ * @param {import('./dexbot_class').DEXBot} bot
+ * @param {Object|Array} plan
+ * @returns {{workingGrid: import('./types').WorkingGrid, workingIndexes: Object, workingBoundary: number, actions: Array}}
+ */
+declare function buildCowResultFromPlan(bot: any, plan: any): {
+    workingGrid: any;
+    workingIndexes: any;
+    workingBoundary: any;
+    actions: any[];
+};
+/**
+ * Restore skipped update slots in the working grid to master state.
+ * @param {import('./dexbot_class').DEXBot} bot
+ * @param {import('./types').WorkingGrid} workingGrid
+ * @param {Set<string>} skippedSlotIds
+ * @param {number} [skippedCount=0]
+ */
+declare function restoreSkippedUpdateSlotsInWorkingGrid(bot: any, workingGrid: any, skippedSlotIds: any, skippedCount?: number): void;
+/**
+ * COW broadcast: Execute blockchain operations and commit working grid on success.
+ * @param {import('./dexbot_class').DEXBot} bot
+ * @param {Object} cowResult
+ * @returns {Promise<Object>}
+ */
+declare function updateOrdersOnChainBatchCOW(bot: any, cowResult: any): Promise<any>;
+/**
+ * Process results from batch transaction execution.
+ * Updates order state, synchronizes with chain, and deducts BTS fees.
+ * @param {import('./dexbot_class').DEXBot} bot
+ * @param {Object} result
+ * @param {Array} opContexts
+ * @returns {Object} Result with { executed: boolean, hadRotation: boolean }
+ */
+declare function processBatchResults(bot: any, result: any, opContexts: any): Promise<{
+    executed: boolean;
+    hadRotation: boolean;
+    updateOperationCount: number;
+}>;
+declare const _default: {
+    buildOutsideInPairGroupsForOrders: typeof buildOutsideInPairGroupsForOrders;
+    buildOutsideInPairGroupsForCreateEntries: typeof buildOutsideInPairGroupsForCreateEntries;
+    extractOperationResults: typeof extractOperationResults;
+    findMissingCreateResultContexts: typeof findMissingCreateResultContexts;
+    recoverAfterMissingCreateResults: typeof recoverAfterMissingCreateResults;
+    preserveMissingCreateBlockersAfterRecovery: typeof preserveMissingCreateBlockersAfterRecovery;
+    markMissingCreateResultsAsStructuralBlocker: typeof markMissingCreateResultsAsStructuralBlocker;
+    formatUnmatchedChainOrderForLog: typeof formatUnmatchedChainOrderForLog;
+    recordPendingBroadcast: typeof recordPendingBroadcast;
+    clearPendingBroadcasts: typeof clearPendingBroadcasts;
+    buildChainOrderFingerprint: typeof buildChainOrderFingerprint;
+    normalizeChainOrderForPendingMatch: typeof normalizeChainOrderForPendingMatch;
+    findChainOrderForSlot: typeof findChainOrderForSlot;
+    reconcileAfterUncertainBroadcast: typeof reconcileAfterUncertainBroadcast;
+    reconcileAfterUncertainBroadcastImpl: typeof reconcileAfterUncertainBroadcastImpl;
+    autoCancelOneUnmatchedOrphan: typeof autoCancelOneUnmatchedOrphan;
+    shouldExecuteCreatePairMode: typeof shouldExecuteCreatePairMode;
+    executeWithRetryOnUncertain: typeof executeWithRetryOnUncertain;
+    executeOperationsWithStrategy: typeof executeOperationsWithStrategy;
+    validateOperationFunds: typeof validateOperationFunds;
+    resolveIdealSizeForValidation: typeof resolveIdealSizeForValidation;
+    validateOrderSizeForExecution: typeof validateOrderSizeForExecution;
+    buildActionsFromPlan: typeof buildActionsFromPlan;
+    buildCowResultFromPlan: typeof buildCowResultFromPlan;
+    restoreSkippedUpdateSlotsInWorkingGrid: typeof restoreSkippedUpdateSlotsInWorkingGrid;
+    updateOrdersOnChainBatchCOW: typeof updateOrdersOnChainBatchCOW;
+    processBatchResults: typeof processBatchResults;
+};
+export = _default;
+//# sourceMappingURL=dexbot_cow_runtime.d.ts.map

package/dist/modules/dexbot_cow_runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dexbot_cow_runtime.d.ts","sourceRoot":"","sources":["../../modules/dexbot_cow_runtime.ts"],"names":[],"mappings":"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"}