fix: prevent and resolve stale dust duplicates at the same price level

froooze · froooze · commit d12e9da23181 · 2026-07-01T19:20:02.000+02:00
Two on-chain orders at the same grid level (e.g. slot-119 with 0.0006 dust
remnant + slot-120 with the real 2.4052 order) were re-forming because the
sync engine adopted orphan remnants into virtual slots, and the dust auto-
cancel only targeted the top-of-window partial, leaving interior duplicates
in place indefinitely. Four coordinated fixes close both the formation
path and the persistence path.

## Sync engine: reject any orphan at a duplicate price level
File: modules/order/sync_engine.ts
- Problem: Pass-2 fallback adopted any orphan into a virtual/spread slot,
  including tiny remnants of replaced orders, creating a duplicate price
  level inside the active grid.
- Impact: Visible as two on-chain orders at the same price (real order
  covered by a grid slot, dust remnant adopted into a different slot).
- Solution: Before adopting an orphan, check if an active grid order of
  the same type already exists at the same price (within
  `calculatePriceTolerance` using `Math.max(size)` to keep tolerance
  tight). If so, the orphan is a duplicate — skip adoption and push to
  `unmatchedChainOrders` so the reconcile layer cancels it on chain.
  Size is irrelevant; any duplicate violates the grid invariant of one
  order per price level.

## Reconcile: cancel duplicate chain orders unconditionally
File: modules/order/grid_reconcile.ts
- Problem: SUSPECTED_DUPLICATE block logged the duplicate but never
  removed it from chain, so duplicates persisted across restarts.
- Impact: Two on-chain orders at the same price level after every restart
  until manual intervention.
- Solution: When an unmatched order is within `looseTolerance` of an
  active grid order, cancel it on chain via `_cancelChainOrder` with
  `releaseUntrackedFunds: true`. Cancelled IDs are filtered out of
  `unmatchedParsed` so `_reconcileStartupSide` doesn't reprocess them.
  No size guard — any duplicate at the same price is a violation.
- Also removed `SUSPECTED_DUPLICATE_TOLERANCE_FLOOR = 0.01` — absolute
  price floor was wrong for low-price assets (BTS/USD: floor is 100% of
  price) and irrelevant for high-price assets. Now just
  `tolerance * SUSPECTED_DUPLICATE_TOLERANCE_MULTIPLIER`.

## Grid: dust detection covers interior partials with duplicate price level
File: modules/order/grid.ts
- Problem: `checkWindowDust` only flagged the top-of-window partial per
  side, so interior dust duplicates at the same price level as an active
  sibling were never detected for the `DUST_CANCEL_DELAY_SEC` auto-cancel.
- Impact: Interior dust duplicates persisted indefinitely even when an
  active sibling at the same price made them safe to cancel (no gap).
- Solution: Interior partials are eligible for dust detection if they
  share a price level with an active sibling (within
  `calculatePriceTolerance` using `Math.max(size)`). Top-of-window
  partials remain always eligible. Only ACTIVE siblings are checked —
  two PARTIALs sharing a price with no active sibling do not qualify;
  that gap is left to the rebalancer.

## Math helper documentation
File: modules/order/utils/math.ts
- Added doc note on `calculatePriceTolerance`: `orderSize` controls
  strictness (larger = tighter tolerance). For duplicate-price-level
  detection, always pass `Math.max(sizeA, sizeB)` to avoid a tiny dust
  order inflating the tolerance window and falsely matching distant
  prices. This makes the symmetric `Math.max`/`Math.min` usage in
  grid.ts and sync_engine.ts self-documenting.

## Testing Notes
- Verified numerically for BTS/XRP @ 1079.67 (precision 5/5) that the
  old tolerance (orphan size 0.0006) was 18.01 for SELL / 19,450 for
  BUY, falsely matching an orphan at 1079.67 to a grid order at the
  next level (1085, +0.5%). New tolerance (`Math.max(0.0006, 2.4052)`)
  is 0.0045 / 4.85 and correctly rejects the false match.
- tests/test_dust_rebalance_logic.ts — added
  `testInteriorDustWithDuplicatePriceLevel` (interior partial + active
  sibling at same price → eligible) and
  `testInteriorDustAdjacentGridLevelNotEligible` (partial at adjacent
  price → not eligible).
- tests/test_sync_logic.ts — updated
  `testOrphanAtDuplicatePriceLevelIsNotAdopted` (orphan sharing price
  with active order → NOT adopted, spread slot stays virtual).
- `npx tsc --noEmit` → clean.
- All relevant tests pass.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -2,6 +2,14 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.0.5] - 2026-07-01 - Grid Invariant Enforcement
+
+### 2026-07-01
+
+- **Fix**: prevent stale dust duplicates at the same price level — sync engine rejects orphan adoption when an active order already occupies that price (uses `Math.max(size)` for tight tolerance). Reconcile unconditionally cancels duplicate chain orders on chain via `_cancelChainOrder` with `releaseUntrackedFunds: true`. Dust detection expanded to interior partials sharing a price level with an active sibling. Three coordinated layers enforce "one order per grid price level" invariant (`modules/order/sync_engine.ts`, `modules/order/grid_reconcile.ts`, `modules/order/grid.ts`).
+- **Chore**: version bumped to 1.0.5 across all manifests.
+- **Docs**: updated `CHANGELOG.md`, `docs/EVOLUTION.md`, `docs/README.md`, `docs/DEXBOT_COMPARISON.md`, `docs/FUND_MOVEMENT_AND_ACCOUNTING.md`.
+
 ## [1.0.4] - 2026-07-01 - Update Script Hardening & Stash Leak Fix
 
 ### 2026-07-01
diff --git a/analysis/ama_fitting/package.json b/analysis/ama_fitting/package.json
@@ -1,6 +1,6 @@
 {
   "name": "ama_fitting",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Tools for fitting AMA parameters to market data",
   "main": "../../dist/analysis/ama_fitting/optimizer_high_resolution.js",
   "scripts": {
diff --git a/claw/package.json b/claw/package.json
@@ -1,6 +1,6 @@
 {
   "name": "dexbot2-claw",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "private": true,
   "description": "Claw bridge and runtime integration layer for BitShares and DEXBot2.",
   "type": "commonjs",
diff --git a/claw/runtimes/openclaw-plugin/openclaw.plugin.json b/claw/runtimes/openclaw-plugin/openclaw.plugin.json
@@ -2,7 +2,7 @@
   "id": "bitshares-claw",
   "name": "BitShares Claw",
   "description": "Native BitShares and DEXBot2 tools from the DEXBot2 claw integration",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "skills": [
     "skills"
   ],
diff --git a/claw/runtimes/openclaw-plugin/package.json b/claw/runtimes/openclaw-plugin/package.json
@@ -1,7 +1,7 @@
 {
   "name": "bitshares-claw-openclaw-plugin",
   "private": true,
-  "version": "1.0.4",
+  "version": "1.0.5",
   "type": "commonjs",
   "main": "index.js"
 }
diff --git a/claw/tests/test_claw_mcp_transport.ts b/claw/tests/test_claw_mcp_transport.ts
@@ -30,7 +30,7 @@ async function testParserAcceptsJsonlAcrossChunksAndSingleBuffer() {
       capabilities: {},
       clientInfo: {
         name: 'claw-mcp-transport-test',
-        version: '1.0.4'
+        version: '1.0.5'
       },
       protocolVersion: '2024-11-05'
     }
@@ -181,7 +181,7 @@ async function testMainEntrypointHandlesRealProcessInitialize() {
       capabilities: {},
       clientInfo: {
         name: 'claw-mcp-transport-test',
-        version: '1.0.4'
+        version: '1.0.5'
       },
       protocolVersion: '2024-11-05'
     }
diff --git a/docs/DEXBOT_COMPARISON.md b/docs/DEXBOT_COMPARISON.md
@@ -1,7 +1,7 @@
 # DEXBot vs DEXBot2 — Detailed Comparison Report
 
 > **Date:** 2026-06-16 *(metrics refreshed against local source trees)*
-> **Scope:** Full architectural, functional, and operational comparison between the original [DEXBot](https://github.com/Codaone/DEXBot) (Python, v1.0.0) and DEXBot2 (TypeScript, v1.0.4).
+> **Scope:** Full architectural, functional, and operational comparison between the original [DEXBot](https://github.com/Codaone/DEXBot) (Python, v1.0.0) and DEXBot2 (TypeScript, v1.0.5).
 > **Audience:** Developers, contributors, and operators evaluating or migrating between the two projects.
 
 ---
@@ -36,7 +36,7 @@
 
 | Attribute | DEXBot (original) | DEXBot2 |
 |---|---|---|
-| **Release Track** | 1.0.0 | v1.0.4 |
+| **Release Track** | 1.0.0 | v1.0.5 |
 | **Language** | Python 3.6+ | TypeScript 5.x |
 | **Status** | Released 1.0.0, unmaintained | Active development |
 | **Last Repo Activity** | May 23, 2020 | 2026-06-25 |
@@ -774,7 +774,7 @@ Where:
 
 | Metric | DEXBot | DEXBot2 |
 |---|---|---|
-| **Release Track** | 1.0.0 | v1.0.4 |
+| **Release Track** | 1.0.0 | v1.0.5 |
 | **Active Since** | ~2018 | December 2025 |
 | **Last Commit** | May 23, 2020 | 2026-06-25 |
 | **Total Commits** | 2281 | 1659 at current HEAD |
diff --git a/docs/EVOLUTION.md b/docs/EVOLUTION.md
@@ -2,14 +2,14 @@
 
 ## Executive Summary
 
-DEXBot2 is a sophisticated decentralized exchange trading bot for the BitShares blockchain. This report documents the complete evolution of the project from its inception in December 2025 through the current 1.0.4 stable release.
+DEXBot2 is a sophisticated decentralized exchange trading bot for the BitShares blockchain. This report documents the complete evolution of the project from its inception in December 2025 through the current 1.0.5 stable release.
 
 ### Key Milestones
 - **Project Inception**: December 2, 2025
 - **Growth Phase**: 1,600+ commits over ~6 active months
 - **Code Maturity**: Evolution from basic utilities to a ~58,000+ LoC intelligent TypeScript system
 - **Stability**: Progression from manual testing to a suite of 200+ automated test files
-- **Releases**: 39 release entries (v0.1.0 to v1.0.4)
+- **Releases**: 40 release entries (v0.1.0 to v1.0.5)
 
 ---
 
@@ -170,6 +170,9 @@ Two-step candle gap repair in market adapter (auto-fill ≤24h, then Kibana), ma
 ### v1.0.3 → v1.0.4 (2 commits)
 Update script hardening: daemon-downtime-after-update fix (pre-update state snapshot, TTY-gated auto-restart fallback), stash leak elimination (conditional push, apply+drop, auto-resolve with `--theirs`, conflicted `package-lock.json` regeneration). SIGUSR2 monolithic restart fix when `UPDATER.ACTIVE` is false — added local `pendingRestart` flag in `unlock.ts` independent of the updater.
 
+### v1.0.4 → v1.0.5 (1 commit)
+Grid invariant enforcement: prevent stale dust duplicates at the same price level. Sync engine rejects orphan adoption when an active order already occupies that price (uses `Math.max(size)` for tight tolerance). Reconcile unconditionally cancels duplicate chain orders on chain. Dust detection expanded to interior partials sharing a price level with an active sibling. Three coordinated layers enforce "one order per grid price level" invariant.
+
 ---
 
 
@@ -218,7 +221,7 @@ DEXBot2 has matured from a basic grid bot into a signal-intelligent, production-
 ---
 
 **Report Originally Generated**: February 19, 2026
-**Last Updated**: July 1, 2026 (v1.0.4)
+**Last Updated**: July 1, 2026 (v1.0.5)
 **Total Commits**: 1661
 **Date Range**: December 2, 2025 - July 1, 2026 (ongoing)
 **Repository**: DEXBot2 (BitShares DEX Trading Bot)
diff --git a/docs/FUND_MOVEMENT_AND_ACCOUNTING.md b/docs/FUND_MOVEMENT_AND_ACCOUNTING.md
@@ -825,4 +825,4 @@ To prevent "Time-of-Check to Time-of-Use" errors:
 3.  **Bootstrapping:** Fills arriving during startup (`isBootstrapping=true`) are queued until the grid is fully reconciled.
 
 ---
-*Technical Reference for DEXBot2 v1.0.4 release*
+*Technical Reference for DEXBot2 v1.0.5 release*
diff --git a/docs/README.md b/docs/README.md
@@ -2,7 +2,7 @@
 
 This directory contains the comprehensive technical documentation for the DEXBot2 trading bot. It is designed to guide developers from high-level architecture down to the nuances of fund accounting and state management.
 
-**Version context:** v1.0.4 is the current release.
+**Version context:** v1.0.5 is the current release.
 
 ---
 
@@ -108,7 +108,7 @@ This directory contains the comprehensive technical documentation for the DEXBot
 
 ### 🧭 [Evolution Report](EVOLUTION.md)
 *Project timeline and major architecture phases.*
-- **Coverage**: Historical milestones from the initial December 2025 bootstrap through the v1.0.4 stable release, including credit maintenance hardening
+- **Coverage**: Historical milestones from the initial December 2025 bootstrap through the v1.0.5 stable release, including credit maintenance hardening
 - **Focus**: Architecture evolution, release history, test growth, and documentation changes
 
 ### 🗒️ [Changelog](../CHANGELOG.md)
diff --git a/modules/order/grid.ts b/modules/order/grid.ts
@@ -116,7 +116,8 @@ const {
     getGridBestPrices,
     calculateSpreadFromOrders,
     allocateFundsByWeights,
-    calculateGapSlots
+    calculateGapSlots,
+    calculatePriceTolerance
 } = require('./utils/math');
 const {
     filterOrdersByType,
@@ -1476,10 +1477,15 @@ class Grid {
     }
 
     /**
-     * Dust check scoped to the top live order on each side.
+     * Dust check covering all partial orders, with interior-only guard.
      *
-     * Dust auto-cancel must only act on the closest live on-chain order per side.
-     * Cancelling an interior partial could punch a hole inside the active grid.
+     * The top-of-window partial (closest to market) is always eligible for dust
+     * detection since cancelling it is just the grid edge moving inward.
+     *
+     * Interior partials (further from market) are only eligible if they have a
+     * duplicate price level — another active order at essentially the same price.
+     * Cancelling such an interior partial won't leave a gap in the grid because
+     * the sibling active order already covers that price level.
      *
      * Returns boolean flags plus the actual dust order objects so callers can act
      * on individual orders (e.g. DUST_CANCEL_DELAY_SEC auto-cancel).
@@ -1498,21 +1504,48 @@ class Grid {
             order.price != null &&
             (order.state === ORDER_STATES.ACTIVE || order.state === ORDER_STATES.PARTIAL);
 
-        let buyDustOrders = [];
+        // Identify top-of-window orders (closest to market per side).
         const topBuyOrder = allOrders
             .filter(o => o.type === ORDER_TYPES.BUY && isLiveOrder(o))
             .sort((a, b) => b.price - a.price)[0];
-        if (topBuyOrder && topBuyOrder.state === ORDER_STATES.PARTIAL) {
-            buyDustOrders = await Grid._getDustOrders(manager, [topBuyOrder], ORDER_TYPES.BUY);
-        }
-
-        let sellDustOrders = [];
         const topSellOrder = allOrders
             .filter(o => o.type === ORDER_TYPES.SELL && isLiveOrder(o))
             .sort((a, b) => a.price - b.price)[0];
-        if (topSellOrder && topSellOrder.state === ORDER_STATES.PARTIAL) {
-            sellDustOrders = await Grid._getDustOrders(manager, [topSellOrder], ORDER_TYPES.SELL);
-        }
+
+        // Check if an order has a duplicate price level — an active sibling at the
+        // same price within tolerance. If so, cancelling won't create a grid gap.
+        // Only checks ACTIVE siblings. If two PARTIALs share a price with no active
+        // sibling, neither qualifies and the gap is left to the rebalancer.
+        // Uses the LARGER size of the two orders for tolerance calculation to prevent
+        // a tiny dust order from inflating the tolerance window.
+        const hasDuplicatePriceLevel = (order: any, assets: any): boolean =>
+            allOrders.some(o => {
+                if (o.id === order.id || o.type !== order.type) return false;
+                if (o.state !== ORDER_STATES.ACTIVE || !o.orderId || o.price == null) return false;
+                const toleranceSize = Math.max(order.size, o.size);
+                const tolerance = calculatePriceTolerance(
+                    Math.min(order.price, o.price), toleranceSize, order.type, assets
+                );
+                return tolerance != null && Math.abs(o.price - order.price) <= tolerance;
+            });
+
+        const assets = manager.assets;
+        const allPartials = allOrders.filter((o: any) => isLiveOrder(o) && o.state === ORDER_STATES.PARTIAL);
+
+        const isTopBuy = (o: any) => topBuyOrder && o.id === topBuyOrder.id;
+        const isTopSell = (o: any) => topSellOrder && o.id === topSellOrder.id;
+
+        // Safety filter: top-of-window partials always qualify; interior partials
+        // only qualify if they have a duplicate price level (no gap risk).
+        const eligibleBuyPartials = allPartials.filter((o: any) =>
+            o.type === ORDER_TYPES.BUY && (isTopBuy(o) || hasDuplicatePriceLevel(o, assets))
+        );
+        const eligibleSellPartials = allPartials.filter((o: any) =>
+            o.type === ORDER_TYPES.SELL && (isTopSell(o) || hasDuplicatePriceLevel(o, assets))
+        );
+
+        const buyDustOrders = await Grid._getDustOrders(manager, eligibleBuyPartials, ORDER_TYPES.BUY);
+        const sellDustOrders = await Grid._getDustOrders(manager, eligibleSellPartials, ORDER_TYPES.SELL);
 
         return {
             buyDust: buyDustOrders.length > 0,
diff --git a/modules/order/grid_reconcile.ts b/modules/order/grid_reconcile.ts
@@ -70,7 +70,6 @@ const { resolveAccountRef } = require('./utils/system');
 const Format = require('./format');
 
 const SUSPECTED_DUPLICATE_TOLERANCE_MULTIPLIER = 5;
-const SUSPECTED_DUPLICATE_TOLERANCE_FLOOR = 0.01;
 
 /**
  * Count active orders on the grid for a given type.
@@ -1309,11 +1308,12 @@ async function reconcileGridOrders({
         }
 
         const unmatchedChain = (Array.isArray(chainOpenOrders) ? chainOpenOrders : []).filter(co => co && !matchedChainOrderIds.has(co.id));
-        const unmatchedParsed = unmatchedChain
+        let unmatchedParsed = unmatchedChain
             .map(co => ({ chain: co, parsed: parseChainOrder(co, manager.assets) }))
             .filter(x => x.parsed);
 
         // Log individual unmatched chain orders with enough context for later adoption analysis.
+        const cancelledDuplicateIds = new Set<string>();
         const activeGridOrders = (Array.from(manager.orders.values()) as any[]).filter((o: any) => o && o.orderId && isOrderPlaced(o));
         for (const u of unmatchedParsed) {
             const p = u.parsed;
@@ -1327,10 +1327,7 @@ async function reconcileGridOrders({
                     gridOrder,
                     priceDiff,
                     tolerance,
-                    looseTolerance: Math.max(
-                        tolerance * SUSPECTED_DUPLICATE_TOLERANCE_MULTIPLIER,
-                        SUSPECTED_DUPLICATE_TOLERANCE_FLOOR
-                    ),
+                    looseTolerance: tolerance * SUSPECTED_DUPLICATE_TOLERANCE_MULTIPLIER,
                 };
                 if (!nearest || priceDiff < nearest.priceDiff) nearest = candidate;
             }
@@ -1342,6 +1339,34 @@ async function reconcileGridOrders({
                     `looseTolerance=${Format.formatPrice6(nearest.looseTolerance)})`,
                     'error'
                 );
+                // Resolve the duplicate price level by cancelling the stale orphan on chain.
+                // The grid has one slot per price level — any duplicate is a violation.
+                if (!dryRun) {
+                    try {
+                        await _cancelChainOrder({
+                            chainOrders,
+                            account,
+                            privateKey,
+                            manager,
+                            chainOrderId: p.orderId,
+                            dryRun,
+                            chainOrderObj: u.chain,
+                            releaseUntrackedFunds: true,
+                            fillLockAlreadyHeld,
+                        });
+                        cancelledDuplicateIds.add(p.orderId);
+                        logger?.log?.(
+                            `Cancelled unmatched duplicate chain order ${p.orderId} at price ${Format.formatPrice6(p.price)} — ` +
+                            `stale dust remnant duplicate of grid ${nearest.gridOrder.id} (${nearest.gridOrder.orderId})`,
+                            'warn'
+                        );
+                    } catch (cancelErr: any) {
+                        logger?.log?.(
+                            `Failed to cancel duplicate chain order ${p.orderId}: ${cancelErr.message}`,
+                            'error'
+                        );
+                    }
+                }
             } else if (nearest) {
                 logger?.log?.(
                     `${desc}; nearest active same-side grid ${nearest.gridOrder.id} ` +
@@ -1355,6 +1380,11 @@ async function reconcileGridOrders({
             }
         }
 
+        // Remove cancelled duplicates so they are not processed by _reconcileStartupSide
+        if (cancelledDuplicateIds.size > 0) {
+            unmatchedParsed = unmatchedParsed.filter(u => !cancelledDuplicateIds.has(u.parsed.orderId));
+        }
+
         let unmatchedBuys = unmatchedParsed.filter(x => x.parsed.type === ORDER_TYPES.BUY).map(x => x.chain);
         let unmatchedSells = unmatchedParsed.filter(x => x.parsed.type === ORDER_TYPES.SELL).map(x => x.chain);
         const plannedCreates = [];
diff --git a/modules/order/sync_engine.ts b/modules/order/sync_engine.ts
@@ -786,6 +786,40 @@ class SyncEngine {
                 // No grid slot matched by type+price+size. Fallback: find the nearest
                 // VIRTUAL slot (including spread slots) by price so the orphaned order
                 // becomes visible to checkWindowDust and can be dust-cancelled.
+                //
+                // BUT: the grid allows at most one order per price level. If an active
+                // grid order already exists at the same price (within tolerance), this
+                // orphan is a stale duplicate — skip adoption so the reconcile layer
+                // cancels it. Size is irrelevant; any duplicate violates the invariant.
+                const duplicatePriceOrder: any = Array.from(mgr.orders.values()).find((o: any) =>
+                    o.type === chainOrder.type &&
+                    isOrderPlaced(o) &&
+                    !matchedGridOrderIds.has(o.id) &&
+                    Math.abs(o.price - chainOrder.price) <= calculatePriceTolerance(
+                        Math.min(o.price, chainOrder.price),
+                        Math.max(o.size, chainOrder.size),
+                        o.type, mgr.assets
+                    )
+                );
+                if (duplicatePriceOrder) {
+                    unmatchedChainOrders.push({
+                        chainOrderId,
+                        type: chainOrder.type,
+                        price: chainOrder.price,
+                        size: chainOrder.size,
+                        raw: rawChainOrders.get(chainOrderId),
+                        reason: 'duplicate-price-level',
+                        candidateSlotId: duplicatePriceOrder.id,
+                    });
+                    mgr.logger?.log?.(
+                        `[SYNC] Orphaned chain order ${chainOrderId} (${chainOrder.type}, price=${chainOrder.price}, ` +
+                        `size=${chainOrder.size}) — NOT adopted: duplicates price level of active ` +
+                        `${duplicatePriceOrder.id} (${duplicatePriceOrder.orderId} at ${duplicatePriceOrder.price})`,
+                        'warn'
+                    );
+                    continue;
+                }
+
                 const adoptedSlot = findMatchingGridOrderByOpenOrder(
                     { orderId: chainOrderId, type: chainOrder.type, price: chainOrder.price, size: chainOrder.size },
                     {
diff --git a/modules/order/utils/math.ts b/modules/order/utils/math.ts
@@ -674,9 +674,14 @@ function getPrecision(assets: any, { type, side, proceeds = false }: { type?: st
  * Calculate price tolerance for order matching on-chain.
  * Accounts for precision limits of both assets to determine acceptable price deviation.
  * Used when matching grid orders to blockchain orders.
+ *
+ * NOTE on the orderSize parameter: larger sizes produce tighter (more precise)
+ * tolerance values. When using this function for duplicate-price-level
+ * detection, always pass Math.max(sizeA, sizeB) as orderSize — a tiny dust
+ * order would inflate the tolerance window and falsely match distant prices.
  * 
  * @param {number} gridPrice - Grid order price
- * @param {number} orderSize - Order size on primary side
+ * @param {number} orderSize - Order size on primary side (larger = tighter tolerance)
  * @param {string} orderType - Order type ("buy" or "sell")
  * @param {Object} [assets=null] - Asset metadata with precision (required)
  * @returns {number|null} Price tolerance value or null if invalid inputs
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
diff --git a/tests/test_dust_rebalance_logic.ts b/tests/test_dust_rebalance_logic.ts
diff --git a/tests/test_sync_logic.ts b/tests/test_sync_logic.ts

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "ama_fitting",`
`3`		`- "version": "1.0.4",`
	`3`	`+ "version": "1.0.5",`
`4`	`4`	`"description": "Tools for fitting AMA parameters to market data",`
`5`	`5`	`"main": "../../dist/analysis/ama_fitting/optimizer_high_resolution.js",`
`6`	`6`	`"scripts": {`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "dexbot2-claw",`
`3`		`- "version": "1.0.4",`
	`3`	`+ "version": "1.0.5",`
`4`	`4`	`"private": true,`
`5`	`5`	`"description": "Claw bridge and runtime integration layer for BitShares and DEXBot2.",`
`6`	`6`	`"type": "commonjs",`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "bitshares-claw-openclaw-plugin",`
`3`	`3`	`"private": true,`
`4`		`- "version": "1.0.4",`
	`4`	`+ "version": "1.0.5",`
`5`	`5`	`"type": "commonjs",`
`6`	`6`	`"main": "index.js"`
`7`	`7`	`}`