@metamask-previews/perps-controller 22.1.2-preview-2c49dc768 → 22.1.2-preview-4a5ac306d

package/dist/providers/HyperLiquidProvider.js

@@ -21,7 +21,7 @@ import { PerpsAnalyticsEvent } from '../types/index.js';
 import { addSpotBalanceToAccountState, aggregateAccountStates, } from '../utils/accountUtils.js';
 import { isValidCapabilitySymbol } from '../utils/capabilitySymbols.js';
 import { PERPS_ERROR_ACTION, PERPS_ERROR_COMPONENT, PERPS_ERROR_OPERATION, createPerpsErrorContext, } from '../utils/errorContext.js';
-import { ensureError, isHyperLiquidMultiSigRequiredError, isHyperLiquidUserNotFoundError, isKeyringLockedError, normalizeHyperLiquidError, } from '../utils/errorUtils.js';
+import { ensureError, isHyperLiquidMultiSigRequiredError, isHyperLiquidUserNotFoundError, isKeyringLockedError, } from '../utils/errorUtils.js';
 import { shouldDeferUnifiedAccountSetup } from '../utils/hyperLiquidAbstraction.js';
 import { adaptAccountStateFromSDK, adaptHyperLiquidLedgerUpdateToUserHistoryItem, adaptMarketFromSDK, adaptOrderFromSDK, adaptPositionFromSDK, adaptPositionTriggerOrderFromSDK, adaptTpslLinkageToGrouping, buildAssetMapping, buildHyperLiquidFillId, formatHyperLiquidPrice, formatHyperLiquidSize, HYPERLIQUID_SCALE_CLOID_MARKER, parseAssetName, readScaleGroupId, } from '../utils/hyperLiquidAdapter.js';
 import { previewHyperLiquidIsolatedPositionModify, resolveHyperLiquidMarginTiers, } from '../utils/hyperLiquidPositionPreview.js';
@@ -835,6 +835,13 @@ export class HyperLiquidProvider {
     #pendingValidatedDexsPromise = null;
     // Cache for USDC token ID from spot metadata
     #cachedUsdcTokenId;
+    // Error mappings from HyperLiquid API errors to standardized PERPS_ERROR_CODES
+    #errorMappings = {
+        'isolated position does not have sufficient margin available to decrease leverage': PERPS_ERROR_CODES.ORDER_LEVERAGE_REDUCTION_FAILED,
+        'could not immediately match': PERPS_ERROR_CODES.IOC_CANCEL,
+        'multi-sig required': PERPS_ERROR_CODES.EXCHANGE_MULTI_SIG_REQUIRED,
+        'invalid nonce': PERPS_ERROR_CODES.EXCHANGE_INVALID_NONCE,
+    };
     // Scale ladders placed by this provider instance, keyed by group handle, so
     // one cancel can reach every rung. Cleared on disconnect; the rung IDs are
     // also returned to the caller as `OrderResult.childOrderIds`.
@@ -3432,7 +3439,22 @@ export class HyperLiquidProvider {
      * @returns The result of the operation.
      */
     #mapError(error) {
-        return normalizeHyperLiquidError(error);
+        const { message } = ensureError(error, 'HyperLiquidProvider.mapError');
+        // "User or API Wallet 0x... does not exist." carries the user's address, so
+        // it cannot be matched by the static substring table below. It means the
+        // wallet has no Hyperliquid account yet — surface an actionable code the
+        // client can translate ("fund your account") instead of leaking the raw
+        // exchange string to the UI and to failed-trade analytics.
+        if (isHyperLiquidUserNotFoundError(error)) {
+            return new PerpsControllerError(PERPS_ERROR_CODES.EXCHANGE_ACCOUNT_NOT_FOUND, PERPS_ERROR_CODES.EXCHANGE_ACCOUNT_NOT_FOUND);
+        }
+        for (const [pattern, code] of Object.entries(this.#errorMappings)) {
+            if (message.toLowerCase().includes(pattern.toLowerCase())) {
+                return new PerpsControllerError(code, code);
+            }
+        }
+        // Return original error to preserve stack trace for unmapped errors
+        return ensureError(error, 'HyperLiquidProvider.mapError');
     }
     /**
      * Map a rejection the venue reported in a status entry rather than threw,
@@ -4884,7 +4906,7 @@ export class HyperLiquidProvider {
                 error: isMinimumOrderError &&
                     !params.reduceOnly &&
                     !isStrategyOrderType(params.orderType)
-                    ? new PerpsControllerError(PERPS_ERROR_CODES.ORDER_SIZE_MIN, PERPS_ERROR_CODES.ORDER_SIZE_MIN, undefined, { cause: error })
+                    ? new PerpsControllerError(PERPS_ERROR_CODES.ORDER_SIZE_MIN, PERPS_ERROR_CODES.ORDER_SIZE_MIN)
                     : error,
                 symbol: params.symbol,
                 orderType: params.orderType,
@@ -7848,15 +7870,21 @@ export class HyperLiquidProvider {
             };
         }
         catch (error) {
-            const mappedError = await this.#reportWriteError(error, 'editOrder', {
+            const signerFailure = await this.#handleSignerFailure(error, 'editOrder', {
+                orderId: params.orderId,
+            });
+            if (signerFailure) {
+                return createErrorResult(signerFailure, { success: false });
+            }
+            this.#deps.logger.error(ensureError(error, 'HyperLiquidProvider.editOrder'), this.#getErrorContext('editOrder', {
                 orderId: params.orderId,
                 coin: params.newOrder.symbol,
                 orderType: params.newOrder.orderType,
             }, {
                 operation: PERPS_ERROR_OPERATION.OrderManagement,
                 action: PERPS_ERROR_ACTION.EditOrder,
-            });
-            return createErrorResult(mappedError, { success: false });
+            }));
+            return createErrorResult(error, { success: false });
         }
     }
     /**
@@ -8347,36 +8375,17 @@ export class HyperLiquidProvider {
             }
             // Index submitted and skipped outcomes by symbol so `results` can keep the
             // order of the requested positions: consumers may correlate them by index.
-            const submittedResults = new Map(statuses.map((status, index) => {
-                const success = isStatusObject(status) &&
-                    (hasProperty(status, 'filled') || hasProperty(status, 'resting'));
-                const rawStatusError = isStatusObject(status) &&
-                    hasProperty(status, 'error') &&
-                    typeof status.error === 'string'
-                    ? status.error
-                    : undefined;
-                const normalizedStatusError = rawStatusError === undefined
-                    ? undefined
-                    : normalizeHyperLiquidError(createStatusError(rawStatusError, result));
-                return [
-                    orderedPositions[index].symbol,
-                    {
-                        symbol: orderedPositions[index].symbol,
-                        success,
-                        error: success || normalizedStatusError === undefined
-                            ? undefined
-                            : normalizedStatusError.message,
-                        ...(success || normalizedStatusError === undefined
-                            ? {}
-                            : {
-                                errorCode: normalizedStatusError.errorCode,
-                                ...(normalizedStatusError.errorDetails === undefined
-                                    ? {}
-                                    : { errorDetails: normalizedStatusError.errorDetails }),
-                            }),
-                    },
-                ];
-            }));
+            const submittedResults = new Map(statuses.map((status, index) => [
+                orderedPositions[index].symbol,
+                {
+                    symbol: orderedPositions[index].symbol,
+                    success: isStatusObject(status) &&
+                        (hasProperty(status, 'filled') || hasProperty(status, 'resting')),
+                    error: isStatusObject(status) && hasProperty(status, 'error')
+                        ? String(status.error)
+                        : undefined,
+                },
+            ]));
             const skippedBySymbol = new Map(skippedResults.map((skipped) => [skipped.symbol, skipped]));
             return {
                 success: successCount > 0,
@@ -8396,31 +8405,34 @@ export class HyperLiquidProvider {
             if (accountContext) {
                 this.#recordUnsupportedAccountFromError(error, accountContext);
             }
-            const mappedError = await this.#reportWriteError(error instanceof Error
-                ? error
-                : new Error(PERPS_ERROR_CODES.BATCH_CLOSE_FAILED), 'closePositions', {
+            const signerFailure = await this.#handleSignerFailure(error, 'closePositions', {
                 positionCount: positionsToClose.length,
-            }, {
-                operation: PERPS_ERROR_OPERATION.PositionManagement,
-                action: PERPS_ERROR_ACTION.ClosePosition,
             });
-            const normalizedError = normalizeHyperLiquidError(mappedError);
-            const { errorDetails } = normalizedError;
+            const safeError = signerFailure ??
+                ensureError(error, 'HyperLiquidProvider.closePositions');
+            if (!signerFailure) {
+                this.#deps.logger.error(safeError, this.#getErrorContext('closePositions', {
+                    positionCount: positionsToClose.length,
+                }, {
+                    operation: PERPS_ERROR_OPERATION.PositionManagement,
+                    action: PERPS_ERROR_ACTION.ClosePosition,
+                }));
+            }
             // Return all selected positions as failed, including unavailable DEXes.
             return {
                 success: false,
                 successCount: 0,
                 failureCount: positionsToClose.length + unavailableResults.length,
-                error: normalizedError.message,
-                errorCode: normalizedError.errorCode,
-                ...(errorDetails === undefined ? {} : { errorDetails }),
+                error: error instanceof Error
+                    ? safeError.message
+                    : PERPS_ERROR_CODES.BATCH_CLOSE_FAILED,
                 results: [
                     ...positionsToClose.map((position) => ({
                         symbol: position.symbol,
                         success: false,
-                        error: normalizedError.message,
-                        errorCode: normalizedError.errorCode,
-                        ...(errorDetails === undefined ? {} : { errorDetails }),
+                        error: error instanceof Error
+                            ? safeError.message
+                            : PERPS_ERROR_CODES.BATCH_CLOSE_FAILED,
                     })),
                     ...unavailableResults,
                 ],
@@ -9260,15 +9272,19 @@ export class HyperLiquidProvider {
             });
         }
         catch (error) {
-            const mappedError = await this.#reportWriteError(error, 'updatePositionTPSL', {
+            const signerFailure = await this.#handleSignerFailure(error, 'updatePositionTPSL', { symbol: params.symbol });
+            if (signerFailure) {
+                return createErrorResult(signerFailure, { success: false });
+            }
+            this.#deps.logger.error(ensureError(error, 'HyperLiquidProvider.updatePositionTPSL'), this.#getErrorContext('updatePositionTPSL', {
                 symbol: params.symbol,
                 hasTakeProfit: params.takeProfitPrice !== undefined,
                 hasStopLoss: params.stopLossPrice !== undefined,
             }, {
                 operation: PERPS_ERROR_OPERATION.PositionManagement,
                 action: PERPS_ERROR_ACTION.PositionTpslUpdate,
-            });
-            return createErrorResult(mappedError, { success: false });
+            }));
+            return createErrorResult(error, { success: false });
         }
     }
     /**
@@ -9414,8 +9430,6 @@ export class HyperLiquidProvider {
             return result;
         }
         catch (error) {
-            // Setup failures are returned for the service boundary to report. The
-            // result is still normalized so the raw message never crosses it.
             const safeError = ensureError(error, 'HyperLiquidProvider.closePosition');
             this.#deps.debugLogger.log('[closePosition] Close failed', {
                 error: safeError.message,
@@ -9499,17 +9513,29 @@ export class HyperLiquidProvider {
             };
         }
         catch (error) {
-            if (accountContext) {
-                this.#recordUnsupportedAccountFromError(error, accountContext);
+            const isMultiSigRequired = accountContext
+                ? this.#recordUnsupportedAccountFromError(error, accountContext)
+                : false;
+            const signerFailure = await this.#handleSignerFailure(error, 'updateMargin', {
+                symbol: params.symbol,
+            });
+            if (signerFailure) {
+                return { success: false, error: signerFailure.message };
             }
-            const mappedError = await this.#reportWriteError(error, 'updateMargin', {
+            const safeError = isMultiSigRequired
+                ? new Error(PERPS_ERROR_CODES.EXCHANGE_MULTI_SIG_REQUIRED)
+                : ensureError(error, 'HyperLiquidProvider.updateMargin');
+            this.#deps.logger.error(safeError, this.#getErrorContext('updateMargin', {
                 symbol: params.symbol,
                 amount: params.amount,
             }, {
                 operation: PERPS_ERROR_OPERATION.PositionManagement,
                 action: PERPS_ERROR_ACTION.UpdateMargin,
-            });
-            return createErrorResult(mappedError, { success: false });
+            }));
+            return {
+                success: false,
+                error: safeError.message,
+            };
         }
     }
     /**
@@ -11606,42 +11632,50 @@ export class HyperLiquidProvider {
                 };
             }
             const rejection = new Error(`Withdrawal failed: ${JSON.stringify(result)}`);
-            this.#recordUnsupportedAccountFromError(rejection, accountContext);
+            const isMultiSigRequired = this.#recordUnsupportedAccountFromError(rejection, accountContext);
+            const errorMessage = isMultiSigRequired
+                ? PERPS_ERROR_CODES.EXCHANGE_MULTI_SIG_REQUIRED
+                : `Withdrawal failed: ${String(result.status)}`;
             this.#deps.debugLogger.log('HyperLiquidProvider: WITHDRAWAL FAILED', {
-                error: rejection.message,
+                error: errorMessage,
                 status: result.status,
                 response: result,
                 params,
             });
-            const mappedError = await this.#reportWriteError(rejection, 'withdraw', {
-                assetId: params.assetId,
-                amount: params.amount,
-                destination: params.destination,
-            }, {
-                operation: PERPS_ERROR_OPERATION.FinancialOperations,
-                action: PERPS_ERROR_ACTION.FinancialWithdrawal,
-            });
-            return createErrorResult(mappedError, { success: false });
+            return {
+                success: false,
+                error: errorMessage,
+            };
         }
         catch (error) {
-            if (accountContext) {
-                this.#recordUnsupportedAccountFromError(error, accountContext);
+            const isMultiSigRequired = accountContext
+                ? this.#recordUnsupportedAccountFromError(error, accountContext)
+                : false;
+            const signerFailure = await this.#handleSignerFailure(error, 'withdraw', {
+                assetId: params.assetId,
+            });
+            if (signerFailure) {
+                return createErrorResult(signerFailure, { success: false });
             }
+            const safeError = isMultiSigRequired
+                ? new Error(PERPS_ERROR_CODES.EXCHANGE_MULTI_SIG_REQUIRED)
+                : ensureError(error, 'HyperLiquidProvider.initiateWithdrawal');
             this.#deps.debugLogger.log('HyperLiquidProvider: WITHDRAWAL EXCEPTION', {
-                error: ensureError(error, 'HyperLiquidProvider.initiateWithdrawal')
-                    .message,
+                error: safeError.message,
+                errorType: safeError.name,
+                stack: safeError.stack,
                 params,
                 timestamp: new Date().toISOString(),
             });
-            const mappedError = await this.#reportWriteError(error, 'withdraw', {
+            this.#deps.logger.error(safeError, this.#getErrorContext('withdraw', {
                 assetId: params.assetId,
                 amount: params.amount,
                 destination: params.destination,
             }, {
                 operation: PERPS_ERROR_OPERATION.FinancialOperations,
                 action: PERPS_ERROR_ACTION.FinancialWithdrawal,
-            });
-            return createErrorResult(mappedError, { success: false });
+            }));
+            return createErrorResult(safeError, { success: false });
         }
     }
     /**
@@ -11745,25 +11779,28 @@ export class HyperLiquidProvider {
             if (this.#recordUnsupportedAccountFromError(new Error(`DEX transfer failed: ${JSON.stringify(result)}`), accountContext)) {
                 throw new Error(PERPS_ERROR_CODES.EXCHANGE_MULTI_SIG_REQUIRED);
             }
-            throw new Error(PERPS_ERROR_CODES.TRANSFER_FAILED, {
-                cause: new Error(`DEX transfer failed: ${JSON.stringify(result)}`),
-            });
+            throw new Error(PERPS_ERROR_CODES.TRANSFER_FAILED);
         }
         catch (error) {
-            if (accountContext) {
-                this.#recordUnsupportedAccountFromError(error, accountContext);
+            const isMultiSigRequired = accountContext
+                ? this.#recordUnsupportedAccountFromError(error, accountContext)
+                : false;
+            const signerFailure = await this.#handleSignerFailure(error, 'transferBetweenDexs', { sourceDex: params.sourceDex, destinationDex: params.destinationDex });
+            if (signerFailure) {
+                return { success: false, error: signerFailure.message };
             }
-            const mappedError = await this.#reportWriteError(error, 'transferBetweenDexs', {
-                sourceDex: params.sourceDex,
-                destinationDex: params.destinationDex,
-            }, {
-                operation: PERPS_ERROR_OPERATION.FinancialOperations,
-            });
+            const safeError = isMultiSigRequired
+                ? new Error(PERPS_ERROR_CODES.EXCHANGE_MULTI_SIG_REQUIRED)
+                : ensureError(error, 'HyperLiquidProvider.transferToSpot');
             this.#deps.debugLogger.log('❌ HyperLiquidProvider: TRANSFER FAILED', {
-                error: mappedError.message,
+                error: safeError.message,
                 params,
             });
-            return createErrorResult(mappedError, { success: false });
+            this.#deps.logger.error(safeError, this.#getErrorContext('transferBetweenDexs', { ...params }));
+            return {
+                success: false,
+                error: safeError.message,
+            };
         }
     }
     /**
@@ -12126,7 +12163,6 @@ export class HyperLiquidProvider {
                 return { ready: false, error: PERPS_ERROR_CODES.KEYRING_LOCKED };
             }
             const caughtError = ensureError(error, 'HyperLiquidProvider.prepareTradingWallet');
-            const normalizedError = normalizeHyperLiquidError(caughtError);
             if (caughtError.message === PERPS_ERROR_CODES.PROVIDER_LIFECYCLE_STALE) {
                 this.#deps.debugLogger.log('[prepareTradingWallet] Provider replaced during preparation');
             }
@@ -12138,16 +12174,9 @@ export class HyperLiquidProvider {
                 this.#deps.debugLogger.log('[prepareTradingWallet] Builder fee approval refused', { error: caughtError.message });
             }
             else {
-                this.#deps.logger.error(normalizedError, this.#getErrorContext('prepareTradingWallet'));
+                this.#deps.logger.error(caughtError, this.#getErrorContext('prepareTradingWallet'));
             }
-            return {
-                ready: false,
-                error: normalizedError.message,
-                errorCode: normalizedError.errorCode,
-                ...(normalizedError.errorDetails === undefined
-                    ? {}
-                    : { errorDetails: normalizedError.errorDetails }),
-            };
+            return { ready: false, error: caughtError.message };
         }
     }
     /**
@@ -12177,16 +12206,13 @@ export class HyperLiquidProvider {
             };
         }
         catch (error) {
-            const normalizedError = normalizeHyperLiquidError(error);
             return {
                 ready: false,
                 walletConnected: false,
                 networkSupported: false,
-                error: normalizedError.message,
-                errorCode: normalizedError.errorCode,
-                ...(normalizedError.errorDetails === undefined
-                    ? {}
-                    : { errorDetails: normalizedError.errorDetails }),
+                error: error instanceof Error
+                    ? error.message
+                    : PERPS_ERROR_CODES.UNKNOWN_ERROR,
             };
         }
     }