@metamask-previews/perps-controller 10.0.0-preview-a42e8d0d2 → 10.0.0-preview-d2f661012

package/CHANGELOG.md

@@ -7,6 +7,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- Add `floorToSizeDecimals(size, szDecimals)` (exported from `@metamask/perps-controller/utils/*`), which rounds an order size down onto an asset's size grid, snapping values that floating-point error leaves just below a grid point. The result is never greater than the input: a value genuinely below a grid point is truncated rather than snapped up ([#9719](https://github.com/MetaMask/core/pull/9719))
+
+### Fixed
+
+- Stop `closePosition` from submitting reduce-only orders that HyperLiquid rejects with "Reduce only order would increase position" ([#9719](https://github.com/MetaMask/core/pull/9719))
+  - The position snapshot callers pass (to avoid a `getPositions()` REST call) is now re-validated against the freshest WebSocket position cache, so the order side and size follow the live position instead of a snapshot that a concurrent TP/SL fill, liquidation, or repeated close has already invalidated. No additional network request is made when the cache covers the symbol's DEX: a missing entry there means the position is already closed, so the close now fails fast with `No position found for <symbol>` instead of submitting a doomed order. When the cache does not cover that DEX — a HIP-3 DEX whose subscription has not published this session — the absence proves nothing, so a single `clearinghouseState` request for that DEX alone supplies live data, which keeps the outcome attributable to the symbol's own DEX: if the DEX answers without this symbol — including when it reports no positions at all — the position is genuinely closed and the close fails with `No position found for <symbol>`; only if that request fails does the caller's snapshot stand, since a failed lookup proves nothing and must not block a position that is open and closable. `HyperLiquidSubscriptionService` exposes the new `getCachedPositionsForDex(dexName)` method this uses, which returns that DEX's own cached positions rather than the cross-DEX aggregate: the aggregate is only rebuilt once every expected DEX has published, so after a WebSocket reconnect it can sit frozen at pre-reconnect contents while the per-DEX slices keep updating.
+  - A caller-supplied close size is clamped to the live position size, and that clamp is binding: for a partial close the `usdAmount` clients also send can no longer recompute the size above it. A close size that is supplied but not a positive number (e.g. `'0'` or `'abc'`) now fails with `ORDER_SIZE_POSITIVE`; only an omitted or empty `size` means "close 100%".
+  - The batch `closePositions` path also rounds each reduce-only size down onto the asset's size grid, instead of letting `formatHyperLiquidSize`'s half-up rounding push it above the position. A position smaller than one size increment is skipped rather than submitted as a zero-size order, and the remaining positions still close. Each skipped position is reported in `results` with `success: false` and `error: ORDER_SIZE_POSITIVE` and counted in `failureCount`, so a caller cannot read "closed everything" from a batch that left one open. `results` keeps the order of the requested positions, so a consumer correlating results to positions by index is unaffected by a skip.
+  - A close that covers the whole position — no `size`, or a `size` that reaches (or was clamped to) the position size — now submits exactly the live position size. The `usdAmount` clients send for slippage protection is no longer forwarded for such a close, because `placeOrder` treats it as the source of truth and would recompute the size from it, discarding the clamp and rounding the size up. Genuine partial closes still use `usdAmount`. As a result, a close of the entire position requested via an explicit `size` is now treated as a full close for validation too, so it skips the USD/$10-minimum check as an omitted `size` already did. The `priceAtCalculation` staleness check is unaffected: `calculateFinalPositionSize` now runs it whenever a caller supplies that field, rather than only inside its `usdAmount` branch, so a full close that drifted past `maxSlippageBps` is still rejected with "Price moved too much" even though its size no longer comes from `usdAmount`.
+  - `placeOrder` no longer retries **any** reduce-only order that the exchange rejected for the $10 minimum order value with a 1.5% larger size; the minimum-value error is surfaced instead. This covers reduce-only limit and TP/SL orders submitted directly through `placeOrder`, not just closes. **It is a behaviour change for partial closes**, which previously recovered from that rejection by closing ~1.5% more than requested: a reduce-only order can no longer grow past the position (full close) or past the size the caller asked to close (partial close), so the retry could only be rejected again or resubmit an identical order.
+  - `calculateFinalPositionSize` throws `ORDER_SIZE_POSITIVE` when a `reduceOnly` call supplies a `size` that is not a positive number, in both its `usdAmount` and legacy-size branches, instead of capping the USD-derived size to that value or passing it through to be formatted as a zero or negative size.
+  - `calculateFinalPositionSize` accepts an optional `reduceOnly` flag. When set, the size is rounded down onto the asset's size grid and the "add one increment to meet the requested USD" adjustment is skipped, so a reduce-only size can never round up past the position. If rounding down leaves a size of `0` (the order is worth less than one size increment), it throws `ORDER_SIZE_POSITIVE` rather than submitting a zero-size order. **This is a behaviour change for a reduce-only close between half an increment and one full increment**: `formatHyperLiquidSize` uses `toFixed`, which rounds half-up, so such a close previously succeeded by closing one whole increment and now fails client-side instead. It is most visible on coarse-grid (low `szDecimals`) assets, and reachable from any partial close that omits `usdAmount` — Mobile limit partial closes do (`usePerpsClosePosition` sends `usdAmount: undefined` for limit orders).
+
 ## [10.0.0]
 
 ### Added

package/dist/providers/HyperLiquidProvider.cjs

@@ -10,7 +10,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _HyperLiquidProvider_instances, _HyperLiquidProvider_deps, _HyperLiquidProvider_clientService, _HyperLiquidProvider_walletService, _HyperLiquidProvider_subscriptionService, _HyperLiquidProvider_symbolToAssetId, _HyperLiquidProvider_userFeeCache, _HyperLiquidProvider_maxLeverageCache, _HyperLiquidProvider_cachedMetaByDex, _HyperLiquidProvider_cachedMarketDataWithPrices, _HyperLiquidProvider_cachedSpotMeta, _HyperLiquidProvider_dexDiscoveryCache, _HyperLiquidProvider_referralCheckCache, _HyperLiquidProvider_builderFeeCheckCache, _HyperLiquidProvider_ensureReadyPromise, _HyperLiquidProvider_pendingBuilderFeeApprovals, _HyperLiquidProvider_compiledAllowlistPatterns, _HyperLiquidProvider_compiledBlocklistPatterns, _HyperLiquidProvider_userFeeDiscountBips, _HyperLiquidProvider_hip3Enabled, _HyperLiquidProvider_allowlistMarkets, _HyperLiquidProvider_blocklistMarkets, _HyperLiquidProvider_useUnifiedAccount, _HyperLiquidProvider_dexDiscoveryComplete, _HyperLiquidProvider_unifiedAccountSetupNeedsRetry, _HyperLiquidProvider_pendingValidatedDexsPromise, _HyperLiquidProvider_cachedUsdcTokenId, _HyperLiquidProvider_errorMappings, _HyperLiquidProvider_clientsInitialized, _HyperLiquidProvider_initializationPromise, _HyperLiquidProvider_messenger, _HyperLiquidProvider_builderAddressTestnet, _HyperLiquidProvider_builderAddressMainnet, _HyperLiquidProvider_priceDeviationLimit, _HyperLiquidProvider_compilePatternsSafely, _HyperLiquidProvider_ensureClientsInitialized, _HyperLiquidProvider_isWalletOnHyperliquid, _HyperLiquidProvider_ensureUnifiedAccountEnabled, _HyperLiquidProvider_ensureReady, _HyperLiquidProvider_tradingSetupPromise, _HyperLiquidProvider_tradingSetupComplete, _HyperLiquidProvider_ensureReadyForTrading, _HyperLiquidProvider_getOrFetchPrice, _HyperLiquidProvider_filterFills, _HyperLiquidProvider_getAllAvailableDexs, _HyperLiquidProvider_getValidatedDexs, _HyperLiquidProvider_fetchValidatedDexsInternal, _HyperLiquidProvider_getCachedMeta, _HyperLiquidProvider_backfillAssetMapForDex, _HyperLiquidProvider_getAssetIdWithRepair, _HyperLiquidProvider_getCachedSpotMeta, _HyperLiquidProvider_getCachedPerpDexs, _HyperLiquidProvider_calculateHip3FeeMultiplier, _HyperLiquidProvider_getCacheKey, _HyperLiquidProvider_fetchMarketsForDex, _HyperLiquidProvider_getUsdcTokenId, _HyperLiquidProvider_isUsdcCollateralDex, _HyperLiquidProvider_buildAssetMapping, _HyperLiquidProvider_queryUserDataAcrossDexs, _HyperLiquidProvider_mapError, _HyperLiquidProvider_getErrorContext, _HyperLiquidProvider_checkBuilderFeeApproval, _HyperLiquidProvider_ensureBuilderFeeApproval, _HyperLiquidProvider_checkBuilderFeeStatus, _HyperLiquidProvider_getBalanceForDex, _HyperLiquidProvider_findSourceDexWithBalance, _HyperLiquidProvider_autoTransferForHip3Order, _HyperLiquidProvider_autoTransferBackAfterClose, _HyperLiquidProvider_calculateHip3RequiredMargin, _HyperLiquidProvider_handleHip3PostOrderRebalance, _HyperLiquidProvider_handleHip3OrderRollback, _HyperLiquidProvider_validateOrderBeforePlacement, _HyperLiquidProvider_getAssetInfo, _HyperLiquidProvider_prepareAssetForTrading, _HyperLiquidProvider_handleHip3PreOrder, _HyperLiquidProvider_submitOrderWithRollback, _HyperLiquidProvider_handleOrderError, _HyperLiquidProvider_getStandaloneValidatedDexs, _HyperLiquidProvider_getAllMids, _HyperLiquidProvider_fetchSingleDexFresh, _HyperLiquidProvider_excludeNonUsdcCollateralResults, _HyperLiquidProvider_mergeDexResultsInto, _HyperLiquidProvider_cacheFreshMarketDataSnapshot, _HyperLiquidProvider_getStaleMarketDataSnapshot, _HyperLiquidProvider_isFeeCacheValid, _HyperLiquidProvider_getBuilderAddress, _HyperLiquidProvider_getReferralCode, _HyperLiquidProvider_ensureReferralSet, _HyperLiquidProvider_isReferralCodeReady, _HyperLiquidProvider_checkReferralSet, _HyperLiquidProvider_setReferralCode;
+var _HyperLiquidProvider_instances, _HyperLiquidProvider_deps, _HyperLiquidProvider_clientService, _HyperLiquidProvider_walletService, _HyperLiquidProvider_subscriptionService, _HyperLiquidProvider_symbolToAssetId, _HyperLiquidProvider_userFeeCache, _HyperLiquidProvider_maxLeverageCache, _HyperLiquidProvider_cachedMetaByDex, _HyperLiquidProvider_cachedMarketDataWithPrices, _HyperLiquidProvider_cachedSpotMeta, _HyperLiquidProvider_dexDiscoveryCache, _HyperLiquidProvider_referralCheckCache, _HyperLiquidProvider_builderFeeCheckCache, _HyperLiquidProvider_ensureReadyPromise, _HyperLiquidProvider_pendingBuilderFeeApprovals, _HyperLiquidProvider_compiledAllowlistPatterns, _HyperLiquidProvider_compiledBlocklistPatterns, _HyperLiquidProvider_userFeeDiscountBips, _HyperLiquidProvider_hip3Enabled, _HyperLiquidProvider_allowlistMarkets, _HyperLiquidProvider_blocklistMarkets, _HyperLiquidProvider_useUnifiedAccount, _HyperLiquidProvider_dexDiscoveryComplete, _HyperLiquidProvider_unifiedAccountSetupNeedsRetry, _HyperLiquidProvider_pendingValidatedDexsPromise, _HyperLiquidProvider_cachedUsdcTokenId, _HyperLiquidProvider_errorMappings, _HyperLiquidProvider_clientsInitialized, _HyperLiquidProvider_initializationPromise, _HyperLiquidProvider_messenger, _HyperLiquidProvider_builderAddressTestnet, _HyperLiquidProvider_builderAddressMainnet, _HyperLiquidProvider_priceDeviationLimit, _HyperLiquidProvider_compilePatternsSafely, _HyperLiquidProvider_ensureClientsInitialized, _HyperLiquidProvider_isWalletOnHyperliquid, _HyperLiquidProvider_ensureUnifiedAccountEnabled, _HyperLiquidProvider_ensureReady, _HyperLiquidProvider_tradingSetupPromise, _HyperLiquidProvider_tradingSetupComplete, _HyperLiquidProvider_ensureReadyForTrading, _HyperLiquidProvider_getOrFetchPrice, _HyperLiquidProvider_filterFills, _HyperLiquidProvider_getAllAvailableDexs, _HyperLiquidProvider_getValidatedDexs, _HyperLiquidProvider_fetchValidatedDexsInternal, _HyperLiquidProvider_getCachedMeta, _HyperLiquidProvider_backfillAssetMapForDex, _HyperLiquidProvider_getAssetIdWithRepair, _HyperLiquidProvider_getCachedSpotMeta, _HyperLiquidProvider_getCachedPerpDexs, _HyperLiquidProvider_calculateHip3FeeMultiplier, _HyperLiquidProvider_getCacheKey, _HyperLiquidProvider_fetchMarketsForDex, _HyperLiquidProvider_getUsdcTokenId, _HyperLiquidProvider_isUsdcCollateralDex, _HyperLiquidProvider_buildAssetMapping, _HyperLiquidProvider_queryUserDataAcrossDexs, _HyperLiquidProvider_mapError, _HyperLiquidProvider_getErrorContext, _HyperLiquidProvider_checkBuilderFeeApproval, _HyperLiquidProvider_ensureBuilderFeeApproval, _HyperLiquidProvider_checkBuilderFeeStatus, _HyperLiquidProvider_getBalanceForDex, _HyperLiquidProvider_findSourceDexWithBalance, _HyperLiquidProvider_autoTransferForHip3Order, _HyperLiquidProvider_autoTransferBackAfterClose, _HyperLiquidProvider_calculateHip3RequiredMargin, _HyperLiquidProvider_handleHip3PostOrderRebalance, _HyperLiquidProvider_handleHip3OrderRollback, _HyperLiquidProvider_validateOrderBeforePlacement, _HyperLiquidProvider_getAssetInfo, _HyperLiquidProvider_prepareAssetForTrading, _HyperLiquidProvider_handleHip3PreOrder, _HyperLiquidProvider_submitOrderWithRollback, _HyperLiquidProvider_handleOrderError, _HyperLiquidProvider_getStandaloneValidatedDexs, _HyperLiquidProvider_queryDexPositions, _HyperLiquidProvider_getAllMids, _HyperLiquidProvider_fetchSingleDexFresh, _HyperLiquidProvider_excludeNonUsdcCollateralResults, _HyperLiquidProvider_mergeDexResultsInto, _HyperLiquidProvider_cacheFreshMarketDataSnapshot, _HyperLiquidProvider_getStaleMarketDataSnapshot, _HyperLiquidProvider_isFeeCacheValid, _HyperLiquidProvider_getBuilderAddress, _HyperLiquidProvider_getReferralCode, _HyperLiquidProvider_ensureReferralSet, _HyperLiquidProvider_isReferralCodeReady, _HyperLiquidProvider_checkReferralSet, _HyperLiquidProvider_setReferralCode;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HyperLiquidProvider = void 0;
 const utils_1 = require("@metamask/utils");
@@ -362,6 +362,7 @@ class HyperLiquidProvider {
                 maxSlippageBps: normalizedMaxSlippageBps,
                 szDecimals: assetInfo.szDecimals,
                 leverage: params.leverage,
+                reduceOnly: params.reduceOnly,
             });
             const { orderPrice, formattedSize, formattedPrice } = (0, orderCalculations_js_1.calculateOrderPriceAndSize)({
                 orderType: params.orderType,
@@ -436,7 +437,13 @@ class HyperLiquidProvider {
             const errorMessage = (0, errorUtils_js_1.ensureError)(error, 'HyperLiquidProvider.placeOrder').message;
             const isMinimumOrderError = errorMessage.includes('Order must have minimum value of $10') ||
                 errorMessage.includes('Order 0: Order must have minimum value');
-            if (isMinimumOrderError && retryCount === 0) {
+            // Reduce-only orders are excluded. The retry works by growing the order
+            // 1.5%, which a close cannot do: a full close already submits the whole
+            // position, and a partial close is capped at the size the caller asked to
+            // close, so the retry would either be rejected as "Reduce only order would
+            // increase position" or resubmit an identical order. Surfacing the
+            // minimum-value error names the real problem instead.
+            if (isMinimumOrderError && retryCount === 0 && !params.reduceOnly) {
                 let adjustedUsdAmount;
                 let originalValue;
                 if (params.usdAmount) {
@@ -744,10 +751,18 @@ class HyperLiquidProvider {
                 ...new Set(positionsToClose.map((pos) => (0, hyperLiquidAdapter_js_1.parseAssetName)(pos.symbol).dex ?? 'main')),
             ];
             await Promise.all(uniqueDexs.map((dex) => __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getCachedMeta).call(this, { dexName: dex === 'main' ? null : dex })));
-            // Track HIP-3 positions and freed margins for post-close transfers
-            const hip3Transfers = [];
-            // Build orders array
+            // Freed-margin transfer for each submitted order, or null when that order
+            // needs none. One entry per order rather than one per HIP-3 position: a
+            // compacted list read with the response-status index credits the wrong
+            // order in a mixed main-DEX/HIP-3 batch.
+            const orderedHip3Transfers = [];
+            // Build orders array, plus the positions each order closes so response
+            // statuses stay index-aligned when a position is skipped below
             const orders = [];
+            const orderedPositions = [];
+            // Positions no order could be built for. Reported as failures so a caller
+            // cannot read "closed everything" from a result that left one open.
+            const skippedResults = [];
             for (const position of positionsToClose) {
                 // Extract DEX name for HIP-3 positions
                 const { dex: dexName } = (0, hyperLiquidAdapter_js_1.parseAssetName)(position.symbol);
@@ -769,13 +784,29 @@ class HyperLiquidProvider {
                 const isBuy = positionSize < 0; // Close opposite side
                 const closeSize = Math.abs(positionSize);
                 const totalMarginUsed = parseFloat(position.marginUsed);
-                // Track HIP-3 transfers (full position close means all margin is freed)
-                if (isHip3Position && dexName && !__classPrivateFieldGet(this, _HyperLiquidProvider_useUnifiedAccount, "f")) {
-                    hip3Transfers.push({
-                        sourceDex: dexName,
-                        freedMargin: totalMarginUsed,
+                // formatHyperLiquidSize() below rounds half-up, so floor onto the size
+                // grid first: a reduce-only order rounded above the position is rejected
+                // with "Reduce only order would increase position".
+                const flooredCloseSize = (0, orderCalculations_js_1.floorToSizeDecimals)(closeSize, assetInfo.szDecimals);
+                // A dust position worth less than one size increment floors to 0, which
+                // would submit a zero-size order. Skip it rather than sending an order
+                // the exchange must reject; the remaining positions still close, and the
+                // skip is reported as a failure below.
+                if (flooredCloseSize <= 0) {
+                    __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Skipping position smaller than one size increment', { coin: position.symbol, size: position.size });
+                    skippedResults.push({
+                        symbol: position.symbol,
+                        success: false,
+                        error: perpsErrorCodes_js_1.PERPS_ERROR_CODES.ORDER_SIZE_POSITIVE,
                     });
+                    continue;
                 }
+                // Track this order's HIP-3 transfer, if it needs one (a full position
+                // close frees all of its margin). Pushed below alongside the order so the
+                // two stay index-aligned.
+                const hip3Transfer = isHip3Position && dexName && !__classPrivateFieldGet(this, _HyperLiquidProvider_useUnifiedAccount, "f")
+                    ? { sourceDex: dexName, freedMargin: totalMarginUsed }
+                    : null;
                 const currentPrice = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getOrFetchPrice).call(this, {
                     symbol: position.symbol,
                     dexName: dexName ?? null,
@@ -785,9 +816,8 @@ class HyperLiquidProvider {
                 const orderPrice = isBuy
                     ? currentPrice * (1 + slippage)
                     : currentPrice * (1 - slippage);
-                // Format size and price
                 const formattedSize = (0, hyperLiquidAdapter_js_1.formatHyperLiquidSize)({
-                    size: closeSize,
+                    size: flooredCloseSize,
                     szDecimals: assetInfo.szDecimals,
                 });
                 const formattedPrice = (0, hyperLiquidAdapter_js_1.formatHyperLiquidPrice)({
@@ -803,6 +833,19 @@ class HyperLiquidProvider {
                     r: true, // reduceOnly
                     t: { limit: { tif: 'Ioc' } }, // Immediate or cancel for market-like execution
                 });
+                orderedPositions.push(position);
+                orderedHip3Transfers.push(hip3Transfer);
+            }
+            // Every position was smaller than one size increment. Return their
+            // failures rather than an empty result, which would be indistinguishable
+            // from "no positions matched".
+            if (orders.length === 0) {
+                return {
+                    success: false,
+                    successCount: 0,
+                    failureCount: skippedResults.length,
+                    results: skippedResults,
+                };
             }
             // Calculate discounted builder fee if reward discount is active
             let builderFee = hyperLiquidConfig_js_1.BUILDER_FEE_CONFIG.MaxFeeTenthsBps;
@@ -822,16 +865,17 @@ class HyperLiquidProvider {
             const { statuses } = result.response.data;
             const successCount = statuses.filter((stat) => isStatusObject(stat) &&
                 ((0, utils_1.hasProperty)(stat, 'filled') || (0, utils_1.hasProperty)(stat, 'resting'))).length;
-            const failureCount = statuses.length - successCount;
+            const failureCount = statuses.length - successCount + skippedResults.length;
             // Handle HIP-3 margin transfers for successful closes
             if (!__classPrivateFieldGet(this, _HyperLiquidProvider_useUnifiedAccount, "f")) {
                 for (let i = 0; i < statuses.length; i++) {
                     const status = statuses[i];
                     const isSuccess = isStatusObject(status) &&
                         ((0, utils_1.hasProperty)(status, 'filled') || (0, utils_1.hasProperty)(status, 'resting'));
-                    if (isSuccess && hip3Transfers[i]) {
-                        const { sourceDex, freedMargin } = hip3Transfers[i];
-                        __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Position closed successfully, initiating manual auto-transfer back', { symbol: positionsToClose[i].symbol, freedMargin });
+                    const transfer = orderedHip3Transfers[i];
+                    if (isSuccess && transfer) {
+                        const { sourceDex, freedMargin } = transfer;
+                        __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Position closed successfully, initiating manual auto-transfer back', { symbol: orderedPositions[i].symbol, freedMargin });
                         // Non-blocking: Transfer freed margin back to main DEX
                         await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_autoTransferBackAfterClose).call(this, {
                             sourceDex,
@@ -840,18 +884,29 @@ class HyperLiquidProvider {
                     }
                 }
             }
-            return {
-                success: successCount > 0,
-                successCount,
-                failureCount,
-                results: statuses.map((status, index) => ({
-                    symbol: positionsToClose[index].symbol,
+            // Index submitted and skipped outcomes by symbol so `results` can keep the
+            // order of the requested positions: consumers may correlate them by index.
+            const submittedResults = new Map(statuses.map((status, index) => [
+                orderedPositions[index].symbol,
+                {
+                    symbol: orderedPositions[index].symbol,
                     success: isStatusObject(status) &&
                         ((0, utils_1.hasProperty)(status, 'filled') || (0, utils_1.hasProperty)(status, 'resting')),
                     error: isStatusObject(status) && (0, utils_1.hasProperty)(status, 'error')
                         ? String(status.error)
                         : undefined,
-                })),
+                },
+            ]));
+            const skippedBySymbol = new Map(skippedResults.map((skipped) => [skipped.symbol, skipped]));
+            return {
+                success: successCount > 0,
+                successCount,
+                failureCount,
+                results: positionsToClose.flatMap((position) => {
+                    const outcome = submittedResults.get(position.symbol) ??
+                        skippedBySymbol.get(position.symbol);
+                    return outcome ? [outcome] : [];
+                }),
             };
         }
         catch (error) {
@@ -1130,6 +1185,68 @@ class HyperLiquidProvider {
             // Use provided position (from WebSocket) or fetch from cache
             // This avoids unnecessary API calls and prevents 429 rate limiting
             let { position } = params;
+            // Re-validate the caller-supplied snapshot against the freshest WebSocket
+            // position cache. Clients pass a throttled snapshot (~1s old on mobile),
+            // so a concurrent TP/SL fill, a liquidation, or a double-tapped close
+            // leaves the snapshot's side/size larger than (or opposite to) the real
+            // position and HyperLiquid rejects the reduce-only order with "Reduce
+            // only order would increase position". Reading the cache never issues a
+            // REST request, so this does not reintroduce 429 rate limiting.
+            if (position && __classPrivateFieldGet(this, _HyperLiquidProvider_subscriptionService, "f").isPositionsCacheInitialized()) {
+                // Read the symbol's own DEX slice, not the aggregate. The aggregate is
+                // only rebuilt once every expected DEX has published, so after a
+                // WebSocket reconnect — which resets the initialized-DEX set without
+                // clearing these caches — it can sit frozen at pre-reconnect contents
+                // while the per-DEX slices keep updating. Deciding "this DEX is covered"
+                // from the per-DEX map and then reading the position from the aggregate
+                // mixed a fresh answer with stale data: a close could reuse a stale size,
+                // or throw for a position that is open.
+                const dexPositions = __classPrivateFieldGet(this, _HyperLiquidProvider_subscriptionService, "f").getCachedPositionsForDex((0, hyperLiquidAdapter_js_1.parseAssetName)(params.symbol).dex ?? '');
+                const livePosition = dexPositions?.find((pos) => pos.symbol === params.symbol);
+                if (livePosition) {
+                    if (livePosition.size !== position.size) {
+                        __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Stale close position snapshot: using live WebSocket position', {
+                            coin: params.symbol,
+                            snapshotSize: position.size,
+                            liveSize: livePosition.size,
+                        });
+                    }
+                    position = livePosition;
+                }
+                else if (dexPositions) {
+                    // That DEX has published and does not hold this symbol, so the position
+                    // is already closed (e.g. a double-tapped close). This is the same read
+                    // the lookup above used, so the two can never disagree. Fail here rather
+                    // than falling back to REST: the cache is the freshest source, so a REST
+                    // lookup can only burn a request that risks 429s and, if it lags, hand
+                    // back a position that no longer exists.
+                    throw new Error(`No position found for ${params.symbol}`);
+                }
+                else {
+                    // The cache holds nothing for this symbol's DEX — a HIP-3 DEX whose
+                    // subscription has not published this session — so the symbol's
+                    // absence proves nothing. Spend one REST request to get live data
+                    // rather than trusting a snapshot the exchange may have moved past.
+                    __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Position cache does not cover this DEX: fetching live positions', { coin: params.symbol });
+                    // Query the symbol's own DEX so the outcome carries provenance.
+                    // getPositions() fans out across every enabled DEX, flattens the subset
+                    // that answered and turns any failure into [], so it cannot distinguish
+                    // "this DEX answered and holds nothing" from "this DEX failed or was
+                    // never queried" — and those two need opposite decisions.
+                    const { answered, positions } = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_queryDexPositions).call(this, (0, hyperLiquidAdapter_js_1.parseAssetName)(params.symbol).dex);
+                    const livePositionFromApi = positions.find((pos) => pos.symbol === params.symbol);
+                    if (livePositionFromApi) {
+                        position = livePositionFromApi;
+                    }
+                    else if (answered) {
+                        // The DEX answered without this symbol — even with no positions at
+                        // all — so it is genuinely closed.
+                        throw new Error(`No position found for ${params.symbol}`);
+                    }
+                    // Otherwise the query failed, so the absence proves nothing: keep the
+                    // caller's snapshot rather than block a position that may be closable.
+                }
+            }
             if (!position) {
                 const positions = await this.getPositions();
                 position = positions.find((pos) => pos.symbol === params.symbol);
@@ -1139,18 +1256,37 @@ class HyperLiquidProvider {
             }
             const positionSize = parseFloat(position.size);
             const isBuy = positionSize < 0;
-            const closeSize = params.size ?? Math.abs(positionSize).toString();
+            const absPositionSize = Math.abs(positionSize);
+            // Only an omitted (or empty) size means "close 100%". A supplied size must
+            // be a positive number: silently promoting '0' or 'abc' to a full close
+            // would liquidate the whole position on a caller-side formatting slip.
+            // A supplied size is clamped to the live position size, because
+            // HyperLiquid rejects reduce-only orders that exceed the position and the
+            // caller computed its size from a snapshot that may already be too large.
+            const hasRequestedSize = params.size !== undefined && params.size !== '';
+            let closeSizeNumber = absPositionSize;
+            if (hasRequestedSize) {
+                const requestedSize = parseFloat(params.size);
+                if (!Number.isFinite(requestedSize) || requestedSize <= 0) {
+                    throw new Error(perpsErrorCodes_js_1.PERPS_ERROR_CODES.ORDER_SIZE_POSITIVE);
+                }
+                closeSizeNumber = Math.min(requestedSize, absPositionSize);
+            }
+            const closeSize = closeSizeNumber.toString();
             // Capture position details BEFORE closing for freed margin calculation
             const totalMarginUsed = parseFloat(position.marginUsed);
-            const totalPositionSize = Math.abs(positionSize);
-            const closeSizeNum = parseFloat(closeSize);
+            const totalPositionSize = absPositionSize;
+            const closeSizeNum = closeSizeNumber;
             const isHip3Position = position.symbol.includes(':');
             const hip3Dex = isHip3Position ? position.symbol.split(':')[0] : null;
             // Calculate freed margin proportionally
             const freedMarginRatio = closeSizeNum / totalPositionSize;
             const freedMargin = totalMarginUsed * freedMarginRatio;
-            // Get current price for validation if not provided (and not a full close)
-            // Full closes don't need price for validation
+            // Get current price for USD/minimum validation if not provided. A full
+            // close skips *that* validation because it submits the exact live size —
+            // but not the price-staleness guard: calculateFinalPositionSize checks
+            // priceAtCalculation against the live price for every close that supplies
+            // it, using the price placeOrder fetches when none is passed here.
             let { currentPrice } = params;
             if (!currentPrice && params.size && !params.usdAmount) {
                 // Partial close without USD or price: use limit price as fallback for validation
@@ -1173,6 +1309,10 @@ class HyperLiquidProvider {
                 closedSize: closeSize,
                 freedMargin: freedMargin.toFixed(2),
             });
+            // True when the order closes 100% of the position: either no size was
+            // provided, or the requested size covers (or was clamped to) the whole
+            // position.
+            const isFullClose = closeSizeNum >= absPositionSize;
             // Execute position close with consistent slippage handling
             const result = await this.placeOrder({
                 symbol: params.symbol,
@@ -1181,10 +1321,17 @@ class HyperLiquidProvider {
                 orderType: params.orderType ?? 'market',
                 price: params.price,
                 reduceOnly: true,
-                isFullClose: !params.size, // True if closing 100% (size not provided)
+                isFullClose,
                 // Pass through price and slippage parameters for consistent validation
                 currentPrice,
-                usdAmount: params.usdAmount,
+                // A close of the whole position must submit exactly the live position
+                // size. Forwarding usdAmount would make placeOrder recompute the size as
+                // usdAmount / currentPrice — discarding the clamp above, since usdAmount
+                // is the source of truth there — and submit more than the position
+                // holds, which is rejected with "Reduce only order would increase
+                // position". Genuine partial closes keep usdAmount so their size stays
+                // USD-accurate.
+                usdAmount: isFullClose ? undefined : params.usdAmount,
                 priceAtCalculation: params.priceAtCalculation,
                 maxSlippageBps: params.maxSlippageBps,
             });
@@ -5785,6 +5932,48 @@ async function _HyperLiquidProvider_getStandaloneValidatedDexs() {
     // buildAssetMapping uses state.raw for perpDexIndex computation.
     const state = __classPrivateFieldGet(this, _HyperLiquidProvider_dexDiscoveryCache, "f").update(allDexs);
     return state.validated;
+}, _HyperLiquidProvider_queryDexPositions = 
+/**
+ * Query one DEX's positions directly, preserving whether that DEX answered.
+ *
+ * `getPositions()` fans out across every enabled DEX, flattens the subset that
+ * answered and converts any thrown error into an empty array, so its result
+ * cannot distinguish "this DEX answered and holds no positions" from "this
+ * DEX's request failed or it was never queried". `closePosition` needs that
+ * distinction: the first means the position is closed and the close must fail
+ * before submitting, the second means the absence proves nothing and the
+ * caller's snapshot should stand.
+ *
+ * TP/SL enrichment is skipped, as in standalone mode: the close path only reads
+ * size, side and margin.
+ *
+ * @param dexName - DEX identifier, or null for the main DEX.
+ * @returns Whether the DEX answered, and the positions it reported.
+ */
+async function _HyperLiquidProvider_queryDexPositions(dexName) {
+    try {
+        await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureClientsInitialized).call(this);
+        __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").ensureInitialized();
+        const infoClient = __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").getInfoClient();
+        const userAddress = await __classPrivateFieldGet(this, _HyperLiquidProvider_walletService, "f").getUserAddressWithDefault();
+        const state = await infoClient.clearinghouseState(dexName ? { user: userAddress, dex: dexName } : { user: userAddress });
+        const positions = (state.assetPositions ?? [])
+            .filter((assetPos) => assetPos.position.szi !== '0')
+            .map((assetPos) => (0, hyperLiquidAdapter_js_1.adaptPositionFromSDK)(assetPos));
+        __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Target DEX position query answered', {
+            dex: dexName ?? 'main',
+            count: positions.length,
+        });
+        return { answered: true, positions };
+    }
+    catch (error) {
+        __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Target DEX position query failed; its silence proves nothing', {
+            dex: dexName ?? 'main',
+            error: (0, errorUtils_js_1.ensureError)(error, 'HyperLiquidProvider.queryDexPositions')
+                .message,
+        });
+        return { answered: false, positions: [] };
+    }
 }, _HyperLiquidProvider_getAllMids = 
 /**
  * Get allMids for a DEX — uses WS snapshot as primary source, REST as fallback.