@metamask-previews/perps-controller 12.2.0-preview-e68ab1498 → 13.0.0-preview-4b37525

package/dist/providers/HyperLiquidProvider.mjs

@@ -9,12 +9,13 @@ 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_subscriptionBuilderApprovalEpoch, _HyperLiquidProvider_approvedBuilderAddresses, _HyperLiquidProvider_compiledAllowlistPatterns, _HyperLiquidProvider_compiledBlocklistPatterns, _HyperLiquidProvider_userFeeDiscountBips, _HyperLiquidProvider_userFeeResolution, _HyperLiquidProvider_hip3Enabled, _HyperLiquidProvider_allowlistMarkets, _HyperLiquidProvider_blocklistMarkets, _HyperLiquidProvider_useUnifiedAccount, _HyperLiquidProvider_dexDiscoveryComplete, _HyperLiquidProvider_unifiedAccountSetupNeedsRetry, _HyperLiquidProvider_pendingValidatedDexsPromise, _HyperLiquidProvider_cachedUsdcTokenId, _HyperLiquidProvider_errorMappings, _HyperLiquidProvider_scaleOrderGroups, _HyperLiquidProvider_chaseSessions, _HyperLiquidProvider_chaseTerminations, _HyperLiquidProvider_terminatedChaseHandles, _HyperLiquidProvider_chasePlacementsInFlight, _HyperLiquidProvider_chasePlacementWaiters, _HyperLiquidProvider_chaseTickQueue, _HyperLiquidProvider_chaseGeneration, _HyperLiquidProvider_chasePlacementBlockers, _HyperLiquidProvider_clientsInitialized, _HyperLiquidProvider_initializationPromise, _HyperLiquidProvider_messenger, _HyperLiquidProvider_builderAddressTestnet, _HyperLiquidProvider_builderAddressMainnet, _HyperLiquidProvider_subscriptionBuilderAddressTestnet, _HyperLiquidProvider_subscriptionBuilderAddressMainnet, _HyperLiquidProvider_priceDeviationLimit, _HyperLiquidProvider_compilePatternsSafely, _HyperLiquidProvider_ensureClientsInitialized, _HyperLiquidProvider_isWalletOnHyperliquid, _HyperLiquidProvider_isHyperliquidMultiSigAccount, _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_getApprovedBuilderKey, _HyperLiquidProvider_fetchMarketsForDex, _HyperLiquidProvider_getUsdcTokenId, _HyperLiquidProvider_isUsdcCollateralDex, _HyperLiquidProvider_buildAssetMapping, _HyperLiquidProvider_queryUserDataAcrossDexs, _HyperLiquidProvider_mapError, _HyperLiquidProvider_getErrorContext, _HyperLiquidProvider_isMappedAccountModeExchangeError, _HyperLiquidProvider_getTradingErrorContext, _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_placeStrategyOrder, _HyperLiquidProvider_prepareStrategyPlacement, _HyperLiquidProvider_getMinimumOrderSize, _HyperLiquidProvider_buildScaleLadder, _HyperLiquidProvider_placeTwapOrder, _HyperLiquidProvider_placeScaleOrder, _HyperLiquidProvider_startChaseSession, _HyperLiquidProvider_getChaseQuotePrice, _HyperLiquidProvider_restChaseOrder, _HyperLiquidProvider_scheduleChaseTick, _HyperLiquidProvider_pauseChaseTicksForPlacement, _HyperLiquidProvider_resumeChaseTicksAfterPlacement, _HyperLiquidProvider_recoverFailedChaseTick, _HyperLiquidProvider_runChaseTick, _HyperLiquidProvider_resolveOwnRestingSizes, _HyperLiquidProvider_readOrderRemainder, _HyperLiquidProvider_cancelChaseChild, _HyperLiquidProvider_retractOrphanedChaseOrder, _HyperLiquidProvider_stopChaseSession, _HyperLiquidProvider_cancelStrategyOrder, _HyperLiquidProvider_cancelTwapOrder, _HyperLiquidProvider_cancelScaleOrder, _HyperLiquidProvider_cancelChaseOrder, _HyperLiquidProvider_performChaseTermination, _HyperLiquidProvider_readOrderIdFromStatus, _HyperLiquidProvider_getDiscountedBuilderFee, _HyperLiquidProvider_getBuilderOrderContext, _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_getSubscriptionBuilderAddress, _HyperLiquidProvider_getReferralCode, _HyperLiquidProvider_ensureReferralSet, _HyperLiquidProvider_isReferralCodeReady, _HyperLiquidProvider_checkReferralSet, _HyperLiquidProvider_setReferralCode;
-import { hasProperty } from "@metamask/utils";
+var _HyperLiquidProvider_instances, _a, _HyperLiquidProvider_deps, _HyperLiquidProvider_clientService, _HyperLiquidProvider_walletService, _HyperLiquidProvider_subscriptionService, _HyperLiquidProvider_symbolToAssetId, _HyperLiquidProvider_userFeeCache, _HyperLiquidProvider_maxLeverageCache, _HyperLiquidProvider_cachedMetaByDex, _HyperLiquidProvider_orderCapabilitiesMarketsByDex, _HyperLiquidProvider_orderCapabilitiesRefreshByDex, _HyperLiquidProvider_isDisconnected, _HyperLiquidProvider_disconnectOperationsInFlight, _HyperLiquidProvider_disconnectOperationPromise, _HyperLiquidProvider_lifecycleGeneration, _HyperLiquidProvider_cachedMarketDataWithPrices, _HyperLiquidProvider_cachedSpotMeta, _HyperLiquidProvider_dexDiscoveryCache, _HyperLiquidProvider_referralCheckCache, _HyperLiquidProvider_builderFeeCheckCache, _HyperLiquidProvider_ensureReadyPromise, _HyperLiquidProvider_pendingBuilderFeeApprovals, _HyperLiquidProvider_subscriptionBuilderApprovalEpoch, _HyperLiquidProvider_approvedBuilderAddresses, _HyperLiquidProvider_compiledAllowlistPatterns, _HyperLiquidProvider_compiledBlocklistPatterns, _HyperLiquidProvider_userFeeDiscountBips, _HyperLiquidProvider_userFeeResolution, _HyperLiquidProvider_hip3Enabled, _HyperLiquidProvider_allowlistMarkets, _HyperLiquidProvider_blocklistMarkets, _HyperLiquidProvider_useUnifiedAccount, _HyperLiquidProvider_dexDiscoveryComplete, _HyperLiquidProvider_unifiedAccountSetupNeedsRetry, _HyperLiquidProvider_pendingValidatedDexsPromise, _HyperLiquidProvider_cachedUsdcTokenId, _HyperLiquidProvider_errorMappings, _HyperLiquidProvider_scaleOrderGroups, _HyperLiquidProvider_cancelledScaleOrderGroups, _HyperLiquidProvider_trackedTwapOrdersByMessenger, _HyperLiquidProvider_trackedTwapOrders, _HyperLiquidProvider_chaseSessions, _HyperLiquidProvider_chaseTerminations, _HyperLiquidProvider_terminatedChaseHandles, _HyperLiquidProvider_chasePlacementsInFlight, _HyperLiquidProvider_chasePlacementWaiters, _HyperLiquidProvider_chaseTickQueue, _HyperLiquidProvider_strategyGeneration, _HyperLiquidProvider_chasePlacementBlockers, _HyperLiquidProvider_clientsInitialized, _HyperLiquidProvider_initializationPromise, _HyperLiquidProvider_messenger, _HyperLiquidProvider_builderAddressTestnet, _HyperLiquidProvider_builderAddressMainnet, _HyperLiquidProvider_subscriptionBuilderAddressTestnet, _HyperLiquidProvider_subscriptionBuilderAddressMainnet, _HyperLiquidProvider_priceDeviationLimit, _HyperLiquidProvider_onChaseOrderMaxDistanceReached, _HyperLiquidProvider_resolveOrderFeePolicy, _HyperLiquidProvider_assertProviderLifecycleCurrent, _HyperLiquidProvider_assertCacheWriteLifecycleCurrent, _HyperLiquidProvider_isCacheWriteLifecycleCurrent, _HyperLiquidProvider_getFreshOrderCapabilityMarkets, _HyperLiquidProvider_compilePatternsSafely, _HyperLiquidProvider_ensureClientsInitialized, _HyperLiquidProvider_isWalletOnHyperliquid, _HyperLiquidProvider_isHyperliquidMultiSigAccount, _HyperLiquidProvider_ensureUnifiedAccountEnabled, _HyperLiquidProvider_ensureReady, _HyperLiquidProvider_tradingSetupPromise, _HyperLiquidProvider_tradingSetupComplete, _HyperLiquidProvider_builderFeeSetupPromises, _HyperLiquidProvider_ensureBuilderFeeSetup, _HyperLiquidProvider_ensureReadyForTrading, _HyperLiquidProvider_getOrFetchPrice, _HyperLiquidProvider_filterFills, _HyperLiquidProvider_getAllAvailableDexs, _HyperLiquidProvider_getValidatedDexs, _HyperLiquidProvider_fetchValidatedDexsInternal, _HyperLiquidProvider_getCachedMeta, _HyperLiquidProvider_fetchMeta, _HyperLiquidProvider_cacheDexMetadata, _HyperLiquidProvider_cacheDexMetadataFromRead, _HyperLiquidProvider_backfillAssetMapForDex, _HyperLiquidProvider_getAssetIdWithRepair, _HyperLiquidProvider_getCachedSpotMeta, _HyperLiquidProvider_getCachedPerpDexs, _HyperLiquidProvider_calculateHip3FeeMultiplier, _HyperLiquidProvider_getCacheKey, _HyperLiquidProvider_getApprovedBuilderKey, _HyperLiquidProvider_fetchMarketsForDex, _HyperLiquidProvider_getUsdcTokenId, _HyperLiquidProvider_isUsdcCollateralDex, _HyperLiquidProvider_buildAssetMapping, _HyperLiquidProvider_queryUserDataAcrossDexs, _HyperLiquidProvider_mapError, _HyperLiquidProvider_getErrorContext, _HyperLiquidProvider_isMappedAccountModeExchangeError, _HyperLiquidProvider_getTradingErrorContext, _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_placeStrategyOrder, _HyperLiquidProvider_submitPreparedStrategy, _HyperLiquidProvider_prepareStrategyPlacement, _HyperLiquidProvider_getMinimumOrderSize, _HyperLiquidProvider_buildScaleLadder, _HyperLiquidProvider_placeTwapOrder, _HyperLiquidProvider_placeScaleOrder, _HyperLiquidProvider_startChaseSession, _HyperLiquidProvider_getChaseQuotePrice, _HyperLiquidProvider_restChaseOrder, _HyperLiquidProvider_scheduleChaseTick, _HyperLiquidProvider_pauseChaseTicksForPlacement, _HyperLiquidProvider_resumeChaseTicksAfterPlacement, _HyperLiquidProvider_recoverFailedChaseTick, _HyperLiquidProvider_runChaseTick, _HyperLiquidProvider_resolveOwnRestingSizes, _HyperLiquidProvider_readOrderRemainder, _HyperLiquidProvider_cancelChaseChild, _HyperLiquidProvider_retractOrphanedChaseOrder, _HyperLiquidProvider_stopChaseSession, _HyperLiquidProvider_rebalanceChaseSession, _HyperLiquidProvider_adaptTwapOrder, _HyperLiquidProvider_rebalanceTrackedTwapOrder, _HyperLiquidProvider_rebalanceTerminalHip3Twaps, _HyperLiquidProvider_cancelStrategyOrder, _HyperLiquidProvider_cancelTwapOrder, _HyperLiquidProvider_cancelScaleOrder, _HyperLiquidProvider_cancelChaseOrder, _HyperLiquidProvider_performChaseTermination, _HyperLiquidProvider_cancelOrderRequests, _HyperLiquidProvider_cancelOrderRequestBatch, _HyperLiquidProvider_readOrderPlacementOutcome, _HyperLiquidProvider_readOrderIdFromStatus, _HyperLiquidProvider_getDiscountedBuilderFee, _HyperLiquidProvider_getBuilderOrderContext, _HyperLiquidProvider_fetchOpenOrders, _HyperLiquidProvider_resolveReplacementOrderId, _HyperLiquidProvider_getStandaloneValidatedDexs, _HyperLiquidProvider_queryDexPositions, _HyperLiquidProvider_restoreScaleOrderGroups, _HyperLiquidProvider_getAllMids, _HyperLiquidProvider_fetchSingleDexFresh, _HyperLiquidProvider_excludeNonUsdcCollateralResults, _HyperLiquidProvider_mergeDexResultsInto, _HyperLiquidProvider_cacheFreshMarketDataSnapshot, _HyperLiquidProvider_getStaleMarketDataSnapshot, _HyperLiquidProvider_isFeeCacheValid, _HyperLiquidProvider_performDisconnect, _HyperLiquidProvider_getBuilderAddress, _HyperLiquidProvider_getSubscriptionBuilderAddress, _HyperLiquidProvider_getReferralCode, _HyperLiquidProvider_ensureReferralSet, _HyperLiquidProvider_isReferralCodeReady, _HyperLiquidProvider_checkReferralSet, _HyperLiquidProvider_setReferralCode;
+import { hasProperty, isHexString } from "@metamask/utils";
+import { BigNumber } from "bignumber.js";
 import { v4 as uuidv4 } from "uuid";
 import { PERPS_EVENT_PROPERTY, PERPS_EVENT_VALUE } from "../constants/eventNames.mjs";
-import { BASIS_POINTS_DIVISOR, BUILDER_FEE_CONFIG, canonicalizeHyperLiquidDexes, FEE_RATES, getBridgeInfo, getChainId, HIP3_ASSET_MARKET_TYPES, HIP3_FEE_CONFIG, HIP3_MARGIN_CONFIG, HYPERLIQUID_ASSET_NAMES, HYPERLIQUID_CONFIG, HYPERLIQUID_WITHDRAWAL_MINUTES, REFERRAL_CONFIG, TRADING_DEFAULTS, USDC_DECIMALS, USDC_SYMBOL } from "../constants/hyperLiquidConfig.mjs";
-import { CHASE_ORDER_CONFIG, CHASE_ORDER_STATUS, HYPERLIQUID_TWAP_LIMITS, ORDER_SLIPPAGE_CONFIG, PERFORMANCE_CONFIG, PERPS_CONSTANTS, TP_SL_CONFIG, WITHDRAWAL_CONSTANTS } from "../constants/perpsConfig.mjs";
+import { BASIS_POINTS_DIVISOR, BUILDER_FEE_CONFIG, canonicalizeHyperLiquidDexes, FEE_RATES, HYPERLIQUID_ORDER_CAPABILITIES, getBridgeInfo, getChainId, HIP3_ASSET_MARKET_TYPES, HIP3_FEE_CONFIG, HIP3_MARGIN_CONFIG, HYPERLIQUID_ASSET_NAMES, HYPERLIQUID_CONFIG, HYPERLIQUID_WITHDRAWAL_MINUTES, REFERRAL_CONFIG, TRADING_DEFAULTS, USDC_DECIMALS, USDC_SYMBOL } from "../constants/hyperLiquidConfig.mjs";
+import { CHASE_ORDER_CONFIG, CHASE_ORDER_STATUS, HYPERLIQUID_TWAP_LIMITS, ORDER_SLIPPAGE_CONFIG, PERFORMANCE_CONFIG, PERPS_CONSTANTS, PROVIDER_CONFIG, TP_SL_CONFIG, WITHDRAWAL_CONSTANTS } from "../constants/perpsConfig.mjs";
 import { PERPS_TRANSACTIONS_HISTORY_CONSTANTS } from "../constants/transactionsHistoryConfig.mjs";
 import { PERPS_ERROR_CODES } from "../perpsErrorCodes.mjs";
 import { DexDiscoveryCacheManager } from "../services/DexDiscoveryCacheManager.mjs";
@@ -25,16 +26,18 @@ import { TradingReadinessCache, PerpsSigningCache } from "../services/TradingRea
 import { HL_ABSTRACTION_WIRE, HL_UNIFIED_ACCOUNT_MODE, hyperLiquidModeFoldsSpot } from "../types/hyperliquid-types.mjs";
 import { PerpsAnalyticsEvent } from "../types/index.mjs";
 import { addSpotBalanceToAccountState, aggregateAccountStates } from "../utils/accountUtils.mjs";
+import { isValidCapabilitySymbol } from "../utils/capabilitySymbols.mjs";
 import { ensureError, isHyperLiquidMultiSigRequiredError, isHyperLiquidUserNotFoundError, isKeyringLockedError } from "../utils/errorUtils.mjs";
 import { shouldDeferUnifiedAccountSetup } from "../utils/hyperLiquidAbstraction.mjs";
-import { adaptAccountStateFromSDK, adaptHyperLiquidLedgerUpdateToUserHistoryItem, adaptMarketFromSDK, adaptOrderFromSDK, adaptPositionFromSDK, adaptPositionTriggerOrderFromSDK, adaptTpslLinkageToGrouping, buildAssetMapping, formatHyperLiquidPrice, formatHyperLiquidSize, parseAssetName } from "../utils/hyperLiquidAdapter.mjs";
+import { adaptAccountStateFromSDK, adaptHyperLiquidLedgerUpdateToUserHistoryItem, adaptMarketFromSDK, adaptOrderFromSDK, adaptPositionFromSDK, adaptPositionTriggerOrderFromSDK, adaptTpslLinkageToGrouping, buildAssetMapping, formatHyperLiquidPrice, formatHyperLiquidSize, HYPERLIQUID_SCALE_CLOID_MARKER, parseAssetName } from "../utils/hyperLiquidAdapter.mjs";
 import { createErrorResult, getMaxOrderValue, getSupportedPaths, validateAssetSupport, validateBalance, validateCoinExists, validateDepositParams, validateOrderParams, validateWithdrawalParams } from "../utils/hyperLiquidValidation.mjs";
 import { generatePerpsId } from "../utils/idUtils.mjs";
 import { transformMarketData } from "../utils/marketDataTransform.mjs";
 import { compileMarketPattern, shouldIncludeMarket } from "../utils/marketUtils.mjs";
 import { buildOrdersArray, calculateFinalPositionSize, calculateOrderPriceAndSize, computeChaseQuotePrice, computeScalePriceLadder, floorToSizeDecimals, formatPartialTpslSize, getPriceTick, splitScaleSizes, validateOrderPrecision } from "../utils/orderCalculations.mjs";
-import { getTriggerExecution, isLimitExecutionOrderType, isStrategyOrderType, isTriggerOrderType, resolvePositionTriggerSummaryPrice, toSDKTimeInForce } from "../utils/orderTypes.mjs";
+import { getTriggerDirection, getTriggerExecution, isLimitExecutionOrderType, isStrategyOrderType, isTriggerOrderType, resolvePositionTriggerSummaryPrice, toSDKTimeInForce } from "../utils/orderTypes.mjs";
 import { createStandaloneInfoClient, queryStandaloneClearinghouseStates, queryStandaloneOpenOrders } from "../utils/standaloneInfoClient.mjs";
+import { parseBoundedNonNegativeDecimal } from "../utils/stringParseUtils.mjs";
 // getStreamManagerInstance removed: use this.#deps.streamManager instead
 /**
  * Type guard to check if a status is an object (not a string literal like "waitingForFill")
@@ -59,15 +62,54 @@ const ALREADY_GONE_CANCEL_MARKERS = [
     'already canceled',
     'already cancelled',
     'order not found',
+    'twap not found',
 ];
 const RETRYABLE_CHASE_PLACEMENT_MARKERS = [
     'post only order would have immediately matched',
     'price too far from oracle',
 ];
+const CHASE_ORDER_STATUS_RETRY_COUNT = 2;
+const CHASE_ORDER_STATUS_RETRY_DELAY_MS = 100;
+const CHASE_ORDER_STATUS_UNAVAILABLE = 'status_unavailable';
+class ChaseOrderStatusUnavailableError extends Error {
+    constructor() {
+        super('Chase order status unavailable');
+        this.name = 'ChaseOrderStatusUnavailableError';
+    }
+}
 const isRetryableChasePlacementError = (error) => {
     const message = ensureError(error, 'HyperLiquidProvider.startChaseSession').message.toLowerCase();
     return RETRYABLE_CHASE_PLACEMENT_MARKERS.some((marker) => message.includes(marker));
 };
+/**
+ * What happened to one order a cancel was asked to remove.
+ *
+ * `Cancelled` and `Gone` both mean nothing of it is resting, which is all a
+ * caller asked for; only `Refused` leaves an order behind.
+ */
+var CancelChildOutcome;
+(function (CancelChildOutcome) {
+    CancelChildOutcome["Cancelled"] = "cancelled";
+    CancelChildOutcome["Gone"] = "gone";
+    CancelChildOutcome["Refused"] = "refused";
+})(CancelChildOutcome || (CancelChildOutcome = {}));
+var HyperLiquidTwapLifecycleStatus;
+(function (HyperLiquidTwapLifecycleStatus) {
+    HyperLiquidTwapLifecycleStatus["Activated"] = "activated";
+    HyperLiquidTwapLifecycleStatus["Failed"] = "error";
+    HyperLiquidTwapLifecycleStatus["Finished"] = "finished";
+    HyperLiquidTwapLifecycleStatus["Stopped"] = "stopped";
+    HyperLiquidTwapLifecycleStatus["Terminated"] = "terminated";
+    HyperLiquidTwapLifecycleStatus["WaitingForTrigger"] = "waitingForTrigger";
+})(HyperLiquidTwapLifecycleStatus || (HyperLiquidTwapLifecycleStatus = {}));
+var PerpsTwapLifecycleStatus;
+(function (PerpsTwapLifecycleStatus) {
+    PerpsTwapLifecycleStatus["Active"] = "active";
+    PerpsTwapLifecycleStatus["Canceled"] = "canceled";
+    PerpsTwapLifecycleStatus["Completed"] = "completed";
+    PerpsTwapLifecycleStatus["CompletedUnderfilled"] = "completed_underfilled";
+    PerpsTwapLifecycleStatus["Failed"] = "failed";
+})(PerpsTwapLifecycleStatus || (PerpsTwapLifecycleStatus = {}));
 /**
  * Classify one entry of a cancel response.
  *
@@ -76,14 +118,14 @@ const isRetryableChasePlacementError = (error) => {
  */
 const classifyCancelStatus = (status) => {
     if (status === 'success') {
-        return 'cancelled';
+        return CancelChildOutcome.Cancelled;
     }
     const message = (isStatusObject(status) && typeof status.error === 'string'
         ? status.error
         : '').toLowerCase();
     return ALREADY_GONE_CANCEL_MARKERS.some((marker) => message.includes(marker))
-        ? 'gone'
-        : 'refused';
+        ? CancelChildOutcome.Gone
+        : CancelChildOutcome.Refused;
 };
 /**
  * Read the best price on one side of the book, discounting the chase's own
@@ -185,6 +227,29 @@ const validateStrategyNotional = (params) => {
     }
     return { isValid: true };
 };
+/**
+ * Create one recoverable identity for a Scale ladder and one venue CLOID per
+ * rung. HyperLiquid requires every CLOID to be unique, so the last byte holds
+ * the rung index while the preceding 15 bytes identify the shared group.
+ *
+ * @param count - Number of ladder rungs.
+ * @returns The public group handle and venue client order IDs.
+ */
+const createScaleOrderIdentity = (count) => {
+    const groupKey = `${HYPERLIQUID_SCALE_CLOID_MARKER}${uuidv4()
+        .replace(/-/gu, '')
+        .slice(0, 22)}`;
+    const clientOrderIds = Array.from({ length: count }, (_, index) => {
+        const clientOrderId = `0x${groupKey}${index
+            .toString(16)
+            .padStart(2, '0')}`;
+        if (!isHexString(clientOrderId)) {
+            throw new Error('Failed to create Scale client order ID');
+        }
+        return clientOrderId;
+    });
+    return { groupId: `scale:${groupKey}`, clientOrderIds };
+};
 /**
  * Collect the order IDs of every TP/SL child carried by a parent order.
  *
@@ -296,6 +361,76 @@ function collectPositionTriggerOrders(params) {
         ...(stopLossSummaryPrice && { stopLossPrice: stopLossSummaryPrice }),
     };
 }
+const MAX_API_FEE_RATE = 1;
+const MAX_API_FEE_DISCOUNT = 1;
+/**
+ * Fee applicability by canonical order type.
+ *
+ * The configuration type makes this map exhaustive, so a new order type cannot
+ * inherit a builder-fee policy accidentally. HyperLiquid's dedicated TWAP
+ * action has no builder field. Every other standalone placement uses an order
+ * action that can carry one builder context. This policy is deliberately not a
+ * constructor or order input. A future backend policy must be resolved inside
+ * the provider from its trusted source rather than accepted from a client.
+ */
+const HYPERLIQUID_ORDER_FEE_CONFIG = {
+    market: { chargesMetamaskBuilderFee: true },
+    limit: { chargesMetamaskBuilderFee: true },
+    stop_market: { chargesMetamaskBuilderFee: true },
+    stop_limit: { chargesMetamaskBuilderFee: true },
+    take_profit_market: { chargesMetamaskBuilderFee: true },
+    take_profit_limit: { chargesMetamaskBuilderFee: true },
+    twap: { chargesMetamaskBuilderFee: false },
+    scale: { chargesMetamaskBuilderFee: true },
+    chase: { chargesMetamaskBuilderFee: true },
+};
+const MILLISECONDS_PER_MINUTE = 60000;
+const MILLISECONDS_PER_SECOND = 1000;
+/**
+ * Normalize the TWAP history timestamp documented in seconds while tolerating
+ * an already-millisecond value from a future SDK response.
+ *
+ * @param timestamp - Venue timestamp in seconds or milliseconds.
+ * @returns Timestamp in milliseconds.
+ */
+const normalizeTwapHistoryTimestamp = (timestamp) => timestamp < 1000000000000
+    ? timestamp * MILLISECONDS_PER_SECOND
+    : timestamp;
+const getTwapOrderScopeKey = (params) => `${params.network}:${params.userAddress.toLowerCase()}:${params.orderId}`;
+const resolveTwapOrderStatus = (historyEntry, executedSize, totalSize) => {
+    switch (historyEntry.status.status) {
+        case HyperLiquidTwapLifecycleStatus.Activated:
+        case HyperLiquidTwapLifecycleStatus.WaitingForTrigger:
+            return PerpsTwapLifecycleStatus.Active;
+        case HyperLiquidTwapLifecycleStatus.Finished:
+            return executedSize.isLessThan(totalSize)
+                ? PerpsTwapLifecycleStatus.CompletedUnderfilled
+                : PerpsTwapLifecycleStatus.Completed;
+        case HyperLiquidTwapLifecycleStatus.Terminated:
+        case HyperLiquidTwapLifecycleStatus.Stopped:
+            return PerpsTwapLifecycleStatus.Canceled;
+        case HyperLiquidTwapLifecycleStatus.Failed:
+            return PerpsTwapLifecycleStatus.Failed;
+        default:
+            // A new venue status is not proof that a schedule stopped. Keep it
+            // non-terminal so collateral cannot be reclaimed from a live TWAP.
+            return PerpsTwapLifecycleStatus.Active;
+    }
+};
+const adaptTwapOrderFill = (entry) => ({
+    fillId: entry.fill.tid.toString(),
+    orderId: entry.fill.oid.toString(),
+    side: entry.fill.side === 'B' ? 'buy' : 'sell',
+    price: entry.fill.px,
+    size: entry.fill.sz,
+    fee: entry.fill.fee,
+    feeToken: entry.fill.feeToken,
+    ...(entry.fill.builderFee === undefined
+        ? {}
+        : { builderFee: entry.fill.builderFee }),
+    timestamp: entry.fill.time,
+    transactionHash: entry.fill.hash,
+});
 /**
  * HyperLiquid provider implementation
  *
@@ -310,7 +445,7 @@ function collectPositionTriggerOrders(params) {
 export class HyperLiquidProvider {
     constructor(options) {
         _HyperLiquidProvider_instances.add(this);
-        this.protocolId = 'hyperliquid';
+        this.protocolId = PROVIDER_CONFIG.DefaultProvider;
         // Platform dependencies for logging and debugging
         _HyperLiquidProvider_deps.set(this, void 0);
         // Service instances
@@ -326,6 +461,16 @@ export class HyperLiquidProvider {
         // Cache for raw meta responses (shared across methods to avoid redundant API calls)
         // Filtering is applied on-demand (cheap array operations) - no need for separate processed cache
         _HyperLiquidProvider_cachedMetaByDex.set(this, new Map());
+        // Fresh filtered markets used only for capability discovery. Each routed
+        // DEX owns its freshness window and coalesced refresh.
+        _HyperLiquidProvider_orderCapabilitiesMarketsByDex.set(this, new Map());
+        _HyperLiquidProvider_orderCapabilitiesRefreshByDex.set(this, new Map());
+        // Sticky for this instance. PerpsController discards disconnected providers
+        // during initialization; direct callers must call initialize() before reuse.
+        _HyperLiquidProvider_isDisconnected.set(this, false);
+        _HyperLiquidProvider_disconnectOperationsInFlight.set(this, 0);
+        _HyperLiquidProvider_disconnectOperationPromise.set(this, null);
+        _HyperLiquidProvider_lifecycleGeneration.set(this, 0);
         // Last known-good market list for stale fallback when every enabled DEX fails in one fetch window.
         _HyperLiquidProvider_cachedMarketDataWithPrices.set(this, null);
         // Session cache for spot metadata (contains token info for HIP-3 collateral checks)
@@ -358,12 +503,9 @@ export class HyperLiquidProvider {
         _HyperLiquidProvider_hip3Enabled.set(this, void 0);
         _HyperLiquidProvider_allowlistMarkets.set(this, void 0);
         _HyperLiquidProvider_blocklistMarkets.set(this, void 0);
-        // Emergency kill-switch for the Unified Account migration flow. Defaults
-        // to true and is the expected production state after HL's DEX Abstraction
-        // deprecation. Kept as a constructor option (not removed) so we can
-        // disable the migration via a hot-fix release if a regression surfaces
-        // in the wild — flipping this to false reverts to the legacy programmatic
-        // HIP-3 transfer path that already lives in the codebase.
+        // Legacy rollback switch. MetaMask production supports unified account and
+        // portfolio margin. The false branch and its manual HIP-3 transfers remain
+        // temporarily for rollback compatibility and will be removed separately.
         _HyperLiquidProvider_useUnifiedAccount.set(this, void 0);
         // True once DEX discovery has succeeded with real data (not a fallback).
         // When false, #ensureReadyPromise is reset after each init so the next
@@ -390,6 +532,10 @@ export class HyperLiquidProvider {
         // one cancel can reach every rung. Cleared on disconnect; the rung IDs are
         // also returned to the caller as `OrderResult.childOrderIds`.
         _HyperLiquidProvider_scaleOrderGroups.set(this, new Map());
+        // Prevent a stale open-order cache from recreating a group that this
+        // provider lifecycle already canceled successfully.
+        _HyperLiquidProvider_cancelledScaleOrderGroups.set(this, new Set());
+        _HyperLiquidProvider_trackedTwapOrders.set(this, void 0);
         // Chase sessions running on this provider instance, keyed by session handle.
         // Each owns a pending timer, so disconnect has to stop them.
         _HyperLiquidProvider_chaseSessions.set(this, new Map());
@@ -412,11 +558,9 @@ export class HyperLiquidProvider {
         // transport, so simultaneous cancel/replace ticks would create avoidable
         // signed traffic and can starve a foreground placement.
         _HyperLiquidProvider_chaseTickQueue.set(this, Promise.resolve());
-        // Bumped by every teardown that clears the chase registry. A placement
-        // captures it before its round trips and refuses to register afterwards if it
-        // has moved: a session registered after a disconnect would schedule a
-        // background timer against a provider that has already been torn down.
-        _HyperLiquidProvider_chaseGeneration.set(this, 0);
+        // Every strategy captures this before its round trips. A changed generation
+        // prevents a late response from registering handles after disconnect.
+        _HyperLiquidProvider_strategyGeneration.set(this, 0);
         // Reference-counted because suspension and disconnect may overlap. One
         // lifecycle owner finishing must not reopen placement while another still
         // drains or tears down the provider.
@@ -431,27 +575,35 @@ export class HyperLiquidProvider {
         _HyperLiquidProvider_subscriptionBuilderAddressTestnet.set(this, void 0);
         _HyperLiquidProvider_subscriptionBuilderAddressMainnet.set(this, void 0);
         _HyperLiquidProvider_priceDeviationLimit.set(this, void 0);
+        _HyperLiquidProvider_onChaseOrderMaxDistanceReached.set(this, void 0);
         /**
          * Ensure provider is ready for TRADING operations (signing required)
          *
-         * This method performs additional setup that requires user signatures:
+         * This method performs shared setup that may require user signatures:
          * - DEX abstraction enablement (for HIP-3 auto-transfers)
-         * - Builder fee approval (required for orders)
          * - Referral code setup (attribution)
+         * - Builder fee approval when the whole action carries a builder context
          *
          * These operations are DEFERRED from ensureReady() to avoid hardware wallet prompt spam
          * when users are just viewing the Perps section (critical for hardware wallets).
          *
-         * Call this method before any trading operation (placeOrder, cancelOrder, etc.)
+         * General trading readiness is independent of builder approval. Native TWAP
+         * and cancellations call this with `requiresBuilderFee: false`.
          */
         _HyperLiquidProvider_tradingSetupPromise.set(this, null);
         _HyperLiquidProvider_tradingSetupComplete.set(this, false);
+        _HyperLiquidProvider_builderFeeSetupPromises.set(this, new Map());
         __classPrivateFieldSet(this, _HyperLiquidProvider_deps, options.platformDependencies, "f");
         __classPrivateFieldSet(this, _HyperLiquidProvider_messenger, options.messenger, "f");
+        const trackedTwapOrders = __classPrivateFieldGet(_a, _a, "f", _HyperLiquidProvider_trackedTwapOrdersByMessenger).get(__classPrivateFieldGet(this, _HyperLiquidProvider_messenger, "f")) ??
+            new Map();
+        __classPrivateFieldGet(_a, _a, "f", _HyperLiquidProvider_trackedTwapOrdersByMessenger).set(__classPrivateFieldGet(this, _HyperLiquidProvider_messenger, "f"), trackedTwapOrders);
+        __classPrivateFieldSet(this, _HyperLiquidProvider_trackedTwapOrders, trackedTwapOrders, "f");
         __classPrivateFieldSet(this, _HyperLiquidProvider_builderAddressTestnet, options.builderAddressTestnet, "f");
         __classPrivateFieldSet(this, _HyperLiquidProvider_builderAddressMainnet, options.builderAddressMainnet, "f");
         __classPrivateFieldSet(this, _HyperLiquidProvider_subscriptionBuilderAddressTestnet, options.subscriptionBuilderAddressTestnet, "f");
         __classPrivateFieldSet(this, _HyperLiquidProvider_subscriptionBuilderAddressMainnet, options.subscriptionBuilderAddressMainnet, "f");
+        __classPrivateFieldSet(this, _HyperLiquidProvider_onChaseOrderMaxDistanceReached, options.onChaseOrderMaxDistanceReached, "f");
         __classPrivateFieldSet(this, _HyperLiquidProvider_priceDeviationLimit, options.priceDeviationLimit ??
             HYPERLIQUID_CONFIG.OraclePriceDeviationLimit, "f");
         const isTestnet = options.isTestnet ?? false;
@@ -501,6 +653,56 @@ export class HyperLiquidProvider {
             isTestnet,
         });
     }
+    /**
+     * Return provider-owned strategy support for a routed market.
+     * HyperLiquid metadata has no per-market strategy flags. This provider
+     * advertises its implemented strategies uniformly after confirming the
+     * routed market exists.
+     *
+     * @param params - Required market route context.
+     * @returns Supported strategy order types.
+     */
+    async getOrderCapabilities(params) {
+        if (!isValidCapabilitySymbol(params.symbol, { allowProviderRoute: true })) {
+            return {
+                status: 'unavailable',
+                providerId: this.protocolId,
+                reason: 'invalid_symbol',
+            };
+        }
+        const { dex } = parseAssetName(params.symbol);
+        if (__classPrivateFieldGet(this, _HyperLiquidProvider_isDisconnected, "f")) {
+            return {
+                status: 'unavailable',
+                providerId: this.protocolId,
+                reason: 'provider_unavailable',
+            };
+        }
+        const lifecycleGeneration = __classPrivateFieldGet(this, _HyperLiquidProvider_lifecycleGeneration, "f");
+        try {
+            const marketExists = (await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getFreshOrderCapabilityMarkets).call(this, dex)).some((market) => market.name === params.symbol);
+            __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_assertProviderLifecycleCurrent).call(this, lifecycleGeneration, 'Order capability read');
+            return marketExists
+                ? HYPERLIQUID_ORDER_CAPABILITIES
+                : {
+                    status: 'unavailable',
+                    providerId: this.protocolId,
+                    reason: 'market_not_found',
+                };
+        }
+        catch (error) {
+            __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('HyperLiquid: Order capabilities unavailable', {
+                symbol: params.symbol,
+                error: ensureError(error, 'HyperLiquidProvider.getOrderCapabilities')
+                    .message,
+            });
+            return {
+                status: 'unavailable',
+                providerId: this.protocolId,
+                reason: 'provider_unavailable',
+            };
+        }
+    }
     /**
      * Get fills using WebSocket cache first, falling back to REST API
      * OPTIMIZATION: Uses cached fills when available (0 API weight), only calls REST on cache miss
@@ -759,7 +961,10 @@ export class HyperLiquidProvider {
             // Ensure provider is ready for trading (includes signing operations).
             // Kept after validation so invalid orders never trigger signature prompts
             // (builder-fee approval, DEX abstraction enablement, etc.).
-            await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureReadyForTrading).call(this);
+            const { chargesMetamaskBuilderFee } = __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_resolveOrderFeePolicy).call(this, params);
+            const builderFeeSetupContext = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureReadyForTrading).call(this, {
+                requiresBuilderFee: chargesMetamaskBuilderFee,
+            });
             // Debug: Log asset map state before order placement
             const allMapKeys = Array.from(__classPrivateFieldGet(this, _HyperLiquidProvider_symbolToAssetId, "f").keys());
             const hip3Keys = allMapKeys.filter((key) => key.includes(':'));
@@ -864,6 +1069,8 @@ export class HyperLiquidProvider {
                 transferInfo,
                 symbol: params.symbol,
                 assetId,
+                chargesMetamaskBuilderFee,
+                builderFeeSetupContext,
             });
         }
         catch (error) {
@@ -930,6 +1137,54 @@ export class HyperLiquidProvider {
             });
         }
     }
+    /**
+     * Read native TWAP schedules and their slice fills from the venue.
+     *
+     * @returns Current and terminal TWAP lifecycle records, newest first.
+     */
+    async getTwapOrders() {
+        await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureClientsInitialized).call(this);
+        __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").ensureInitialized();
+        const lifecycleGeneration = __classPrivateFieldGet(this, _HyperLiquidProvider_lifecycleGeneration, "f");
+        const infoClient = __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").getInfoClient();
+        const userAddress = await __classPrivateFieldGet(this, _HyperLiquidProvider_walletService, "f").getUserAddressWithDefault();
+        const [history, sliceFills] = await Promise.all([
+            infoClient.twapHistory({ user: userAddress }),
+            infoClient.userTwapSliceFills({ user: userAddress }),
+        ]);
+        __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_assertProviderLifecycleCurrent).call(this, lifecycleGeneration, 'TWAP lifecycle read');
+        const fillsByTwapId = new Map();
+        for (const sliceFill of sliceFills) {
+            const existing = fillsByTwapId.get(sliceFill.twapId) ?? [];
+            existing.push(sliceFill);
+            fillsByTwapId.set(sliceFill.twapId, existing);
+        }
+        const now = Date.now();
+        const ordersById = new Map();
+        for (const historyEntry of history) {
+            const order = __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_adaptTwapOrder).call(this, {
+                historyEntry,
+                sliceFills: historyEntry.twapId === undefined
+                    ? []
+                    : (fillsByTwapId.get(historyEntry.twapId) ?? []),
+                now,
+            });
+            if (!order) {
+                continue;
+            }
+            const existing = ordersById.get(order.orderId);
+            if (!existing || order.lastUpdated >= existing.lastUpdated) {
+                ordersById.set(order.orderId, order);
+            }
+        }
+        const orders = [...ordersById.values()].sort((left, right) => right.startedAt - left.startedAt);
+        const network = __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").isTestnetMode() ? 'testnet' : 'mainnet';
+        await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_rebalanceTerminalHip3Twaps).call(this, orders, {
+            network,
+            userAddress,
+        });
+        return orders;
+    }
     /**
      * Return stable client-facing snapshots for every Chase session retained by
      * this provider instance. A read may refresh the current child order's
@@ -947,12 +1202,26 @@ export class HyperLiquidProvider {
                 session.lastSnapshotSizeRefreshAt = now;
                 const snapshotOrderId = session.orderId;
                 try {
-                    const liveRemainder = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_readOrderRemainder).call(this, snapshotOrderId);
-                    if (liveRemainder !== null &&
-                        session.orderId === snapshotOrderId &&
+                    const liveRemainder = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_readOrderRemainder).call(this, snapshotOrderId, CHASE_ORDER_STATUS_RETRY_COUNT);
+                    if (session.orderId === snapshotOrderId &&
                         session.pendingReplacement === null) {
-                        Object.assign(session, { size: liveRemainder });
-                        snapshotRemainingSize = liveRemainder;
+                        if (liveRemainder.terminalStatus === null) {
+                            if (liveRemainder.remainingSize !== null) {
+                                session.size = liveRemainder.remainingSize;
+                                snapshotRemainingSize = liveRemainder.remainingSize;
+                            }
+                        }
+                        else {
+                            session.orderId = null;
+                            session.size = liveRemainder.remainingSize ?? '0';
+                            session.active = false;
+                            if (session.timer) {
+                                clearTimeout(session.timer);
+                                session.timer = null;
+                            }
+                            session.status = liveRemainder.terminalStatus;
+                            snapshotRemainingSize = session.size;
+                        }
                     }
                 }
                 catch (error) {
@@ -963,6 +1232,12 @@ export class HyperLiquidProvider {
                     });
                 }
             }
+            if (!session.active && session.hip3Transfer) {
+                const rebalanced = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_rebalanceChaseSession).call(this, session);
+                if (rebalanced && session.removeAfterRebalance) {
+                    __classPrivateFieldGet(this, _HyperLiquidProvider_chaseSessions, "f").delete(handle);
+                }
+            }
             const arrival = Number.parseFloat(session.arrivalPrice);
             const resting = Number.parseFloat(session.restingPrice);
             const adverseDistance = session.isBuy
@@ -1000,9 +1275,6 @@ export class HyperLiquidProvider {
      */
     async suspendChaseOrders() {
         __classPrivateFieldSet(this, _HyperLiquidProvider_chasePlacementBlockers, __classPrivateFieldGet(this, _HyperLiquidProvider_chasePlacementBlockers, "f") + 1, "f");
-        // Abort a placement that passed the blocker check but has not completed
-        // its final generation check; the waiter below then drains its cleanup.
-        __classPrivateFieldSet(this, _HyperLiquidProvider_chaseGeneration, __classPrivateFieldGet(this, _HyperLiquidProvider_chaseGeneration, "f") + 1, "f");
         try {
             await Promise.all([...__classPrivateFieldGet(this, _HyperLiquidProvider_chasePlacementWaiters, "f")]);
             // Clear timers without deactivating sessions, then let any tick already
@@ -1185,10 +1457,10 @@ export class HyperLiquidProvider {
                     ? 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);
+            // Every refusal is behind us, so shared trading readiness can run now.
+            // HyperLiquid's modify action has no builder field and must not request a
+            // builder-fee approval.
+            await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureReadyForTrading).call(this, { requiresBuilderFee: false });
             // Submit modification via SDK
             const exchangeClient = __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").getExchangeClient();
             const result = await exchangeClient.modify({
@@ -1253,24 +1525,25 @@ export class HyperLiquidProvider {
             if (owningChase) {
                 __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_stopChaseSession).call(this, owningChase[0]);
                 await __classPrivateFieldGet(this, _HyperLiquidProvider_chaseTickQueue, "f");
-                return await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_cancelChaseOrder).call(this, {
+                const result = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_cancelChaseOrder).call(this, {
                     ...params,
                     orderId: owningChase[0],
                     orderType: 'chase',
                 });
+                return { ...result, orderId: params.orderId };
             }
             __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Canceling order:', params);
             // Hydrate the asset map before coin validation so a cold start (e.g.
             // service-worker restart with an empty prefetch map) can self-heal
             // without signature prompts on invalid cancels. Trading setup (builder
-            // fee, referral, unified account) runs only after validation passes,
-            // matching placeOrder / editOrder.
+            // referral and unified-account setup runs only after validation passes,
+            // matching placeOrder / editOrder. Cancel has no builder field.
             await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureReady).call(this);
             const coinValidation = validateCoinExists(params.symbol, __classPrivateFieldGet(this, _HyperLiquidProvider_symbolToAssetId, "f"));
             if (!coinValidation.isValid) {
                 throw new Error(coinValidation.error);
             }
-            await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureReadyForTrading).call(this);
+            await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureReadyForTrading).call(this, { requiresBuilderFee: false });
             const exchangeClient = __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").getExchangeClient();
             const asset = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getAssetIdWithRepair).call(this, {
                 symbol: params.symbol,
@@ -1294,10 +1567,10 @@ export class HyperLiquidProvider {
             // HyperLiquid usually rejects a cancel without throwing: the status entry
             // carries the raw exchange string (e.g. "multi-sig required"). Map it the
             // same way as a thrown rejection so callers get a standardized code
-            // instead of a generic message. The SDK types every status as 'success',
-            // so the rejection shape needs the same cast cancelOrders already uses.
-            const rawError = status?.error ??
-                'Order cancellation failed';
+            // instead of a generic message.
+            const rawError = isStatusObject(status) && typeof status.error === 'string'
+                ? status.error
+                : 'Order cancellation failed';
             return createErrorResult(__classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_mapError).call(this, new Error(rawError)), {
                 success: false,
                 orderId: params.orderId,
@@ -1309,7 +1582,10 @@ export class HyperLiquidProvider {
                 orderId: params.orderId,
                 coin: params.symbol,
             }));
-            return createErrorResult(mappedError, { success: false });
+            return createErrorResult(mappedError, {
+                success: false,
+                orderId: params.orderId,
+            });
         }
     }
     /**
@@ -1320,87 +1596,126 @@ export class HyperLiquidProvider {
      * @returns A promise that resolves to the result.
      */
     async cancelOrders(params) {
+        __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Batch canceling orders:', {
+            count: params.length,
+        });
+        if (params.length === 0) {
+            return {
+                success: false,
+                successCount: 0,
+                failureCount: 0,
+                results: [],
+            };
+        }
+        const results = params.map((order) => ({
+            orderId: order.orderId,
+            symbol: order.symbol,
+            success: false,
+            error: PERPS_ERROR_CODES.BATCH_CANCEL_FAILED,
+        }));
+        // Resolve Chase ownership before the first await. A queued reprice may
+        // replace the child ID, but the stable session handle still reaches it.
+        const chaseSessions = [...__classPrivateFieldGet(this, _HyperLiquidProvider_chaseSessions, "f").entries()];
+        const chaseRoutes = params.flatMap((order, index) => {
+            const owner = chaseSessions.find(([, session]) => session.orderId === order.orderId ||
+                session.replacingOrderId === order.orderId);
+            return owner ? [{ handle: owner[0], index, order }] : [];
+        });
+        const chaseIndexes = new Set(chaseRoutes.map(({ index }) => index));
         try {
-            __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Batch canceling orders:', {
-                count: params.length,
-            });
-            if (params.length === 0) {
-                return {
-                    success: false,
-                    successCount: 0,
-                    failureCount: 0,
-                    results: [],
-                };
+            for (const handle of new Set(chaseRoutes.map((route) => route.handle))) {
+                __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_stopChaseSession).call(this, handle);
             }
-            // Ensure provider is ready for trading (includes signing operations)
-            await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureReadyForTrading).call(this);
-            const exchangeClient = __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").getExchangeClient();
-            // Map orders to SDK format and validate coins
-            const cancelRequests = await Promise.all(params.map(async (order) => {
-                const asset = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getAssetIdWithRepair).call(this, {
+            if (chaseRoutes.length > 0) {
+                await __classPrivateFieldGet(this, _HyperLiquidProvider_chaseTickQueue, "f");
+            }
+            for (const { handle, index, order } of chaseRoutes) {
+                const result = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_cancelStrategyOrder).call(this, {
+                    orderId: handle,
                     symbol: order.symbol,
-                    dexName: parseAssetName(order.symbol).dex,
+                    orderType: 'chase',
                 });
-                return {
-                    a: asset,
-                    o: parseInt(order.orderId, 10),
+                results[index] = {
+                    orderId: order.orderId,
+                    symbol: order.symbol,
+                    success: result.success,
+                    ...(result.error === undefined ? {} : { error: result.error }),
                 };
-            }));
-            // Single batch API call
-            const result = await exchangeClient.cancel({
-                cancels: cancelRequests,
-            });
-            // Parse response statuses (one per order)
-            const { statuses } = result.response.data;
-            const successCount = statuses.filter((status) => status === 'success').length;
-            const failureCount = statuses.length - successCount;
-            return {
-                success: successCount > 0,
-                successCount,
-                failureCount,
-                results: statuses.map((status, index) => {
-                    // Map each per-status rejection the same way cancelOrder does, so a
-                    // batch cancel reports standardized codes rather than raw exchange
-                    // strings for the rejections this provider recognizes.
-                    const statusError = status?.error;
+            }
+            const ordinaryOrders = params.flatMap((order, index) => chaseIndexes.has(index) ? [] : [{ index, order }]);
+            if (ordinaryOrders.length > 0) {
+                // Cancellation carries no builder context, so it must not prompt for a
+                // fee approval that the action cannot use.
+                await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureReadyForTrading).call(this, { requiresBuilderFee: false });
+                const exchangeClient = __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").getExchangeClient();
+                const cancelRequests = await Promise.all(ordinaryOrders.map(async ({ order }) => {
+                    const asset = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getAssetIdWithRepair).call(this, {
+                        symbol: order.symbol,
+                        dexName: parseAssetName(order.symbol).dex,
+                    });
                     return {
-                        orderId: params[index].orderId,
-                        symbol: params[index].symbol,
-                        success: status === 'success',
-                        error: statusError
-                            ? __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_mapError).call(this, new Error(statusError)).message
-                            : undefined,
+                        a: asset,
+                        o: parseInt(order.orderId, 10),
                     };
-                }),
-            };
+                }));
+                const result = await exchangeClient.cancel({
+                    cancels: cancelRequests,
+                });
+                const statuses = result.response?.data?.statuses ?? [];
+                if (result.status === 'ok' &&
+                    statuses.length === ordinaryOrders.length) {
+                    ordinaryOrders.forEach(({ index, order }, statusIndex) => {
+                        const status = statuses[statusIndex];
+                        const success = status === 'success';
+                        const statusError = isStatusObject(status) && typeof status.error === 'string'
+                            ? status.error
+                            : undefined;
+                        results[index] = {
+                            orderId: order.orderId,
+                            symbol: order.symbol,
+                            success,
+                            ...(success
+                                ? {}
+                                : {
+                                    error: statusError === undefined
+                                        ? PERPS_ERROR_CODES.BATCH_CANCEL_FAILED
+                                        : __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_mapError).call(this, new Error(statusError)).message,
+                                }),
+                        };
+                    });
+                }
+            }
         }
         catch (error) {
             const mappedError = __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_mapError).call(this, error);
             __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").logger.error(mappedError, await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getTradingErrorContext).call(this, 'cancelOrders', mappedError, {
                 orderCount: params.length,
             }));
-            // Return all orders as failed
-            return {
-                success: false,
-                successCount: 0,
-                failureCount: params.length,
-                results: params.map((order) => ({
-                    orderId: order.orderId,
-                    symbol: order.symbol,
-                    success: false,
-                    error: error instanceof Error
-                        ? mappedError.message
-                        : PERPS_ERROR_CODES.BATCH_CANCEL_FAILED,
-                })),
-            };
+            for (const result of results) {
+                if (!result.success &&
+                    result.error === PERPS_ERROR_CODES.BATCH_CANCEL_FAILED) {
+                    result.error =
+                        error instanceof Error
+                            ? mappedError.message
+                            : PERPS_ERROR_CODES.BATCH_CANCEL_FAILED;
+                }
+            }
         }
+        const successCount = results.filter(({ success }) => success).length;
+        return {
+            success: successCount > 0,
+            successCount,
+            failureCount: results.length - successCount,
+            results,
+        };
     }
     async closePositions(params) {
         // Declare outside try block so it's accessible in catch block
         let positionsToClose = [];
         try {
-            // Ensure provider is ready for trading (includes signing operations)
-            await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureReadyForTrading).call(this);
+            // Batch preparation needs trading readiness but not builder approval yet.
+            // The provider-owned market policy is resolved from the positions below.
+            await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureReadyForTrading).call(this, { requiresBuilderFee: false });
             // Get all current positions from cache (avoids 429 rate limiting)
             const positions = await this.getPositions();
             // Filter positions based on params
@@ -1438,6 +1753,7 @@ export class HyperLiquidProvider {
             // Build orders array, plus the positions each order closes so response
             // statuses stay index-aligned when a position is skipped below
             const orders = [];
+            const feePolicyContexts = [];
             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.
@@ -1512,6 +1828,13 @@ export class HyperLiquidProvider {
                     r: true, // reduceOnly
                     t: { limit: { tif: 'Ioc' } }, // Immediate or cancel for market-like execution
                 });
+                feePolicyContexts.push({
+                    symbol: position.symbol,
+                    isBuy,
+                    size: formattedSize,
+                    orderType: 'market',
+                    reduceOnly: true,
+                });
                 orderedPositions.push(position);
                 orderedHip3Transfers.push(hip3Transfer);
             }
@@ -1526,11 +1849,19 @@ export class HyperLiquidProvider {
                     results: skippedResults,
                 };
             }
+            // HyperLiquid accepts one builder context for the whole close batch.
+            // Resolve every position context and charge the batch when any included
+            // policy charges, preserving deterministic behavior for future policies
+            // that vary by market or route.
+            const chargesMetamaskBuilderFee = feePolicyContexts.some((context) => __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_resolveOrderFeePolicy).call(this, context).chargesMetamaskBuilderFee);
+            const builder = chargesMetamaskBuilderFee
+                ? await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getBuilderOrderContext).call(this, await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureReadyForTrading).call(this, { requiresBuilderFee: true }))
+                : undefined;
             // Single batch API call
             const result = await exchangeClient.order({
                 orders,
                 grouping: 'na',
-                builder: await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getBuilderOrderContext).call(this),
+                ...(builder && { builder }),
             });
             // Parse response statuses (one per order)
             const { statuses } = result.response.data;
@@ -1644,11 +1975,11 @@ export class HyperLiquidProvider {
             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;
-            if (position) {
+            let fetchedPosition;
+            if (livePosition) {
                 __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Using live position from WebSocket', {
-                    symbol: position.symbol,
-                    size: position.size,
+                    symbol: livePosition.symbol,
+                    size: livePosition.size,
                 });
             }
             else {
@@ -1664,8 +1995,9 @@ export class HyperLiquidProvider {
                     }));
                     throw error;
                 }
-                position = positions.find((pos) => pos.symbol === symbol);
+                fetchedPosition = positions.find((pos) => pos.symbol === symbol);
             }
+            const position = livePosition ?? fetchedPosition;
             if (!position) {
                 throw new Error(`No position found for ${symbol}`);
             }
@@ -1729,17 +2061,117 @@ export class HyperLiquidProvider {
                     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)
             const assetId = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getAssetIdWithRepair).call(this, {
                 symbol,
                 dexName,
             });
+            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,
+                });
+            // HyperLiquid accepts one builder context for the whole TP/SL action.
+            // Position TP/SL has no parent policy to inherit, so resolve every
+            // included trigger and charge the batch when any child policy charges.
+            const feePolicyContexts = [
+                ...(takeProfitPrice
+                    ? [
+                        {
+                            symbol,
+                            isBuy: !isLong,
+                            size: resolveTpslSize(takeProfitSize),
+                            orderType: 'take_profit_limit',
+                            price: takeProfitPrice,
+                            triggerPrice: takeProfitPrice,
+                            reduceOnly: true,
+                        },
+                    ]
+                    : []),
+                ...(stopLossPrice
+                    ? [
+                        {
+                            symbol,
+                            isBuy: !isLong,
+                            size: resolveTpslSize(stopLossSize),
+                            orderType: 'stop_market',
+                            triggerPrice: stopLossPrice,
+                            reduceOnly: true,
+                        },
+                    ]
+                    : []),
+            ];
+            const replacementChargesMetamaskBuilderFee = feePolicyContexts.some((feePolicyContext) => __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_resolveOrderFeePolicy).call(this, feePolicyContext)
+                .chargesMetamaskBuilderFee);
+            // 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)
             let cancelRequests = [];
+            const restorablePositionTpslOrders = [];
+            const restorableStandaloneTpslOrders = [];
+            // Every replacement must cancel first so old and new reduce-only triggers
+            // cannot execute together. Retain the exact trigger definitions so a
+            // definitively failed replacement can restore confirmed cancellations.
+            const captureRestorableTpslOrders = (tpslOrders) => {
+                if (!takeProfitPrice && !stopLossPrice) {
+                    return;
+                }
+                tpslOrders.forEach((order) => {
+                    const orderId = Number(order.orderId);
+                    const orderType = order.triggerOrderType;
+                    const triggerPrice = order.triggerPrice ?? order.price;
+                    if (!Number.isSafeInteger(orderId) || !orderType || !triggerPrice) {
+                        throw new Error(PERPS_ERROR_CODES.TPSL_UPDATE_FAILED);
+                    }
+                    const size = order.isPositionTpsl ? '0' : order.remainingSize;
+                    const isBuy = order.side === 'buy';
+                    const feePolicyContext = {
+                        symbol,
+                        isBuy,
+                        size,
+                        orderType,
+                        triggerPrice,
+                        reduceOnly: true,
+                        ...(isLimitExecutionOrderType(orderType) && {
+                            price: order.price,
+                        }),
+                    };
+                    const restorableOrder = {
+                        orderId,
+                        order: {
+                            a: assetId,
+                            b: isBuy,
+                            p: order.price,
+                            s: size,
+                            r: true,
+                            t: {
+                                trigger: {
+                                    isMarket: !isLimitExecutionOrderType(orderType),
+                                    triggerPx: triggerPrice,
+                                    tpsl: getTriggerDirection(orderType) === 'stop' ? 'sl' : 'tp',
+                                },
+                            },
+                        },
+                        chargesMetamaskBuilderFee: __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_resolveOrderFeePolicy).call(this, feePolicyContext)
+                            .chargesMetamaskBuilderFee,
+                    };
+                    if (order.isPositionTpsl) {
+                        restorablePositionTpslOrders.push(restorableOrder);
+                    }
+                    else {
+                        restorableStandaloneTpslOrders.push(restorableOrder);
+                    }
+                });
+            };
             // Use atomic getter to prevent race condition between check and get
             const cachedOrders = __classPrivateFieldGet(this, _HyperLiquidProvider_subscriptionService, "f").getOrdersCacheIfInitialized();
             // Replacing TP/SL has to consider standalone ('na' grouping) triggers —
@@ -1766,16 +2198,16 @@ export class HyperLiquidProvider {
                 __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({
+                const openOrders = 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);
+                const childOrderIds = collectChildOrderIds(openOrders);
                 // Filter using raw SDK response properties
-                const tpslOrders = orders.filter((order) => order.coin === symbol &&
+                const tpslOrders = openOrders.filter((order) => order.coin === symbol &&
                     order.reduceOnly &&
                     // Position-bound TP/SL always qualifies, and so do standalone
                     // triggers on this market (they belong to the position too, whether
@@ -1787,6 +2219,7 @@ export class HyperLiquidProvider {
                     order.isTrigger &&
                     (order.orderType.includes('Take Profit') ||
                         order.orderType.includes('Stop')));
+                captureRestorableTpslOrders(tpslOrders.map((order) => adaptOrderFromSDK(order, position)));
                 cancelRequests = tpslOrders.map((order) => ({
                     a: assetId,
                     o: order.oid,
@@ -1810,36 +2243,14 @@ export class HyperLiquidProvider {
                     order.detailedOrderType &&
                     (order.detailedOrderType.includes('Take Profit') ||
                         order.detailedOrderType.includes('Stop')));
+                captureRestorableTpslOrders(tpslOrders);
                 cancelRequests = tpslOrders.map((order) => ({
                     a: assetId,
                     o: parseInt(order.orderId, 10),
                 }));
             }
-            if (cancelRequests.length > 0) {
-                __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log(`Canceling ${cancelRequests.length} existing TP/SL orders for ${symbol}`);
-                const cancelResult = await exchangeClient.cancel({
-                    cancels: cancelRequests,
-                });
-                __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Cancel result:', cancelResult);
-            }
-            // assetId already validated above when building cancelRequests
             // Build orders array for TP/SL
             const orders = [];
-            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 = {
@@ -1888,24 +2299,184 @@ export class HyperLiquidProvider {
                 };
                 orders.push(slOrder);
             }
-            // If no new orders, we've just cancelled existing ones (clearing TP/SL)
+            const rollbackRequiresBuilderFee = [
+                ...restorablePositionTpslOrders,
+                ...restorableStandaloneTpslOrders,
+            ].some((order) => order.chargesMetamaskBuilderFee);
+            const requiresBuilderFee = replacementChargesMetamaskBuilderFee || rollbackRequiresBuilderFee;
+            // Approval and builder-context resolution both finish before the
+            // pre-cancel. A failure here therefore leaves the old protection intact.
+            const builderFeeSetupContext = requiresBuilderFee
+                ? await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureReadyForTrading).call(this, {
+                    requiresBuilderFee: true,
+                    builderFeeApprovalFailureCode: PERPS_ERROR_CODES.TPSL_UPDATE_FAILED,
+                })
+                : await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureReadyForTrading).call(this, { requiresBuilderFee: false });
+            const builderOrderContext = builderFeeSetupContext
+                ? await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getBuilderOrderContext).call(this, builderFeeSetupContext)
+                : undefined;
+            const restoreCancelledProtection = async (cancelledOrderIds) => {
+                const restoredOrderIds = [];
+                let success = true;
+                const protectionGroups = [
+                    {
+                        grouping: 'positionTpsl',
+                        entries: restorablePositionTpslOrders,
+                    },
+                    {
+                        grouping: 'na',
+                        entries: restorableStandaloneTpslOrders,
+                    },
+                ];
+                for (const protection of protectionGroups) {
+                    const entries = protection.entries.filter((entry) => cancelledOrderIds.has(entry.orderId));
+                    if (entries.length === 0) {
+                        continue;
+                    }
+                    try {
+                        const result = await exchangeClient.order({
+                            orders: entries.map((entry) => entry.order),
+                            grouping: protection.grouping,
+                            ...(entries.some((entry) => entry.chargesMetamaskBuilderFee) &&
+                                builderOrderContext && { builder: builderOrderContext }),
+                        });
+                        const statuses = result.response?.data?.statuses ?? [];
+                        const outcomes = statuses
+                            .slice(0, entries.length)
+                            .map((status) => __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_readOrderPlacementOutcome).call(this, status));
+                        restoredOrderIds.push(...outcomes.flatMap((outcome) => outcome ? [outcome.orderId] : []));
+                        if (result.status !== 'ok' ||
+                            statuses.length !== entries.length ||
+                            outcomes.some((outcome) => outcome === undefined)) {
+                            success = false;
+                            __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").logger.error(new Error(PERPS_ERROR_CODES.TPSL_UPDATE_FAILED), __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getErrorContext).call(this, 'updatePositionTPSL > restoreCancelledProtection', { symbol, grouping: protection.grouping, statuses }));
+                        }
+                    }
+                    catch (error) {
+                        success = false;
+                        __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").logger.error(ensureError(error, 'HyperLiquidProvider.updatePositionTPSL.restoreCancelledProtection'), __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getErrorContext).call(this, 'updatePositionTPSL > restoreCancelledProtection', { symbol, grouping: protection.grouping }));
+                    }
+                }
+                return { restoredOrderIds, success };
+            };
+            const createProtectionLostResult = (survivingOrderIds) => createErrorResult(new Error(PERPS_ERROR_CODES.TPSL_PROTECTION_LOST), {
+                success: false,
+                childOrderIds: [...new Set(survivingOrderIds)],
+            });
+            // Clearing has no replacement batch to preserve. A partial cancellation
+            // is reported so the caller can retry the same clear operation.
             if (orders.length === 0) {
+                const remainingOrderIds = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_cancelOrderRequests).call(this, exchangeClient, cancelRequests);
+                if (remainingOrderIds.length > 0) {
+                    throw new Error(PERPS_ERROR_CODES.TPSL_UPDATE_FAILED);
+                }
                 __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('No new TP/SL orders to place - existing ones cancelled');
                 return {
                     success: true,
                     // No orderId since we only cancelled orders, didn't place new ones
                 };
             }
-            // 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: isPartialTpsl ? 'na' : 'positionTpsl',
-                builder: await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getBuilderOrderContext).call(this),
-            });
-            if (result.status !== 'ok') {
-                throw new Error(`TP/SL update failed: ${JSON.stringify(result)}`);
+            // Cancel before placing for both position-bound and standalone partial
+            // triggers. A place-first partial update leaves both trigger sets live
+            // during the cancellation round trip and can reduce more than requested.
+            const confirmedCancelledOldOrderIds = new Set();
+            const oldCancellation = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_cancelOrderRequestBatch).call(this, exchangeClient, cancelRequests);
+            if (!oldCancellation.responseComplete) {
+                const requestedOrderIds = new Set(cancelRequests.map((request) => request.o));
+                let possiblyLiveOrderIds = Array.from(requestedOrderIds, String);
+                try {
+                    const liveOrders = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_fetchOpenOrders).call(this, { dexName });
+                    possiblyLiveOrderIds = liveOrders
+                        .filter((order) => requestedOrderIds.has(order.oid))
+                        .map((order) => String(order.oid));
+                }
+                catch (error) {
+                    __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Could not reconcile TP/SL protection after an incomplete cancel', {
+                        symbol,
+                        error: ensureError(error, 'HyperLiquidProvider.updatePositionTPSL.reconcileProtection').message,
+                    });
+                }
+                return createProtectionLostResult(possiblyLiveOrderIds);
+            }
+            oldCancellation.cancelledOrderIds.forEach((orderId) => confirmedCancelledOldOrderIds.add(orderId));
+            if (oldCancellation.remainingOrderIds.length > 0) {
+                const restoration = await restoreCancelledProtection(confirmedCancelledOldOrderIds);
+                if (!restoration.success) {
+                    return createProtectionLostResult([
+                        ...oldCancellation.remainingOrderIds.map(String),
+                        ...restoration.restoredOrderIds,
+                    ]);
+                }
+                const updateError = new Error(PERPS_ERROR_CODES.TPSL_UPDATE_FAILED);
+                __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").logger.error(updateError, __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getErrorContext).call(this, 'updatePositionTPSL', {
+                    symbol: params.symbol,
+                    hasTakeProfit: params.takeProfitPrice !== undefined,
+                    hasStopLoss: params.stopLossPrice !== undefined,
+                }));
+                return createErrorResult(updateError, {
+                    success: false,
+                    childOrderIds: [
+                        ...new Set([
+                            ...oldCancellation.remainingOrderIds.map(String),
+                            ...restoration.restoredOrderIds,
+                        ]),
+                    ],
+                });
+            }
+            let result;
+            try {
+                result = await exchangeClient.order({
+                    orders,
+                    grouping: isPartialTpsl ? 'na' : 'positionTpsl',
+                    ...(replacementChargesMetamaskBuilderFee &&
+                        builderOrderContext && { builder: builderOrderContext }),
+                });
+            }
+            catch (error) {
+                const restoration = await restoreCancelledProtection(confirmedCancelledOldOrderIds);
+                if (!restoration.success) {
+                    return createProtectionLostResult(restoration.restoredOrderIds);
+                }
+                throw error;
+            }
+            const placementStatuses = result.response?.data?.statuses ?? [];
+            const placementOutcomes = placementStatuses
+                .slice(0, orders.length)
+                .map((status) => __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_readOrderPlacementOutcome).call(this, status));
+            const replacementOrderIds = placementOutcomes.flatMap((outcome) => outcome ? [outcome.orderId] : []);
+            const restingReplacementOrderIds = placementOutcomes.flatMap((outcome) => outcome?.state === 'resting' ? [outcome.orderId] : []);
+            const filledReplacementOrderIds = placementOutcomes.flatMap((outcome) => outcome?.state === 'filled' ? [outcome.orderId] : []);
+            if (result.status !== 'ok' ||
+                placementStatuses.length !== orders.length ||
+                replacementOrderIds.length !== orders.length) {
+                const remainingReplacementIds = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_cancelOrderRequests).call(this, exchangeClient, restingReplacementOrderIds.map((orderId) => ({
+                    a: assetId,
+                    o: Number(orderId),
+                })));
+                const recoverableOrderIds = [
+                    ...filledReplacementOrderIds,
+                    ...remainingReplacementIds.map(String),
+                ];
+                if (recoverableOrderIds.length === 0) {
+                    const restoration = await restoreCancelledProtection(confirmedCancelledOldOrderIds);
+                    if (!restoration.success) {
+                        return createProtectionLostResult(restoration.restoredOrderIds);
+                    }
+                }
+                // A filled replacement may have changed or closed the position, while
+                // an uncancelled replacement may still protect it. Restoring the old
+                // whole-position triggers in either case risks stale or duplicate
+                // protection, so return those IDs for caller reconciliation instead.
+                if (recoverableOrderIds.length > 0) {
+                    if (!isPartialTpsl) {
+                        return createProtectionLostResult(recoverableOrderIds);
+                    }
+                    return createErrorResult(new Error(PERPS_ERROR_CODES.TPSL_UPDATE_FAILED), {
+                        success: false,
+                        childOrderIds: recoverableOrderIds,
+                    });
+                }
+                throw new Error(PERPS_ERROR_CODES.TPSL_UPDATE_FAILED);
             }
             return {
                 success: true,
@@ -1933,8 +2504,9 @@ export class HyperLiquidProvider {
     async closePosition(params) {
         try {
             __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Closing position:', params);
-            // Ensure provider is ready for trading (includes signing operations)
-            await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureReadyForTrading).call(this);
+            // The delegated placeOrder call resolves the builder-fee policy for the
+            // concrete close order after validation.
+            await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureReadyForTrading).call(this, { requiresBuilderFee: false });
             // Use provided position (from WebSocket) or fetch from cache
             // This avoids unnecessary API calls and prevents 429 rate limiting
             let { position } = params;
@@ -2734,6 +3306,7 @@ export class HyperLiquidProvider {
                     __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Using cached open orders from WebSocket', {
                         count: cachedOrders.length,
                     });
+                    __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_restoreScaleOrderGroups).call(this, cachedOrders);
                     return cachedOrders;
                 }
             }
@@ -2764,6 +3337,7 @@ export class HyperLiquidProvider {
                 const position = positions.find((pos) => pos.symbol === order.coin);
                 return adaptOrderFromSDK(order, position);
             });
+            __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_restoreScaleOrderGroups).call(this, orders);
             return orders;
         }
         catch (error) {
@@ -3317,6 +3891,7 @@ export class HyperLiquidProvider {
      * @returns A promise that resolves to the combined market data from all enabled DEXs.
      */
     async getMarketDataWithPrices() {
+        const lifecycleGeneration = __classPrivateFieldGet(this, _HyperLiquidProvider_lifecycleGeneration, "f");
         __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Getting market data with prices via HyperLiquid SDK');
         // Ensure asset mapping is built first (populates meta cache)
         // This guarantees buildAssetMapping has run before we check cache,
@@ -3332,16 +3907,15 @@ export class HyperLiquidProvider {
         // Check the meta cache first to avoid redundant API calls when buildAssetMapping
         // has already populated it; on cache miss, delegate to #fetchSingleDexFresh.
         const dexDataResults = await Promise.all(enabledDexs.map(async (dex) => {
-            const dexKey = dex ?? '';
             const dexParam = dex ?? '';
-            const cachedMeta = __classPrivateFieldGet(this, _HyperLiquidProvider_cachedMetaByDex, "f").get(dexKey);
+            const cachedMeta = __classPrivateFieldGet(this, _HyperLiquidProvider_cachedMetaByDex, "f").get(dex);
             if (!cachedMeta) {
                 __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log(`[getMarketDataWithPrices] Cache miss for ${dex ?? 'main'}, fetching`);
-                return __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_fetchSingleDexFresh).call(this, infoClient, dex);
+                return __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_fetchSingleDexFresh).call(this, infoClient, dex, lifecycleGeneration);
             }
             __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log(`[getMarketDataWithPrices] Using cached meta for ${dex ?? 'main'}`, { universeSize: cachedMeta.universe.length });
             let metaForDex = cachedMeta;
-            let assetCtxs = __classPrivateFieldGet(this, _HyperLiquidProvider_subscriptionService, "f").getDexAssetCtxsCache(dexKey) ?? [];
+            let assetCtxs = __classPrivateFieldGet(this, _HyperLiquidProvider_subscriptionService, "f").getDexAssetCtxsCache(dexParam) ?? [];
             let failedStep;
             let errorMessage;
             if (assetCtxs.length !== metaForDex.universe.length) {
@@ -3362,10 +3936,12 @@ export class HyperLiquidProvider {
                     }
                     metaForDex = freshMeta;
                     assetCtxs = freshAssetCtxs;
-                    __classPrivateFieldGet(this, _HyperLiquidProvider_cachedMetaByDex, "f").set(dexKey, freshMeta);
-                    __classPrivateFieldGet(this, _HyperLiquidProvider_subscriptionService, "f").setDexMetaCache(dexKey, freshMeta);
-                    __classPrivateFieldGet(this, _HyperLiquidProvider_subscriptionService, "f").setDexAssetCtxsCache(dexKey, assetCtxs);
-                    await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_backfillAssetMapForDex).call(this, dex, freshMeta);
+                    await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_cacheDexMetadataFromRead).call(this, {
+                        dex,
+                        meta: freshMeta,
+                        assetCtxs,
+                        lifecycleGeneration,
+                    });
                 }
                 catch (error) {
                     return {
@@ -3417,7 +3993,7 @@ export class HyperLiquidProvider {
             const retryDelayMs = 2000;
             __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log(`[getMarketDataWithPrices] All DEXs returned empty, retrying in ${retryDelayMs}ms`);
             await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
-            const retryResults = await Promise.all(enabledDexs.map((dex) => __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_fetchSingleDexFresh).call(this, infoClient, dex)));
+            const retryResults = await Promise.all(enabledDexs.map((dex) => __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_fetchSingleDexFresh).call(this, infoClient, dex, lifecycleGeneration)));
             const usdcFilteredRetryResults = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_excludeNonUsdcCollateralResults).call(this, retryResults);
             __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_mergeDexResultsInto).call(this, usdcFilteredRetryResults, combinedUniverse, combinedAssetCtxs, combinedAllMids);
             latestDexResults = usdcFilteredRetryResults;
@@ -3477,6 +4053,9 @@ export class HyperLiquidProvider {
             assetCtxs: combinedAssetCtxs,
             allMids: combinedAllMids,
         }, __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").marketDataFormatters, HIP3_ASSET_MARKET_TYPES, HYPERLIQUID_ASSET_NAMES);
+        if (!__classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_isCacheWriteLifecycleCurrent).call(this, lifecycleGeneration, 'Market data cache write')) {
+            return transformedMarketData;
+        }
         return __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_cacheFreshMarketDataSnapshot).call(this, transformedMarketData, latestDexResults);
     }
     /**
@@ -4131,23 +4710,28 @@ export class HyperLiquidProvider {
     async toggleTestnet() {
         try {
             const newIsTestnet = !__classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").isTestnetMode();
-            // Await pending initialization to prevent race condition where
-            // the IIFE sets clientsInitialized = true after we reset it
-            const pendingInit = __classPrivateFieldGet(this, _HyperLiquidProvider_initializationPromise, "f");
-            __classPrivateFieldSet(this, _HyperLiquidProvider_initializationPromise, null, "f");
-            if (pendingInit) {
-                try {
-                    await pendingInit;
-                }
-                catch {
-                    // Ignore - we're switching networks anyway
-                }
+            const disconnectResult = await this.disconnect();
+            if (!disconnectResult.success) {
+                // The network did not change. Keep the provider eligible for lazy
+                // recovery instead of leaving this aborted toggle permanently sticky.
+                __classPrivateFieldSet(this, _HyperLiquidProvider_isDisconnected, false, "f");
+                throw new Error(disconnectResult.error ??
+                    'Failed to disconnect before network toggle');
             }
             // Update all services
             __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").setTestnetMode(newIsTestnet);
+            // Invalidate reads that started after disconnect completed but before
+            // the clients switched networks.
+            __classPrivateFieldSet(this, _HyperLiquidProvider_lifecycleGeneration, __classPrivateFieldGet(this, _HyperLiquidProvider_lifecycleGeneration, "f") + 1, "f");
             __classPrivateFieldGet(this, _HyperLiquidProvider_walletService, "f").setTestnetMode(newIsTestnet);
-            // Reset initialization flag so clients will be recreated on next use
-            __classPrivateFieldSet(this, _HyperLiquidProvider_clientsInitialized, false, "f");
+            const initializeResult = await this.initialize();
+            if (!initializeResult.success) {
+                // The network switch is already committed. Leave the provider eligible
+                // for lazy initialization so the next operation can retry the failed
+                // client setup instead of remaining permanently disconnected.
+                __classPrivateFieldSet(this, _HyperLiquidProvider_isDisconnected, false, "f");
+                throw new Error(initializeResult.error ?? 'Failed to initialize after network toggle');
+            }
             return {
                 success: true,
                 isTestnet: newIsTestnet,
@@ -4166,9 +4750,18 @@ export class HyperLiquidProvider {
      * @returns A promise that resolves to the result.
      */
     async initialize() {
+        const lifecycleGeneration = __classPrivateFieldGet(this, _HyperLiquidProvider_lifecycleGeneration, "f");
         try {
+            if (__classPrivateFieldGet(this, _HyperLiquidProvider_disconnectOperationsInFlight, "f") > 0) {
+                throw new Error(PERPS_ERROR_CODES.PROVIDER_LIFECYCLE_STALE);
+            }
             // Ensure clients are initialized (lazy initialization)
             await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureClientsInitialized).call(this);
+            if (__classPrivateFieldGet(this, _HyperLiquidProvider_disconnectOperationsInFlight, "f") > 0 ||
+                lifecycleGeneration !== __classPrivateFieldGet(this, _HyperLiquidProvider_lifecycleGeneration, "f")) {
+                throw new Error(PERPS_ERROR_CODES.PROVIDER_LIFECYCLE_STALE);
+            }
+            __classPrivateFieldSet(this, _HyperLiquidProvider_isDisconnected, false, "f");
             return {
                 success: true,
                 chainId: getChainId(__classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").isTestnetMode()),
@@ -4306,6 +4899,7 @@ export class HyperLiquidProvider {
      * @returns A promise that resolves to the numeric result.
      */
     async getMaxLeverage(asset) {
+        const lifecycleGeneration = __classPrivateFieldGet(this, _HyperLiquidProvider_lifecycleGeneration, "f");
         try {
             // Check cache first
             const cached = __classPrivateFieldGet(this, _HyperLiquidProvider_maxLeverageCache, "f").get(asset);
@@ -4338,11 +4932,12 @@ export class HyperLiquidProvider {
                 __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log(`Asset ${asset} not found in universe, using default max leverage`);
                 return PERPS_CONSTANTS.DefaultMaxLeverage;
             }
-            // Cache the result
-            __classPrivateFieldGet(this, _HyperLiquidProvider_maxLeverageCache, "f").set(asset, {
-                value: assetInfo.maxLeverage,
-                timestamp: now,
-            });
+            if (__classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_isCacheWriteLifecycleCurrent).call(this, lifecycleGeneration, 'Maximum leverage cache write')) {
+                __classPrivateFieldGet(this, _HyperLiquidProvider_maxLeverageCache, "f").set(asset, {
+                    value: assetInfo.maxLeverage,
+                    timestamp: now,
+                });
+            }
             return assetInfo.maxLeverage;
         }
         catch (error) {
@@ -4363,7 +4958,13 @@ export class HyperLiquidProvider {
      * @returns A promise that resolves to the result.
      */
     async calculateFees(params) {
+        const lifecycleGeneration = __classPrivateFieldGet(this, _HyperLiquidProvider_lifecycleGeneration, "f");
         const { orderType, isMaker = false, amount, symbol } = params;
+        const numericAmount = amount === undefined ? undefined : Number.parseFloat(amount);
+        const parsedAmount = numericAmount === undefined ||
+            (Number.isFinite(numericAmount) && numericAmount >= 0)
+            ? numericAmount
+            : 0;
         // Every placement is charged as its execution kind: a stop_market fills as a
         // market order (taker), a stop_limit as a limit order, a scale ladder as the
         // resting limit orders it fans out into, and a TWAP as the marketable
@@ -4410,6 +5011,7 @@ export class HyperLiquidProvider {
         // Try to get user-specific rates if wallet is connected
         try {
             const userAddress = await __classPrivateFieldGet(this, _HyperLiquidProvider_walletService, "f").getUserAddressWithDefault();
+            __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_assertProviderLifecycleCurrent).call(this, lifecycleGeneration, 'User fee cache read');
             __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('User Address Retrieved', {
                 userAddress,
                 network: __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").isTestnetMode() ? 'testnet' : 'mainnet',
@@ -4450,7 +5052,9 @@ export class HyperLiquidProvider {
                 });
                 // Fetch fresh rates from SDK
                 // Read-only operation: only need client initialization
+                __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_assertProviderLifecycleCurrent).call(this, lifecycleGeneration, 'User fee fetch');
                 await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureClientsInitialized).call(this);
+                __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_assertProviderLifecycleCurrent).call(this, lifecycleGeneration, 'User fee fetch');
                 __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").ensureInitialized();
                 const infoClient = __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").getInfoClient();
                 const userFees = await infoClient.userFees({
@@ -4463,13 +5067,21 @@ export class HyperLiquidProvider {
                     activeStakingDiscount: userFees.activeStakingDiscount,
                 });
                 // Parse base user rates (these don't include discounts as expected)
-                const baseUserTakerRate = parseFloat(userFees.userCrossRate);
-                const baseUserMakerRate = parseFloat(userFees.userAddRate);
-                const baseUserSpotTakerRate = parseFloat(userFees.userSpotCrossRate);
-                const baseUserSpotMakerRate = parseFloat(userFees.userSpotAddRate);
+                const baseUserTakerRate = parseBoundedNonNegativeDecimal(userFees.userCrossRate, MAX_API_FEE_RATE);
+                const baseUserMakerRate = parseBoundedNonNegativeDecimal(userFees.userAddRate, MAX_API_FEE_RATE);
+                const baseUserSpotTakerRate = parseBoundedNonNegativeDecimal(userFees.userSpotCrossRate, MAX_API_FEE_RATE);
+                const baseUserSpotMakerRate = parseBoundedNonNegativeDecimal(userFees.userSpotAddRate, MAX_API_FEE_RATE);
                 // Apply discounts manually since HyperLiquid API doesn't apply them
-                const referralDiscount = parseFloat(userFees.activeReferralDiscount || '0');
-                const stakingDiscount = parseFloat(userFees.activeStakingDiscount?.discount || '0');
+                const referralDiscount = parseBoundedNonNegativeDecimal(userFees.activeReferralDiscount || '0', MAX_API_FEE_DISCOUNT);
+                const stakingDiscount = parseBoundedNonNegativeDecimal(userFees.activeStakingDiscount?.discount || '0', MAX_API_FEE_DISCOUNT);
+                if (baseUserTakerRate === null ||
+                    baseUserMakerRate === null ||
+                    baseUserSpotTakerRate === null ||
+                    baseUserSpotMakerRate === null ||
+                    referralDiscount === null ||
+                    stakingDiscount === null) {
+                    throw new Error('Invalid fee rates received from API');
+                }
                 // Calculate total discount (referral + staking, but not compounding)
                 const totalDiscount = Math.min(referralDiscount + stakingDiscount, 0.4); // Cap at 40%
                 // Apply discount to rates
@@ -4495,20 +5107,20 @@ export class HyperLiquidProvider {
                     },
                 });
                 // Validate all rates are valid numbers before caching
-                if (isNaN(perpsTakerRate) ||
-                    isNaN(perpsMakerRate) ||
-                    isNaN(spotTakerRate) ||
-                    isNaN(spotMakerRate) ||
+                if (!Number.isFinite(perpsTakerRate) ||
+                    !Number.isFinite(perpsMakerRate) ||
+                    !Number.isFinite(spotTakerRate) ||
+                    !Number.isFinite(spotMakerRate) ||
                     perpsTakerRate < 0 ||
                     perpsMakerRate < 0 ||
                     spotTakerRate < 0 ||
                     spotMakerRate < 0) {
                     __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Fee Rate Validation Failed', {
                         validation: {
-                            perpsTakerValid: !isNaN(perpsTakerRate) && perpsTakerRate >= 0,
-                            perpsMakerValid: !isNaN(perpsMakerRate) && perpsMakerRate >= 0,
-                            spotTakerValid: !isNaN(spotTakerRate) && spotTakerRate >= 0,
-                            spotMakerValid: !isNaN(spotMakerRate) && spotMakerRate >= 0,
+                            perpsTakerValid: Number.isFinite(perpsTakerRate) && perpsTakerRate >= 0,
+                            perpsMakerValid: Number.isFinite(perpsMakerRate) && perpsMakerRate >= 0,
+                            spotTakerValid: Number.isFinite(spotTakerRate) && spotTakerRate >= 0,
+                            spotMakerValid: Number.isFinite(spotMakerRate) && spotMakerRate >= 0,
                         },
                         rawValues: {
                             perpsTakerRate,
@@ -4527,6 +5139,7 @@ export class HyperLiquidProvider {
                     timestamp: Date.now(),
                     ttl: 5 * 60 * 1000, // 5 minutes
                 };
+                __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_assertProviderLifecycleCurrent).call(this, lifecycleGeneration, 'User fee cache write');
                 __classPrivateFieldGet(this, _HyperLiquidProvider_userFeeCache, "f").set(userAddress, rates);
                 // Same maker/taker decision as the base rates above, chase included.
                 let userFeeRate = chargesMakerRate
@@ -4550,6 +5163,9 @@ export class HyperLiquidProvider {
         catch (error) {
             // Silently fall back to base rates
             const safeError = ensureError(error, 'HyperLiquidProvider.getFeeSchedule');
+            if (safeError.message === PERPS_ERROR_CODES.PROVIDER_LIFECYCLE_STALE) {
+                throw safeError;
+            }
             __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Fee API Call Failed - Falling Back to Base Rates', {
                 error: safeError.message,
                 errorType: safeError.name,
@@ -4558,43 +5174,46 @@ export class HyperLiquidProvider {
                 userAddress: 'unknown',
             });
         }
-        const parsedAmount = amount ? parseFloat(amount) : 0;
+        __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_assertProviderLifecycleCurrent).call(this, lifecycleGeneration, 'Fee calculation');
         // Protocol base fee (HyperLiquid's fee)
         const protocolFeeRate = feeRate;
-        let protocolFeeAmount;
-        if (amount === undefined) {
-            protocolFeeAmount = undefined;
-        }
-        else if (isNaN(parsedAmount)) {
-            protocolFeeAmount = 0;
-        }
-        else {
-            protocolFeeAmount = parsedAmount * protocolFeeRate;
-        }
-        // MetaMask builder fee (0.1% = 0.001) with optional reward discount
-        let metamaskFeeRate = BUILDER_FEE_CONFIG.MaxFeeDecimal;
-        // Apply MetaMask reward discount if active
-        if (__classPrivateFieldGet(this, _HyperLiquidProvider_userFeeDiscountBips, "f") !== undefined) {
-            const discount = __classPrivateFieldGet(this, _HyperLiquidProvider_userFeeDiscountBips, "f") / BASIS_POINTS_DIVISOR; // Convert basis points to decimal
-            metamaskFeeRate = BUILDER_FEE_CONFIG.MaxFeeDecimal * (1 - discount);
+        const protocolFeeAmount = parsedAmount === undefined ? undefined : parsedAmount * protocolFeeRate;
+        // The provider policy, not the client, owns whether this placement can
+        // carry a builder fee. The dedicated TWAP action has no builder field.
+        const { chargesMetamaskBuilderFee } = __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_resolveOrderFeePolicy).call(this, params);
+        const baseMetamaskFeeRate = chargesMetamaskBuilderFee
+            ? BUILDER_FEE_CONFIG.MaxFeeDecimal
+            : 0;
+        const metamaskFeeDiscount = __classPrivateFieldGet(this, _HyperLiquidProvider_userFeeDiscountBips, "f") === undefined
+            ? 0
+            : __classPrivateFieldGet(this, _HyperLiquidProvider_userFeeDiscountBips, "f") / BASIS_POINTS_DIVISOR;
+        const metamaskFeeRate = baseMetamaskFeeRate * (1 - metamaskFeeDiscount);
+        if (chargesMetamaskBuilderFee && __classPrivateFieldGet(this, _HyperLiquidProvider_userFeeDiscountBips, "f") !== undefined) {
             __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('HyperLiquid: Applied MetaMask fee discount', {
-                originalRate: BUILDER_FEE_CONFIG.MaxFeeDecimal,
+                originalRate: baseMetamaskFeeRate,
                 discountBips: __classPrivateFieldGet(this, _HyperLiquidProvider_userFeeDiscountBips, "f"),
                 discountPercentage: __classPrivateFieldGet(this, _HyperLiquidProvider_userFeeDiscountBips, "f") / 100,
                 adjustedRate: metamaskFeeRate,
-                discountAmount: BUILDER_FEE_CONFIG.MaxFeeDecimal * discount,
+                discountAmount: baseMetamaskFeeRate * metamaskFeeDiscount,
             });
         }
-        const validAmountForMetamaskFee = isNaN(parsedAmount)
-            ? 0
-            : parsedAmount * metamaskFeeRate;
-        const metamaskFeeAmount = amount === undefined ? undefined : validAmountForMetamaskFee;
+        const metamaskFeeAmount = parsedAmount === undefined ? undefined : parsedAmount * metamaskFeeRate;
         // Total fees
         const totalFeeRate = protocolFeeRate + metamaskFeeRate;
-        const validAmountForTotalFee = isNaN(parsedAmount)
-            ? 0
-            : parsedAmount * totalFeeRate;
-        const totalFeeAmount = amount === undefined ? undefined : validAmountForTotalFee;
+        const totalFeeAmount = parsedAmount === undefined ? undefined : parsedAmount * totalFeeRate;
+        if (!Number.isFinite(protocolFeeRate) ||
+            protocolFeeRate < 0 ||
+            !Number.isFinite(metamaskFeeRate) ||
+            metamaskFeeRate < 0 ||
+            !Number.isFinite(totalFeeRate) ||
+            totalFeeRate < 0 ||
+            (protocolFeeAmount !== undefined &&
+                !Number.isFinite(protocolFeeAmount)) ||
+            (metamaskFeeAmount !== undefined &&
+                !Number.isFinite(metamaskFeeAmount)) ||
+            (totalFeeAmount !== undefined && !Number.isFinite(totalFeeAmount))) {
+            throw new Error('Invalid fee calculation result');
+        }
         const result = {
             // Total fees
             feeRate: totalFeeRate,
@@ -4653,100 +5272,18 @@ export class HyperLiquidProvider {
      * @returns A promise that resolves to the result.
      */
     async disconnect() {
-        __classPrivateFieldSet(this, _HyperLiquidProvider_chasePlacementBlockers, __classPrivateFieldGet(this, _HyperLiquidProvider_chasePlacementBlockers, "f") + 1, "f");
-        __classPrivateFieldSet(this, _HyperLiquidProvider_chaseGeneration, __classPrivateFieldGet(this, _HyperLiquidProvider_chaseGeneration, "f") + 1, "f");
+        if (__classPrivateFieldGet(this, _HyperLiquidProvider_disconnectOperationPromise, "f")) {
+            return __classPrivateFieldGet(this, _HyperLiquidProvider_disconnectOperationPromise, "f");
+        }
+        const operation = __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_performDisconnect).call(this);
+        __classPrivateFieldSet(this, _HyperLiquidProvider_disconnectOperationPromise, operation, "f");
         try {
-            __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('HyperLiquid: Disconnecting provider', {
-                isTestnet: __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").isTestnetMode(),
-                timestamp: new Date().toISOString(),
-            });
-            // Clear subscriptions through subscription service
-            __classPrivateFieldGet(this, _HyperLiquidProvider_subscriptionService, "f").clearAll();
-            // Stop every chase loop: each holds a pending timer, and re-pricing after
-            // a disconnect would sign orders against a client that is being torn down.
-            // Orders already resting are deliberately left alone — disconnecting is
-            // not a request to cancel the user's positions or orders.
-            // Invalidate placements first, then drain every mutation before clearing
-            // the registry and tearing down the clients they use.
-            for (const [sessionId, session] of __classPrivateFieldGet(this, _HyperLiquidProvider_chaseSessions, "f").entries()) {
-                if (session.active) {
-                    __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_stopChaseSession).call(this, sessionId);
-                }
-            }
-            await Promise.all([...__classPrivateFieldGet(this, _HyperLiquidProvider_chasePlacementWaiters, "f")]);
-            await __classPrivateFieldGet(this, _HyperLiquidProvider_chaseTickQueue, "f");
-            await Promise.allSettled([...__classPrivateFieldGet(this, _HyperLiquidProvider_chaseTerminations, "f").values()]);
-            __classPrivateFieldGet(this, _HyperLiquidProvider_chaseSessions, "f").clear();
-            __classPrivateFieldGet(this, _HyperLiquidProvider_chaseTerminations, "f").clear();
-            __classPrivateFieldGet(this, _HyperLiquidProvider_terminatedChaseHandles, "f").clear();
-            __classPrivateFieldGet(this, _HyperLiquidProvider_scaleOrderGroups, "f").clear();
-            // Clear fee cache
-            this.clearFeeCache();
-            // Clear session caches (ensures fresh state on reconnect/account switch)
-            __classPrivateFieldGet(this, _HyperLiquidProvider_referralCheckCache, "f").clear();
-            __classPrivateFieldGet(this, _HyperLiquidProvider_builderFeeCheckCache, "f").clear();
-            __classPrivateFieldSet(this, _HyperLiquidProvider_subscriptionBuilderApprovalEpoch, __classPrivateFieldGet(this, _HyperLiquidProvider_subscriptionBuilderApprovalEpoch, "f") + 1, "f");
-            __classPrivateFieldGet(this, _HyperLiquidProvider_approvedBuilderAddresses, "f").clear();
-            __classPrivateFieldSet(this, _HyperLiquidProvider_userFeeResolution, undefined, "f");
-            __classPrivateFieldSet(this, _HyperLiquidProvider_userFeeDiscountBips, undefined, "f");
-            // NOTE: UnifiedAccountCache is global and NOT cleared on disconnect
-            // to prevent repeated signing requests across reconnections
-            __classPrivateFieldGet(this, _HyperLiquidProvider_cachedMetaByDex, "f").clear();
-            __classPrivateFieldSet(this, _HyperLiquidProvider_cachedSpotMeta, null, "f");
-            __classPrivateFieldGet(this, _HyperLiquidProvider_dexDiscoveryCache, "f").reset();
-            __classPrivateFieldSet(this, _HyperLiquidProvider_dexDiscoveryComplete, false, "f");
-            // Await pending initialization before clearing to prevent the IIFE from
-            // setting clientsInitialized = true after disconnect completes
-            const pendingInit = __classPrivateFieldGet(this, _HyperLiquidProvider_initializationPromise, "f");
-            const pendingReady = __classPrivateFieldGet(this, _HyperLiquidProvider_ensureReadyPromise, "f");
-            const pendingTradingSetup = __classPrivateFieldGet(this, _HyperLiquidProvider_tradingSetupPromise, "f");
-            // Clear references first to prevent new callers from reusing
-            __classPrivateFieldSet(this, _HyperLiquidProvider_initializationPromise, null, "f");
-            __classPrivateFieldSet(this, _HyperLiquidProvider_ensureReadyPromise, null, "f");
-            __classPrivateFieldSet(this, _HyperLiquidProvider_tradingSetupPromise, null, "f");
-            __classPrivateFieldSet(this, _HyperLiquidProvider_tradingSetupComplete, false, "f");
-            __classPrivateFieldGet(this, _HyperLiquidProvider_pendingBuilderFeeApprovals, "f").clear();
-            // Wait for pending operations to complete (ignore errors)
-            // This prevents IIFEs from setting state after disconnect completes
-            if (pendingInit) {
-                try {
-                    await pendingInit;
-                }
-                catch {
-                    // Ignore - we're disconnecting anyway
-                }
-            }
-            if (pendingReady) {
-                try {
-                    await pendingReady;
-                }
-                catch {
-                    // Ignore - we're disconnecting anyway
-                }
-            }
-            if (pendingTradingSetup) {
-                try {
-                    await pendingTradingSetup;
-                }
-                catch {
-                    // Ignore - we're disconnecting anyway
-                }
-            }
-            // Reset client initialization flag so wallet adapter will be recreated with new account
-            // This fixes account synchronization issue where old account's address persists in wallet adapter
-            __classPrivateFieldSet(this, _HyperLiquidProvider_clientsInitialized, false, "f");
-            // Disconnect client service
-            await __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").disconnect();
-            __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('HyperLiquid: Provider fully disconnected', {
-                timestamp: new Date().toISOString(),
-            });
-            return { success: true };
-        }
-        catch (error) {
-            return createErrorResult(error, { success: false });
+            return await operation;
         }
         finally {
-            __classPrivateFieldSet(this, _HyperLiquidProvider_chasePlacementBlockers, __classPrivateFieldGet(this, _HyperLiquidProvider_chasePlacementBlockers, "f") - 1, "f");
+            if (__classPrivateFieldGet(this, _HyperLiquidProvider_disconnectOperationPromise, "f") === operation) {
+                __classPrivateFieldSet(this, _HyperLiquidProvider_disconnectOperationPromise, null, "f");
+            }
         }
     }
     /**
@@ -4872,7 +5409,75 @@ export class HyperLiquidProvider {
         return `${baseUrl}/explorer`;
     }
 }
-_HyperLiquidProvider_deps = new WeakMap(), _HyperLiquidProvider_clientService = new WeakMap(), _HyperLiquidProvider_walletService = new WeakMap(), _HyperLiquidProvider_subscriptionService = new WeakMap(), _HyperLiquidProvider_symbolToAssetId = new WeakMap(), _HyperLiquidProvider_userFeeCache = new WeakMap(), _HyperLiquidProvider_maxLeverageCache = new WeakMap(), _HyperLiquidProvider_cachedMetaByDex = new WeakMap(), _HyperLiquidProvider_cachedMarketDataWithPrices = new WeakMap(), _HyperLiquidProvider_cachedSpotMeta = new WeakMap(), _HyperLiquidProvider_dexDiscoveryCache = new WeakMap(), _HyperLiquidProvider_referralCheckCache = new WeakMap(), _HyperLiquidProvider_builderFeeCheckCache = new WeakMap(), _HyperLiquidProvider_ensureReadyPromise = new WeakMap(), _HyperLiquidProvider_pendingBuilderFeeApprovals = new WeakMap(), _HyperLiquidProvider_subscriptionBuilderApprovalEpoch = new WeakMap(), _HyperLiquidProvider_approvedBuilderAddresses = new WeakMap(), _HyperLiquidProvider_compiledAllowlistPatterns = new WeakMap(), _HyperLiquidProvider_compiledBlocklistPatterns = new WeakMap(), _HyperLiquidProvider_userFeeDiscountBips = new WeakMap(), _HyperLiquidProvider_userFeeResolution = new WeakMap(), _HyperLiquidProvider_hip3Enabled = new WeakMap(), _HyperLiquidProvider_allowlistMarkets = new WeakMap(), _HyperLiquidProvider_blocklistMarkets = new WeakMap(), _HyperLiquidProvider_useUnifiedAccount = new WeakMap(), _HyperLiquidProvider_dexDiscoveryComplete = new WeakMap(), _HyperLiquidProvider_unifiedAccountSetupNeedsRetry = new WeakMap(), _HyperLiquidProvider_pendingValidatedDexsPromise = new WeakMap(), _HyperLiquidProvider_cachedUsdcTokenId = new WeakMap(), _HyperLiquidProvider_errorMappings = new WeakMap(), _HyperLiquidProvider_scaleOrderGroups = new WeakMap(), _HyperLiquidProvider_chaseSessions = new WeakMap(), _HyperLiquidProvider_chaseTerminations = new WeakMap(), _HyperLiquidProvider_terminatedChaseHandles = new WeakMap(), _HyperLiquidProvider_chasePlacementsInFlight = new WeakMap(), _HyperLiquidProvider_chasePlacementWaiters = new WeakMap(), _HyperLiquidProvider_chaseTickQueue = new WeakMap(), _HyperLiquidProvider_chaseGeneration = new WeakMap(), _HyperLiquidProvider_chasePlacementBlockers = new WeakMap(), _HyperLiquidProvider_clientsInitialized = new WeakMap(), _HyperLiquidProvider_initializationPromise = new WeakMap(), _HyperLiquidProvider_messenger = new WeakMap(), _HyperLiquidProvider_builderAddressTestnet = new WeakMap(), _HyperLiquidProvider_builderAddressMainnet = new WeakMap(), _HyperLiquidProvider_subscriptionBuilderAddressTestnet = new WeakMap(), _HyperLiquidProvider_subscriptionBuilderAddressMainnet = new WeakMap(), _HyperLiquidProvider_priceDeviationLimit = new WeakMap(), _HyperLiquidProvider_tradingSetupPromise = new WeakMap(), _HyperLiquidProvider_tradingSetupComplete = new WeakMap(), _HyperLiquidProvider_instances = new WeakSet(), _HyperLiquidProvider_compilePatternsSafely = function _HyperLiquidProvider_compilePatternsSafely(patterns, listName) {
+_a = HyperLiquidProvider, _HyperLiquidProvider_deps = new WeakMap(), _HyperLiquidProvider_clientService = new WeakMap(), _HyperLiquidProvider_walletService = new WeakMap(), _HyperLiquidProvider_subscriptionService = new WeakMap(), _HyperLiquidProvider_symbolToAssetId = new WeakMap(), _HyperLiquidProvider_userFeeCache = new WeakMap(), _HyperLiquidProvider_maxLeverageCache = new WeakMap(), _HyperLiquidProvider_cachedMetaByDex = new WeakMap(), _HyperLiquidProvider_orderCapabilitiesMarketsByDex = new WeakMap(), _HyperLiquidProvider_orderCapabilitiesRefreshByDex = new WeakMap(), _HyperLiquidProvider_isDisconnected = new WeakMap(), _HyperLiquidProvider_disconnectOperationsInFlight = new WeakMap(), _HyperLiquidProvider_disconnectOperationPromise = new WeakMap(), _HyperLiquidProvider_lifecycleGeneration = new WeakMap(), _HyperLiquidProvider_cachedMarketDataWithPrices = new WeakMap(), _HyperLiquidProvider_cachedSpotMeta = new WeakMap(), _HyperLiquidProvider_dexDiscoveryCache = new WeakMap(), _HyperLiquidProvider_referralCheckCache = new WeakMap(), _HyperLiquidProvider_builderFeeCheckCache = new WeakMap(), _HyperLiquidProvider_ensureReadyPromise = new WeakMap(), _HyperLiquidProvider_pendingBuilderFeeApprovals = new WeakMap(), _HyperLiquidProvider_subscriptionBuilderApprovalEpoch = new WeakMap(), _HyperLiquidProvider_approvedBuilderAddresses = new WeakMap(), _HyperLiquidProvider_compiledAllowlistPatterns = new WeakMap(), _HyperLiquidProvider_compiledBlocklistPatterns = new WeakMap(), _HyperLiquidProvider_userFeeDiscountBips = new WeakMap(), _HyperLiquidProvider_userFeeResolution = new WeakMap(), _HyperLiquidProvider_hip3Enabled = new WeakMap(), _HyperLiquidProvider_allowlistMarkets = new WeakMap(), _HyperLiquidProvider_blocklistMarkets = new WeakMap(), _HyperLiquidProvider_useUnifiedAccount = new WeakMap(), _HyperLiquidProvider_dexDiscoveryComplete = new WeakMap(), _HyperLiquidProvider_unifiedAccountSetupNeedsRetry = new WeakMap(), _HyperLiquidProvider_pendingValidatedDexsPromise = new WeakMap(), _HyperLiquidProvider_cachedUsdcTokenId = new WeakMap(), _HyperLiquidProvider_errorMappings = new WeakMap(), _HyperLiquidProvider_scaleOrderGroups = new WeakMap(), _HyperLiquidProvider_cancelledScaleOrderGroups = new WeakMap(), _HyperLiquidProvider_trackedTwapOrders = new WeakMap(), _HyperLiquidProvider_chaseSessions = new WeakMap(), _HyperLiquidProvider_chaseTerminations = new WeakMap(), _HyperLiquidProvider_terminatedChaseHandles = new WeakMap(), _HyperLiquidProvider_chasePlacementsInFlight = new WeakMap(), _HyperLiquidProvider_chasePlacementWaiters = new WeakMap(), _HyperLiquidProvider_chaseTickQueue = new WeakMap(), _HyperLiquidProvider_strategyGeneration = new WeakMap(), _HyperLiquidProvider_chasePlacementBlockers = new WeakMap(), _HyperLiquidProvider_clientsInitialized = new WeakMap(), _HyperLiquidProvider_initializationPromise = new WeakMap(), _HyperLiquidProvider_messenger = new WeakMap(), _HyperLiquidProvider_builderAddressTestnet = new WeakMap(), _HyperLiquidProvider_builderAddressMainnet = new WeakMap(), _HyperLiquidProvider_subscriptionBuilderAddressTestnet = new WeakMap(), _HyperLiquidProvider_subscriptionBuilderAddressMainnet = new WeakMap(), _HyperLiquidProvider_priceDeviationLimit = new WeakMap(), _HyperLiquidProvider_onChaseOrderMaxDistanceReached = new WeakMap(), _HyperLiquidProvider_tradingSetupPromise = new WeakMap(), _HyperLiquidProvider_tradingSetupComplete = new WeakMap(), _HyperLiquidProvider_builderFeeSetupPromises = new WeakMap(), _HyperLiquidProvider_instances = new WeakSet(), _HyperLiquidProvider_resolveOrderFeePolicy = function _HyperLiquidProvider_resolveOrderFeePolicy(params) {
+    const fallbackPolicy = Object.prototype.hasOwnProperty.call(HYPERLIQUID_ORDER_FEE_CONFIG, params.orderType)
+        ? HYPERLIQUID_ORDER_FEE_CONFIG[params.orderType]
+        : undefined;
+    if (fallbackPolicy) {
+        return fallbackPolicy;
+    }
+    __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('HyperLiquid: Unknown order type used the safe builder-fee policy', { orderType: params.orderType });
+    return HYPERLIQUID_ORDER_FEE_CONFIG.market;
+}, _HyperLiquidProvider_assertProviderLifecycleCurrent = function _HyperLiquidProvider_assertProviderLifecycleCurrent(generation, operation) {
+    if (__classPrivateFieldGet(this, _HyperLiquidProvider_isDisconnected, "f") || generation !== __classPrivateFieldGet(this, _HyperLiquidProvider_lifecycleGeneration, "f")) {
+        __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('HyperLiquid: Provider operation became stale during disconnect', { operation });
+        throw new Error(PERPS_ERROR_CODES.PROVIDER_LIFECYCLE_STALE);
+    }
+}, _HyperLiquidProvider_assertCacheWriteLifecycleCurrent = function _HyperLiquidProvider_assertCacheWriteLifecycleCurrent(generation, operation) {
+    if (!__classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_isCacheWriteLifecycleCurrent).call(this, generation, operation)) {
+        throw new Error(PERPS_ERROR_CODES.PROVIDER_LIFECYCLE_STALE);
+    }
+}, _HyperLiquidProvider_isCacheWriteLifecycleCurrent = function _HyperLiquidProvider_isCacheWriteLifecycleCurrent(generation, operation) {
+    if (__classPrivateFieldGet(this, _HyperLiquidProvider_disconnectOperationsInFlight, "f") > 0 ||
+        generation !== __classPrivateFieldGet(this, _HyperLiquidProvider_lifecycleGeneration, "f")) {
+        __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('HyperLiquid: Cache write became stale during disconnect', { operation });
+        return false;
+    }
+    return true;
+}, _HyperLiquidProvider_getFreshOrderCapabilityMarkets = 
+/**
+ * Return filtered market metadata fresh enough for a capability query.
+ * Each DEX shares one refresh across concurrent callers, and a failed
+ * refresh remains immediately retryable.
+ *
+ * @param dex - Routed DEX, or null for the main DEX.
+ * @returns Fresh filtered markets for that route.
+ */
+async function _HyperLiquidProvider_getFreshOrderCapabilityMarkets(dex) {
+    const lifecycleGeneration = __classPrivateFieldGet(this, _HyperLiquidProvider_lifecycleGeneration, "f");
+    const cachedMarkets = __classPrivateFieldGet(this, _HyperLiquidProvider_orderCapabilitiesMarketsByDex, "f").get(dex);
+    if (cachedMarkets &&
+        Date.now() - cachedMarkets.freshAt <
+            PERFORMANCE_CONFIG.OrderCapabilitiesMetaFreshnessMs) {
+        return cachedMarkets.markets;
+    }
+    let refreshPromise = __classPrivateFieldGet(this, _HyperLiquidProvider_orderCapabilitiesRefreshByDex, "f").get(dex);
+    if (!refreshPromise) {
+        refreshPromise = (async () => {
+            const markets = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_fetchMarketsForDex).call(this, {
+                dex,
+                skipCache: true,
+            });
+            __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_assertProviderLifecycleCurrent).call(this, lifecycleGeneration, 'Order capability metadata refresh');
+            __classPrivateFieldGet(this, _HyperLiquidProvider_orderCapabilitiesMarketsByDex, "f").set(dex, {
+                markets,
+                freshAt: Date.now(),
+            });
+            return markets;
+        })();
+        __classPrivateFieldGet(this, _HyperLiquidProvider_orderCapabilitiesRefreshByDex, "f").set(dex, refreshPromise);
+    }
+    try {
+        const markets = await refreshPromise;
+        __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_assertProviderLifecycleCurrent).call(this, lifecycleGeneration, 'Order capability read');
+        return markets;
+    }
+    finally {
+        if (__classPrivateFieldGet(this, _HyperLiquidProvider_orderCapabilitiesRefreshByDex, "f").get(dex) === refreshPromise) {
+            __classPrivateFieldGet(this, _HyperLiquidProvider_orderCapabilitiesRefreshByDex, "f").delete(dex);
+        }
+    }
+}, _HyperLiquidProvider_compilePatternsSafely = function _HyperLiquidProvider_compilePatternsSafely(patterns, listName) {
     const compiled = [];
     for (const pattern of patterns) {
         try {
@@ -4895,6 +5500,9 @@ _HyperLiquidProvider_deps = new WeakMap(), _HyperLiquidProvider_clientService =
  * the connection is fully established before marking initialization complete.
  */
 async function _HyperLiquidProvider_ensureClientsInitialized() {
+    if (__classPrivateFieldGet(this, _HyperLiquidProvider_disconnectOperationsInFlight, "f") > 0) {
+        throw new Error(PERPS_ERROR_CODES.PROVIDER_LIFECYCLE_STALE);
+    }
     if (__classPrivateFieldGet(this, _HyperLiquidProvider_clientsInitialized, "f")) {
         return; // Already initialized
     }
@@ -4902,6 +5510,9 @@ async function _HyperLiquidProvider_ensureClientsInitialized() {
     // This prevents race conditions when multiple methods call concurrently
     if (__classPrivateFieldGet(this, _HyperLiquidProvider_initializationPromise, "f")) {
         await __classPrivateFieldGet(this, _HyperLiquidProvider_initializationPromise, "f");
+        if (__classPrivateFieldGet(this, _HyperLiquidProvider_disconnectOperationsInFlight, "f") > 0) {
+            throw new Error(PERPS_ERROR_CODES.PROVIDER_LIFECYCLE_STALE);
+        }
         return;
     }
     // Create and cache the initialization promise
@@ -4910,8 +5521,14 @@ async function _HyperLiquidProvider_ensureClientsInitialized() {
         if (__classPrivateFieldGet(this, _HyperLiquidProvider_clientsInitialized, "f")) {
             return;
         }
+        if (__classPrivateFieldGet(this, _HyperLiquidProvider_disconnectOperationsInFlight, "f") > 0) {
+            throw new Error(PERPS_ERROR_CODES.PROVIDER_LIFECYCLE_STALE);
+        }
         const wallet = __classPrivateFieldGet(this, _HyperLiquidProvider_walletService, "f").createWalletAdapter();
         await __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").initialize(wallet);
+        if (__classPrivateFieldGet(this, _HyperLiquidProvider_disconnectOperationsInFlight, "f") > 0) {
+            throw new Error(PERPS_ERROR_CODES.PROVIDER_LIFECYCLE_STALE);
+        }
         // Set termination callback for logging when WebSocket terminates
         // Note: Do NOT restore subscriptions here - termination means connection failed permanently
         __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").setOnTerminateCallback((error) => {
@@ -5382,7 +5999,13 @@ async function _HyperLiquidProvider_ensureReady() {
     // Await initialization - keep the promise so subsequent calls resolve immediately
     // The promise is only reset in disconnect() for clean reconnection,
     // or when DEX discovery was degraded so the next caller retries.
-    await __classPrivateFieldGet(this, _HyperLiquidProvider_ensureReadyPromise, "f");
+    try {
+        await __classPrivateFieldGet(this, _HyperLiquidProvider_ensureReadyPromise, "f");
+    }
+    catch (error) {
+        __classPrivateFieldSet(this, _HyperLiquidProvider_ensureReadyPromise, null, "f");
+        throw error;
+    }
     if (!__classPrivateFieldGet(this, _HyperLiquidProvider_dexDiscoveryComplete, "f")) {
         // DEX discovery failed transiently — reset so next call retries.
         // Trading still works (main DEX mapping is populated), but HIP-3 markets
@@ -5397,72 +6020,102 @@ async function _HyperLiquidProvider_ensureReady() {
         __classPrivateFieldSet(this, _HyperLiquidProvider_ensureReadyPromise, null, "f");
     }
     __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('[ensureReady] Initialization complete');
-}, _HyperLiquidProvider_ensureReadyForTrading = async function _HyperLiquidProvider_ensureReadyForTrading() {
+}, _HyperLiquidProvider_ensureBuilderFeeSetup = 
+/**
+ * Approve the standard builder fee once for the current account and network.
+ * TWAP never calls this because its native action has no builder field.
+ * Without an approval failure code, approval remains non-blocking and the
+ * returned context describes attribution only; it does not prove approval.
+ *
+ * @param approvalFailureCode - Operation-specific error to throw when
+ * approval is unavailable or fails.
+ * @returns The account, network, and configured builder for the action.
+ */
+async function _HyperLiquidProvider_ensureBuilderFeeSetup(approvalFailureCode) {
+    const isTestnet = __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").isTestnetMode();
+    const network = isTestnet ? 'testnet' : 'mainnet';
+    const userAddress = await __classPrivateFieldGet(this, _HyperLiquidProvider_walletService, "f").getUserAddressWithDefault();
+    const cacheKey = __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getCacheKey).call(this, network, userAddress);
+    const builderAddress = __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getBuilderAddress).call(this, isTestnet);
+    const context = {
+        network,
+        userAddress,
+        builderAddress,
+    };
+    const setupKey = __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getApprovedBuilderKey).call(this, network, userAddress, builderAddress);
+    if (__classPrivateFieldGet(this, _HyperLiquidProvider_builderFeeCheckCache, "f").has(cacheKey)) {
+        return context;
+    }
+    let pendingApproval = __classPrivateFieldGet(this, _HyperLiquidProvider_builderFeeSetupPromises, "f").get(setupKey);
+    if (!pendingApproval) {
+        pendingApproval = __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureBuilderFeeApproval).call(this, context);
+        __classPrivateFieldGet(this, _HyperLiquidProvider_builderFeeSetupPromises, "f").set(setupKey, pendingApproval);
+    }
+    try {
+        await pendingApproval;
+    }
+    catch (error) {
+        __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('[ensureBuilderFeeSetup] Builder fee approval failed', error);
+        if (approvalFailureCode) {
+            throw new Error(approvalFailureCode);
+        }
+    }
+    finally {
+        if (__classPrivateFieldGet(this, _HyperLiquidProvider_builderFeeSetupPromises, "f").get(setupKey) === pendingApproval) {
+            __classPrivateFieldGet(this, _HyperLiquidProvider_builderFeeSetupPromises, "f").delete(setupKey);
+        }
+    }
+    if (approvalFailureCode && !__classPrivateFieldGet(this, _HyperLiquidProvider_builderFeeCheckCache, "f").has(cacheKey)) {
+        throw new Error(approvalFailureCode);
+    }
+    return context;
+}, _HyperLiquidProvider_ensureReadyForTrading = async function _HyperLiquidProvider_ensureReadyForTrading(options) {
     // First ensure basic initialization is complete
     await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureReady).call(this);
     // dexAbstraction users were deferred during init to avoid an EIP-712 prompt
     // on Perps section open. Drive the migration here, gated by its own cache so
     // already-migrated or already-rejected users are not re-prompted.
     await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureUnifiedAccountEnabled).call(this, { allowUserSigning: true });
-    // If trading setup already complete, only retry builder fee if it previously failed
-    if (__classPrivateFieldGet(this, _HyperLiquidProvider_tradingSetupComplete, "f")) {
-        const isTestnet = __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").isTestnetMode();
-        const network = isTestnet ? 'testnet' : 'mainnet';
-        const userAddress = await __classPrivateFieldGet(this, _HyperLiquidProvider_walletService, "f").getUserAddressWithDefault();
-        const cacheKey = __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getCacheKey).call(this, network, userAddress);
-        if (!__classPrivateFieldGet(this, _HyperLiquidProvider_builderFeeCheckCache, "f").has(cacheKey)) {
-            __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('[ensureReadyForTrading] Retrying builder fee approval (previous attempt failed)');
-            try {
-                await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureBuilderFeeApproval).call(this);
+    if (!__classPrivateFieldGet(this, _HyperLiquidProvider_tradingSetupComplete, "f") && !__classPrivateFieldGet(this, _HyperLiquidProvider_tradingSetupPromise, "f")) {
+        const lifecycleGeneration = __classPrivateFieldGet(this, _HyperLiquidProvider_lifecycleGeneration, "f");
+        __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('[ensureReadyForTrading] Starting shared trading setup');
+        __classPrivateFieldSet(this, _HyperLiquidProvider_tradingSetupPromise, (async () => {
+            // Pre-fetch spotMeta for HIP-3 operations (non-blocking if it fails)
+            // This ensures token info (e.g. USDC token index) is available during order placement
+            if (__classPrivateFieldGet(this, _HyperLiquidProvider_hip3Enabled, "f")) {
+                try {
+                    await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getCachedSpotMeta).call(this);
+                }
+                catch (error) {
+                    __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('[ensureReadyForTrading] spotMeta pre-fetch failed, will retry when needed', error);
+                    // Don't throw - spotMeta will be fetched on-demand if needed
+                }
             }
-            catch (error) {
-                // Don't throw - retry is best-effort, trading continues regardless
-                __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('[ensureReadyForTrading] Builder fee retry failed', error);
+            // Set up referral code independently from builder-fee applicability.
+            await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureReferralSet).call(this);
+            __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_assertProviderLifecycleCurrent).call(this, lifecycleGeneration, 'Trading setup completion');
+            // Only mark complete if keyring was unlocked (signing could actually happen)
+            if (__classPrivateFieldGet(this, _HyperLiquidProvider_walletService, "f").isKeyringUnlocked()) {
+                __classPrivateFieldSet(this, _HyperLiquidProvider_tradingSetupComplete, true, "f");
             }
-        }
-        return;
-    }
-    // If trading setup is in progress, wait for it
-    if (__classPrivateFieldGet(this, _HyperLiquidProvider_tradingSetupPromise, "f")) {
-        __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('[ensureReadyForTrading] Waiting for in-progress trading setup');
-        await __classPrivateFieldGet(this, _HyperLiquidProvider_tradingSetupPromise, "f");
-        return;
+        })(), "f");
     }
-    __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('[ensureReadyForTrading] Starting trading setup (may require signatures)');
-    __classPrivateFieldSet(this, _HyperLiquidProvider_tradingSetupPromise, (async () => {
-        // Pre-fetch spotMeta for HIP-3 operations (non-blocking if it fails)
-        // This ensures token info (e.g. USDC token index) is available during order placement
-        if (__classPrivateFieldGet(this, _HyperLiquidProvider_hip3Enabled, "f")) {
-            try {
-                await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getCachedSpotMeta).call(this);
-            }
-            catch (error) {
-                __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('[ensureReadyForTrading] spotMeta pre-fetch failed, will retry when needed', error);
-                // Don't throw - spotMeta will be fetched on-demand if needed
-            }
-        }
-        // Set up builder fee approval
+    const pendingSetup = __classPrivateFieldGet(this, _HyperLiquidProvider_tradingSetupPromise, "f");
+    if (pendingSetup) {
         try {
-            await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureBuilderFeeApproval).call(this);
-        }
-        catch (error) {
-            __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('HyperLiquidProvider: Builder fee approval failed', error);
-            // Don't throw - let trading continue, will fail with clear error if needed
+            await pendingSetup;
         }
-        // Set up referral code
-        await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureReferralSet).call(this);
-        // Only mark complete if keyring was unlocked (signing could actually happen)
-        if (__classPrivateFieldGet(this, _HyperLiquidProvider_walletService, "f").isKeyringUnlocked()) {
-            __classPrivateFieldSet(this, _HyperLiquidProvider_tradingSetupComplete, true, "f");
+        finally {
+            if (__classPrivateFieldGet(this, _HyperLiquidProvider_tradingSetupPromise, "f") === pendingSetup) {
+                __classPrivateFieldSet(this, _HyperLiquidProvider_tradingSetupPromise, null, "f");
+            }
         }
-    })(), "f");
-    try {
-        await __classPrivateFieldGet(this, _HyperLiquidProvider_tradingSetupPromise, "f");
-    }
-    finally {
-        __classPrivateFieldSet(this, _HyperLiquidProvider_tradingSetupPromise, null, "f");
     }
+    const builderFeeSetupContext = options.requiresBuilderFee
+        ? await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureBuilderFeeSetup).call(this, options.builderFeeApprovalFailureCode)
+        : undefined;
     __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('[ensureReadyForTrading] Trading setup complete');
+    return builderFeeSetupContext;
 }, _HyperLiquidProvider_getOrFetchPrice = 
 /**
  * Get current price for a symbol using WebSocket cache first, REST API fallback
@@ -5525,6 +6178,7 @@ async function _HyperLiquidProvider_getOrFetchPrice(params) {
  * @returns Array of all DEX names (null for main DEX, strings for HIP-3 DEXs)
  */
 async function _HyperLiquidProvider_getAllAvailableDexs() {
+    const lifecycleGeneration = __classPrivateFieldGet(this, _HyperLiquidProvider_lifecycleGeneration, "f");
     // Use unified state if available
     if (__classPrivateFieldGet(this, _HyperLiquidProvider_dexDiscoveryCache, "f").state) {
         const availableHip3Dexs = [];
@@ -5542,6 +6196,7 @@ async function _HyperLiquidProvider_getAllAvailableDexs() {
         if (!allDexs || !Array.isArray(allDexs)) {
             return [null]; // Fallback to main DEX only
         }
+        __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_assertCacheWriteLifecycleCurrent).call(this, lifecycleGeneration, 'DEX discovery cache write');
         const state = __classPrivateFieldGet(this, _HyperLiquidProvider_dexDiscoveryCache, "f").update(allDexs);
         const availableHip3Dexs = [];
         state.raw.forEach((dex) => {
@@ -5588,14 +6243,17 @@ async function _HyperLiquidProvider_getValidatedDexs() {
         return __classPrivateFieldGet(this, _HyperLiquidProvider_pendingValidatedDexsPromise, "f");
     }
     // Create and cache the pending promise for deduplication
-    __classPrivateFieldSet(this, _HyperLiquidProvider_pendingValidatedDexsPromise, __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_fetchValidatedDexsInternal).call(this), "f");
+    const pendingPromise = __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_fetchValidatedDexsInternal).call(this);
+    __classPrivateFieldSet(this, _HyperLiquidProvider_pendingValidatedDexsPromise, pendingPromise, "f");
     try {
-        const result = await __classPrivateFieldGet(this, _HyperLiquidProvider_pendingValidatedDexsPromise, "f");
+        const result = await pendingPromise;
         return result;
     }
     finally {
-        // Clear the pending promise when done (success or error)
-        __classPrivateFieldSet(this, _HyperLiquidProvider_pendingValidatedDexsPromise, null, "f");
+        // A stale request must not clear a newer lifecycle's pending request.
+        if (__classPrivateFieldGet(this, _HyperLiquidProvider_pendingValidatedDexsPromise, "f") === pendingPromise) {
+            __classPrivateFieldSet(this, _HyperLiquidProvider_pendingValidatedDexsPromise, null, "f");
+        }
     }
 }, _HyperLiquidProvider_fetchValidatedDexsInternal = 
 /**
@@ -5605,6 +6263,7 @@ async function _HyperLiquidProvider_getValidatedDexs() {
  * @returns A promise that resolves to the result.
  */
 async function _HyperLiquidProvider_fetchValidatedDexsInternal() {
+    const lifecycleGeneration = __classPrivateFieldGet(this, _HyperLiquidProvider_lifecycleGeneration, "f");
     // Kill switch: HIP-3 disabled, return main DEX only
     if (!__classPrivateFieldGet(this, _HyperLiquidProvider_hip3Enabled, "f")) {
         __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('HyperLiquidProvider: HIP-3 disabled via hip3Enabled flag');
@@ -5634,6 +6293,7 @@ async function _HyperLiquidProvider_fetchValidatedDexsInternal() {
         return [null];
     }
     // Atomically update unified state (raw + validated + timestamp)
+    __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_assertCacheWriteLifecycleCurrent).call(this, lifecycleGeneration, 'DEX discovery cache write');
     const state = __classPrivateFieldGet(this, _HyperLiquidProvider_dexDiscoveryCache, "f").update(allDexs);
     __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('HyperLiquidProvider: Available DEXs (market filtering applied at data layer)', {
         count: state.validated.filter((dex) => dex !== null).length,
@@ -5652,13 +6312,12 @@ async function _HyperLiquidProvider_fetchValidatedDexsInternal() {
  * @throws Error if API returns invalid data
  */
 async function _HyperLiquidProvider_getCachedMeta(params) {
+    const lifecycleGeneration = __classPrivateFieldGet(this, _HyperLiquidProvider_lifecycleGeneration, "f");
     const { dexName, skipCache } = params;
-    // Use empty string for main DEX key (consistent with buildAssetMapping cache population)
-    const dexKey = dexName ?? '';
-    const dexDisplayName = dexKey || 'main';
+    const dexDisplayName = dexName ?? 'main';
     // Skip cache if requested (forces fresh fetch)
     if (!skipCache) {
-        const cached = __classPrivateFieldGet(this, _HyperLiquidProvider_cachedMetaByDex, "f").get(dexKey);
+        const cached = __classPrivateFieldGet(this, _HyperLiquidProvider_cachedMetaByDex, "f").get(dexName);
         if (cached) {
             __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('[getCachedMeta] Using cached meta response', {
                 dex: dexDisplayName,
@@ -5668,6 +6327,29 @@ async function _HyperLiquidProvider_getCachedMeta(params) {
         }
     }
     // Cache miss or skipCache=true - fetch from API.
+    const meta = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_fetchMeta).call(this, dexName);
+    const cached = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_cacheDexMetadataFromRead).call(this, {
+        dex: dexName,
+        meta,
+        lifecycleGeneration,
+    });
+    if (cached) {
+        __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('[getCachedMeta] Fetched and cached meta response', {
+            dex: dexDisplayName,
+            universeSize: meta.universe.length,
+            skipCache,
+        });
+    }
+    return meta;
+}, _HyperLiquidProvider_fetchMeta = 
+/**
+ * Fetch and validate metadata without mutating provider caches.
+ *
+ * @param dexName - DEX name, or null for the main DEX.
+ * @returns Validated metadata for the requested DEX.
+ */
+async function _HyperLiquidProvider_fetchMeta(dexName) {
+    const dexDisplayName = dexName ?? 'main';
     // Bring the SDK clients up first. This is the first client touch on the
     // write path — placeOrder resolves asset info before it ensures trading
     // readiness — so without it a cold start or a post-disconnect action fails
@@ -5679,20 +6361,54 @@ async function _HyperLiquidProvider_getCachedMeta(params) {
     const infoClient = __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").getInfoClient({ useHttp: true });
     // Pass dex only for HIP-3 DEXs; omit for main DEX (empty string).
     // Testnet API returns null when dex="" is explicitly sent.
-    const meta = await infoClient.meta(dexKey ? { dex: dexKey } : undefined);
+    const meta = await infoClient.meta(dexName ? { dex: dexName } : undefined);
     // Defensive validation before caching
     if (!meta?.universe || !Array.isArray(meta.universe)) {
         throw new Error(`[HyperLiquidProvider] Invalid meta response for DEX ${dexDisplayName}: universe is ${meta?.universe ? 'not an array' : 'missing'}`);
     }
-    // Store raw meta response for reuse
-    __classPrivateFieldGet(this, _HyperLiquidProvider_cachedMetaByDex, "f").set(dexKey, meta);
-    await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_backfillAssetMapForDex).call(this, dexName, meta);
-    __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('[getCachedMeta] Fetched and cached meta response', {
-        dex: dexDisplayName,
-        universeSize: meta.universe.length,
-        skipCache,
-    });
     return meta;
+}, _HyperLiquidProvider_cacheDexMetadata = function _HyperLiquidProvider_cacheDexMetadata(params) {
+    const { dex, meta, assetCtxs, lifecycleGeneration } = params;
+    __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_assertCacheWriteLifecycleCurrent).call(this, lifecycleGeneration, 'DEX metadata cache write');
+    __classPrivateFieldGet(this, _HyperLiquidProvider_cachedMetaByDex, "f").set(dex, meta);
+    if (assetCtxs) {
+        const subscriptionDexKey = dex ?? '';
+        __classPrivateFieldGet(this, _HyperLiquidProvider_subscriptionService, "f").setDexMetaCache(subscriptionDexKey, meta);
+        __classPrivateFieldGet(this, _HyperLiquidProvider_subscriptionService, "f").setDexAssetCtxsCache(subscriptionDexKey, assetCtxs);
+    }
+}, _HyperLiquidProvider_cacheDexMetadataFromRead = 
+/**
+ * Cache metadata fetched for a read without discarding a valid response.
+ *
+ * @param params - Metadata and lifecycle context.
+ * @param params.dex - DEX name, or null for the main DEX.
+ * @param params.meta - Validated DEX metadata.
+ * @param params.assetCtxs - Asset contexts shared with subscriptions, if any.
+ * @param params.lifecycleGeneration - Lifecycle that produced the metadata.
+ * @returns Whether the fetched metadata was cached.
+ */
+async function _HyperLiquidProvider_cacheDexMetadataFromRead(params) {
+    const { dex, meta, assetCtxs, lifecycleGeneration } = params;
+    if (!__classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_isCacheWriteLifecycleCurrent).call(this, lifecycleGeneration, 'DEX metadata read cache write')) {
+        return false;
+    }
+    try {
+        __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_cacheDexMetadata).call(this, {
+            dex,
+            meta,
+            assetCtxs,
+            lifecycleGeneration,
+        });
+        await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_backfillAssetMapForDex).call(this, dex, meta, lifecycleGeneration);
+        return true;
+    }
+    catch (error) {
+        if (ensureError(error, 'HyperLiquidProvider.cacheDexMetadataFromRead')
+            .message === PERPS_ERROR_CODES.PROVIDER_LIFECYCLE_STALE) {
+            return false;
+        }
+        throw error;
+    }
 }, _HyperLiquidProvider_backfillAssetMapForDex = 
 /**
  * Backfill the asset ID map for a single DEX from a fresh meta response.
@@ -5700,9 +6416,11 @@ async function _HyperLiquidProvider_getCachedMeta(params) {
  *
  * @param dex - DEX name (null for main DEX).
  * @param meta - Meta response containing the DEX universe.
+ * @param lifecycleGeneration - Lifecycle that produced the metadata.
  * @returns True if the mapping was rebuilt for the DEX.
  */
-async function _HyperLiquidProvider_backfillAssetMapForDex(dex, meta) {
+async function _HyperLiquidProvider_backfillAssetMapForDex(dex, meta, lifecycleGeneration) {
+    __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_assertCacheWriteLifecycleCurrent).call(this, lifecycleGeneration, 'Asset map backfill');
     if (!meta?.universe || !Array.isArray(meta.universe)) {
         return false;
     }
@@ -5717,6 +6435,7 @@ async function _HyperLiquidProvider_backfillAssetMapForDex(dex, meta) {
             });
         }
     }
+    __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_assertCacheWriteLifecycleCurrent).call(this, lifecycleGeneration, 'Asset map backfill');
     const allPerpDexs = __classPrivateFieldGet(this, _HyperLiquidProvider_dexDiscoveryCache, "f").state?.raw ?? [null];
     const perpDexIndex = allPerpDexs.findIndex((entry) => {
         if (dex === null) {
@@ -5753,6 +6472,7 @@ async function _HyperLiquidProvider_backfillAssetMapForDex(dex, meta) {
  * @returns The asset ID.
  */
 async function _HyperLiquidProvider_getAssetIdWithRepair(params) {
+    const lifecycleGeneration = __classPrivateFieldGet(this, _HyperLiquidProvider_lifecycleGeneration, "f");
     const { symbol, dexName } = params;
     const existingAssetId = __classPrivateFieldGet(this, _HyperLiquidProvider_symbolToAssetId, "f").get(symbol);
     if (existingAssetId !== undefined) {
@@ -5761,7 +6481,7 @@ async function _HyperLiquidProvider_getAssetIdWithRepair(params) {
     const meta = params.meta ?? (await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getCachedMeta).call(this, { dexName: dexName ?? null }));
     const assetExistsInMeta = meta.universe.some((asset) => asset.name === symbol);
     if (assetExistsInMeta) {
-        await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_backfillAssetMapForDex).call(this, dexName, meta);
+        await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_backfillAssetMapForDex).call(this, dexName, meta, lifecycleGeneration);
         const repairedAssetId = __classPrivateFieldGet(this, _HyperLiquidProvider_symbolToAssetId, "f").get(symbol);
         if (repairedAssetId !== undefined) {
             return repairedAssetId;
@@ -5792,13 +6512,16 @@ async function _HyperLiquidProvider_getCachedSpotMeta() {
         });
         return __classPrivateFieldGet(this, _HyperLiquidProvider_cachedSpotMeta, "f");
     }
+    const lifecycleGeneration = __classPrivateFieldGet(this, _HyperLiquidProvider_lifecycleGeneration, "f");
     const infoClient = __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").getInfoClient();
     const spotMeta = await infoClient.spotMeta();
-    __classPrivateFieldSet(this, _HyperLiquidProvider_cachedSpotMeta, spotMeta, "f");
-    __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('[getCachedSpotMeta] Fetched and cached spotMeta', {
-        tokensCount: spotMeta.tokens.length,
-        universeCount: spotMeta.universe.length,
-    });
+    if (__classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_isCacheWriteLifecycleCurrent).call(this, lifecycleGeneration, 'Spot metadata cache write')) {
+        __classPrivateFieldSet(this, _HyperLiquidProvider_cachedSpotMeta, spotMeta, "f");
+        __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('[getCachedSpotMeta] Fetched and cached spotMeta', {
+            tokensCount: spotMeta.tokens.length,
+            universeCount: spotMeta.universe.length,
+        });
+    }
     return spotMeta;
 }, _HyperLiquidProvider_getCachedPerpDexs = 
 /**
@@ -5808,6 +6531,7 @@ async function _HyperLiquidProvider_getCachedSpotMeta() {
  * @returns Array of ExtendedPerpDex objects (null entries represent main DEX)
  */
 async function _HyperLiquidProvider_getCachedPerpDexs() {
+    const lifecycleGeneration = __classPrivateFieldGet(this, _HyperLiquidProvider_lifecycleGeneration, "f");
     const now = Date.now();
     // Return cached data if still valid (uses unified state timestamp for TTL)
     if (__classPrivateFieldGet(this, _HyperLiquidProvider_dexDiscoveryCache, "f").state &&
@@ -5825,17 +6549,19 @@ async function _HyperLiquidProvider_getCachedPerpDexs() {
     await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureClientsInitialized).call(this);
     const infoClient = __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").getInfoClient();
     const perpDexs = (await infoClient.perpDexs());
-    // Atomically update unified state (raw + validated + timestamp)
-    __classPrivateFieldGet(this, _HyperLiquidProvider_dexDiscoveryCache, "f").update(perpDexs);
-    __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('[getCachedPerpDexs] Fetched and cached perpDexs data', {
-        count: perpDexs.length,
-        dexes: perpDexs
-            .filter((dex) => dex !== null)
-            .map((dex) => ({
-            name: dex.name,
-            deployerFeeScale: dex.deployerFeeScale,
-        })),
-    });
+    if (__classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_isCacheWriteLifecycleCurrent).call(this, lifecycleGeneration, 'Perp DEX cache write')) {
+        // Atomically update unified state (raw + validated + timestamp)
+        __classPrivateFieldGet(this, _HyperLiquidProvider_dexDiscoveryCache, "f").update(perpDexs);
+        __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('[getCachedPerpDexs] Fetched and cached perpDexs data', {
+            count: perpDexs.length,
+            dexes: perpDexs
+                .filter((dex) => dex !== null)
+                .map((dex) => ({
+                name: dex.name,
+                deployerFeeScale: dex.deployerFeeScale,
+            })),
+        });
+    }
     return perpDexs;
 }, _HyperLiquidProvider_calculateHip3FeeMultiplier = 
 /**
@@ -6007,6 +6733,7 @@ async function _HyperLiquidProvider_isUsdcCollateralDex(dexName) {
  * the asset ID lookup succeeds and the order routes to the correct DEX.
  */
 async function _HyperLiquidProvider_buildAssetMapping() {
+    const lifecycleGeneration = __classPrivateFieldGet(this, _HyperLiquidProvider_lifecycleGeneration, "f");
     // Get feature-flag-validated DEXs to map (respects hip3Enabled and enabledDexs)
     let dexsToMap;
     try {
@@ -6037,14 +6764,14 @@ async function _HyperLiquidProvider_buildAssetMapping() {
     // Extract HIP-3 DEX names (filter out null which represents main DEX)
     const enabledDexs = dexsToMap.filter((dex) => dex !== null);
     await __classPrivateFieldGet(this, _HyperLiquidProvider_subscriptionService, "f").updateFeatureFlags(__classPrivateFieldGet(this, _HyperLiquidProvider_hip3Enabled, "f"), enabledDexs, __classPrivateFieldGet(this, _HyperLiquidProvider_allowlistMarkets, "f"), __classPrivateFieldGet(this, _HyperLiquidProvider_blocklistMarkets, "f"));
+    __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_assertCacheWriteLifecycleCurrent).call(this, lifecycleGeneration, 'Asset mapping rebuild');
     // Fetch metadata for each DEX in parallel using metaAndAssetCtxs
     // Optimization: Check cache first - getMarketDataWithPrices may have already fetched
     // If not cached, fetch via metaAndAssetCtxs and populate cache for other methods
     const infoClient = __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").getInfoClient();
     const allMetas = await Promise.allSettled(dexsToMap.map((dex) => {
-        const dexKey = dex ?? '';
         // Check if already cached (e.g., by getMarketDataWithPrices running in parallel)
-        const cachedMeta = __classPrivateFieldGet(this, _HyperLiquidProvider_cachedMetaByDex, "f").get(dexKey);
+        const cachedMeta = __classPrivateFieldGet(this, _HyperLiquidProvider_cachedMetaByDex, "f").get(dex);
         if (cachedMeta) {
             __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log(`[buildAssetMapping] Using cached meta for ${dex ?? 'main'}`, { universeSize: cachedMeta.universe.length });
             return Promise.resolve({
@@ -6062,11 +6789,12 @@ async function _HyperLiquidProvider_buildAssetMapping() {
             const assetCtxs = result?.[1] || [];
             // Cache meta for later use by getCachedMeta
             if (meta?.universe) {
-                __classPrivateFieldGet(this, _HyperLiquidProvider_cachedMetaByDex, "f").set(dexKey, meta);
-                // Also populate subscription service cache to avoid redundant API calls
-                __classPrivateFieldGet(this, _HyperLiquidProvider_subscriptionService, "f").setDexMetaCache(dexKey, meta);
-                // Cache assetCtxs for getMarketDataWithPrices (avoids duplicate metaAndAssetCtxs calls)
-                __classPrivateFieldGet(this, _HyperLiquidProvider_subscriptionService, "f").setDexAssetCtxsCache(dexKey, assetCtxs);
+                __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_cacheDexMetadata).call(this, {
+                    dex,
+                    meta,
+                    assetCtxs,
+                    lifecycleGeneration,
+                });
             }
             return { dex, meta, success: true };
         })
@@ -6075,6 +6803,7 @@ async function _HyperLiquidProvider_buildAssetMapping() {
             return { dex, meta: null, success: false };
         });
     }));
+    __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_assertCacheWriteLifecycleCurrent).call(this, lifecycleGeneration, 'Asset mapping rebuild');
     // Build mapping with DEX prefixes for HIP-3 DEXs using the utility function
     __classPrivateFieldGet(this, _HyperLiquidProvider_symbolToAssetId, "f").clear();
     let dexDiscoveryComplete = __classPrivateFieldGet(this, _HyperLiquidProvider_dexDiscoveryCache, "f").state !== null;
@@ -6246,12 +6975,16 @@ async function _HyperLiquidProvider_checkBuilderFeeApproval(builder, userAddress
  * This prevents repeated signing requests for hardware wallets.
  *
  * Note: This is network-specific - testnet and mainnet have separate builder fee states
+ *
+ * @param params - Builder fee setup context.
+ * @param params.network - HyperLiquid network for the approval.
+ * @param params.userAddress - Account that owns the approval.
+ * @param params.builderAddress - Builder address being approved.
  */
-async function _HyperLiquidProvider_ensureBuilderFeeApproval() {
-    const isTestnet = __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").isTestnetMode();
-    const network = isTestnet ? 'testnet' : 'mainnet';
-    const builderAddress = __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getBuilderAddress).call(this, isTestnet);
-    const userAddress = await __classPrivateFieldGet(this, _HyperLiquidProvider_walletService, "f").getUserAddressWithDefault();
+async function _HyperLiquidProvider_ensureBuilderFeeApproval(params) {
+    const lifecycleGeneration = __classPrivateFieldGet(this, _HyperLiquidProvider_lifecycleGeneration, "f");
+    const { network, userAddress, builderAddress } = params;
+    __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_assertProviderLifecycleCurrent).call(this, lifecycleGeneration, 'Builder fee approval');
     const cacheKey = __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getCacheKey).call(this, network, userAddress);
     // Check GLOBAL cache first to avoid repeated signing requests across reconnections
     // This is CRITICAL for hardware wallets to prevent repeated signing prompts
@@ -6268,6 +7001,11 @@ async function _HyperLiquidProvider_ensureBuilderFeeApproval() {
     if (inFlightPromise) {
         __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('[ensureBuilderFeeApproval] Global in-flight, waiting...', { network });
         await inFlightPromise;
+        const completedApproval = PerpsSigningCache.getBuilderFee(network, userAddress);
+        if (completedApproval?.attempted && completedApproval.success) {
+            __classPrivateFieldGet(this, _HyperLiquidProvider_builderFeeCheckCache, "f").set(cacheKey, true);
+            __classPrivateFieldGet(this, _HyperLiquidProvider_approvedBuilderAddresses, "f").add(__classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getApprovedBuilderKey).call(this, network, userAddress, builderAddress));
+        }
         return;
     }
     // Set global in-flight lock
@@ -6277,10 +7015,13 @@ async function _HyperLiquidProvider_ensureBuilderFeeApproval() {
         const recheckCache = PerpsSigningCache.getBuilderFee(network, userAddress);
         if (recheckCache?.attempted && recheckCache?.success) {
             __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('[ensureBuilderFeeApproval] Completed by another provider', { network });
+            __classPrivateFieldGet(this, _HyperLiquidProvider_builderFeeCheckCache, "f").set(cacheKey, true);
+            __classPrivateFieldGet(this, _HyperLiquidProvider_approvedBuilderAddresses, "f").add(__classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getApprovedBuilderKey).call(this, network, userAddress, builderAddress));
             completeInFlight();
             return;
         }
         const { isApproved, requiredDecimal } = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_checkBuilderFeeStatus).call(this, builderAddress, userAddress);
+        __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_assertProviderLifecycleCurrent).call(this, lifecycleGeneration, 'Builder fee approval');
         if (isApproved) {
             // User already has approval on-chain
             PerpsSigningCache.setBuilderFee(network, userAddress, {
@@ -6305,11 +7046,15 @@ async function _HyperLiquidProvider_ensureBuilderFeeApproval() {
                 afterApprovalDecimal < requiredDecimal) {
                 throw new Error('[HyperLiquidProvider] Builder fee approval verification failed');
             }
-            // Cache success in BOTH global and instance caches
+            // The approval is already confirmed on-chain. Preserve that fact for
+            // the next provider lifecycle even if this instance became stale while
+            // the approval request was in flight.
             PerpsSigningCache.setBuilderFee(network, userAddress, {
                 attempted: true,
                 success: true,
             });
+            __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_assertProviderLifecycleCurrent).call(this, lifecycleGeneration, 'Builder fee approval');
+            // Cache success in the current instance after the lifecycle check.
             __classPrivateFieldGet(this, _HyperLiquidProvider_builderFeeCheckCache, "f").set(cacheKey, true);
             __classPrivateFieldGet(this, _HyperLiquidProvider_approvedBuilderAddresses, "f").add(__classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getApprovedBuilderKey).call(this, network, userAddress, builderAddress));
             __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('[ensureBuilderFeeApproval] Approval successful', {
@@ -6320,6 +7065,11 @@ async function _HyperLiquidProvider_ensureBuilderFeeApproval() {
         completeInFlight();
     }
     catch (error) {
+        if (ensureError(error, 'HyperLiquidProvider.ensureBuilderFeeApproval')
+            .message === PERPS_ERROR_CODES.PROVIDER_LIFECYCLE_STALE) {
+            completeInFlight();
+            return;
+        }
         // HyperLiquid wraps wallet signing failures and preserves KEYRING_LOCKED
         // in `cause`, so classify the full chain and leave retry caches empty.
         if (isKeyringLockedError(error)) {
@@ -6657,6 +7407,7 @@ async function _HyperLiquidProvider_calculateHip3RequiredMargin(params) {
  * @param params.transferInfo - The transfer information.
  * @param params.transferInfo.amount - The amount value.
  * @param params.transferInfo.sourceDex - The source DEX for the transfer.
+ * @returns Whether the balance check and any required transfer succeeded.
  * @private
  */
 async function _HyperLiquidProvider_handleHip3PostOrderRebalance(params) {
@@ -6685,16 +7436,20 @@ async function _HyperLiquidProvider_handleHip3PostOrderRebalance(params) {
                     excessAmount: excessAmount.toFixed(2),
                     destinationDex: transferInfo.sourceDex,
                 });
-                await this.transferBetweenDexs({
+                const transferResult = await this.transferBetweenDexs({
                     sourceDex: dexName,
                     destinationDex: transferInfo.sourceDex,
                     amount: excessAmount.toFixed(USDC_DECIMALS),
                 });
+                if (!transferResult.success) {
+                    throw new Error(transferResult.error ?? PERPS_ERROR_CODES.TRANSFER_FAILED);
+                }
                 __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('✅ HyperLiquidProvider: Auto-rebalance completed', {
                     transferredBack: excessAmount.toFixed(2),
                     from: dexName,
                     to: transferInfo.sourceDex,
                 });
+                return true;
             }
             catch (rebalanceError) {
                 // Don't fail the order if rebalance fails (order already succeeded)
@@ -6703,6 +7458,7 @@ async function _HyperLiquidProvider_handleHip3PostOrderRebalance(params) {
                     excessAmount: excessAmount.toFixed(2),
                     note: 'Auto-rebalance failed - funds remain on HIP-3 DEX',
                 }));
+                return false;
             }
         }
         else {
@@ -6711,6 +7467,7 @@ async function _HyperLiquidProvider_handleHip3PostOrderRebalance(params) {
                 threshold: minimumTransferThreshold.toFixed(2),
                 note: 'Excess below minimum transfer threshold',
             });
+            return true;
         }
     }
     catch (balanceCheckError) {
@@ -6719,6 +7476,7 @@ async function _HyperLiquidProvider_handleHip3PostOrderRebalance(params) {
             dex: dexName,
             note: 'Failed to verify post-order balance for auto-rebalance',
         }));
+        return false;
     }
 }, _HyperLiquidProvider_handleHip3OrderRollback = 
 /**
@@ -6902,7 +7660,10 @@ async function _HyperLiquidProvider_handleHip3PreOrder(params) {
 async function _HyperLiquidProvider_submitOrderWithRollback(params) {
     const { orders, grouping, isHip3Order, dexName, transferInfo, symbol } = params;
     const exchangeClient = __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").getExchangeClient();
-    const builder = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getBuilderOrderContext).call(this);
+    const builder = params.chargesMetamaskBuilderFee
+        ? await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getBuilderOrderContext).call(this, params.builderFeeSetupContext ??
+            (await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureBuilderFeeSetup).call(this)))
+        : undefined;
     __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Submitting order via asset ID routing', {
         symbol,
         assetId: orders[0].a,
@@ -6915,7 +7676,7 @@ async function _HyperLiquidProvider_submitOrderWithRollback(params) {
         const result = await exchangeClient.order({
             orders,
             grouping,
-            builder,
+            ...(builder && { builder }),
         });
         if (result.status !== 'ok') {
             throw new Error(`Order failed: ${JSON.stringify(result)}`);
@@ -6990,18 +7751,22 @@ async function _HyperLiquidProvider_handleOrderError(params) {
 async function _HyperLiquidProvider_placeStrategyOrder(params, orderType) {
     // Captured before the shared preamble, not after it: that preamble awaits
     // asset info, validation, trading readiness and a leverage update, and a
-    // disconnect during any of them has to be seen by the chase registration
-    // at the end.
+    // disconnect during any of them has to be seen before or after submission.
+    const generation = __classPrivateFieldGet(this, _HyperLiquidProvider_strategyGeneration, "f");
     if (orderType !== 'chase') {
         const context = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_prepareStrategyPlacement).call(this, params);
-        return orderType === 'twap'
-            ? await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_placeTwapOrder).call(this, params, context)
-            : await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_placeScaleOrder).call(this, params, context);
+        return await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_submitPreparedStrategy).call(this, params, context, async () => {
+            if (generation !== __classPrivateFieldGet(this, _HyperLiquidProvider_strategyGeneration, "f")) {
+                throw new Error(PERPS_ERROR_CODES.PROVIDER_LIFECYCLE_STALE);
+            }
+            return orderType === 'twap'
+                ? await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_placeTwapOrder).call(this, params, context, generation)
+                : await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_placeScaleOrder).call(this, params, context, generation);
+        });
     }
     if (__classPrivateFieldGet(this, _HyperLiquidProvider_chasePlacementBlockers, "f") > 0) {
         throw new Error(PERPS_ERROR_CODES.ORDER_CHASE_ABANDONED);
     }
-    const generation = __classPrivateFieldGet(this, _HyperLiquidProvider_chaseGeneration, "f");
     // The chase slot is claimed before the preamble, not after it: the preamble
     // completes the signing setup and can change the asset's leverage, and a
     // request that is going to be refused for exceeding the venue's cap must
@@ -7023,7 +7788,7 @@ async function _HyperLiquidProvider_placeStrategyOrder(params, orderType) {
     try {
         await __classPrivateFieldGet(this, _HyperLiquidProvider_chaseTickQueue, "f");
         const context = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_prepareStrategyPlacement).call(this, params);
-        return await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_startChaseSession).call(this, params, context, generation);
+        return await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_submitPreparedStrategy).call(this, params, context, async () => await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_startChaseSession).call(this, params, context, generation));
     }
     finally {
         settlePlacement?.();
@@ -7033,6 +7798,74 @@ async function _HyperLiquidProvider_placeStrategyOrder(params, orderType) {
             __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_resumeChaseTicksAfterPlacement).call(this);
         }
     }
+}, _HyperLiquidProvider_submitPreparedStrategy = 
+/**
+ * Submit a prepared strategy and settle any manual HIP-3 collateral move.
+ *
+ * Scale and Chase leave regular orders or fills on the venue, so the normal
+ * HIP-3 post-order balance check can return any unreserved excess. Native
+ * TWAP executes future slices, so its transferred collateral stays on the
+ * routed DEX until cancellation confirms the schedule has stopped.
+ *
+ * @param params - Strategy order parameters.
+ * @param context - Prepared placement and HIP-3 transfer context.
+ * @param submit - Venue submission.
+ * @returns The strategy placement result.
+ */
+async function _HyperLiquidProvider_submitPreparedStrategy(params, context, submit) {
+    const { dexName, network, transferInfo, userAddress } = context;
+    let result;
+    try {
+        result = await submit();
+    }
+    catch (error) {
+        if (dexName && transferInfo) {
+            await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_handleHip3OrderRollback).call(this, { dexName, transferInfo });
+        }
+        throw error;
+    }
+    const hasVenueExposure = result.success === true ||
+        result.orderId !== undefined ||
+        (result.childOrderIds?.length ?? 0) > 0;
+    if (dexName && transferInfo && !hasVenueExposure) {
+        await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_handleHip3OrderRollback).call(this, { dexName, transferInfo });
+        return result;
+    }
+    if (params.orderType === 'twap' && result.orderId) {
+        __classPrivateFieldGet(this, _HyperLiquidProvider_trackedTwapOrders, "f").set(getTwapOrderScopeKey({
+            network,
+            userAddress,
+            orderId: result.orderId,
+        }), {
+            symbol: params.symbol,
+            ...(dexName && transferInfo
+                ? { hip3Transfer: { dexName, transferInfo } }
+                : {}),
+        });
+        return result;
+    }
+    if (params.orderType === 'chase' &&
+        result.success &&
+        result.orderId &&
+        dexName &&
+        transferInfo) {
+        const session = __classPrivateFieldGet(this, _HyperLiquidProvider_chaseSessions, "f").get(result.orderId);
+        if (session) {
+            session.hip3Transfer = { dexName, transferInfo };
+            return result;
+        }
+    }
+    if (params.orderType === 'chase' && hasVenueExposure) {
+        // A stale placement can fail after its child rests and the best-effort
+        // retraction is refused. With no session left to own that child, keep
+        // manual HIP-3 collateral on its DEX until the caller cancels the
+        // reported exchange ID.
+        return result;
+    }
+    if (dexName && transferInfo) {
+        await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_handleHip3PostOrderRebalance).call(this, { dexName, transferInfo });
+    }
+    return result;
 }, _HyperLiquidProvider_prepareStrategyPlacement = 
 /**
  * Run the shared preamble every strategy placement needs.
@@ -7046,13 +7879,6 @@ async function _HyperLiquidProvider_placeStrategyOrder(params, orderType) {
  */
 async function _HyperLiquidProvider_prepareStrategyPlacement(params) {
     const { dex: dexName } = parseAssetName(params.symbol);
-    // A HIP-3 order is preceded by a margin transfer onto the builder DEX and
-    // followed by a rebalance, both of which are wired into the single-order
-    // submit path and its rollback. Rather than half-support that here, a
-    // strategy placement on a HIP-3 market is refused outright.
-    if (dexName !== null) {
-        throw new Error(PERPS_ERROR_CODES.ORDER_STRATEGY_MARKET_UNSUPPORTED);
-    }
     const { assetInfo, currentPrice, meta } = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getAssetInfo).call(this, {
         symbol: params.symbol,
         dexName,
@@ -7113,7 +7939,10 @@ async function _HyperLiquidProvider_prepareStrategyPlacement(params) {
     }
     // Kept after validation so an invalid strategy order never triggers the
     // signature prompts in trading setup — same ordering as `placeOrder`.
-    await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureReadyForTrading).call(this);
+    const { chargesMetamaskBuilderFee } = __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_resolveOrderFeePolicy).call(this, params);
+    const builderFeeSetupContext = chargesMetamaskBuilderFee
+        ? await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureReadyForTrading).call(this, { requiresBuilderFee: true })
+        : await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureReadyForTrading).call(this, { requiresBuilderFee: false });
     const assetId = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getAssetIdWithRepair).call(this, {
         symbol: params.symbol,
         dexName,
@@ -7124,12 +7953,38 @@ async function _HyperLiquidProvider_prepareStrategyPlacement(params) {
         assetId,
         leverage: params.leverage,
     });
+    const builder = builderFeeSetupContext
+        ? await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getBuilderOrderContext).call(this, builderFeeSetupContext)
+        : undefined;
+    const network = __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").isTestnetMode() ? 'testnet' : 'mainnet';
+    const userAddress = builderFeeSetupContext?.userAddress ??
+        (await __classPrivateFieldGet(this, _HyperLiquidProvider_walletService, "f").getUserAddressWithDefault());
+    let transferInfo = null;
+    if (dexName) {
+        const orderPrice = ladder === undefined
+            ? effectivePrice
+            : Math.max(...ladder.prices.map(Number.parseFloat));
+        const hip3Result = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_handleHip3PreOrder).call(this, {
+            dexName,
+            symbol: params.symbol,
+            orderPrice,
+            positionSize: parseFloat(formattedSize),
+            leverage: params.leverage ?? assetInfo.maxLeverage ?? 1,
+            isBuy: params.isBuy,
+            maxLeverage: assetInfo.maxLeverage,
+        });
+        transferInfo = hip3Result.transferInfo;
+    }
     return {
         assetId,
         szDecimals: assetInfo.szDecimals,
-        finalPositionSize,
         formattedSize,
         ladder,
+        builder,
+        dexName,
+        network,
+        transferInfo,
+        userAddress,
     };
 }, _HyperLiquidProvider_getMinimumOrderSize = function _HyperLiquidProvider_getMinimumOrderSize() {
     return __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").isTestnetMode()
@@ -7137,11 +7992,17 @@ async function _HyperLiquidProvider_prepareStrategyPlacement(params) {
         : TRADING_DEFAULTS.amount.mainnet;
 }, _HyperLiquidProvider_buildScaleLadder = function _HyperLiquidProvider_buildScaleLadder(options) {
     const { params, szDecimals, finalPositionSize } = options;
-    const count = params.scaleNumOrders;
+    const { scaleMinPrice, scaleMaxPrice, scaleNumOrders } = params;
+    if (scaleMinPrice === undefined || scaleMaxPrice === undefined) {
+        throw new Error(PERPS_ERROR_CODES.ORDER_SCALE_RANGE_REQUIRED);
+    }
+    if (scaleNumOrders === undefined) {
+        throw new Error(PERPS_ERROR_CODES.ORDER_SCALE_COUNT_INVALID);
+    }
     const prices = computeScalePriceLadder({
-        minPrice: parseFloat(params.scaleMinPrice),
-        maxPrice: parseFloat(params.scaleMaxPrice),
-        count,
+        minPrice: parseFloat(scaleMinPrice),
+        maxPrice: parseFloat(scaleMaxPrice),
+        count: scaleNumOrders,
     }).map((price) => formatHyperLiquidPrice({ price, szDecimals }));
     if (new Set(prices).size !== prices.length) {
         throw new Error(PERPS_ERROR_CODES.ORDER_SCALE_RANGE_INVALID);
@@ -7150,7 +8011,7 @@ async function _HyperLiquidProvider_prepareStrategyPlacement(params) {
     // which a skew weighted far enough from even can do on its own.
     const sizes = splitScaleSizes({
         totalSize: finalPositionSize,
-        count,
+        count: scaleNumOrders,
         szDecimals,
         skew: params.scaleSkew,
     });
@@ -7170,16 +8031,26 @@ async function _HyperLiquidProvider_prepareStrategyPlacement(params) {
  *
  * @param params - Order parameters.
  * @param context - Prepared asset and sizing context.
+ * @param generation - Teardown generation captured before preparation.
  * @returns A promise that resolves to the result.
  */
-async function _HyperLiquidProvider_placeTwapOrder(params, context) {
+async function _HyperLiquidProvider_placeTwapOrder(params, context, generation) {
     const { assetId, formattedSize } = context;
+    const durationMinutes = params.twapDuration;
+    if (durationMinutes === undefined) {
+        throw new Error(PERPS_ERROR_CODES.ORDER_TWAP_DURATION_REQUIRED);
+    }
+    if (!Number.isSafeInteger(durationMinutes) ||
+        durationMinutes < HYPERLIQUID_TWAP_LIMITS.MinDurationMinutes ||
+        durationMinutes > HYPERLIQUID_TWAP_LIMITS.MaxDurationMinutes) {
+        throw new Error(PERPS_ERROR_CODES.ORDER_TWAP_DURATION_INVALID);
+    }
     const exchangeClient = __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").getExchangeClient();
     __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Submitting TWAP order', {
         symbol: params.symbol,
         assetId,
         size: formattedSize,
-        durationMinutes: params.twapDuration,
+        durationMinutes,
         randomize: params.twapRandomize ?? false,
     });
     const result = await exchangeClient.twapOrder({
@@ -7188,9 +8059,7 @@ async function _HyperLiquidProvider_placeTwapOrder(params, context) {
             b: params.isBuy,
             s: formattedSize,
             r: params.reduceOnly ?? false,
-            // Validation has already established this is a whole number of minutes
-            // inside the venue's bounds.
-            m: params.twapDuration,
+            m: durationMinutes,
             t: params.twapRandomize ?? false,
         },
     });
@@ -7198,15 +8067,44 @@ async function _HyperLiquidProvider_placeTwapOrder(params, context) {
         throw new Error(`TWAP order failed: ${JSON.stringify(result)}`);
     }
     const status = result.response?.data?.status;
-    if (!isStatusObject(status) || !hasProperty(status, 'running')) {
-        const rawError = status?.error ??
-            'TWAP order rejected';
+    if (!isStatusObject(status)) {
+        throw new Error('TWAP order rejected');
+    }
+    const rawError = typeof status.error === 'string' ? status.error : 'TWAP order rejected';
+    const { running } = status;
+    if (!isStatusObject(running) ||
+        typeof running.twapId !== 'number' ||
+        !Number.isSafeInteger(running.twapId) ||
+        running.twapId < 0) {
         throw new Error(rawError);
     }
-    const running = status.running;
+    const orderId = running.twapId.toString();
+    if (generation !== __classPrivateFieldGet(this, _HyperLiquidProvider_strategyGeneration, "f")) {
+        let remainsLive = true;
+        try {
+            const cancelResult = await exchangeClient.twapCancel({
+                a: assetId,
+                t: running.twapId,
+            });
+            remainsLive =
+                classifyCancelStatus(cancelResult.response?.data?.status) ===
+                    CancelChildOutcome.Refused;
+        }
+        catch (error) {
+            __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Stale TWAP placement could not be retracted', {
+                error: ensureError(error, 'HyperLiquidProvider.placeTwapOrder.retract').message,
+                orderId,
+            });
+        }
+        return createErrorResult(new Error(PERPS_ERROR_CODES.PROVIDER_LIFECYCLE_STALE), {
+            success: false,
+            submittedSize: formattedSize,
+            ...(remainsLive && { orderId }),
+        });
+    }
     return {
         success: true,
-        orderId: running.twapId.toString(),
+        orderId,
         submittedSize: formattedSize,
     };
 }, _HyperLiquidProvider_placeScaleOrder = 
@@ -7215,22 +8113,25 @@ async function _HyperLiquidProvider_placeTwapOrder(params, context) {
  *
  * The whole ladder goes in a single `order` action, which is one round trip
  * and one signature rather than one per rung. It is **not** atomic: an `na`
- * grouping evaluates each entry independently, so the response can report
- * some rungs resting and others rejected. A partial ladder is reported as
- * such — `submittedSize` covers only the rungs that actually rested — rather
- * than as a full submission.
+ * grouping evaluates each entry independently. Every rung must either rest
+ * or fill; otherwise all known resting rungs are retracted before failure.
  *
  * @param params - Order parameters.
  * @param context - Prepared asset and sizing context.
+ * @param generation - Teardown generation captured before preparation.
  * @returns A promise that resolves to the result.
  */
-async function _HyperLiquidProvider_placeScaleOrder(params, context) {
-    const { assetId, szDecimals, formattedSize, ladder } = context;
+async function _HyperLiquidProvider_placeScaleOrder(params, context, generation) {
+    const { assetId, formattedSize, ladder, builder } = context;
     // Built and validated in `#prepareStrategyPlacement`, before anything was
     // signed, so what is submitted here is exactly what the minimums were
     // applied to.
+    if (!ladder) {
+        throw new Error(PERPS_ERROR_CODES.ORDER_SCALE_RANGE_REQUIRED);
+    }
     const { prices, sizes } = ladder;
     const count = prices.length;
+    const { groupId, clientOrderIds } = createScaleOrderIdentity(count);
     const orders = prices.map((price, index) => ({
         a: assetId,
         b: params.isBuy,
@@ -7238,6 +8139,7 @@ async function _HyperLiquidProvider_placeScaleOrder(params, context) {
         s: sizes[index],
         r: params.reduceOnly ?? false,
         t: { limit: { tif: 'Gtc' } },
+        c: clientOrderIds[index],
     }));
     __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Submitting scale ladder', {
         symbol: params.symbol,
@@ -7250,50 +8152,81 @@ async function _HyperLiquidProvider_placeScaleOrder(params, context) {
     const result = await exchangeClient.order({
         orders,
         grouping: 'na',
-        builder: await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getBuilderOrderContext).call(this),
+        ...(builder && { builder }),
     });
-    if (result.status !== 'ok') {
-        throw new Error(`Scale order failed: ${JSON.stringify(result)}`);
-    }
     const statuses = result.response?.data?.statuses ?? [];
-    // Which rung each ID came from matters: `submittedSize` has to add up the
-    // slices that actually rested, not the total that was asked for.
-    const restedRungs = statuses
-        .map((status, index) => ({
-        orderId: __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_readOrderIdFromStatus).call(this, status),
-        size: sizes[index],
-    }))
-        .filter((rung) => rung.orderId !== undefined);
-    // A ladder that came back with no IDs at all rested nothing; reporting it
-    // as a success would hand the caller a handle that cancels nothing.
-    if (restedRungs.length === 0) {
-        throw new Error(`Scale order rejected: ${JSON.stringify(result.response?.data)}`);
-    }
-    const childOrderIds = restedRungs.map((rung) => rung.orderId);
-    const groupId = generatePerpsId('scale');
-    __classPrivateFieldGet(this, _HyperLiquidProvider_scaleOrderGroups, "f").set(groupId, { assetId, orderIds: childOrderIds });
-    // The batch is not atomic, so a ladder can come back part-rested. Reporting
-    // the requested total as submitted would tell the caller they are exposed
-    // for more than they are.
-    const isPartial = restedRungs.length < count;
-    if (isPartial) {
-        __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Scale ladder only partly rested', {
-            groupId,
-            rested: restedRungs.length,
+    const outcomes = statuses
+        .slice(0, count)
+        .map((status) => __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_readOrderPlacementOutcome).call(this, status));
+    const acceptedCount = outcomes.filter((outcome) => outcome !== undefined).length;
+    const restingChildOrderIds = outcomes.flatMap((outcome) => outcome?.state === 'resting' ? [outcome.orderId] : []);
+    const filledChildOrderIds = outcomes.flatMap((outcome) => outcome?.state === 'filled' ? [outcome.orderId] : []);
+    if (generation !== __classPrivateFieldGet(this, _HyperLiquidProvider_strategyGeneration, "f")) {
+        const remainingOrderIds = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_cancelOrderRequests).call(this, exchangeClient, restingChildOrderIds.map((orderId) => ({
+            a: assetId,
+            o: Number(orderId),
+        })));
+        const recoverableOrderIds = [
+            ...filledChildOrderIds,
+            ...remainingOrderIds.map(String),
+        ];
+        return createErrorResult(new Error(PERPS_ERROR_CODES.PROVIDER_LIFECYCLE_STALE), {
+            success: false,
+            submittedSize: formattedSize,
+            ...(recoverableOrderIds.length > 0 && {
+                childOrderIds: recoverableOrderIds,
+            }),
+        });
+    }
+    if (result.status !== 'ok' ||
+        statuses.length !== count ||
+        acceptedCount !== count) {
+        __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Scale ladder was not fully accepted', {
+            accepted: acceptedCount,
+            filled: filledChildOrderIds.length,
+            resting: restingChildOrderIds.length,
             requested: count,
             statuses,
         });
+        const remainingOrderIds = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_cancelOrderRequests).call(this, exchangeClient, restingChildOrderIds.map((orderId) => ({
+            a: assetId,
+            o: Number(orderId),
+        })));
+        const recoverableOrderIds = [
+            ...filledChildOrderIds,
+            ...remainingOrderIds.map(String),
+        ];
+        if (remainingOrderIds.length > 0) {
+            const remainingRestingOrderIds = remainingOrderIds.map(String);
+            __classPrivateFieldGet(this, _HyperLiquidProvider_scaleOrderGroups, "f").set(groupId, {
+                symbol: params.symbol,
+                orderIds: remainingRestingOrderIds,
+            });
+            return createErrorResult(new Error(PERPS_ERROR_CODES.ORDER_STRATEGY_CANCEL_INCOMPLETE), {
+                success: false,
+                orderId: groupId,
+                childOrderIds: recoverableOrderIds,
+                submittedSize: formattedSize,
+            });
+        }
+        if (recoverableOrderIds.length > 0) {
+            return createErrorResult(new Error(PERPS_ERROR_CODES.ORDER_REJECTED), {
+                success: false,
+                childOrderIds: recoverableOrderIds,
+                submittedSize: formattedSize,
+            });
+        }
+        throw new Error(PERPS_ERROR_CODES.ORDER_REJECTED);
     }
+    __classPrivateFieldGet(this, _HyperLiquidProvider_scaleOrderGroups, "f").set(groupId, {
+        symbol: params.symbol,
+        orderIds: restingChildOrderIds,
+    });
     return {
         success: true,
         orderId: groupId,
-        childOrderIds,
-        submittedSize: isPartial
-            ? formatHyperLiquidSize({
-                size: restedRungs.reduce((total, rung) => total + parseFloat(rung.size), 0),
-                szDecimals,
-            })
-            : formattedSize,
+        childOrderIds: restingChildOrderIds,
+        submittedSize: formattedSize,
     };
 }, _HyperLiquidProvider_startChaseSession = 
 /**
@@ -7308,12 +8241,12 @@ async function _HyperLiquidProvider_placeScaleOrder(params, context) {
  * @returns A promise that resolves to the result.
  */
 async function _HyperLiquidProvider_startChaseSession(params, context, generation) {
-    const { assetId, szDecimals, formattedSize } = context;
+    const { assetId, szDecimals, formattedSize, builder } = context;
     // The preamble is several round trips long. A disconnect during it has
     // already torn down everything this session would run on, so the chase
     // stops here rather than reading the book and putting a fresh order on it
     // for a provider that no longer exists.
-    if (generation !== __classPrivateFieldGet(this, _HyperLiquidProvider_chaseGeneration, "f")) {
+    if (generation !== __classPrivateFieldGet(this, _HyperLiquidProvider_strategyGeneration, "f")) {
         throw new Error(PERPS_ERROR_CODES.ORDER_CHASE_ABANDONED);
     }
     let quotePrice = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getChaseQuotePrice).call(this, {
@@ -7321,8 +8254,9 @@ async function _HyperLiquidProvider_startChaseSession(params, context, generatio
         isBuy: params.isBuy,
         szDecimals,
     });
-    if (quotePrice === 'gone') {
-        // No own order to be gone on a first placement; narrows the union.
+    if (quotePrice === CHASE_ORDER_STATUS_UNAVAILABLE ||
+        typeof quotePrice !== 'string') {
+        // A first placement has no child whose terminal state could be read.
         throw new Error(PERPS_ERROR_CODES.ORDER_CHASE_TOUCH_UNAVAILABLE);
     }
     // The book read is a round trip of its own, so the check above does not
@@ -7331,12 +8265,7 @@ async function _HyperLiquidProvider_startChaseSession(params, context, generatio
     // before the next one, leaving one window that cannot be closed from here
     // — a disconnect arriving while the submission itself is in flight, which
     // the check after it handles.
-    if (generation !== __classPrivateFieldGet(this, _HyperLiquidProvider_chaseGeneration, "f")) {
-        throw new Error(PERPS_ERROR_CODES.ORDER_CHASE_ABANDONED);
-    }
-    // Read once, while the caller's fee-source context is still set.
-    const builder = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getBuilderOrderContext).call(this);
-    if (generation !== __classPrivateFieldGet(this, _HyperLiquidProvider_chaseGeneration, "f")) {
+    if (generation !== __classPrivateFieldGet(this, _HyperLiquidProvider_strategyGeneration, "f")) {
         throw new Error(PERPS_ERROR_CODES.ORDER_CHASE_ABANDONED);
     }
     // Held onto rather than looked up again after the submission returns.
@@ -7354,8 +8283,7 @@ async function _HyperLiquidProvider_startChaseSession(params, context, generatio
                 price: quotePrice,
                 size: formattedSize,
                 reduceOnly: params.reduceOnly ?? false,
-                builderFee: builder.f,
-                builderAddress: builder.b,
+                builder,
                 exchangeClient: placingClient,
             });
             break;
@@ -7365,7 +8293,7 @@ async function _HyperLiquidProvider_startChaseSession(params, context, generatio
                 !isRetryableChasePlacementError(error)) {
                 throw error;
             }
-            if (generation !== __classPrivateFieldGet(this, _HyperLiquidProvider_chaseGeneration, "f")) {
+            if (generation !== __classPrivateFieldGet(this, _HyperLiquidProvider_strategyGeneration, "f")) {
                 throw new Error(PERPS_ERROR_CODES.ORDER_CHASE_ABANDONED);
             }
             const refreshedQuote = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getChaseQuotePrice).call(this, {
@@ -7373,10 +8301,11 @@ async function _HyperLiquidProvider_startChaseSession(params, context, generatio
                 isBuy: params.isBuy,
                 szDecimals,
             });
-            if (refreshedQuote === 'gone') {
+            if (refreshedQuote === CHASE_ORDER_STATUS_UNAVAILABLE ||
+                typeof refreshedQuote !== 'string') {
                 throw new Error(PERPS_ERROR_CODES.ORDER_CHASE_TOUCH_UNAVAILABLE);
             }
-            if (generation !== __classPrivateFieldGet(this, _HyperLiquidProvider_chaseGeneration, "f")) {
+            if (generation !== __classPrivateFieldGet(this, _HyperLiquidProvider_strategyGeneration, "f")) {
                 throw new Error(PERPS_ERROR_CODES.ORDER_CHASE_ABANDONED);
             }
             quotePrice = refreshedQuote;
@@ -7404,11 +8333,11 @@ async function _HyperLiquidProvider_startChaseSession(params, context, generatio
         maxDistanceBps: params.chaseMaxDistanceBps,
         intervalMs,
         lastSnapshotSizeRefreshAt: 0,
-        builderFee: builder.f,
-        builderAddress: builder.b,
-        deadline: Date.now() +
-            (params.chaseMaxDurationMs ?? CHASE_ORDER_CONFIG.DefaultMaxDurationMs),
-        maxRepricings: params.chaseMaxRepricings ?? CHASE_ORDER_CONFIG.DefaultMaxRepricings,
+        builder,
+        deadline: params.chaseMaxDurationMs === undefined
+            ? Number.POSITIVE_INFINITY
+            : Date.now() + params.chaseMaxDurationMs,
+        maxRepricings: params.chaseMaxRepricings ?? Number.POSITIVE_INFINITY,
         repricings: 0,
         timer: null,
         active: true,
@@ -7427,7 +8356,7 @@ async function _HyperLiquidProvider_startChaseSession(params, context, generatio
     // and the failure is then true of the venue as well as of this provider.
     // Best-effort still: the transport underneath that client may already be
     // closing, so a cancel that does not land falls back to reporting the id.
-    if (generation !== __classPrivateFieldGet(this, _HyperLiquidProvider_chaseGeneration, "f")) {
+    if (generation !== __classPrivateFieldGet(this, _HyperLiquidProvider_strategyGeneration, "f")) {
         __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Chase placement outlived its provider', {
             orderId,
             restingPrice: quotePrice,
@@ -7439,7 +8368,9 @@ async function _HyperLiquidProvider_startChaseSession(params, context, generatio
             // that is no longer on the book would send the caller to cancel
             // something already gone; naming one that still rests is the only
             // route left to it.
-            ...(outcome === 'refused' ? { childOrderIds: [orderId] } : {}),
+            ...(outcome === CancelChildOutcome.Refused
+                ? { childOrderIds: [orderId] }
+                : {}),
             submittedSize: formattedSize,
         });
     }
@@ -7475,8 +8406,8 @@ async function _HyperLiquidProvider_startChaseSession(params, context, generatio
  * @param params.own.orderId - Exchange ID of that order.
  * @param params.own.price - Price that order rests at.
  * @param params.own.size - Size it was last placed for.
- * @returns The formatted price the chase should rest at, or `'gone'` when the
- * order it was chasing is no longer live.
+ * @returns The formatted price, a terminal child result, or the status
+ * unavailable sentinel when the child may still be live.
  */
 async function _HyperLiquidProvider_getChaseQuotePrice(params) {
     const { symbol, isBuy, szDecimals, own } = params;
@@ -7491,8 +8422,9 @@ async function _HyperLiquidProvider_getChaseQuotePrice(params) {
         callerOrderId: own?.orderId,
         ownSide,
     });
-    if (netting === 'gone') {
-        return 'gone';
+    if (netting === CHASE_ORDER_STATUS_UNAVAILABLE ||
+        !(netting instanceof Map)) {
+        return netting;
     }
     const bestBid = readBestExternalPrice(book?.levels?.[0], netting);
     const bestAsk = readBestExternalPrice(book?.levels?.[1], netting);
@@ -7510,9 +8442,7 @@ async function _HyperLiquidProvider_getChaseQuotePrice(params) {
  * @param params.price - Formatted limit price.
  * @param params.size - Formatted size.
  * @param params.reduceOnly - Whether the order may only reduce a position.
- * @param params.builderFee - Builder fee, in tenths of a basis point, captured
- * when the session started so replacements keep the rate they were quoted at.
- * @param params.builderAddress - Builder address captured with the fee.
+ * @param params.builder - Builder context captured when the session started.
  * @param params.exchangeClient - Client to submit through. Passed in rather
  * than looked up here so a first placement can keep the instance it signed
  * with, which is the only one that can take the order back once `disconnect`
@@ -7534,10 +8464,7 @@ async function _HyperLiquidProvider_restChaseOrder(params) {
             },
         ],
         grouping: 'na',
-        builder: {
-            b: params.builderAddress,
-            f: params.builderFee,
-        },
+        ...(params.builder && { builder: params.builder }),
     });
     if (result.status !== 'ok') {
         throw new Error(`Chase order failed: ${JSON.stringify(result)}`);
@@ -7549,25 +8476,21 @@ async function _HyperLiquidProvider_restChaseOrder(params) {
     return orderId;
 }, _HyperLiquidProvider_scheduleChaseTick = function _HyperLiquidProvider_scheduleChaseTick(sessionId) {
     const session = __classPrivateFieldGet(this, _HyperLiquidProvider_chaseSessions, "f").get(sessionId);
-    if (!session?.active) {
+    if (!session?.active || session.timer !== null) {
         return;
     }
     const timer = setTimeout(() => {
         session.timer = null;
-        __classPrivateFieldSet(this, _HyperLiquidProvider_chaseTickQueue, __classPrivateFieldGet(this, _HyperLiquidProvider_chaseTickQueue, "f").then(async () => {
-            // A rejected tick must not stop the session from being cancellable, and
-            // must not surface as an unhandled rejection either.
-            try {
-                await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_runChaseTick).call(this, sessionId);
-            }
-            catch (error) {
-                __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Chase tick failed', {
-                    sessionId,
-                    error: ensureError(error, 'HyperLiquidProvider.chaseTick').message,
-                });
-                __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_recoverFailedChaseTick).call(this, sessionId);
-            }
-            return undefined;
+        __classPrivateFieldSet(this, _HyperLiquidProvider_chaseTickQueue, __classPrivateFieldGet(this, _HyperLiquidProvider_chaseTickQueue, "f")
+            .then(() => __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_runChaseTick).call(this, sessionId))
+            .catch((error) => {
+            // Resolve the shared queue after every failure. Otherwise one
+            // rejected tick prevents all later ticks and teardown from running.
+            __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Chase tick failed', {
+                sessionId,
+                error: ensureError(error, 'HyperLiquidProvider.chaseTick').message,
+            });
+            __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_recoverFailedChaseTick).call(this, sessionId);
         }), "f");
     }, session.intervalMs);
     // Node keeps the process alive for a pending timer; a background chase is
@@ -7599,6 +8522,12 @@ async function _HyperLiquidProvider_restChaseOrder(params) {
         __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Chase ended with nothing resting', {
             sessionId,
         });
+        __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_rebalanceChaseSession).call(this, session).catch((error) => {
+            __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Chase collateral cleanup failed', {
+                sessionId,
+                error: ensureError(error, 'HyperLiquidProvider.recoverFailedChaseTick').message,
+            });
+        });
         return;
     }
     __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_scheduleChaseTick).call(this, sessionId);
@@ -7632,6 +8561,7 @@ async function _HyperLiquidProvider_runChaseTick(sessionId) {
         session.active = false;
         session.status = CHASE_ORDER_STATUS.DurationReached;
         __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Chase session window closed', { sessionId });
+        await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_rebalanceChaseSession).call(this, session);
         return;
     }
     const rawQuotePrice = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getChaseQuotePrice).call(this, {
@@ -7646,16 +8576,29 @@ async function _HyperLiquidProvider_runChaseTick(sessionId) {
             }
             : undefined,
     });
-    if (rawQuotePrice === 'gone') {
-        // The order left the book without the loop seeing it — it filled. Ending
-        // here releases its slot against the venue's concurrency cap instead of
-        // holding one until the window closes.
+    if (typeof rawQuotePrice !== 'string') {
+        // The order left the book without the loop seeing it. Preserve the venue
+        // status so an external cancellation is not reported as a fill.
         session.orderId = null;
         session.active = false;
-        session.status = CHASE_ORDER_STATUS.Filled;
-        __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Chase order filled between ticks', {
+        session.status = rawQuotePrice.status;
+        session.size = rawQuotePrice.remainingSize ?? '0';
+        __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Chase order ended between ticks', {
+            sessionId,
+            status: session.status,
+        });
+        await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_rebalanceChaseSession).call(this, session);
+        return;
+    }
+    if (rawQuotePrice === CHASE_ORDER_STATUS_UNAVAILABLE) {
+        // The child may still be live. Leave it untouched and retry on the next
+        // normal interval instead of permanently stranding the Chase after one
+        // short status outage.
+        __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Chase order status unavailable', {
             sessionId,
+            orderId: session.orderId,
         });
+        __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_scheduleChaseTick).call(this, sessionId);
         return;
     }
     const arrivalPrice = Number.parseFloat(session.arrivalPrice);
@@ -7713,12 +8656,12 @@ async function _HyperLiquidProvider_runChaseTick(sessionId) {
             // A refused cancel leaves the child resting. Preserve its ID so the
             // caller that stopped this session can report an incomplete cancel and
             // retry it instead of orphaning the order.
-            if (outcome !== 'refused') {
+            if (outcome !== CancelChildOutcome.Refused) {
                 session.orderId = null;
             }
             return;
         }
-        if (outcome === 'refused') {
+        if (outcome === CancelChildOutcome.Refused) {
             // The exchange kept the order, so it is still resting at the old price.
             // Placing the replacement anyway would double the position. Leave it
             // alone and try again on the next tick, which is why this falls through
@@ -7729,25 +8672,36 @@ async function _HyperLiquidProvider_runChaseTick(sessionId) {
             });
             reachedMaxDistance = false;
         }
-        else if (outcome === 'gone') {
+        else if (outcome === CancelChildOutcome.Gone) {
             // The order left the book between ticks: it filled, or something else
             // cancelled it. There is nothing left to chase.
             const goneOrderId = session.orderId;
-            const remaining = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_readOrderRemainder).call(this, goneOrderId);
             session.orderId = null;
             session.active = false;
-            session.status =
-                remaining === null
-                    ? CHASE_ORDER_STATUS.Filled
-                    : CHASE_ORDER_STATUS.Failed;
-            if (remaining !== null) {
-                session.size = remaining;
+            let remainder;
+            try {
+                remainder = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_readOrderRemainder).call(this, goneOrderId, CHASE_ORDER_STATUS_RETRY_COUNT);
+            }
+            catch (error) {
+                session.status = CHASE_ORDER_STATUS.Failed;
+                __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Chase order status unavailable', {
+                    sessionId,
+                    orderId: goneOrderId,
+                    error: ensureError(error, 'HyperLiquidProvider.chaseGoneOrderStatus').message,
+                });
+                await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_rebalanceChaseSession).call(this, session);
+                return;
+            }
+            session.status = remainder.terminalStatus ?? CHASE_ORDER_STATUS.Failed;
+            if (remainder.remainingSize !== null) {
+                session.size = remainder.remainingSize;
             }
             __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Chase order no longer resting', {
                 sessionId,
                 status: session.status,
                 remainingSize: session.size,
             });
+            await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_rebalanceChaseSession).call(this, session);
             return;
         }
         else {
@@ -7761,25 +8715,44 @@ async function _HyperLiquidProvider_runChaseTick(sessionId) {
             // No further fills can reach a cancelled order, so what it did not fill
             // is now fixed. Sampling before the cancel would have left a window in
             // which a fill lands and is then re-placed.
-            const remaining = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_readOrderRemainder).call(this, cancelledOrderId);
+            let remainder;
+            try {
+                remainder = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_readOrderRemainder).call(this, cancelledOrderId, CHASE_ORDER_STATUS_RETRY_COUNT);
+            }
+            catch (error) {
+                session.replacingOrderId = null;
+                throw error;
+            }
             // Another round trip, another window for a cancel to land. By now the
             // old order is already off the book, so a cancel that arrived during it
             // found nothing to cancel and reported success — resting a replacement
             // after that would put an order on the book the caller believes is gone
             // and has no handle for.
             if (!session.active || !__classPrivateFieldGet(this, _HyperLiquidProvider_chaseSessions, "f").has(sessionId)) {
+                session.replacingOrderId = null;
                 __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Chase cancelled mid-reprice', {
                     sessionId,
                 });
                 return;
             }
-            if (remaining === null) {
-                // It filled completely between ticks; there is nothing left to chase.
+            if (remainder.remainingSize === null ||
+                (remainder.terminalStatus !== null &&
+                    remainder.terminalStatus !== CHASE_ORDER_STATUS.Canceled)) {
+                // Nothing is left to chase. Preserve whether the venue actually
+                // confirmed a fill rather than labelling every zero remainder filled.
+                session.replacingOrderId = null;
                 session.active = false;
-                session.status = CHASE_ORDER_STATUS.Filled;
-                __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Chase order fully filled', { sessionId });
+                session.size = remainder.remainingSize ?? '0';
+                session.status =
+                    remainder.terminalStatus ?? CHASE_ORDER_STATUS.Failed;
+                __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Chase order has no remainder', {
+                    sessionId,
+                    status: session.status,
+                });
+                await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_rebalanceChaseSession).call(this, session);
                 return;
             }
+            const remaining = remainder.remainingSize;
             // Published *before* the placement starts, not from the promise it
             // returns: the window opens the moment `#restChaseOrder` is entered, so
             // deriving the marker from its return value would leave the synchronous
@@ -7798,8 +8771,7 @@ async function _HyperLiquidProvider_runChaseTick(sessionId) {
                     price: quotePrice,
                     size: remaining,
                     reduceOnly: session.reduceOnly,
-                    builderFee: session.builderFee,
-                    builderAddress: session.builderAddress,
+                    builder: session.builder,
                     // A running session is on a live provider, so the current client is
                     // the right one; only the first placement has a teardown to survive.
                     exchangeClient: __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").getExchangeClient(),
@@ -7837,7 +8809,7 @@ async function _HyperLiquidProvider_runChaseTick(sessionId) {
             }
         }
     }
-    if (reachedMaxDistance) {
+    if (reachedMaxDistance && session.maxDistanceBps !== undefined) {
         session.active = false;
         session.status = CHASE_ORDER_STATUS.MaxDistanceReached;
         __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Chase max distance reached', {
@@ -7845,12 +8817,24 @@ async function _HyperLiquidProvider_runChaseTick(sessionId) {
             restingPrice: session.restingPrice,
             maxDistanceBps: session.maxDistanceBps,
         });
+        __classPrivateFieldGet(this, _HyperLiquidProvider_onChaseOrderMaxDistanceReached, "f")?.call(this, {
+            handle: sessionId,
+            symbol: session.symbol,
+            side: session.isBuy ? 'buy' : 'sell',
+            restingOrderId: session.orderId,
+            restingPrice: session.restingPrice,
+            maxDistanceBps: session.maxDistanceBps,
+            timestamp: Date.now(),
+            providerId: PROVIDER_CONFIG.DefaultProvider,
+        });
+        await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_rebalanceChaseSession).call(this, session);
         return;
     }
     if (session.repricings >= session.maxRepricings) {
         session.active = false;
         session.status = CHASE_ORDER_STATUS.RepricingLimitReached;
         __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Chase repricing cap reached', { sessionId });
+        await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_rebalanceChaseSession).call(this, session);
         return;
     }
     __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_scheduleChaseTick).call(this, sessionId);
@@ -7873,21 +8857,24 @@ async function _HyperLiquidProvider_runChaseTick(sessionId) {
  * @param params.isBuy - Side being quoted.
  * @param params.callerOrderId - The asking session's order, if it has one.
  * @param params.ownSide - The side of the book those orders rest on.
- * @returns Our resting size at each price, or `'gone'` when the asking
- * session's own order is no longer live.
+ * @returns Our resting size at each price, the asking child's terminal
+ * result, or the unavailable sentinel.
  */
 async function _HyperLiquidProvider_resolveOwnRestingSizes(params) {
     const { symbol, isBuy, callerOrderId, ownSide } = params;
     // Every chase this provider is running on this side, the caller included.
-    const ourOrders = [...__classPrivateFieldGet(this, _HyperLiquidProvider_chaseSessions, "f").values()]
-        .filter((session) => session.orderId !== null &&
-        session.symbol === symbol &&
-        session.isBuy === isBuy)
-        .map((session) => ({
-        orderId: session.orderId,
-        price: session.restingPrice,
-        size: session.size,
-    }));
+    const ourOrders = [];
+    for (const session of __classPrivateFieldGet(this, _HyperLiquidProvider_chaseSessions, "f").values()) {
+        if (session.orderId !== null &&
+            session.symbol === symbol &&
+            session.isBuy === isBuy) {
+            ourOrders.push({
+                orderId: session.orderId,
+                price: session.restingPrice,
+                size: session.size,
+            });
+        }
+    }
     if (ourOrders.length === 0) {
         return new Map();
     }
@@ -7904,27 +8891,44 @@ async function _HyperLiquidProvider_resolveOwnRestingSizes(params) {
         const level = ownSide?.find((entry) => entry.px === order.price);
         return !level || parseFloat(level.sz) <= (recorded.get(order.price) ?? 0);
     });
-    let callerIsGone = false;
-    for (const order of ambiguous) {
-        try {
-            const live = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_readOrderRemainder).call(this, order.orderId);
+    let callerTerminalResult = null;
+    let callerStatusUnavailable = false;
+    const resolutions = await Promise.allSettled(ambiguous.map((order) => __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_readOrderRemainder).call(this, order.orderId, CHASE_ORDER_STATUS_RETRY_COUNT)));
+    resolutions.forEach((resolution, index) => {
+        const order = ambiguous[index];
+        if (resolution.status === 'fulfilled') {
+            const { remainingSize: live, terminalStatus } = resolution.value;
             const delta = (live === null ? 0 : parseFloat(live)) - parseFloat(order.size);
             recorded.set(order.price, Math.max(0, (recorded.get(order.price) ?? 0) + delta));
-            if (live === null && order.orderId === callerOrderId) {
-                callerIsGone = true;
+            if (terminalStatus !== null && order.orderId === callerOrderId) {
+                callerTerminalResult = {
+                    remainingSize: live,
+                    status: terminalStatus,
+                };
             }
         }
-        catch (error) {
-            // A failed lookup must not stop the chase. Keeping the recorded size can
-            // only over-subtract, which quotes a level deeper rather than leaving
-            // the order stranded at a stale price.
-            __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Chase own-size lookup failed', {
-                orderId: order.orderId,
-                error: ensureError(error, 'HyperLiquidProvider.chaseOwnSize').message,
-            });
+        else {
+            const { reason: error } = resolution;
+            if (error instanceof ChaseOrderStatusUnavailableError &&
+                order.orderId === callerOrderId) {
+                callerStatusUnavailable = true;
+            }
+            else {
+                // A failed lookup must not stop the chase. Keeping the recorded size
+                // can only over-subtract, which quotes a level deeper rather than
+                // leaving the order stranded at a stale price.
+                __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Chase own-size lookup failed', {
+                    orderId: order.orderId,
+                    error: ensureError(error, 'HyperLiquidProvider.chaseOwnSize')
+                        .message,
+                });
+            }
         }
+    });
+    if (callerStatusUnavailable) {
+        return CHASE_ORDER_STATUS_UNAVAILABLE;
     }
-    return callerIsGone ? 'gone' : recorded;
+    return callerTerminalResult ?? recorded;
 }, _HyperLiquidProvider_readOrderRemainder = 
 /**
  * Read what a chase's just-cancelled order left unfilled.
@@ -7940,19 +8944,51 @@ async function _HyperLiquidProvider_resolveOwnRestingSizes(params) {
  * window in which a fill lands and is then re-placed on top.
  *
  * @param orderId - Exchange ID of the order that was just cancelled.
- * @returns The unfilled size, or null when nothing is left to chase.
+ * @param unknownStatusRetries - Remaining retries for a transient unknown ID.
+ * @returns The unfilled size and exact terminal status, when present.
  */
-async function _HyperLiquidProvider_readOrderRemainder(orderId) {
+async function _HyperLiquidProvider_readOrderRemainder(orderId, unknownStatusRetries = 0) {
     const userAddress = await __classPrivateFieldGet(this, _HyperLiquidProvider_walletService, "f").getUserAddressWithDefault();
     const status = await __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").getInfoClient().orderStatus({
         user: userAddress,
         oid: parseInt(orderId, 10),
     });
     if (status.status !== 'order') {
-        return null;
+        // unknownOid can be transient while the order-status index catches up.
+        // Treating it as a fill would drop the only handle to a live order.
+        if (unknownStatusRetries > 0) {
+            await new Promise((resolve) => setTimeout(resolve, CHASE_ORDER_STATUS_RETRY_DELAY_MS));
+            return await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_readOrderRemainder).call(this, orderId, unknownStatusRetries - 1);
+        }
+        throw new ChaseOrderStatusUnavailableError();
     }
     const remaining = String(status.order.order.sz);
-    return parseFloat(remaining) > 0 ? remaining : null;
+    const remainingSize = parseFloat(remaining) > 0 ? remaining : null;
+    switch (status.order.status) {
+        case 'open':
+        case 'triggered':
+            return { remainingSize, terminalStatus: null };
+        case 'filled':
+            return {
+                remainingSize: null,
+                terminalStatus: CHASE_ORDER_STATUS.Filled,
+            };
+        case 'canceled':
+            return remainingSize === null
+                ? {
+                    remainingSize: null,
+                    terminalStatus: CHASE_ORDER_STATUS.Filled,
+                }
+                : {
+                    remainingSize,
+                    terminalStatus: CHASE_ORDER_STATUS.Canceled,
+                };
+        default:
+            return {
+                remainingSize,
+                terminalStatus: CHASE_ORDER_STATUS.Failed,
+            };
+    }
 }, _HyperLiquidProvider_cancelChaseChild = 
 /**
  * Cancel the order a chase session currently has resting.
@@ -7965,7 +9001,7 @@ async function _HyperLiquidProvider_readOrderRemainder(orderId) {
  */
 async function _HyperLiquidProvider_cancelChaseChild(session, placingClient) {
     if (!session.orderId) {
-        return 'gone';
+        return CancelChildOutcome.Gone;
     }
     // Looked up only once there is something to cancel, so a session with
     // nothing resting still answers on a provider whose client is already gone.
@@ -7979,7 +9015,7 @@ async function _HyperLiquidProvider_cancelChaseChild(session, placingClient) {
     catch (error) {
         const message = ensureError(error, 'HyperLiquidProvider.cancelChaseChild').message.toLowerCase();
         if (ALREADY_GONE_CANCEL_MARKERS.some((marker) => message.includes(marker))) {
-            return 'gone';
+            return CancelChildOutcome.Gone;
         }
         throw error;
     }
@@ -8014,19 +9050,194 @@ async function _HyperLiquidProvider_retractOrphanedChaseOrder(session, placingCl
             error: ensureError(error, 'HyperLiquidProvider.startChaseSession')
                 .message,
         });
-        return 'refused';
+        return CancelChildOutcome.Refused;
     }
 }, _HyperLiquidProvider_stopChaseSession = function _HyperLiquidProvider_stopChaseSession(sessionId) {
     const session = __classPrivateFieldGet(this, _HyperLiquidProvider_chaseSessions, "f").get(sessionId);
     if (!session) {
         return;
     }
+    const wasActive = session.active;
     session.active = false;
-    session.status = CHASE_ORDER_STATUS.TerminationPending;
+    if (wasActive) {
+        session.status = CHASE_ORDER_STATUS.TerminationPending;
+    }
     if (session.timer) {
         clearTimeout(session.timer);
         session.timer = null;
     }
+}, _HyperLiquidProvider_rebalanceChaseSession = 
+/**
+ * Rebalance one Chase session at most once at a time. Failed cleanup keeps
+ * the transfer context so a later lifecycle read or cancel can retry it.
+ *
+ * @param session - Chase session whose manual HIP-3 transfer is complete.
+ * @returns Whether no collateral cleanup remains for the session.
+ */
+async function _HyperLiquidProvider_rebalanceChaseSession(session) {
+    const { hip3Transfer } = session;
+    if (!hip3Transfer) {
+        return true;
+    }
+    if (session.orderId !== null ||
+        session.replacingOrderId !== null ||
+        session.pendingReplacement !== null) {
+        return false;
+    }
+    let rebalancePromise = session.hip3RebalancePromise;
+    if (!rebalancePromise) {
+        rebalancePromise = __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_handleHip3PostOrderRebalance).call(this, hip3Transfer);
+        session.hip3RebalancePromise = rebalancePromise;
+    }
+    try {
+        const success = await rebalancePromise;
+        if (success && session.hip3Transfer === hip3Transfer) {
+            delete session.hip3Transfer;
+        }
+        return success;
+    }
+    finally {
+        if (session.hip3RebalancePromise === rebalancePromise) {
+            delete session.hip3RebalancePromise;
+        }
+    }
+}, _HyperLiquidProvider_adaptTwapOrder = function _HyperLiquidProvider_adaptTwapOrder(params) {
+    const { historyEntry, now } = params;
+    const { state, twapId } = historyEntry;
+    if (twapId === undefined || !Number.isSafeInteger(twapId) || twapId < 0) {
+        return null;
+    }
+    const totalSize = new BigNumber(state.sz);
+    const executedSize = new BigNumber(state.executedSz);
+    const executedNotional = new BigNumber(state.executedNtl);
+    if (!totalSize.isFinite() ||
+        !executedSize.isFinite() ||
+        !executedNotional.isFinite() ||
+        !Number.isFinite(state.timestamp) ||
+        !Number.isFinite(historyEntry.time) ||
+        !Number.isFinite(state.minutes)) {
+        return null;
+    }
+    let boundedExecutedSize = executedSize;
+    if (executedSize.isLessThan(0)) {
+        boundedExecutedSize = new BigNumber(0);
+    }
+    else if (executedSize.isGreaterThan(totalSize)) {
+        boundedExecutedSize = totalSize;
+    }
+    const rawRemainingSize = totalSize.minus(boundedExecutedSize);
+    const remainingSize = rawRemainingSize.isGreaterThan(0)
+        ? rawRemainingSize
+        : new BigNumber(0);
+    const status = resolveTwapOrderStatus(historyEntry, boundedExecutedSize, totalSize);
+    const fills = params.sliceFills
+        .map(adaptTwapOrderFill)
+        .sort((left, right) => left.timestamp - right.timestamp);
+    const startedAt = state.timestamp;
+    const historyUpdatedAt = normalizeTwapHistoryTimestamp(historyEntry.time);
+    const lastUpdated = Math.max(startedAt, historyUpdatedAt, ...fills.map((fill) => fill.timestamp));
+    const durationMilliseconds = state.minutes * MILLISECONDS_PER_MINUTE;
+    const elapsedTimeMilliseconds = Math.min(durationMilliseconds, Math.max(0, (status === PerpsTwapLifecycleStatus.Active ? now : lastUpdated) -
+        startedAt));
+    const fillProgressBps = totalSize.isGreaterThan(0)
+        ? boundedExecutedSize
+            .dividedBy(totalSize)
+            .multipliedBy(BASIS_POINTS_DIVISOR)
+            .integerValue(BigNumber.ROUND_FLOOR)
+            .toNumber()
+        : 0;
+    const timeProgressBps = durationMilliseconds > 0
+        ? Math.floor((elapsedTimeMilliseconds / durationMilliseconds) *
+            BASIS_POINTS_DIVISOR)
+        : 0;
+    return {
+        orderId: twapId.toString(),
+        symbol: state.coin,
+        side: state.side === 'B' ? 'buy' : 'sell',
+        size: state.sz,
+        executedSize: boundedExecutedSize.toString(),
+        remainingSize: remainingSize.toFixed(),
+        executedNotional: state.executedNtl,
+        ...(executedSize.isGreaterThan(0) && {
+            averagePrice: executedNotional.dividedBy(executedSize).toFixed(),
+        }),
+        fillProgressBps,
+        timeProgressBps,
+        elapsedTimeMilliseconds,
+        durationMinutes: state.minutes,
+        randomize: state.randomize,
+        reduceOnly: state.reduceOnly,
+        status,
+        startedAt,
+        lastUpdated,
+        ...(historyEntry.status.status ===
+            HyperLiquidTwapLifecycleStatus.Failed && {
+            error: historyEntry.status.description,
+        }),
+        fills,
+    };
+}, _HyperLiquidProvider_rebalanceTrackedTwapOrder = 
+/**
+ * Rebalance one tracked TWAP at most once at a time. A failed transfer keeps
+ * the tracking entry so the next lifecycle read or cancel can retry it.
+ *
+ * @param trackingKey - Account-scoped TWAP tracking key.
+ * @returns Whether no cleanup remains for the entry.
+ */
+async function _HyperLiquidProvider_rebalanceTrackedTwapOrder(trackingKey) {
+    const trackedOrder = __classPrivateFieldGet(this, _HyperLiquidProvider_trackedTwapOrders, "f").get(trackingKey);
+    if (!trackedOrder) {
+        return true;
+    }
+    if (!trackedOrder.hip3Transfer) {
+        if (__classPrivateFieldGet(this, _HyperLiquidProvider_trackedTwapOrders, "f").get(trackingKey) === trackedOrder) {
+            __classPrivateFieldGet(this, _HyperLiquidProvider_trackedTwapOrders, "f").delete(trackingKey);
+        }
+        return true;
+    }
+    let { rebalancePromise } = trackedOrder;
+    if (!rebalancePromise) {
+        rebalancePromise = __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_handleHip3PostOrderRebalance).call(this, trackedOrder.hip3Transfer);
+        trackedOrder.rebalancePromise = rebalancePromise;
+    }
+    try {
+        const success = await rebalancePromise;
+        if (success &&
+            __classPrivateFieldGet(this, _HyperLiquidProvider_trackedTwapOrders, "f").get(trackingKey) === trackedOrder) {
+            __classPrivateFieldGet(this, _HyperLiquidProvider_trackedTwapOrders, "f").delete(trackingKey);
+        }
+        return success;
+    }
+    finally {
+        if (__classPrivateFieldGet(this, _HyperLiquidProvider_trackedTwapOrders, "f").get(trackingKey) === trackedOrder &&
+            trackedOrder.rebalancePromise === rebalancePromise) {
+            delete trackedOrder.rebalancePromise;
+        }
+    }
+}, _HyperLiquidProvider_rebalanceTerminalHip3Twaps = 
+/**
+ * Return manually moved HIP-3 collateral after a TWAP reaches a terminal
+ * venue state. The scoped registry survives reconnects so an active schedule
+ * cannot lose its eventual cleanup path.
+ *
+ * @param orders - Current and historical TWAP lifecycle records.
+ * @param scope - Current account and network identity.
+ */
+async function _HyperLiquidProvider_rebalanceTerminalHip3Twaps(orders, scope) {
+    for (const order of orders) {
+        if (order.status === PerpsTwapLifecycleStatus.Active) {
+            continue;
+        }
+        const trackingKey = getTwapOrderScopeKey({
+            ...scope,
+            orderId: order.orderId,
+        });
+        const trackedOrder = __classPrivateFieldGet(this, _HyperLiquidProvider_trackedTwapOrders, "f").get(trackingKey);
+        if (trackedOrder?.symbol !== order.symbol) {
+            continue;
+        }
+        await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_rebalanceTrackedTwapOrder).call(this, trackingKey);
+    }
 }, _HyperLiquidProvider_cancelStrategyOrder = 
 /**
  * Cancel a strategy placement by its handle.
@@ -8073,21 +9284,64 @@ async function _HyperLiquidProvider_cancelTwapOrder(params) {
     if (!coinValidation.isValid) {
         throw new Error(coinValidation.error);
     }
-    await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureReadyForTrading).call(this);
+    const twapId = Number(params.orderId);
+    if (!/^\d+$/u.test(params.orderId) || !Number.isSafeInteger(twapId)) {
+        throw new Error(PERPS_ERROR_CODES.ORDER_STRATEGY_HANDLE_UNKNOWN);
+    }
+    await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureReadyForTrading).call(this, { requiresBuilderFee: false });
+    const network = __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").isTestnetMode() ? 'testnet' : 'mainnet';
+    const userAddress = await __classPrivateFieldGet(this, _HyperLiquidProvider_walletService, "f").getUserAddressWithDefault();
+    const trackingKey = getTwapOrderScopeKey({
+        network,
+        userAddress,
+        orderId: params.orderId,
+    });
+    const trackedOrder = __classPrivateFieldGet(this, _HyperLiquidProvider_trackedTwapOrders, "f").get(trackingKey);
+    let ownershipAuthenticated = trackedOrder !== undefined;
+    if (trackedOrder) {
+        if (trackedOrder.symbol !== params.symbol) {
+            throw new Error(PERPS_ERROR_CODES.ORDER_STRATEGY_HANDLE_UNKNOWN);
+        }
+    }
+    else {
+        let venueOrders = null;
+        try {
+            venueOrders = await this.getTwapOrders();
+        }
+        catch (error) {
+            // History is an ownership check, not the cancellation transport. A
+            // transient read failure must not make a live TWAP impossible to stop.
+            __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('TWAP history unavailable before cancellation', {
+                orderId: params.orderId,
+                error: ensureError(error, 'HyperLiquidProvider.cancelTwapOrderHistory').message,
+            });
+        }
+        const venueOrder = venueOrders?.find((order) => order.orderId === params.orderId);
+        if (venueOrders !== null && venueOrder?.symbol !== params.symbol) {
+            throw new Error(PERPS_ERROR_CODES.ORDER_STRATEGY_HANDLE_UNKNOWN);
+        }
+        ownershipAuthenticated = venueOrder !== undefined;
+    }
     const assetId = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getAssetIdWithRepair).call(this, {
         symbol: params.symbol,
         dexName: parseAssetName(params.symbol).dex,
     });
     const result = await __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").getExchangeClient().twapCancel({
         a: assetId,
-        t: parseInt(params.orderId, 10),
+        t: twapId,
     });
     const status = result.response?.data?.status;
-    if (status === 'success') {
+    const cancelOutcome = classifyCancelStatus(status);
+    if (cancelOutcome === CancelChildOutcome.Gone && !ownershipAuthenticated) {
+        throw new Error(PERPS_ERROR_CODES.ORDER_STRATEGY_HANDLE_UNKNOWN);
+    }
+    if (cancelOutcome !== CancelChildOutcome.Refused) {
+        await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_rebalanceTrackedTwapOrder).call(this, trackingKey);
         return { success: true, orderId: params.orderId };
     }
-    const rawError = status?.error ??
-        'TWAP cancellation failed';
+    const rawError = isStatusObject(status) && typeof status.error === 'string'
+        ? status.error
+        : 'TWAP cancellation failed';
     return createErrorResult(__classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_mapError).call(this, new Error(rawError)), {
         success: false,
         orderId: params.orderId,
@@ -8104,19 +9358,25 @@ async function _HyperLiquidProvider_cancelScaleOrder(params) {
     if (!group) {
         throw new Error(PERPS_ERROR_CODES.ORDER_STRATEGY_HANDLE_UNKNOWN);
     }
-    await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureReadyForTrading).call(this);
-    const result = await __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").getExchangeClient().cancel({
-        cancels: group.orderIds.map((orderId) => ({
-            a: group.assetId,
-            o: parseInt(orderId, 10),
-        })),
+    await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureReadyForTrading).call(this, { requiresBuilderFee: false });
+    const assetId = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getAssetIdWithRepair).call(this, {
+        symbol: group.symbol,
+        dexName: parseAssetName(group.symbol).dex,
     });
-    const statuses = result.response?.data?.statuses ?? [];
-    // A rung that filled or was cancelled individually comes back as a
-    // rejection, but nothing of it is resting — counting it as still live would
-    // pin the handle open for a ladder that is entirely off the book.
-    const remaining = group.orderIds.filter((_unused, index) => classifyCancelStatus(statuses[index]) === 'refused');
+    const exchangeClient = __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").getExchangeClient();
+    const cancelRequests = group.orderIds.map((orderId) => ({
+        a: assetId,
+        o: Number(orderId),
+    }));
+    const remaining = (await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_cancelOrderRequests).call(this, exchangeClient, cancelRequests)).map(String);
+    /*
+     * A rung that filled or was cancelled individually comes back as a
+     * rejection, but nothing of it is resting. The shared cancellation helper
+     * distinguishes that result from a refusal while retaining every child
+     * after a malformed or non-ok batch response.
+     */
     if (remaining.length === 0) {
+        __classPrivateFieldGet(this, _HyperLiquidProvider_cancelledScaleOrderGroups, "f").add(params.orderId);
         __classPrivateFieldGet(this, _HyperLiquidProvider_scaleOrderGroups, "f").delete(params.orderId);
         return { success: true, orderId: params.orderId };
     }
@@ -8124,7 +9384,7 @@ async function _HyperLiquidProvider_cancelScaleOrder(params) {
     // handle registered against what is left means the caller can retry the
     // same cancel rather than being told the ladder is gone when it is not.
     __classPrivateFieldGet(this, _HyperLiquidProvider_scaleOrderGroups, "f").set(params.orderId, {
-        assetId: group.assetId,
+        symbol: group.symbol,
         orderIds: remaining,
     });
     __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Scale group cancel left children resting', {
@@ -8185,39 +9445,120 @@ async function _HyperLiquidProvider_performChaseTermination(params) {
     // Nothing rests: the order filled, something else cancelled it, or a
     // replacement failed to go up. Either way the session ends cleanly.
     if (session.orderId === null) {
-        __classPrivateFieldGet(this, _HyperLiquidProvider_chaseSessions, "f").delete(params.orderId);
+        session.removeAfterRebalance = true;
+        if (await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_rebalanceChaseSession).call(this, session)) {
+            __classPrivateFieldGet(this, _HyperLiquidProvider_chaseSessions, "f").delete(params.orderId);
+        }
         return { success: true, orderId: params.orderId };
     }
-    await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureReadyForTrading).call(this);
+    await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureReadyForTrading).call(this, { requiresBuilderFee: false });
     // Only a refusal leaves an order behind. A child that had already filled or
     // been cancelled is reported as a rejection too, but nothing of it is
     // resting — treating that as a failure would pin the handle open forever on
     // a chase that is entirely finished.
     const cancelOutcome = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_cancelChaseChild).call(this, session);
-    if (cancelOutcome === 'refused') {
+    if (cancelOutcome === CancelChildOutcome.Refused) {
         // The order is still resting. The session stays registered — stopped, but
         // still cancellable — so the caller can retry with the same handle.
         __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Chase cancel left its order resting', {
             sessionId: params.orderId,
             orderId: session.orderId,
         });
+        await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_rebalanceChaseSession).call(this, session);
         return createErrorResult(new Error(PERPS_ERROR_CODES.ORDER_STRATEGY_CANCEL_INCOMPLETE), { success: false, orderId: params.orderId });
     }
-    __classPrivateFieldGet(this, _HyperLiquidProvider_chaseSessions, "f").delete(params.orderId);
+    session.orderId = null;
+    session.status = CHASE_ORDER_STATUS.Canceled;
+    session.removeAfterRebalance = true;
+    if (await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_rebalanceChaseSession).call(this, session)) {
+        __classPrivateFieldGet(this, _HyperLiquidProvider_chaseSessions, "f").delete(params.orderId);
+    }
     return { success: true, orderId: params.orderId };
-}, _HyperLiquidProvider_readOrderIdFromStatus = function _HyperLiquidProvider_readOrderIdFromStatus(status) {
+}, _HyperLiquidProvider_cancelOrderRequests = 
+/**
+ * Cancel a batch and retain every order that may still be live.
+ *
+ * A malformed, truncated, or rejected response cannot prove which requests
+ * reached the venue, so every requested ID remains recoverable for a retry.
+ *
+ * @param exchangeClient - Client that owns the orders.
+ * @param requests - Venue cancel requests.
+ * @returns Order IDs that may still be resting.
+ */
+async function _HyperLiquidProvider_cancelOrderRequests(exchangeClient, requests) {
+    return (await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_cancelOrderRequestBatch).call(this, exchangeClient, requests))
+        .remainingOrderIds;
+}, _HyperLiquidProvider_cancelOrderRequestBatch = 
+/**
+ * Cancel a batch while distinguishing confirmed cancellations from orders
+ * that were already gone. Replacement rollback may only restore the former.
+ *
+ * @param exchangeClient - Client that owns the orders.
+ * @param requests - Venue cancel requests.
+ * @returns IDs that may still rest and IDs this call confirmed it cancelled.
+ */
+async function _HyperLiquidProvider_cancelOrderRequestBatch(exchangeClient, requests) {
+    if (requests.length === 0) {
+        return {
+            remainingOrderIds: [],
+            cancelledOrderIds: [],
+            responseComplete: true,
+        };
+    }
+    try {
+        const result = await exchangeClient.cancel({ cancels: requests });
+        const statuses = result.response?.data?.statuses ?? [];
+        if (result.status !== 'ok' || statuses.length !== requests.length) {
+            return {
+                remainingOrderIds: requests.map((request) => request.o),
+                cancelledOrderIds: [],
+                responseComplete: false,
+            };
+        }
+        const remainingOrderIds = [];
+        const cancelledOrderIds = [];
+        requests.forEach((request, index) => {
+            const outcome = classifyCancelStatus(statuses[index]);
+            if (outcome === CancelChildOutcome.Refused) {
+                remainingOrderIds.push(request.o);
+            }
+            else if (outcome === CancelChildOutcome.Cancelled) {
+                cancelledOrderIds.push(request.o);
+            }
+        });
+        return { remainingOrderIds, cancelledOrderIds, responseComplete: true };
+    }
+    catch (error) {
+        __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Order cancellation batch failed', {
+            error: ensureError(error, 'HyperLiquidProvider.cancelOrderRequests')
+                .message,
+            orderIds: requests.map((request) => request.o),
+        });
+        return {
+            remainingOrderIds: requests.map((request) => request.o),
+            cancelledOrderIds: [],
+            responseComplete: false,
+        };
+    }
+}, _HyperLiquidProvider_readOrderPlacementOutcome = function _HyperLiquidProvider_readOrderPlacementOutcome(status) {
     if (!isStatusObject(status)) {
         return undefined;
     }
-    // `hasProperty` types the property as `unknown`, so each branch is cast to
-    // the only shape the exchange puts there.
-    const restingOrder = hasProperty(status, 'resting')
-        ? status.resting
-        : undefined;
-    const filledOrder = hasProperty(status, 'filled')
-        ? status.filled
-        : undefined;
-    return (restingOrder?.oid?.toString() ?? filledOrder?.oid?.toString() ?? undefined);
+    for (const state of ['resting', 'filled']) {
+        if (!hasProperty(status, state)) {
+            continue;
+        }
+        const order = status[state];
+        if (isStatusObject(order) &&
+            typeof order.oid === 'number' &&
+            Number.isSafeInteger(order.oid) &&
+            order.oid >= 0) {
+            return { orderId: order.oid.toString(), state };
+        }
+    }
+    return undefined;
+}, _HyperLiquidProvider_readOrderIdFromStatus = function _HyperLiquidProvider_readOrderIdFromStatus(status) {
+    return __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_readOrderPlacementOutcome).call(this, status)?.orderId;
 }, _HyperLiquidProvider_getDiscountedBuilderFee = function _HyperLiquidProvider_getDiscountedBuilderFee() {
     if (__classPrivateFieldGet(this, _HyperLiquidProvider_userFeeDiscountBips, "f") === undefined) {
         return BUILDER_FEE_CONFIG.MaxFeeTenthsBps;
@@ -8232,15 +9573,14 @@ async function _HyperLiquidProvider_performChaseTermination(params) {
  * cached for this provider/account session. Until then, the ordinary builder
  * and standard fee keep the trade attributable and non-blocking.
  *
+ * @param setupContext - Account, network, and builder approved for the order.
  * @returns HyperLiquid builder address and fee payload.
  */
-async function _HyperLiquidProvider_getBuilderOrderContext() {
-    const isTestnet = __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").isTestnetMode();
-    const network = isTestnet ? 'testnet' : 'mainnet';
-    const defaultBuilder = __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getBuilderAddress).call(this, isTestnet);
+async function _HyperLiquidProvider_getBuilderOrderContext(setupContext) {
+    const { network, userAddress, builderAddress: defaultBuilder, } = setupContext;
+    const isTestnet = network === 'testnet';
     if (__classPrivateFieldGet(this, _HyperLiquidProvider_userFeeResolution, "f")?.source === 'subscription') {
         const subscriptionBuilder = __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getSubscriptionBuilderAddress).call(this, isTestnet);
-        const userAddress = await __classPrivateFieldGet(this, _HyperLiquidProvider_walletService, "f").getUserAddressWithDefault();
         if (subscriptionBuilder &&
             __classPrivateFieldGet(this, _HyperLiquidProvider_approvedBuilderAddresses, "f").has(__classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getApprovedBuilderKey).call(this, network, userAddress, subscriptionBuilder))) {
             return { b: subscriptionBuilder, f: 0 };
@@ -8390,6 +9730,41 @@ async function _HyperLiquidProvider_queryDexPositions(dexName) {
         });
         return { answered: false, positions: [] };
     }
+}, _HyperLiquidProvider_restoreScaleOrderGroups = function _HyperLiquidProvider_restoreScaleOrderGroups(orders) {
+    const recovered = new Map();
+    for (const order of orders) {
+        if (!order.strategyGroupId) {
+            continue;
+        }
+        const group = recovered.get(order.strategyGroupId) ?? {
+            symbol: order.symbol,
+            orderIds: [],
+        };
+        group.orderIds.push(order.orderId);
+        recovered.set(order.strategyGroupId, group);
+    }
+    for (const [groupId, group] of recovered) {
+        if (__classPrivateFieldGet(this, _HyperLiquidProvider_cancelledScaleOrderGroups, "f").has(groupId)) {
+            continue;
+        }
+        const existingGroup = __classPrivateFieldGet(this, _HyperLiquidProvider_scaleOrderGroups, "f").get(groupId);
+        if (!existingGroup) {
+            __classPrivateFieldGet(this, _HyperLiquidProvider_scaleOrderGroups, "f").set(groupId, group);
+            continue;
+        }
+        if (existingGroup.symbol === group.symbol) {
+            existingGroup.orderIds = [
+                ...new Set([...existingGroup.orderIds, ...group.orderIds]),
+            ];
+        }
+        else {
+            __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Scale group symbol mismatch during recovery', {
+                groupId,
+                existingSymbol: existingGroup.symbol,
+                recoveredSymbol: group.symbol,
+            });
+        }
+    }
 }, _HyperLiquidProvider_getAllMids = 
 /**
  * Get allMids for a DEX — uses WS snapshot as primary source, REST as fallback.
@@ -8406,7 +9781,7 @@ async function _HyperLiquidProvider_getAllMids(infoClient, dexParam) {
     __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('[getMarketDataWithPrices] No WS allMids snapshot, falling back to REST', { dexParam: dexParam ?? 'main' });
     const mids = await infoClient.allMids(dexParam ? { dex: dexParam } : undefined);
     return mids ?? {};
-}, _HyperLiquidProvider_fetchSingleDexFresh = async function _HyperLiquidProvider_fetchSingleDexFresh(infoClient, dex) {
+}, _HyperLiquidProvider_fetchSingleDexFresh = async function _HyperLiquidProvider_fetchSingleDexFresh(infoClient, dex, lifecycleGeneration) {
     const dexParam = dex ?? '';
     let metaAndCtxs = null;
     try {
@@ -8434,10 +9809,12 @@ async function _HyperLiquidProvider_getAllMids(infoClient, dexParam) {
         allMidsErrorMessage = ensureError(error, 'HyperLiquidProvider.getMarketDataWithPrices.allMids').message;
     }
     if (meta?.universe) {
-        __classPrivateFieldGet(this, _HyperLiquidProvider_cachedMetaByDex, "f").set(dexParam, meta);
-        __classPrivateFieldGet(this, _HyperLiquidProvider_subscriptionService, "f").setDexMetaCache(dexParam, meta);
-        __classPrivateFieldGet(this, _HyperLiquidProvider_subscriptionService, "f").setDexAssetCtxsCache(dexParam, assetCtxs);
-        await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_backfillAssetMapForDex).call(this, dex, meta);
+        await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_cacheDexMetadataFromRead).call(this, {
+            dex,
+            meta,
+            assetCtxs,
+            lifecycleGeneration,
+        });
     }
     return {
         dex,
@@ -8540,6 +9917,128 @@ async function _HyperLiquidProvider_excludeNonUsdcCollateralResults(results) {
         return false;
     }
     return Date.now() - cached.timestamp < cached.ttl;
+}, _HyperLiquidProvider_performDisconnect = 
+/**
+ * Perform one provider teardown shared by every concurrent caller.
+ *
+ * @returns A promise that resolves to the result.
+ */
+async function _HyperLiquidProvider_performDisconnect() {
+    __classPrivateFieldSet(this, _HyperLiquidProvider_chasePlacementBlockers, __classPrivateFieldGet(this, _HyperLiquidProvider_chasePlacementBlockers, "f") + 1, "f");
+    __classPrivateFieldSet(this, _HyperLiquidProvider_strategyGeneration, __classPrivateFieldGet(this, _HyperLiquidProvider_strategyGeneration, "f") + 1, "f");
+    __classPrivateFieldSet(this, _HyperLiquidProvider_disconnectOperationsInFlight, __classPrivateFieldGet(this, _HyperLiquidProvider_disconnectOperationsInFlight, "f") + 1, "f");
+    __classPrivateFieldSet(this, _HyperLiquidProvider_isDisconnected, true, "f");
+    __classPrivateFieldSet(this, _HyperLiquidProvider_lifecycleGeneration, __classPrivateFieldGet(this, _HyperLiquidProvider_lifecycleGeneration, "f") + 1, "f");
+    try {
+        __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('HyperLiquid: Disconnecting provider', {
+            isTestnet: __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").isTestnetMode(),
+            timestamp: new Date().toISOString(),
+        });
+        // Clear subscriptions through subscription service
+        __classPrivateFieldGet(this, _HyperLiquidProvider_subscriptionService, "f").clearAll();
+        // Stop every chase loop: each holds a pending timer, and re-pricing after
+        // a disconnect would sign orders against a client that is being torn down.
+        // Orders already resting are deliberately left alone — disconnecting is
+        // not a request to cancel the user's positions or orders.
+        // Invalidate placements first, then drain every mutation before clearing
+        // the registry and tearing down the clients they use.
+        for (const [sessionId, session] of __classPrivateFieldGet(this, _HyperLiquidProvider_chaseSessions, "f").entries()) {
+            if (session.active) {
+                __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_stopChaseSession).call(this, sessionId);
+            }
+        }
+        await Promise.all([...__classPrivateFieldGet(this, _HyperLiquidProvider_chasePlacementWaiters, "f")]);
+        await __classPrivateFieldGet(this, _HyperLiquidProvider_chaseTickQueue, "f");
+        await Promise.allSettled([...__classPrivateFieldGet(this, _HyperLiquidProvider_chaseTerminations, "f").values()]);
+        await Promise.all([...__classPrivateFieldGet(this, _HyperLiquidProvider_chaseSessions, "f").values()].map(async (session) => await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_rebalanceChaseSession).call(this, session)));
+        __classPrivateFieldGet(this, _HyperLiquidProvider_chaseSessions, "f").clear();
+        __classPrivateFieldGet(this, _HyperLiquidProvider_chaseTerminations, "f").clear();
+        __classPrivateFieldGet(this, _HyperLiquidProvider_terminatedChaseHandles, "f").clear();
+        __classPrivateFieldGet(this, _HyperLiquidProvider_scaleOrderGroups, "f").clear();
+        __classPrivateFieldGet(this, _HyperLiquidProvider_cancelledScaleOrderGroups, "f").clear();
+        // Clear session caches. Capability and fee reads use the lifecycle
+        // generation above to discard any old response that resolves later.
+        this.clearFeeCache();
+        __classPrivateFieldGet(this, _HyperLiquidProvider_referralCheckCache, "f").clear();
+        __classPrivateFieldGet(this, _HyperLiquidProvider_builderFeeCheckCache, "f").clear();
+        __classPrivateFieldSet(this, _HyperLiquidProvider_subscriptionBuilderApprovalEpoch, __classPrivateFieldGet(this, _HyperLiquidProvider_subscriptionBuilderApprovalEpoch, "f") + 1, "f");
+        __classPrivateFieldGet(this, _HyperLiquidProvider_approvedBuilderAddresses, "f").clear();
+        __classPrivateFieldSet(this, _HyperLiquidProvider_userFeeResolution, undefined, "f");
+        __classPrivateFieldSet(this, _HyperLiquidProvider_userFeeDiscountBips, undefined, "f");
+        // UnifiedAccountCache stays global to avoid repeated signing requests.
+        __classPrivateFieldGet(this, _HyperLiquidProvider_cachedMetaByDex, "f").clear();
+        __classPrivateFieldSet(this, _HyperLiquidProvider_pendingValidatedDexsPromise, null, "f");
+        __classPrivateFieldGet(this, _HyperLiquidProvider_orderCapabilitiesMarketsByDex, "f").clear();
+        __classPrivateFieldGet(this, _HyperLiquidProvider_orderCapabilitiesRefreshByDex, "f").clear();
+        __classPrivateFieldSet(this, _HyperLiquidProvider_cachedSpotMeta, null, "f");
+        __classPrivateFieldGet(this, _HyperLiquidProvider_dexDiscoveryCache, "f").reset();
+        __classPrivateFieldSet(this, _HyperLiquidProvider_dexDiscoveryComplete, false, "f");
+        // Await pending initialization before clearing to prevent the IIFE from
+        // setting clientsInitialized = true after disconnect completes
+        const pendingInit = __classPrivateFieldGet(this, _HyperLiquidProvider_initializationPromise, "f");
+        const pendingReady = __classPrivateFieldGet(this, _HyperLiquidProvider_ensureReadyPromise, "f");
+        const pendingTradingSetup = __classPrivateFieldGet(this, _HyperLiquidProvider_tradingSetupPromise, "f");
+        const pendingBuilderFeeSetups = [
+            ...__classPrivateFieldGet(this, _HyperLiquidProvider_builderFeeSetupPromises, "f").values(),
+        ];
+        // Clear references first to prevent new callers from reusing
+        __classPrivateFieldSet(this, _HyperLiquidProvider_initializationPromise, null, "f");
+        __classPrivateFieldSet(this, _HyperLiquidProvider_ensureReadyPromise, null, "f");
+        __classPrivateFieldSet(this, _HyperLiquidProvider_tradingSetupPromise, null, "f");
+        __classPrivateFieldSet(this, _HyperLiquidProvider_tradingSetupComplete, false, "f");
+        __classPrivateFieldGet(this, _HyperLiquidProvider_builderFeeSetupPromises, "f").clear();
+        __classPrivateFieldGet(this, _HyperLiquidProvider_pendingBuilderFeeApprovals, "f").clear();
+        // Wait for pending operations to complete (ignore errors)
+        // This prevents IIFEs from setting state after disconnect completes
+        if (pendingInit) {
+            try {
+                await pendingInit;
+            }
+            catch {
+                // Ignore - we're disconnecting anyway
+            }
+        }
+        if (pendingReady) {
+            try {
+                await pendingReady;
+            }
+            catch {
+                // Ignore - we're disconnecting anyway
+            }
+        }
+        if (pendingTradingSetup) {
+            try {
+                await pendingTradingSetup;
+            }
+            catch {
+                // Ignore - we're disconnecting anyway
+            }
+        }
+        for (const pendingBuilderFeeSetup of pendingBuilderFeeSetups) {
+            try {
+                await pendingBuilderFeeSetup;
+            }
+            catch {
+                // Ignore - we're disconnecting anyway
+            }
+        }
+        // Reset client initialization flag so wallet adapter will be recreated with new account
+        // This fixes account synchronization issue where old account's address persists in wallet adapter
+        __classPrivateFieldSet(this, _HyperLiquidProvider_clientsInitialized, false, "f");
+        // Disconnect client service
+        await __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").disconnect();
+        __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('HyperLiquid: Provider fully disconnected', {
+            timestamp: new Date().toISOString(),
+        });
+        return { success: true };
+    }
+    catch (error) {
+        return createErrorResult(error, { success: false });
+    }
+    finally {
+        __classPrivateFieldSet(this, _HyperLiquidProvider_chasePlacementBlockers, __classPrivateFieldGet(this, _HyperLiquidProvider_chasePlacementBlockers, "f") - 1, "f");
+        __classPrivateFieldSet(this, _HyperLiquidProvider_disconnectOperationsInFlight, __classPrivateFieldGet(this, _HyperLiquidProvider_disconnectOperationsInFlight, "f") - 1, "f");
+    }
 }, _HyperLiquidProvider_getBuilderAddress = function _HyperLiquidProvider_getBuilderAddress(isTestnet) {
     // || intentional: env vars default to '' which must fall through to the hardcoded default
     if (isTestnet) {
@@ -8793,4 +10292,9 @@ async function _HyperLiquidProvider_setReferralCode() {
         throw error;
     }
 };
+// Native TWAP IDs and any manual HIP-3 collateral transfer must outlive one
+// provider instance: controller disconnect/reinitialization replaces the
+// provider while the venue schedule keeps running. Each controller messenger
+// owns one registry, so separate controller lifecycles never share handles.
+_HyperLiquidProvider_trackedTwapOrdersByMessenger = { value: new WeakMap() };
 //# sourceMappingURL=HyperLiquidProvider.mjs.map