dexbot 1.4.6 → 1.4.8

package/dist/modules/order/grid_reconcile_internal.js

@@ -62,6 +62,7 @@ exports._buildOutsideInCreateGroups = _buildOutsideInCreateGroups;
 exports._executePlannedStartupCreates = _executePlannedStartupCreates;
 exports._reconcileStartupSide = _reconcileStartupSide;
 const constants_1 = require("../constants");
+const chain_orders_1 = require("../chain_orders");
 const math_1 = require("./utils/math");
 const order_1 = require("./utils/order");
 const system_1 = require("./utils/system");
@@ -90,10 +91,41 @@ function _countActiveOnGrid(manager, type) {
 function _pickVirtualSlotsToActivate(manager, type, count) {
     if (count <= 0)
         return [];
+    // Boundary geometry: slots in the spread band (between boundary and
+    // sellStart) must never be activated as BUY/SELL — an order placed there
+    // would sit inside the gap and remove the spread. The SPREAD GUARD keeps
+    // such slots typed BUY/SELL (never SPREAD+ACTIVE), so a VIRTUAL sell left
+    // behind by a rotation/rebalance could otherwise be re-picked here and
+    // placed back inside the gap. Filter by geometry, not just type.
+    const gapSlots = (manager._gapSlots ?? calculateGapSlotsFromConfig(manager)) || 0;
+    const boundaryIdx = manager.boundaryIdx;
+    const sellStartIdx = (boundaryIdx !== null && Number.isFinite(Number(boundaryIdx)))
+        ? Number(boundaryIdx) + gapSlots + 1
+        : null;
+    const slotIndex = (id) => {
+        if (typeof id !== 'string')
+            return null;
+        const match = /^slot-(\d+)$/.exec(id);
+        if (!match)
+            return null;
+        const idx = parseInt(match[1], 10);
+        return Number.isFinite(idx) ? idx : null;
+    };
+    const inRail = (slot) => {
+        if (sellStartIdx === null)
+            return true;
+        const idx = slotIndex(slot.id);
+        if (idx === null)
+            return true;
+        if (type === constants_1.ORDER_TYPES.BUY)
+            return idx <= Number(boundaryIdx);
+        return idx >= sellStartIdx;
+    };
     // CRITICAL FIX: Filter by type BEFORE sorting
     // Only get slots of the requested type (SELL or BUY), not a mix
     const slotsOfType = Array.from(manager.orders.values())
         .filter((slot) => slot && slot.type === type)
+        .filter(inRail)
         .sort((a, b) => type === constants_1.ORDER_TYPES.BUY ? b.price - a.price : a.price - b.price);
     let effectiveMin = 0;
     try {
@@ -116,6 +148,14 @@ function _pickVirtualSlotsToActivate(manager, type, count) {
     }
     return valid;
 }
+function calculateGapSlotsFromConfig(manager) {
+    try {
+        return (0, math_1.calculateGapSlots)(manager?.config?.incrementPercent, manager?.config?.targetSpreadPercent, manager?.config?.gridLimits);
+    }
+    catch (e) {
+        return null;
+    }
+}
 function _getStartupSideComparators(orderType, assets) {
     const isSell = orderType === constants_1.ORDER_TYPES.SELL;
     const sortUpdateComparator = isSell
@@ -265,16 +305,16 @@ async function _cancelLargestOrder({ chainOrders, account, privateKey, manager,
  * @param {boolean} params.dryRun - Whether to simulate.
  * @returns {Promise<void>}
  */
-async function _createOrderFromGrid({ chainOrders, account, privateKey, manager, gridOrder, dryRun }) {
+async function _createOrderFromGrid({ chainOrders, account, privateKey, manager, gridOrder, dryRun, extraOptions = {} }) {
     if (dryRun)
-        return;
+        return null;
     // ATOMIC RE-VERIFICATION: Ensure slot is still virtual and hasn't been filled by recovery sync.
     // This protects the same slot (own orderId). The collision check below protects
     // against other slots at the same price — the two are complementary.
     const currentSlot = manager.orders.get(gridOrder.id);
     if (currentSlot && currentSlot.orderId) {
         manager.logger?.log?.(`[_createOrderFromGrid] SKIP: Slot ${gridOrder.id} already has orderId ${currentSlot.orderId}`, 'warn');
-        return;
+        return null;
     }
     // Price collision guard: reject if another placed order already exists at this price level.
     const createPrice = gridOrder.price;
@@ -283,41 +323,64 @@ async function _createOrderFromGrid({ chainOrders, account, privateKey, manager,
     if (priceCollision) {
         manager.logger?.log?.(`[_createOrderFromGrid] SKIP: Create for ${gridOrder.id} at ${Format.formatPrice6(createPrice)} ` +
             `collides with placed order ${priceCollision.id} (${priceCollision.orderId}) at ${Format.formatPrice6(priceCollision.price)}`, 'warn');
-        return;
+        return null;
     }
     const { amountToSell, sellAssetId, minToReceive, receiveAssetId } = (0, order_1.buildCreateOrderArgs)(gridOrder, manager.assets.assetA, manager.assets.assetB);
-    const result = await chainOrders.createOrder(account, privateKey, amountToSell, sellAssetId, minToReceive, receiveAssetId, null, false);
+    const result = await chainOrders.createOrder(account, privateKey, amountToSell, sellAssetId, minToReceive, receiveAssetId, null, false, extraOptions);
     if (result && result.skipped) {
         const logger = manager && manager.logger;
         logger?.log?.(`[_createOrderFromGrid] Skipped slot ${gridOrder.id}: order amounts too small to place on-chain`, 'warn');
-        return;
+        return null;
     }
     const operationResults = (0, order_1.extractBatchOperationResults)(result) || [];
     const chainOrderId = operationResults[0] && operationResults[0][1];
     if (chainOrderId) {
-        const btsFeeData = (0, math_1.getAssetFees)('BTS');
-        // Centralized Fund Tracking: Use manager's sync core to handle state transition and fund deduction
-        await manager._applySync({
-            gridOrderId: gridOrder.id,
-            chainOrderId,
-            isPartialPlacement: false,
-            expectedType: gridOrder.type,
-            fee: btsFeeData.createFee
-        }, 'createOrder');
+        // Capture chain order ID BEFORE _applySync, so even if _applySync
+        // fails (leaving the order unregistered in manager.orders), Phase 3
+        // will still know this order was legitimately created and avoid cancelling it.
+        const capturedId = chainOrderId;
+        try {
+            const btsFeeData = (0, math_1.getAssetFees)('BTS');
+            await manager._applySync({
+                gridOrderId: gridOrder.id,
+                chainOrderId,
+                isPartialPlacement: false,
+                expectedType: gridOrder.type,
+                fee: btsFeeData.createFee
+            }, 'createOrder');
+        }
+        catch (syncErr) {
+            const logger = manager && manager.logger;
+            logger?.log?.(`[_createOrderFromGrid] _applySync failed after successful broadcast for ${capturedId}: ${(0, errors_1.getErrorMessage)(syncErr)}`, 'error');
+            // Run recovery sync to register the orphaned order. If this also
+            // fails (or the chain read is empty/truncated), the returned
+            // capturedId still prevents Phase 3 cancellation.
+            await _recoverSyncFromChain({
+                chainOrders,
+                manager,
+                account,
+                logger,
+                source: 'createOrder-applySync-failure',
+            });
+            // Return the captured ID regardless so Phase 3 knows this order was
+            // legitimately created and avoids cancelling it.
+            return capturedId;
+        }
+        return capturedId;
     }
     else {
         // CRITICAL FIX: Recovery sync if order extraction fails
         const logger = manager && manager.logger;
         logger?.log?.(`[_createOrderFromGrid] CRITICAL: createOrder succeeded but chainOrderId extraction failed`, 'error');
-        try {
-            const freshChainOrders = await chainOrders.readOpenOrders((0, system_1.resolveAccountRef)(manager, account), constants_1.TIMING.CONNECTION_TIMEOUT_MS);
-            await manager.syncFromOpenOrders(freshChainOrders, {
-                skipAccounting: false,
-                source: 'chainOrderIdExtractionFailure',
-            });
-        }
-        catch (syncErr) {
-            logger?.log?.(`[_createOrderFromGrid] Recovery sync failed: ${(0, errors_1.getErrorMessage)(syncErr)}`, 'error');
+        const recovered = await _recoverSyncFromChain({
+            chainOrders,
+            manager,
+            account,
+            logger,
+            source: 'chainOrderIdExtractionFailure',
+        });
+        if (!recovered) {
+            logger?.log?.(`[_createOrderFromGrid] Recovery sync unavailable; zeroing slot ${gridOrder.id} to prevent duplicate creation`, 'error');
             // Transition the slot to zero-size VIRTUAL to prevent duplicate
             // creation on the next COW cycle. The orphaned chain order will
             // be picked up by the next normal full sync.
@@ -334,6 +397,7 @@ async function _createOrderFromGrid({ chainOrders, account, privateKey, manager,
             }
         }
     }
+    return null;
 }
 /**
  * Cancel a chain order and sync with manager.
@@ -356,11 +420,23 @@ async function _cancelChainOrder({ chainOrders, account, privateKey, manager, ch
         return;
     const cancelResult = await chainOrders.cancelOrder(account, privateKey, chainOrderId);
     if (cancelResult?.verifiedAfterFailure) {
-        const freshChainOrders = await chainOrders.readOpenOrders((0, system_1.resolveAccountRef)(manager, account), constants_1.TIMING.CONNECTION_TIMEOUT_MS);
-        await manager.syncFromOpenOrders(freshChainOrders, {
-            skipAccounting: false,
+        const recovered = await _recoverSyncFromChain({
+            chainOrders,
+            manager,
+            account,
+            logger: manager && manager.logger,
             source: 'cancelOrder',
         });
+        if (!recovered) {
+            // The cancellation was authoritatively confirmed absent inside
+            // cancelOrder, but the recovery refetch was skipped (empty/
+            // truncated read — ambiguous, so the full sync must NOT run) or
+            // failed. The order is provably gone, so apply the local cancel
+            // sync to release its capital and clear the slot — same fallback
+            // as the dust-cancel path. Skipping it would leave the slot stuck
+            // ACTIVE with a chain order that no longer exists.
+            await manager._applySync({ orderId: chainOrderId }, 'cancelOrder');
+        }
     }
     else {
         await manager._applySync({ orderId: chainOrderId }, 'cancelOrder');
@@ -370,14 +446,37 @@ async function _cancelChainOrder({ chainOrders, account, privateKey, manager, ch
     if (releaseUntrackedFunds && manager.accountant && chainOrderObj) {
         const parsed = (0, order_1.parseChainOrder)(chainOrderObj, manager.assets);
         if (parsed && parsed.size != null && parsed.size > 0) {
-            await manager.accountant.addToChainFree(parsed.type, parsed.size, 'startup-cancel-unmatched');
+            await manager._fundLock.acquire(async () => {
+                await manager.accountant.addToChainFree(parsed.type, parsed.size, 'startup-cancel-unmatched');
+            });
         }
     }
 }
-async function _recoverStartupSyncFailure({ chainOrders, manager, account, logger, triggerMessage, source }) {
+/**
+ * Recovery sync from a fresh chain read, guarded against ambiguous snapshots.
+ * An empty read (node may be lagging behind a just-broadcast transaction) and
+ * a truncated read (get_full_accounts caps the limit_orders window; fresh
+ * orders sort last and are the first entries omitted) are both treated as
+ * unreadable: running syncFromOpenOrders on them would let pass-1 phantom
+ * cleanup virtualize ACTIVE/PARTIAL slots that are actually live on chain,
+ * after which the next cycle re-creates them and duplicates the orders.
+ * Returns the fresh orders when the sync ran, null when skipped/failed.
+ * @returns {Promise<any[] | null>}
+ * @private
+ */
+async function _recoverSyncFromChain({ chainOrders, manager, account, logger, source, triggerMessage, skipMessage }) {
     try {
-        logger?.log?.(triggerMessage, 'warn');
-        const freshChainOrders = await chainOrders.readOpenOrders((0, system_1.resolveAccountRef)(manager, account), constants_1.TIMING.CONNECTION_TIMEOUT_MS);
+        if (triggerMessage)
+            logger?.log?.(triggerMessage, 'warn');
+        const freshChainOrders = await (0, chain_orders_1.readOpenOrdersGuarded)(chainOrders, (0, system_1.resolveAccountRef)(manager, account), {
+            log: (message, level) => logger?.log?.(message, level),
+            label: 'RECOVERY',
+            deferEmpty: true,
+            timeoutMs: constants_1.TIMING.CONNECTION_TIMEOUT_MS,
+            skipMessage: skipMessage || 'Recovery sync skipped - empty/truncated chain read is ambiguous (node may be lagging, or the get_full_accounts window omitted fresh orders); deferring to next reconcile cycle',
+        });
+        if (freshChainOrders === null)
+            return null;
         await manager.syncFromOpenOrders(freshChainOrders, {
             skipAccounting: false,
             source,
@@ -385,10 +484,22 @@ async function _recoverStartupSyncFailure({ chainOrders, manager, account, logge
         return freshChainOrders;
     }
     catch (syncErr) {
-        logger?.log?.(`Startup: Recovery sync failed: ${(0, errors_1.getErrorMessage)(syncErr)}`, 'error');
+        logger?.log?.(`Recovery sync failed: ${(0, errors_1.getErrorMessage)(syncErr)}`, 'error');
         return null;
     }
 }
+async function _recoverStartupSyncFailure({ chainOrders, manager, account, logger, triggerMessage, source }) {
+    return _recoverSyncFromChain({
+        chainOrders,
+        manager,
+        account,
+        logger,
+        source,
+        triggerMessage,
+        skipMessage: 'Startup: Recovery sync skipped - empty/truncated chain read is ambiguous (node may be lagging, ' +
+            'or the get_full_accounts window omitted fresh orders); deferring to next reconcile cycle',
+    });
+}
 function _refreshStartupUpdatePlans(updatePlans, chainOpenOrders) {
     if (!Array.isArray(updatePlans) || updatePlans.length === 0)
         return [];
@@ -440,7 +551,9 @@ function _prepareStartupUpdatePlan(plan, manager, logger) {
 async function _finalizeStartupUpdate({ manager, preparedUpdate }) {
     const { plan, parsedChain } = preparedUpdate;
     if (parsedChain && parsedChain.size > 0 && manager.accountant) {
-        await manager.accountant.addToChainFree(plan.gridOrder.type, parsedChain.size, 'startup-align');
+        await manager._fundLock.acquire(async () => {
+            await manager.accountant.addToChainFree(plan.gridOrder.type, parsedChain.size, 'startup-align');
+        });
     }
     // Extract deferred_fee from the raw chain order object so the fee
     // lifecycle (cancel refunds, fill maker discounts) reconstructs
@@ -582,23 +695,126 @@ async function _executeStartupSequentialUpdateFallback({ updatePlans, chainOrder
     }
     return { executed, skipped, failed };
 }
-async function _createStartupOrderWithHandling({ chainOrders, account, privateKey, manager, gridOrder, orderLabel, dryRun, recovery, }) {
+/**
+ * Verify whether an uncertain startup create actually landed on chain, and if
+ * so adopt it via a chain sync so the slot is registered with its real orderId.
+ * Returns the chain order id when the create landed.
+ * Returns the string 'unknown' when the chain state could NOT be verified
+ * (read failure, an empty read which is indistinguishable from a lagging
+ * node that missed the just-broadcast transaction, or a truncated read whose
+ * capped result set omits the fresh create) — the caller must NOT
+ * re-broadcast on 'unknown', or a landed order would be duplicated.
+ * Returns null only on AUTHORITATIVE absence: a successful non-empty,
+ * non-truncated read that contains no matching order. In that case
+ * re-broadcasting is safe.
+ * @private
+ */
+async function _adoptPossiblyLandedCreate({ chainOrders, manager, account, gridOrder, }) {
     try {
-        await _createOrderFromGrid({ chainOrders, account, privateKey, manager, gridOrder, dryRun });
+        // Truncated reads omit the newest limit orders (by_account index
+        // order) — exactly the create this check is verifying — and empty
+        // reads are indistinguishable from a lagging node that missed the
+        // just-broadcast transaction. Both are unverifiable; absence is only
+        // authoritative on a clean, non-empty read.
+        const freshChainOrders = await (0, chain_orders_1.readOpenOrdersGuarded)(chainOrders, (0, system_1.resolveAccountRef)(manager, account), {
+            deferEmpty: true,
+            timeoutMs: constants_1.TIMING.CONNECTION_TIMEOUT_MS,
+        });
+        if (freshChainOrders === null) {
+            return 'unknown';
+        }
+        const assets = manager?.assets;
+        if (!assets?.assetA || !assets?.assetB)
+            return 'unknown';
+        let matched = null;
+        for (const o of freshChainOrders) {
+            const parsed = (0, order_1.parseChainOrder)(o, assets);
+            if (!parsed || parsed.type !== gridOrder.type)
+                continue;
+            if (parsed.orderId && Array.from(manager.orders.values()).some((g) => g.orderId === parsed.orderId))
+                continue;
+            if (!(0, order_1.chainOrderMatchesSlot)(parsed, gridOrder, assets))
+                continue;
+            matched = o;
+            break;
+        }
+        if (!matched)
+            return null;
+        await manager.syncFromOpenOrders(freshChainOrders, {
+            // Accounting enabled: the landed order must be committed in the
+            // optimistic balances (VIRTUAL→ACTIVE locks its capital), or the
+            // funds appear free while locked on chain — same policy as
+            // _recoverStartupSyncFailure and the group-uncertain adoption.
+            skipAccounting: false,
+            source: 'startup-create-uncertain-adopt',
+        });
+        // Deduct the create fee: syncFromOpenOrders activates the slot and locks
+        // its capital but does not apply the on-chain create cost. The group
+        // batch path and the grid_reconcile adoption loop both apply it via
+        // _applySync(fee: createFee) — mirror that here so the optimistic
+        // balance reflects the real chain cost.
+        const btsFeeData = (0, math_1.getAssetFeesSafe)('BTS');
+        await manager._applySync({
+            gridOrderId: gridOrder.id,
+            chainOrderId: matched.id,
+            isPartialPlacement: false,
+            expectedType: gridOrder.type,
+            fee: btsFeeData?.createFee || 0,
+        }, 'createOrder');
+        return matched.id || null;
     }
-    catch (err) {
-        manager?.logger?.log?.(`Startup: Failed to create ${orderLabel}: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
-        if (recovery && recovery.triggerMessage && recovery.source) {
-            await _recoverStartupSyncFailure({
-                chainOrders,
-                manager,
-                account,
-                logger: manager?.logger,
-                triggerMessage: recovery.triggerMessage,
-                source: recovery.source,
-            });
+    catch (adoptErr) {
+        manager?.logger?.log?.(`Startup: Uncertain-create adoption check failed for ${gridOrder?.id}: ${(0, errors_1.getErrorMessage)(adoptErr)}`, 'warn');
+        return 'unknown';
+    }
+}
+async function _createStartupOrderWithHandling({ chainOrders, account, privateKey, manager, gridOrder, orderLabel, dryRun, recovery, }) {
+    const maxAttempts = 2;
+    let failedWithUncertain = false;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+            const chainOrderId = await _createOrderFromGrid({ chainOrders, account, privateKey, manager, gridOrder, dryRun });
+            if (chainOrderId)
+                return chainOrderId;
+            return null;
         }
+        catch (err) {
+            const isUncertain = err?.code === 'BROADCAST_UNCERTAIN' || err?.name === 'BroadcastUncertainError';
+            manager?.logger?.log?.(`Startup: Failed to create ${orderLabel} (attempt ${attempt}/${maxAttempts}${isUncertain ? ', uncertain broadcast' : ''}): ${(0, errors_1.getErrorMessage)(err)}`, 'error');
+            if (!isUncertain)
+                break;
+            failedWithUncertain = true;
+            const landed = await _adoptPossiblyLandedCreate({ chainOrders, manager, account, gridOrder });
+            if (landed && landed !== 'unknown') {
+                manager?.logger?.log?.(`Startup: Uncertain create for ${orderLabel} confirmed on chain (${landed}); adopted via chain sync`, 'warn');
+                return landed;
+            }
+            if (landed === 'unknown') {
+                // Chain state unverifiable (lagging/empty read). Re-broadcasting
+                // now could duplicate an order that actually landed; defer the
+                // create to the next startup reconcile cycle instead.
+                manager?.logger?.log?.(`Startup: Uncertain create for ${orderLabel} could not be verified on chain; deferring re-broadcast to next reconcile cycle (duplicate-order protection)`, 'warn');
+                break;
+            }
+            if (attempt < maxAttempts) {
+                manager?.logger?.log?.(`Startup: Uncertain create for ${orderLabel} not found on chain; retrying (authoritative absence verified)`, 'warn');
+            }
+        }
+    }
+    if (recovery && recovery.triggerMessage && recovery.source) {
+        await _recoverStartupSyncFailure({
+            chainOrders,
+            manager,
+            account,
+            logger: manager?.logger,
+            triggerMessage: recovery.triggerMessage,
+            source: recovery.source,
+        });
+    }
+    if (failedWithUncertain) {
+        manager?.logger?.log?.(`Startup: Create failed for ${orderLabel} after ${maxAttempts} attempt(s); slot kept for next startup reconcile cycle`, 'warn');
     }
+    return null;
 }
 // _extractBatchOperationResults — thin wrapper over shared utility,
 // returns empty array (not null) for callers that iterate directly.
@@ -615,7 +831,7 @@ function _resolveGroupRecovery(group, fallbackMessage, fallbackSource) {
 }
 async function _executeStartupCreateGroupBatch({ group, chainOrders, account, privateKey, manager, dryRun, groupIndex, totalGroups, }) {
     if (!Array.isArray(group) || group.length === 0 || dryRun)
-        return;
+        return [];
     if (typeof chainOrders?.buildCreateOrderOp !== 'function' || typeof chainOrders?.executeBatch !== 'function') {
         throw new Error('chainOrders does not support batch create operations');
     }
@@ -651,13 +867,18 @@ async function _executeStartupCreateGroupBatch({ group, chainOrders, account, pr
         prepared.push({ plan, op: buildResult.op });
     }
     if (prepared.length === 0)
-        return;
+        return [];
     const recovery = _resolveGroupRecovery(group, `Startup: Triggering recovery sync after create group ${groupIndex + 1}/${totalGroups} failure`, 'startupCreateGroupFailure');
+    const createdOrderIds = [];
     try {
         logger?.log?.(`Startup: Broadcasting create group ${groupIndex + 1}/${totalGroups} in single batch (${prepared.length} op${prepared.length > 1 ? 's' : ''})`, 'info');
         const batchResult = await chainOrders.executeBatch(account, privateKey, prepared.map((p) => p.op));
         const opResults = _extractBatchOperationResults(batchResult);
         const btsFeeData = (0, math_1.getAssetFees)('BTS');
+        // Phase A: Extract ALL chain order IDs from batch results first, capturing
+        // every on-chain ID before any _applySync call. This ensures createdOrderIds
+        // is complete even if a subsequent _applySync throws mid-loop.
+        const batchResults = [];
         let missingChainOrderId = false;
         for (let i = 0; i < prepared.length; i++) {
             const chainOrderId = opResults[i] && opResults[i][1];
@@ -665,8 +886,17 @@ async function _executeStartupCreateGroupBatch({ group, chainOrders, account, pr
             if (!chainOrderId) {
                 logger?.log?.(`Startup: create result missing chainOrderId for ${plan.orderLabel}`, 'error');
                 missingChainOrderId = true;
-                continue;
             }
+            else {
+                createdOrderIds.push(chainOrderId);
+            }
+            batchResults.push({ chainOrderId, plan });
+        }
+        // Phase B: Register each created order with the manager. All IDs are
+        // already in createdOrderIds, so _applySync failures won't lose them.
+        for (const { chainOrderId, plan } of batchResults) {
+            if (!chainOrderId)
+                continue;
             await manager._applySync({
                 gridOrderId: plan.gridOrder.id,
                 chainOrderId,
@@ -687,16 +917,104 @@ async function _executeStartupCreateGroupBatch({ group, chainOrders, account, pr
         }
     }
     catch (err) {
-        logger?.log?.(`Startup: Failed to create group ${groupIndex + 1}/${totalGroups}: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
-        await _recoverStartupSyncFailure({
-            chainOrders,
-            manager,
-            account,
-            logger,
-            triggerMessage: recovery.triggerMessage,
-            source: recovery.source,
-        });
+        const isUncertain = err?.code === 'BROADCAST_UNCERTAIN' || err?.name === 'BroadcastUncertainError';
+        logger?.log?.(`Startup: Failed to create group ${groupIndex + 1}/${totalGroups}${isUncertain ? ' (uncertain broadcast)' : ''}: ${(0, errors_1.getErrorMessage)(err)}`, 'error');
+        if (isUncertain) {
+            // The batch may have landed despite the deadline. Verify on chain and
+            // adopt any landed orders via chain sync instead of blindly
+            // re-broadcasting (duplicate order risk).
+            logger?.log?.(`Startup: Verifying uncertain create group ${groupIndex + 1}/${totalGroups} on chain; adopting any landed orders`, 'warn');
+            try {
+                // An empty/truncated verification read is ambiguous, NOT
+                // proof that nothing landed: a truncated get_full_accounts
+                // window omits the freshest creates (exactly this batch's),
+                // and an empty snapshot may be a node lagging behind the
+                // just-broadcast transaction. Treating it as "nothing
+                // landed" would let a later pass re-create (duplicate) or
+                // cancel as surplus the very orders this batch placed.
+                // Mirror the single-create sibling: defer through the
+                // guarded recovery sync, which re-reads and only syncs on
+                // an authoritative snapshot (deferring to the next
+                // reconcile cycle otherwise).
+                const freshChainOrders = await (0, chain_orders_1.readOpenOrdersGuarded)(chainOrders, (0, system_1.resolveAccountRef)(manager, account), {
+                    log: (message, level) => logger?.log?.(message, level),
+                    label: 'STARTUP',
+                    deferEmpty: true,
+                    timeoutMs: constants_1.TIMING.CONNECTION_TIMEOUT_MS,
+                    skipMessage: (kind) => `Startup: Uncertain create group ${groupIndex + 1}/${totalGroups} verification read is ` +
+                        `${kind}; cannot confirm whether the batch landed - ` +
+                        `deferring to guarded recovery sync (duplicate-order protection)`,
+                });
+                if (freshChainOrders === null) {
+                    await _recoverStartupSyncFailure({
+                        chainOrders,
+                        manager,
+                        account,
+                        logger,
+                        triggerMessage: recovery.triggerMessage,
+                        source: recovery.source,
+                    });
+                }
+                else {
+                    await manager.syncFromOpenOrders(freshChainOrders, {
+                        // Accounting enabled: the batch's created orders were
+                        // never registered (no _applySync ran), so the adoption
+                        // must lock their capital. skipAccounting:true would
+                        // leave the optimistic balances drifted.
+                        skipAccounting: false,
+                        source: 'startup-create-group-uncertain-adopt',
+                    });
+                    // Complete the create accounting (fees + order registration)
+                    // for every group plan whose slot was adopted, and register
+                    // the adopted IDs so the final refresh never cancels them
+                    // as surplus.
+                    const btsFeeData = (0, math_1.getAssetFeesSafe)('BTS');
+                    for (const item of prepared) {
+                        const plan = item?.plan;
+                        const slot = plan?.gridOrder?.id ? manager.orders.get(plan.gridOrder.id) : null;
+                        if (!slot?.orderId)
+                            continue;
+                        try {
+                            await manager._applySync({
+                                gridOrderId: plan.gridOrder.id,
+                                chainOrderId: slot.orderId,
+                                isPartialPlacement: false,
+                                expectedType: plan.gridOrder.type,
+                                fee: btsFeeData?.createFee || 0,
+                            }, 'createOrder');
+                            createdOrderIds.push(slot.orderId);
+                            logger?.log?.(`Startup: Uncertain create for ${plan.orderLabel} confirmed on chain (${slot.orderId}); adopted + accounted`, 'warn');
+                        }
+                        catch (applyErr) {
+                            logger?.log?.(`Startup: Adoption accounting failed for ${plan.orderLabel}: ${(0, errors_1.getErrorMessage)(applyErr)}`, 'warn');
+                        }
+                    }
+                }
+            }
+            catch (verifyErr) {
+                logger?.log?.(`Startup: Uncertain group verification failed: ${(0, errors_1.getErrorMessage)(verifyErr)}; falling back to recovery sync`, 'error');
+                await _recoverStartupSyncFailure({
+                    chainOrders,
+                    manager,
+                    account,
+                    logger,
+                    triggerMessage: recovery.triggerMessage,
+                    source: recovery.source,
+                });
+            }
+        }
+        else {
+            await _recoverStartupSyncFailure({
+                chainOrders,
+                manager,
+                account,
+                logger,
+                triggerMessage: recovery.triggerMessage,
+                source: recovery.source,
+            });
+        }
     }
+    return createdOrderIds;
 }
 function _buildOutsideInCreateGroups(createPlans) {
     return (0, order_1.buildOutsideInPairGroups)(createPlans, {
@@ -708,8 +1026,9 @@ function _buildOutsideInCreateGroups(createPlans) {
 async function _executePlannedStartupCreates({ createPlans, chainOrders, account, privateKey, manager, dryRun, }) {
     const logger = manager?.logger;
     const groups = _buildOutsideInCreateGroups(createPlans);
+    const createdOrderIds = new Set();
     if (groups.length === 0)
-        return;
+        return createdOrderIds;
     logger?.log?.(`Startup: Executing ${createPlans.length} planned create(s) in ${groups.length} outside->center group(s)`, 'info');
     for (let i = 0; i < groups.length; i++) {
         const group = groups[i];
@@ -717,7 +1036,7 @@ async function _executePlannedStartupCreates({ createPlans, chainOrders, account
         logger?.log?.(`Startup: Create group ${i + 1}/${groups.length} (${labels})`, 'info');
         const canBatchCreate = typeof chainOrders?.buildCreateOrderOp === 'function' && typeof chainOrders?.executeBatch === 'function';
         if (group.length > 1 && canBatchCreate) {
-            await _executeStartupCreateGroupBatch({
+            const batchIds = await _executeStartupCreateGroupBatch({
                 group,
                 chainOrders,
                 account,
@@ -727,13 +1046,15 @@ async function _executePlannedStartupCreates({ createPlans, chainOrders, account
                 groupIndex: i,
                 totalGroups: groups.length,
             });
+            for (const id of batchIds)
+                createdOrderIds.add(id);
             continue;
         }
         if (group.length > 1 && !canBatchCreate) {
             logger?.log?.('Startup: Batch create helpers unavailable; falling back to sequential creates for this group', 'warn');
         }
         for (const plan of group) {
-            await _createStartupOrderWithHandling({
+            const chainOrderId = await _createStartupOrderWithHandling({
                 chainOrders,
                 account,
                 privateKey,
@@ -743,8 +1064,14 @@ async function _executePlannedStartupCreates({ createPlans, chainOrders, account
                 dryRun,
                 recovery: plan.recovery,
             });
+            if (chainOrderId)
+                createdOrderIds.add(chainOrderId);
         }
     }
+    const failedCount = Math.max(0, createPlans.length - createdOrderIds.size);
+    logger?.log?.(`Startup: Create execution summary: ${createdOrderIds.size}/${createPlans.length} planned create(s) placed ` +
+        `across ${groups.length} group(s)${failedCount > 0 ? `, ${failedCount} failed/skipped (see error logs)` : ''}`, failedCount > 0 ? 'warn' : 'info');
+    return createdOrderIds;
 }
 async function _reconcileStartupSide({ orderType, targetCount, chainSideOrders, unmatchedSideOrders, manager, chainOrders, account, privateKey, dryRun, plannedCreates, plannedUpdates, plannedCancels, planOnly = false, }) {
     const logger = manager?.logger;