@metamask-previews/perps-controller 10.0.0-preview-a42e8d0d2 → 10.0.0-preview-5a03e1b92

package/dist/providers/HyperLiquidProvider.mjs

@@ -9,7 +9,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_fetchOpenOrders, _HyperLiquidProvider_resolveReplacementOrderId, _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;
 import { hasProperty } from "@metamask/utils";
 import { v4 as uuidv4 } from "uuid";
 import { PERPS_EVENT_PROPERTY, PERPS_EVENT_VALUE } from "../constants/eventNames.mjs";
@@ -27,11 +27,12 @@ import { PerpsAnalyticsEvent } from "../types/index.mjs";
 import { addSpotBalanceToAccountState, aggregateAccountStates } from "../utils/accountUtils.mjs";
 import { ensureError, isHyperLiquidUserNotFoundError, isKeyringLockedError } from "../utils/errorUtils.mjs";
 import { shouldDeferUnifiedAccountSetup } from "../utils/hyperLiquidAbstraction.mjs";
-import { adaptAccountStateFromSDK, adaptHyperLiquidLedgerUpdateToUserHistoryItem, adaptMarketFromSDK, adaptOrderFromSDK, adaptPositionFromSDK, buildAssetMapping, formatHyperLiquidPrice, formatHyperLiquidSize, parseAssetName } from "../utils/hyperLiquidAdapter.mjs";
+import { adaptAccountStateFromSDK, adaptHyperLiquidLedgerUpdateToUserHistoryItem, adaptMarketFromSDK, adaptOrderFromSDK, adaptPositionFromSDK, adaptPositionTriggerOrderFromSDK, adaptTpslLinkageToGrouping, buildAssetMapping, formatHyperLiquidPrice, formatHyperLiquidSize, parseAssetName } from "../utils/hyperLiquidAdapter.mjs";
 import { createErrorResult, getMaxOrderValue, getSupportedPaths, validateAssetSupport, validateBalance, validateCoinExists, validateDepositParams, validateOrderParams, validateWithdrawalParams } from "../utils/hyperLiquidValidation.mjs";
 import { transformMarketData } from "../utils/marketDataTransform.mjs";
 import { compileMarketPattern, shouldIncludeMarket } from "../utils/marketUtils.mjs";
-import { buildOrdersArray, calculateFinalPositionSize, calculateOrderPriceAndSize } from "../utils/orderCalculations.mjs";
+import { buildOrdersArray, calculateFinalPositionSize, calculateOrderPriceAndSize, floorToSizeDecimals, formatPartialTpslSize, validateOrderPrecision } from "../utils/orderCalculations.mjs";
+import { getTriggerExecution, isLimitExecutionOrderType, isTriggerOrderType, toSDKTimeInForce } from "../utils/orderTypes.mjs";
 import { createStandaloneInfoClient, queryStandaloneClearinghouseStates, queryStandaloneOpenOrders } from "../utils/standaloneInfoClient.mjs";
 // getStreamManagerInstance removed: use this.#deps.streamManager instead
 /**
@@ -42,6 +43,80 @@ import { createStandaloneInfoClient, queryStandaloneClearinghouseStates, querySt
  * @returns The result of the operation.
  */
 const isStatusObject = (status) => typeof status === 'object' && status !== null;
+/**
+ * Collect the order IDs of every TP/SL child carried by a parent order.
+ *
+ * HyperLiquid lists `normalTpsl` children both nested under their parent and as
+ * top-level entries in `frontendOpenOrders`. Those children protect the pending
+ * parent order rather than the position, so callers use this set to exclude them.
+ *
+ * @param orders - Raw frontend open orders for the account.
+ * @returns The set of child order IDs.
+ */
+function collectChildOrderIds(orders) {
+    const childOrderIds = new Set();
+    orders.forEach((order) => {
+        order.children?.forEach((child) => {
+            childOrderIds.add(child.oid);
+        });
+    });
+    return childOrderIds;
+}
+/**
+ * Group orders by market, so a per-position pass does not rescan every order.
+ *
+ * @param orders - Raw frontend open orders across all DEXs.
+ * @returns Orders keyed by market symbol.
+ */
+function groupOrdersBySymbol(orders) {
+    const bySymbol = new Map();
+    orders.forEach((order) => {
+        const existing = bySymbol.get(order.coin);
+        if (existing) {
+            existing.push(order);
+        }
+        else {
+            bySymbol.set(order.coin, [order]);
+        }
+    });
+    return bySymbol;
+}
+/**
+ * Build the trigger-order view of a position: position-bound TP/SL plus
+ * standalone (partial) reduce-only triggers on the same market, de-duplicated by
+ * order ID and excluding children of pending parent orders.
+ *
+ * @param params - Collection parameters.
+ * @param params.orders - Raw frontend open orders across all DEXs.
+ * @param params.position - Position the triggers are attached to.
+ * @param params.childOrderIds - Order IDs that belong to a pending parent order.
+ * @returns The take profit and stop loss trigger orders for the position.
+ */
+function collectPositionTriggerOrders(params) {
+    const { orders, position, childOrderIds } = params;
+    const byOrderId = new Map();
+    orders.forEach((rawOrder) => {
+        if (rawOrder.coin !== position.symbol ||
+            !rawOrder.isTrigger ||
+            !rawOrder.reduceOnly ||
+            childOrderIds.has(rawOrder.oid)) {
+            return;
+        }
+        const triggerOrder = adaptPositionTriggerOrderFromSDK({
+            rawOrder,
+            positionSize: position.size,
+            entryPrice: position.entryPrice,
+        });
+        if (triggerOrder && !byOrderId.has(triggerOrder.orderId)) {
+            byOrderId.set(triggerOrder.orderId, triggerOrder);
+        }
+    });
+    const triggerOrders = Array.from(byOrderId.values());
+    return {
+        takeProfitOrders: triggerOrders.filter((order) => order.direction === 'take_profit'),
+        stopLossOrders: triggerOrders.filter((order) => order.direction !== 'take_profit'),
+    };
+}
 /**
  * HyperLiquid provider implementation
  *
@@ -295,6 +370,14 @@ export class HyperLiquidProvider {
                 size: params.size,
                 price: params.price,
                 orderType: params.orderType,
+                triggerPrice: params.triggerPrice,
+                takeProfitPrice: params.takeProfitPrice,
+                stopLossPrice: params.stopLossPrice,
+                takeProfitSize: params.takeProfitSize,
+                stopLossSize: params.stopLossSize,
+                tpslLinkage: params.tpslLinkage,
+                grouping: params.grouping,
+                timeInForce: params.timeInForce,
             });
             if (!validation.isValid) {
                 throw new Error(validation.error);
@@ -307,6 +390,22 @@ export class HyperLiquidProvider {
                 symbol: params.symbol,
                 dexName,
             });
+            // A price or partial size that rounds away at the asset precision is
+            // caught here, as soon as szDecimals is known and before anything is
+            // committed: the signing prompts in #ensureReadyForTrading, the leverage
+            // change in #prepareAssetForTrading, and the HIP-3 margin transfer all
+            // come later.
+            const precision = validateOrderPrecision({
+                triggerPrice: params.triggerPrice,
+                takeProfitPrice: params.takeProfitPrice,
+                stopLossPrice: params.stopLossPrice,
+                takeProfitSize: params.takeProfitSize,
+                stopLossSize: params.stopLossSize,
+                szDecimals: assetInfo.szDecimals,
+            });
+            if (!precision.isValid) {
+                throw new Error(precision.error);
+            }
             // Allow override with UI-provided price (optimization to avoid API call).
             effectivePrice =
                 params.currentPrice && params.currentPrice > 0
@@ -359,6 +458,7 @@ export class HyperLiquidProvider {
                 maxSlippageBps: normalizedMaxSlippageBps,
                 szDecimals: assetInfo.szDecimals,
                 leverage: params.leverage,
+                reduceOnly: params.reduceOnly,
             });
             const { orderPrice, formattedSize, formattedPrice } = calculateOrderPriceAndSize({
                 orderType: params.orderType,
@@ -366,6 +466,7 @@ export class HyperLiquidProvider {
                 finalPositionSize,
                 currentPrice: effectivePrice,
                 limitPrice: params.price,
+                triggerPrice: params.triggerPrice,
                 maxSlippageBps: normalizedMaxSlippageBps,
                 szDecimals: assetInfo.szDecimals,
             });
@@ -410,11 +511,19 @@ export class HyperLiquidProvider {
                 formattedSize,
                 reduceOnly: params.reduceOnly ?? false,
                 orderType: params.orderType,
+                timeInForce: params.timeInForce,
                 clientOrderId: params.clientOrderId,
+                triggerPrice: params.triggerPrice,
                 takeProfitPrice: params.takeProfitPrice,
                 stopLossPrice: params.stopLossPrice,
+                takeProfitSize: params.takeProfitSize,
+                stopLossSize: params.stopLossSize,
                 szDecimals: assetInfo.szDecimals,
-                grouping: params.grouping,
+                // The provider-agnostic linkage wins; `grouping` is the deprecated
+                // HyperLiquid-shaped spelling kept for existing callers.
+                grouping: params.tpslLinkage
+                    ? adaptTpslLinkageToGrouping(params.tpslLinkage)
+                    : params.grouping,
             });
             // 8. Submit order with atomic rollback
             return await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_submitOrderWithRollback).call(this, {
@@ -433,7 +542,13 @@ export class HyperLiquidProvider {
             const errorMessage = 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) {
@@ -500,20 +615,84 @@ export class HyperLiquidProvider {
                     error: PERPS_ERROR_CODES.ORDER_SIZE_POSITIVE,
                 };
             }
+            // `modify` rebuilds an order as a plain limit/market order, so a trigger
+            // on either side of the edit would be silently dropped. Reject a resting
+            // trigger order as well as an edit *into* one; cancel and re-place instead.
+            if (isTriggerOrderType(params.newOrder.orderType)) {
+                return {
+                    success: false,
+                    error: PERPS_ERROR_CODES.ORDER_EDIT_TRIGGER_UNSUPPORTED,
+                };
+            }
+            // The WebSocket order cache is the cheap source for the resting order's
+            // placement type, but it may be cold or stale.
+            const cachedRestingOrder = __classPrivateFieldGet(this, _HyperLiquidProvider_subscriptionService, "f")
+                .getOrdersCacheIfInitialized()
+                ?.find((order) => order.orderId === params.orderId.toString());
+            if (cachedRestingOrder?.isTrigger === true) {
+                return {
+                    success: false,
+                    error: PERPS_ERROR_CODES.ORDER_EDIT_TRIGGER_UNSUPPORTED,
+                };
+            }
             // Validate new order parameters
             const validation = validateOrderParams({
                 coin: params.newOrder.symbol,
                 size: params.newOrder.size,
                 price: params.newOrder.price,
                 orderType: params.newOrder.orderType,
+                triggerPrice: params.newOrder.triggerPrice,
+                takeProfitPrice: params.newOrder.takeProfitPrice,
+                stopLossPrice: params.newOrder.stopLossPrice,
+                takeProfitSize: params.newOrder.takeProfitSize,
+                stopLossSize: params.newOrder.stopLossSize,
+                tpslLinkage: params.newOrder.tpslLinkage,
+                grouping: params.newOrder.grouping,
+                timeInForce: params.newOrder.timeInForce,
             });
             if (!validation.isValid) {
                 throw new Error(validation.error);
             }
-            // Ensure provider is ready for trading (includes signing operations)
-            await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureReadyForTrading).call(this);
             // Extract DEX name for API calls (main DEX = null)
             const { dex: dexName } = parseAssetName(params.newOrder.symbol);
+            // Initialization only — clients and the asset mapping. The signing half
+            // of readiness is deferred until after the checks below, so a refused
+            // edit never prompts for a signature or writes an approval.
+            await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureReady).call(this);
+            // What is resting before the edit serves two purposes, and they carry
+            // different weight. Verifying the target is REQUIRED when the cache could
+            // not do it — an unverified edit can rebuild a protective stop as a plain
+            // order — so that read must fail closed. Providing a baseline for the
+            // optional orderId resolution is not: when the cache already confirmed the
+            // order, a failed read must not sink a modify that would otherwise
+            // succeed, exactly as the post-modify lookup does not.
+            let ordersBeforeEdit;
+            if (cachedRestingOrder === undefined) {
+                ordersBeforeEdit = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_fetchOpenOrders).call(this, { dexName });
+                const restingOrder = ordersBeforeEdit.find((order) => order.oid.toString() === params.orderId.toString());
+                if (!restingOrder) {
+                    return {
+                        success: false,
+                        error: PERPS_ERROR_CODES.ORDER_EDIT_ORDER_UNVERIFIABLE,
+                    };
+                }
+                if (restingOrder.isTrigger) {
+                    return {
+                        success: false,
+                        error: PERPS_ERROR_CODES.ORDER_EDIT_TRIGGER_UNSUPPORTED,
+                    };
+                }
+            }
+            else {
+                try {
+                    ordersBeforeEdit = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_fetchOpenOrders).call(this, { dexName });
+                }
+                catch (error) {
+                    // Only the optional identity baseline is lost. Without it novelty
+                    // cannot be judged, so the id is omitted below rather than guessed.
+                    __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Could not read the pre-edit orders baseline:', error);
+                }
+            }
             // Get asset info and prices (uses cache to avoid redundant API calls)
             const meta = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getCachedMeta).call(this, { dexName });
             // asset.name format: "BTC" for main DEX, "xyz:XYZ100" for HIP-3
@@ -553,14 +732,20 @@ export class HyperLiquidProvider {
                 p: formattedPrice,
                 s: formattedSize,
                 r: params.newOrder.reduceOnly ?? false,
-                // Same TIF logic as placeOrder - see documentation above for details
+                // Same TIF logic as placeOrder - see documentation above for details.
+                // A limit order honours the caller's time in force; validation above has
+                // already rejected one on any other order shape.
                 t: params.newOrder.orderType === 'limit'
-                    ? { limit: { tif: 'Gtc' } } // Standard limit order
+                    ? { limit: { tif: toSDKTimeInForce(params.newOrder.timeInForce) } }
                     : { limit: { tif: 'FrontendMarket' } }, // True market order
                 c: params.newOrder.clientOrderId
                     ? params.newOrder.clientOrderId
                     : undefined,
             };
+            // Every refusal is behind us, so the setup that may prompt for signatures
+            // and write builder-fee/referral approvals can run now — a rejected edit
+            // costs the caller nothing, matching placeOrder and updatePositionTPSL.
+            await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureReadyForTrading).call(this);
             // Submit modification via SDK
             const exchangeClient = __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").getExchangeClient();
             const result = await exchangeClient.modify({
@@ -572,9 +757,25 @@ export class HyperLiquidProvider {
             if (result.status !== 'ok') {
                 throw new Error(`Order modification failed: ${JSON.stringify(result)}`);
             }
+            // `params.orderId` is the order that was just REPLACED, so returning it
+            // as OrderResult.orderId (documented as the exchange order ID) names an
+            // order the venue has already cancelled. Report the replacement when it
+            // can be resolved unambiguously, and otherwise omit the optional id
+            // rather than fabricate identity.
+            const replacementOrderId = ordersBeforeEdit === undefined
+                ? undefined
+                : await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_resolveReplacementOrderId).call(this, {
+                    previousOrders: ordersBeforeEdit,
+                    dexName,
+                    symbol: params.newOrder.symbol,
+                    isBuy: params.newOrder.isBuy,
+                    size: formattedSize,
+                });
             return {
                 success: true,
-                orderId: params.orderId.toString(),
+                ...(replacementOrderId === undefined
+                    ? {}
+                    : { orderId: replacementOrderId }),
             };
         }
         catch (error) {
@@ -741,10 +942,18 @@ export class HyperLiquidProvider {
                 ...new Set(positionsToClose.map((pos) => 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 } = parseAssetName(position.symbol);
@@ -766,13 +975,29 @@ export 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 = 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: 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,
@@ -782,9 +1007,8 @@ export class HyperLiquidProvider {
                 const orderPrice = isBuy
                     ? currentPrice * (1 + slippage)
                     : currentPrice * (1 - slippage);
-                // Format size and price
                 const formattedSize = formatHyperLiquidSize({
-                    size: closeSize,
+                    size: flooredCloseSize,
                     szDecimals: assetInfo.szDecimals,
                 });
                 const formattedPrice = formatHyperLiquidPrice({
@@ -800,6 +1024,19 @@ export 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 = BUILDER_FEE_CONFIG.MaxFeeTenthsBps;
@@ -819,16 +1056,17 @@ export class HyperLiquidProvider {
             const { statuses } = result.response.data;
             const successCount = statuses.filter((stat) => isStatusObject(stat) &&
                 (hasProperty(stat, 'filled') || 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) &&
                         (hasProperty(status, 'filled') || 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,
@@ -837,18 +1075,29 @@ export 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) &&
                         (hasProperty(status, 'filled') || hasProperty(status, 'resting')),
                     error: isStatusObject(status) && 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) {
@@ -884,18 +1133,35 @@ export class HyperLiquidProvider {
      * 1. 'normalTpsl' - Tied to a parent order (set when placing the order)
      * 2. 'positionTpsl' - Tied to a position (can be set/modified after fill)
      *
+     * Partial TP/SL: when `takeProfitSize` or `stopLossSize` is supplied, the
+     * orders cannot use 'positionTpsl' (which always covers the whole position and
+     * requires size 0). They are submitted as standalone reduce-only trigger orders
+     * with 'na' grouping and explicit sizes instead.
+     *
+     * Note that the pre-cancel sweep clears every standalone reduce-only trigger
+     * on the symbol — whether this update is partial or whole-position — not only
+     * the ones this method placed. A trigger the caller placed independently
+     * through `placeOrder` (for example a manual reduce-only stop) is therefore
+     * cancelled too. Only TP/SL children of another pending order are protected.
+     *
      * @param params - The operation parameters.
      * @param params.symbol - Asset symbol of the position
      * @param params.takeProfitPrice - TP price (undefined to remove)
      * @param params.stopLossPrice - SL price (undefined to remove)
+     * @param params.takeProfitSize - Partial TP size (undefined for the whole position)
+     * @param params.stopLossSize - Partial SL size (undefined for the whole position)
      * @returns A promise that resolves to the result.
      */
     async updatePositionTPSL(params) {
         try {
             __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Updating position TP/SL:', params);
-            const { symbol, takeProfitPrice, stopLossPrice, position: livePosition, } = params;
-            // Ensure provider is ready for trading (includes signing operations)
-            await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureReadyForTrading).call(this);
+            const { symbol, takeProfitPrice, stopLossPrice, takeProfitSize, stopLossSize, position: livePosition, } = params;
+            const isPartialTpsl = takeProfitSize !== undefined || stopLossSize !== undefined;
+            // Basic initialization only. The trading setup that can prompt a hardware
+            // wallet and write the referral / builder-fee approvals is deferred until
+            // every validation below has passed, so a rejected update leaves nothing
+            // behind.
+            await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureReady).call(this);
             // Use live position (from WebSocket) if available, otherwise fetch via REST
             // Preferring WebSocket data avoids rate limiting issues with the REST API
             let position = livePosition;
@@ -925,12 +1191,67 @@ export class HyperLiquidProvider {
             }
             const positionSize = Math.abs(parseFloat(position.size));
             const isLong = parseFloat(position.size) > 0;
-            // Get clients for API calls (ensureReady already called at method start)
+            // Partial TP/SL sizes must be positive, paired with their price, and no
+            // larger than the position they close.
+            const tpslSizeValidation = validateOrderParams({
+                coin: symbol,
+                size: positionSize.toString(),
+                takeProfitPrice,
+                stopLossPrice,
+                takeProfitSize,
+                stopLossSize,
+            });
+            if (!tpslSizeValidation.isValid) {
+                return {
+                    success: false,
+                    error: tpslSizeValidation.error,
+                };
+            }
+            // Get clients for API calls (#ensureReady already called at method start).
+            // Holding the exchange client reference is not itself a write; it is only
+            // used below, after the trading setup has run.
             const infoClient = __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").getInfoClient();
             const exchangeClient = __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").getExchangeClient();
             const userAddress = await __classPrivateFieldGet(this, _HyperLiquidProvider_walletService, "f").getUserAddressWithDefault();
             // Extract DEX name for API calls (main DEX = null)
             const { dex: dexName } = parseAssetName(symbol);
+            // Asset info is resolved before the pre-cancel sweep so a partial size
+            // that rounds away at the asset precision is rejected while the
+            // position's existing triggers are still in place. Rejecting it after the
+            // sweep would leave the position unprotected with nothing put back.
+            const meta = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getCachedMeta).call(this, { dexName });
+            // Check if meta is an error response (string) or doesn't have universe property
+            if (!meta ||
+                typeof meta === 'string' ||
+                !meta.universe ||
+                !Array.isArray(meta.universe)) {
+                __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Failed to fetch metadata for asset mapping', {
+                    meta,
+                    dex: dexName ?? 'main',
+                });
+                throw new Error(`Failed to fetch market metadata for DEX ${dexName ?? 'main'}`);
+            }
+            // asset.name format: "BTC" for main DEX, "xyz:XYZ100" for HIP-3
+            const assetInfo = meta.universe.find((asset) => asset.name === symbol);
+            if (!assetInfo) {
+                throw new Error(`Asset ${symbol} not found in ${dexName ?? 'main'} DEX universe`);
+            }
+            const precision = validateOrderPrecision({
+                takeProfitPrice,
+                stopLossPrice,
+                takeProfitSize,
+                stopLossSize,
+                szDecimals: assetInfo.szDecimals,
+            });
+            if (!precision.isValid) {
+                return {
+                    success: false,
+                    error: precision.error,
+                };
+            }
+            // Everything is validated: only now run the trading setup that can prompt
+            // for signatures and write the referral / builder-fee approvals.
+            await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureReadyForTrading).call(this);
             // Cancel existing TP/SL orders for this position
             // OPTIMIZATION: Use WebSocket cache first (0 weight), fall back to single-DEX REST (20 weight)
             // Previously: queryUserDataAcrossDexs queried ALL DEXs (20 weight × N DEXs = 40+ weight)
@@ -941,18 +1262,48 @@ export class HyperLiquidProvider {
             let cancelRequests = [];
             // Use atomic getter to prevent race condition between check and get
             const cachedOrders = __classPrivateFieldGet(this, _HyperLiquidProvider_subscriptionService, "f").getOrdersCacheIfInitialized();
-            if (cachedOrders === null) {
+            // Replacing TP/SL has to consider standalone ('na' grouping) triggers —
+            // left by a partial update or placed independently — which are not
+            // position-bound. Telling those apart from a pending order's normalTpsl
+            // child requires the parent/child relationship, which only the REST
+            // payload carries. The cache path is therefore only safe when the cache
+            // shows no such trigger on this market: a partial update always places
+            // standalone triggers, and a whole-position update must still clear any
+            // standalone leftovers instead of letting them fire beside the new
+            // position-bound orders.
+            const cacheShowsStandaloneTriggers = Boolean(cachedOrders?.some((order) => order.symbol === symbol &&
+                order.reduceOnly === true &&
+                order.isTrigger === true &&
+                order.isPositionTpsl !==
+                    Boolean(TP_SL_CONFIG.UsePositionBoundTpsl) &&
+                order.detailedOrderType &&
+                (order.detailedOrderType.includes('Take Profit') ||
+                    order.detailedOrderType.includes('Stop'))));
+            if (cachedOrders === null ||
+                isPartialTpsl ||
+                cacheShowsStandaloneTriggers) {
                 // Fallback: Query only the specific DEX (20 weight instead of 40+)
-                __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('WebSocket cache not initialized, falling back to single-DEX REST query', { dex: dexName ?? 'main' });
+                __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log(cachedOrders === null
+                    ? 'WebSocket cache not initialized, falling back to single-DEX REST query'
+                    : 'TP/SL update needs parent/child order context: using single-DEX REST query', { dex: dexName ?? 'main', isPartialTpsl });
                 const orders = await infoClient.frontendOpenOrders({
                     user: userAddress,
                     dex: dexName ?? undefined,
                 });
+                // Orders that belong to a pending parent order (normalTpsl children) are
+                // also listed at the top level, so collect their IDs to exclude them:
+                // they protect that pending order, not this position.
+                const childOrderIds = collectChildOrderIds(orders);
                 // Filter using raw SDK response properties
                 const tpslOrders = orders.filter((order) => order.coin === symbol &&
                     order.reduceOnly &&
-                    order.isPositionTpsl ===
-                        Boolean(TP_SL_CONFIG.UsePositionBoundTpsl) &&
+                    // Position-bound TP/SL always qualifies, and so do standalone
+                    // triggers on this market (they belong to the position too, whether
+                    // this update is partial or whole) — but never another order's
+                    // TP/SL children.
+                    (order.isPositionTpsl ===
+                        Boolean(TP_SL_CONFIG.UsePositionBoundTpsl) ||
+                        !childOrderIds.has(order.oid)) &&
                     order.isTrigger &&
                     (order.orderType.includes('Take Profit') ||
                         order.orderType.includes('Stop')));
@@ -991,33 +1342,24 @@ export class HyperLiquidProvider {
                 });
                 __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Cancel result:', cancelResult);
             }
-            // Get asset info (dexName already extracted above) - uses cache
-            const meta = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getCachedMeta).call(this, { dexName });
-            // Check if meta is an error response (string) or doesn't have universe property
-            if (!meta ||
-                typeof meta === 'string' ||
-                !meta.universe ||
-                !Array.isArray(meta.universe)) {
-                __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Failed to fetch metadata for asset mapping', {
-                    meta,
-                    dex: dexName ?? 'main',
-                });
-                throw new Error(`Failed to fetch market metadata for DEX ${dexName ?? 'main'}`);
-            }
-            // asset.name format: "BTC" for main DEX, "xyz:XYZ100" for HIP-3
-            const assetInfo = meta.universe.find((asset) => asset.name === symbol);
-            if (!assetInfo) {
-                throw new Error(`Asset ${symbol} not found in ${dexName ?? 'main'} DEX universe`);
-            }
             // assetId already validated above when building cancelRequests
             // Build orders array for TP/SL
             const orders = [];
-            const size = TP_SL_CONFIG.UsePositionBoundTpsl
+            const fullSize = TP_SL_CONFIG.UsePositionBoundTpsl && !isPartialTpsl
                 ? '0'
                 : formatHyperLiquidSize({
                     size: positionSize,
                     szDecimals: assetInfo.szDecimals,
                 });
+            // Partial TP/SL orders carry their own size; the rest cover the position.
+            // A partial size that rounds away at the asset precision is rejected
+            // rather than sent as '0', which the exchange reads as whole-position.
+            const resolveTpslSize = (tpslSize) => tpslSize === undefined
+                ? fullSize
+                : formatPartialTpslSize({
+                    size: parseFloat(tpslSize),
+                    szDecimals: assetInfo.szDecimals,
+                });
             // Take Profit order
             if (takeProfitPrice) {
                 const tpOrder = {
@@ -1027,7 +1369,7 @@ export class HyperLiquidProvider {
                         price: parseFloat(takeProfitPrice),
                         szDecimals: assetInfo.szDecimals,
                     }),
-                    s: size,
+                    s: resolveTpslSize(takeProfitSize),
                     r: true, // Always reduce-only for position TP
                     t: {
                         trigger: {
@@ -1051,7 +1393,7 @@ export class HyperLiquidProvider {
                         price: parseFloat(stopLossPrice),
                         szDecimals: assetInfo.szDecimals,
                     }),
-                    s: size,
+                    s: resolveTpslSize(stopLossSize),
                     r: true, // Always reduce-only for position SL
                     t: {
                         trigger: {
@@ -1084,10 +1426,12 @@ export class HyperLiquidProvider {
                     discountedFee: builderFee,
                 });
             }
-            // Submit via SDK exchange client with positionTpsl grouping
+            // Submit via SDK exchange client. Position-bound TP/SL uses 'positionTpsl';
+            // partial TP/SL must be standalone reduce-only triggers ('na'), since a
+            // position-bound TP/SL always closes the whole position.
             const result = await exchangeClient.order({
                 orders,
-                grouping: 'positionTpsl',
+                grouping: isPartialTpsl ? 'na' : 'positionTpsl',
                 builder: {
                     b: __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getBuilderAddress).call(this, __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").isTestnetMode()),
                     f: builderFee,
@@ -1127,6 +1471,68 @@ export 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(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, 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);
@@ -1136,18 +1542,37 @@ export 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(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
@@ -1170,6 +1595,10 @@ export 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,
@@ -1178,10 +1607,17 @@ export 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,
             });
@@ -1365,6 +1801,12 @@ export class HyperLiquidProvider {
             }
             // Combine all orders from all DEXs for TP/SL lookup
             const allOrders = orderResults.flatMap((result) => result.data);
+            // TP/SL children of pending parent orders are listed at the top level too;
+            // they belong to that order, not to a position.
+            const allOrdersChildIds = collectChildOrderIds(allOrders);
+            // Grouped once here rather than rescanned per position, mirroring the
+            // positionsBySymbol map on the WebSocket path.
+            const ordersBySymbol = groupOrdersBySymbol(allOrders);
             __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Frontend open orders (all DEXs):', {
                 count: allOrders.length,
                 orders: allOrders.map((ord) => ({
@@ -1400,6 +1842,16 @@ export class HyperLiquidProvider {
                 // Look for TP and SL trigger orders
                 let takeProfitPrice;
                 let stopLossPrice;
+                // Trigger orders attached to this position: position-bound TP/SL plus
+                // standalone ('na' grouping) partial TP/SL. A pending order's
+                // normalTpsl children are excluded — they are also listed at the top
+                // level, but they protect that order, not this position (same rule as
+                // the positionOrders filter above).
+                const { takeProfitOrders, stopLossOrders } = collectPositionTriggerOrders({
+                    orders: ordersBySymbol.get(position.symbol) ?? [],
+                    position,
+                    childOrderIds: allOrdersChildIds,
+                });
                 // Check direct trigger orders
                 positionOrders.forEach((order) => {
                     // Frontend orders have explicit orderType field
@@ -1457,6 +1909,10 @@ export class HyperLiquidProvider {
                     ...position,
                     takeProfitPrice,
                     stopLossPrice,
+                    takeProfitCount: takeProfitOrders.length,
+                    stopLossCount: stopLossOrders.length,
+                    takeProfitOrders,
+                    stopLossOrders,
                 };
             }));
             return allPositions;
@@ -2461,6 +2917,14 @@ export class HyperLiquidProvider {
                 size: params.size,
                 price: params.price,
                 orderType: params.orderType,
+                triggerPrice: params.triggerPrice,
+                takeProfitPrice: params.takeProfitPrice,
+                stopLossPrice: params.stopLossPrice,
+                takeProfitSize: params.takeProfitSize,
+                stopLossSize: params.stopLossSize,
+                tpslLinkage: params.tpslLinkage,
+                grouping: params.grouping,
+                timeInForce: params.timeInForce,
             });
             if (!basicValidation.isValid) {
                 return basicValidation;
@@ -2489,16 +2953,29 @@ export class HyperLiquidProvider {
                     // Fallback: Calculate from size × price
                     const size = parseFloat(params.size || '0');
                     let priceForValidation = params.currentPrice;
-                    // For limit orders without currentPrice, use limit price as fallback
+                    // For limit-executing orders without currentPrice, use limit price as
+                    // fallback (plain limit, stop_limit, take_profit_limit)
                     if (!priceForValidation &&
                         params.price &&
-                        params.orderType === 'limit') {
+                        isLimitExecutionOrderType(params.orderType)) {
                         priceForValidation = parseFloat(params.price);
                         __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Using limit price for order validation (limit order):', {
                             size,
                             limitPrice: priceForValidation,
                         });
                     }
+                    // Market-executing trigger orders (stop_market, take_profit_market)
+                    // have no limit price; the trigger price is the best notional estimate.
+                    if (!priceForValidation &&
+                        params.triggerPrice &&
+                        isTriggerOrderType(params.orderType)) {
+                        priceForValidation = parseFloat(params.triggerPrice);
+                        __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Using trigger price for order validation (trigger order):', {
+                            size,
+                            triggerPrice: priceForValidation,
+                            orderType: params.orderType,
+                        });
+                    }
                     if (!priceForValidation) {
                         return {
                             isValid: false,
@@ -3285,8 +3762,11 @@ export class HyperLiquidProvider {
      */
     async calculateFees(params) {
         const { orderType, isMaker = false, amount, symbol } = params;
+        // Trigger placements are charged as their execution kind: a stop_market fills
+        // as a market order (taker), a stop_limit as a limit order.
+        const isMarketExecution = getTriggerExecution(orderType) === 'market';
         // Start with base rates from config
-        let feeRate = orderType === 'market' || !isMaker ? FEE_RATES.taker : FEE_RATES.maker;
+        let feeRate = isMarketExecution || !isMaker ? FEE_RATES.taker : FEE_RATES.maker;
         // Parse symbol to detect HIP-3 DEX (e.g., "xyz:TSLA" → dex="xyz", parsedSymbol="TSLA")
         const { dex, symbol: parsedSymbol } = parseAssetName(symbol);
         const isHip3Asset = dex !== null;
@@ -3331,7 +3811,7 @@ export class HyperLiquidProvider {
                 const cached = __classPrivateFieldGet(this, _HyperLiquidProvider_userFeeCache, "f").get(userAddress);
                 if (cached) {
                     // Market orders always use taker rate, limit orders check isMaker
-                    let userFeeRate = orderType === 'market' || !isMaker
+                    let userFeeRate = isMarketExecution || !isMaker
                         ? cached.perpsTakerRate
                         : cached.perpsMakerRate;
                     // Apply HIP-3 dynamic multiplier to user-specific rates (includes Growth Mode)
@@ -3439,7 +3919,7 @@ export class HyperLiquidProvider {
                 };
                 __classPrivateFieldGet(this, _HyperLiquidProvider_userFeeCache, "f").set(userAddress, rates);
                 // Market orders always use taker rate, limit orders check isMaker
-                let userFeeRate = orderType === 'market' || !isMaker
+                let userFeeRate = isMarketExecution || !isMaker
                     ? rates.perpsTakerRate
                     : rates.perpsMakerRate;
                 // Apply HIP-3 dynamic multiplier to API-fetched rates (includes Growth Mode)
@@ -4972,6 +5452,14 @@ async function _HyperLiquidProvider_queryUserDataAcrossDexs(baseParams, queryFn)
     return { results, failedDexs };
 }, _HyperLiquidProvider_mapError = function _HyperLiquidProvider_mapError(error) {
     const { message } = ensureError(error, 'HyperLiquidProvider.mapError');
+    // "User or API Wallet 0x... does not exist." carries the user's address, so
+    // it cannot be matched by the static substring table below. It means the
+    // wallet has no Hyperliquid account yet — surface an actionable code the
+    // client can translate ("fund your account") instead of leaking the raw
+    // exchange string to the UI and to failed-trade analytics.
+    if (isHyperLiquidUserNotFoundError(error)) {
+        return new Error(PERPS_ERROR_CODES.EXCHANGE_ACCOUNT_NOT_FOUND);
+    }
     for (const [pattern, code] of Object.entries(__classPrivateFieldGet(this, _HyperLiquidProvider_errorMappings, "f"))) {
         if (message.toLowerCase().includes(pattern.toLowerCase())) {
             return new Error(code);
@@ -5734,13 +6222,80 @@ async function _HyperLiquidProvider_submitOrderWithRollback(params) {
     }
 }, _HyperLiquidProvider_handleOrderError = function _HyperLiquidProvider_handleOrderError(params) {
     const { error, symbol, orderType, isBuy } = params;
-    __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").logger.error(ensureError(error, 'HyperLiquidProvider.handleOrderError'), __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getErrorContext).call(this, 'placeOrder', {
-        symbol,
-        orderType,
-        isBuy,
-    }));
+    // A wallet with no Hyperliquid account is an expected pre-account state,
+    // not an app defect — same policy already applied to every other
+    // user-scoped exchange write in this provider. Keep it out of Sentry; the
+    // failure is still reported to the caller (and to trade analytics) via the
+    // mapped EXCHANGE_ACCOUNT_NOT_FOUND code below.
+    if (isHyperLiquidUserNotFoundError(error)) {
+        __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('[handleOrderError] Wallet has no Hyperliquid account, order cannot be placed', { symbol, orderType, isBuy });
+    }
+    else {
+        __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").logger.error(ensureError(error, 'HyperLiquidProvider.handleOrderError'), __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getErrorContext).call(this, 'placeOrder', {
+            symbol,
+            orderType,
+            isBuy,
+        }));
+    }
     const mappedError = __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_mapError).call(this, error);
     return createErrorResult(mappedError, { success: false });
+}, _HyperLiquidProvider_fetchOpenOrders = 
+/**
+ * Read the account's currently resting orders.
+ *
+ * @param params - The lookup parameters.
+ * @param params.dexName - DEX to query, or null for the main DEX.
+ * @returns The raw open orders.
+ */
+async function _HyperLiquidProvider_fetchOpenOrders(params) {
+    const userAddress = await __classPrivateFieldGet(this, _HyperLiquidProvider_walletService, "f").getUserAddressWithDefault();
+    return await __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").getInfoClient().frontendOpenOrders({
+        user: userAddress,
+        dex: params.dexName ?? undefined,
+    });
+}, _HyperLiquidProvider_resolveReplacementOrderId = 
+/**
+ * Resolve the order id that a `modify` rested the replacement under.
+ *
+ * HyperLiquid does not edit an order in place: it cancels the target and
+ * rests a replacement under a NEW oid, which the SDK's modify response does
+ * not carry. The submitted oid therefore names an order that no longer
+ * exists, so the only honest source of identity is a post-modify read.
+ *
+ * An id is returned only when exactly one newly-rested order carries the
+ * attributes just submitted. Everything else leaves it absent: a market edit
+ * that filled rather than rested, a read that has not caught up yet, or two
+ * equally plausible candidates. Novelty is judged against the pre-edit
+ * snapshot rather than attributes alone, because an order that was already
+ * resting can share a market, side and size with the replacement.
+ *
+ * @param params - The resolution parameters.
+ * @param params.previousOrders - Orders resting immediately before the edit.
+ * @param params.dexName - DEX to query, or null for the main DEX.
+ * @param params.symbol - Market the edit was submitted against.
+ * @param params.isBuy - Direction submitted.
+ * @param params.size - Formatted size submitted.
+ * @returns The replacement order id, or undefined when it cannot be resolved unambiguously.
+ */
+async function _HyperLiquidProvider_resolveReplacementOrderId(params) {
+    try {
+        const previousOrderIds = new Set(params.previousOrders.map((order) => order.oid.toString()));
+        const ordersAfterEdit = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_fetchOpenOrders).call(this, {
+            dexName: params.dexName,
+        });
+        const submittedSize = parseFloat(params.size);
+        const candidates = ordersAfterEdit.filter((order) => !previousOrderIds.has(order.oid.toString()) &&
+            order.coin === params.symbol &&
+            (order.side === 'B') === params.isBuy &&
+            parseFloat(order.sz) === submittedSize);
+        return candidates.length === 1 ? candidates[0].oid.toString() : undefined;
+    }
+    catch (error) {
+        // The modify was accepted; only the identity lookup failed. Reporting a
+        // failed edit here would misstate an order that really was changed.
+        __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Could not resolve the replacement order id after modify:', error);
+        return undefined;
+    }
 }, _HyperLiquidProvider_getStandaloneValidatedDexs = 
 /**
  * Get validated DEXs for standalone mode using a standalone InfoClient.
@@ -5781,6 +6336,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) => 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: 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.