chore: init fix, catch case where account is not yet setup

Author: gambinish

app/controllers/perps/constants/eventNames.ts

@@ -360,6 +360,10 @@ export const PERPS_EVENT_VALUE = {
     SUCCESS: 'success',
     ALREADY_ENABLED: 'already_enabled',
     MIGRATION_REQUIRED: 'migration_required',
+    // Emitted when a migration attempt is skipped because it is not applicable
+    // (e.g. the user has no HyperLiquid account yet — nothing to migrate).
+    // Distinguishes expected no-ops from real failures in dashboards.
+    NOT_APPLICABLE: 'not_applicable',
   },
   SCREEN_TYPE: {
     MARKETS: 'markets',

app/controllers/perps/providers/HyperLiquidProvider.test.ts

@@ -9354,6 +9354,163 @@ describe('HyperLiquidProvider', () => {
       expect(mockExchangeClient.agentSetAbstraction).not.toHaveBeenCalled();
     });
 
+    // ─────────────────────────────────────────────────
+    // "User or API Wallet does not exist" — unfunded wallet no-op
+    //
+    // HL returns this error when a wallet has never deposited funds.
+    // The migration should be silently recorded as not_applicable
+    // and must NOT fire a Sentry error or a failed analytics event.
+    // ─────────────────────────────────────────────────
+
+    it('silences the "User or API Wallet does not exist" error from agentSetAbstraction (default → unified)', async () => {
+      // Arrange: HL reports the wallet has no account
+      const userNotFoundError = new Error(
+        'User or API Wallet 0xabc does not exist.',
+      );
+      const mockExchangeClient = createMockExchangeClient();
+      mockExchangeClient.agentSetAbstraction = jest
+        .fn()
+        .mockRejectedValue(userNotFoundError);
+      mockClientService.getExchangeClient = jest
+        .fn()
+        .mockReturnValue(mockExchangeClient);
+      mockClientService.getInfoClient = jest.fn().mockReturnValue(
+        createMockInfoClient({
+          userAbstraction: jest.fn().mockResolvedValue('default'),
+        }),
+      );
+
+      // Act — must resolve, not throw
+      await expect(provider.getMarketDataWithPrices()).resolves.not.toThrow();
+
+      // Cache written with reason: 'no_hl_account' so we stop retrying
+      expect(
+        (TradingReadinessCache as jest.Mocked<typeof TradingReadinessCache>)
+          .set,
+      ).toHaveBeenCalledWith('mainnet', USER_ADDRESS, {
+        attempted: true,
+        enabled: false,
+        reason: 'no_hl_account',
+      });
+
+      // Analytics: one migration_required event followed by one not_applicable
+      const trackCalls = (
+        mockPlatformDependencies.metrics.trackPerpsEvent as jest.Mock
+      ).mock.calls.filter((call) => call[0] === 'Perp Account Setup');
+      const notApplicableCall = trackCalls.find(
+        (call) => call[1]?.status === 'not_applicable',
+      );
+      expect(notApplicableCall).toBeDefined();
+      expect(notApplicableCall[1]).toEqual(
+        expect.objectContaining({
+          previous_abstraction_mode: 'default',
+          abstraction_mode: 'unifiedAccount',
+          status: 'not_applicable',
+          error_message: 'no_hl_account',
+        }),
+      );
+
+      // Sentry NOT called — this is not a real failure
+      expect(mockPlatformDependencies.logger.error).not.toHaveBeenCalled();
+    });
+
+    it('silences the "User or API Wallet does not exist" error from userSetAbstraction (dexAbstraction → unified)', async () => {
+      // Arrange: dexAbstraction user with no HL account
+      const userNotFoundError = new Error(
+        'User or API Wallet 0xdef does not exist.',
+      );
+      const mockExchangeClient = createMockExchangeClient();
+      mockExchangeClient.userSetAbstraction = jest
+        .fn()
+        .mockRejectedValue(userNotFoundError);
+      mockClientService.getExchangeClient = jest
+        .fn()
+        .mockReturnValue(mockExchangeClient);
+      mockClientService.getInfoClient = jest.fn().mockReturnValue(
+        createMockInfoClient({
+          userAbstraction: jest.fn().mockResolvedValue('dexAbstraction'),
+        }),
+      );
+
+      // Act — init path for software wallet (allowUserSigning=true via
+      // isSelectedHardwareWallet returning false)
+      await expect(provider.getMarketDataWithPrices()).resolves.not.toThrow();
+
+      // Cache written with reason: 'no_hl_account' (not the dexAbstraction-
+      // failure path — the no_hl_account branch must win)
+      expect(
+        (TradingReadinessCache as jest.Mocked<typeof TradingReadinessCache>)
+          .set,
+      ).toHaveBeenCalledWith('mainnet', USER_ADDRESS, {
+        attempted: true,
+        enabled: false,
+        reason: 'no_hl_account',
+      });
+
+      // Analytics: not_applicable, not failed
+      const trackCalls = (
+        mockPlatformDependencies.metrics.trackPerpsEvent as jest.Mock
+      ).mock.calls.filter((call) => call[0] === 'Perp Account Setup');
+      const notApplicableCall = trackCalls.find(
+        (call) => call[1]?.status === 'not_applicable',
+      );
+      expect(notApplicableCall).toBeDefined();
+      expect(notApplicableCall[1]).toEqual(
+        expect.objectContaining({
+          previous_abstraction_mode: 'dexAbstraction',
+          abstraction_mode: 'unifiedAccount',
+          status: 'not_applicable',
+          error_message: 'no_hl_account',
+        }),
+      );
+
+      // Sentry NOT called
+      expect(mockPlatformDependencies.logger.error).not.toHaveBeenCalled();
+    });
+
+    it('still fires the failed analytics event and Sentry for unrelated agentSetAbstraction errors', async () => {
+      // Arrange: unrelated error to confirm the special case does not
+      // swallow legitimate failures
+      const unrelatedError = new Error('Insufficient margin');
+      const mockExchangeClient = createMockExchangeClient();
+      mockExchangeClient.agentSetAbstraction = jest
+        .fn()
+        .mockRejectedValue(unrelatedError);
+      mockClientService.getExchangeClient = jest
+        .fn()
+        .mockReturnValue(mockExchangeClient);
+      mockClientService.getInfoClient = jest.fn().mockReturnValue(
+        createMockInfoClient({
+          userAbstraction: jest.fn().mockResolvedValue('default'),
+        }),
+      );
+
+      // Act — still resolves (error is caught internally)
+      await expect(provider.getMarketDataWithPrices()).resolves.not.toThrow();
+
+      // Analytics: should have a failed event, no not_applicable
+      const trackCalls = (
+        mockPlatformDependencies.metrics.trackPerpsEvent as jest.Mock
+      ).mock.calls.filter((call) => call[0] === 'Perp Account Setup');
+      const failedCall = trackCalls.find(
+        (call) => call[1]?.status === 'failed',
+      );
+      expect(failedCall).toBeDefined();
+      expect(failedCall[1]).toEqual(
+        expect.objectContaining({
+          status: 'failed',
+          error_message: 'Insufficient margin',
+        }),
+      );
+      const notApplicableCall = trackCalls.find(
+        (call) => call[1]?.status === 'not_applicable',
+      );
+      expect(notApplicableCall).toBeUndefined();
+
+      // Sentry IS called
+      expect(mockPlatformDependencies.logger.error).toHaveBeenCalled();
+    });
+
     // ─────────────────────────────────────────────────
     // Network key (mainnet vs testnet)
     // ─────────────────────────────────────────────────

app/controllers/perps/providers/HyperLiquidProvider.ts

@@ -128,7 +128,10 @@ import {
   addSpotBalanceToAccountState,
   aggregateAccountStates,
 } from '../utils/accountUtils';
-import { ensureError } from '../utils/errorUtils';
+import {
+  ensureError,
+  isHyperLiquidUserNotFoundError,
+} from '../utils/errorUtils';
 import {
   adaptAccountStateFromSDK,
   adaptHyperLiquidLedgerUpdateToUserHistoryItem,
@@ -824,6 +827,37 @@ export class HyperLiquidProvider implements PerpsProvider {
         return;
       }
 
+      // User has no HL account yet — nothing to migrate. HL surfaces this as
+      // "User or API Wallet 0x… does not exist." for both the agent-key and
+      // user-signed paths. This is benign: the user has no funds on HL, and
+      // the next migration attempt after their first deposit will succeed.
+      // We cache it so we don't re-fire the doomed call (and the failed
+      // analytics/Sentry events) on every Perps section open. The cache resets
+      // on app restart, which is sufficient coverage for users who deposit and
+      // trade within the same session.
+      if (isHyperLiquidUserNotFoundError(error)) {
+        this.#deps.debugLogger.log(
+          '[ensureUnifiedAccountEnabled] User has no HL account yet, skipping migration',
+          { user: userAddress, network },
+        );
+        TradingReadinessCache.set(network, userAddress, {
+          attempted: true,
+          enabled: false,
+          reason: 'no_hl_account',
+        });
+        this.#deps.metrics.trackPerpsEvent(PerpsAnalyticsEvent.AccountSetup, {
+          ...(currentMode && {
+            [PERPS_EVENT_PROPERTY.PREVIOUS_ABSTRACTION_MODE]: currentMode,
+            [PERPS_EVENT_PROPERTY.ABSTRACTION_MODE]: HL_UNIFIED_ACCOUNT_MODE,
+          }),
+          [PERPS_EVENT_PROPERTY.STATUS]:
+            PERPS_EVENT_VALUE.STATUS.NOT_APPLICABLE,
+          [PERPS_EVENT_PROPERTY.ERROR_MESSAGE]: 'no_hl_account',
+        });
+        completeInFlight();
+        return;
+      }
+
       // Cache failure ONLY for the user-prompted path
       // (`dexAbstraction → unifiedAccount` via `userSetAbstraction`). The
       // rationale for caching is "don't re-prompt a user who already saw the

app/controllers/perps/services/TradingReadinessCache.test.ts

@@ -118,6 +118,43 @@ describe('TradingReadinessCache / PerpsSigningCache', () => {
           false,
         );
       });
+
+      it('stores and returns a reason discriminator', () => {
+        TradingReadinessCache.set(network, userAddress, {
+          attempted: true,
+          enabled: false,
+          reason: 'no_hl_account',
+        });
+
+        const result = TradingReadinessCache.get(network, userAddress);
+        expect(result?.reason).toBe('no_hl_account');
+        expect(result?.attempted).toBe(true);
+        expect(result?.enabled).toBe(false);
+      });
+
+      it('returns undefined reason when set without one', () => {
+        TradingReadinessCache.set(network, userAddress, {
+          attempted: true,
+          enabled: false,
+        });
+
+        const result = TradingReadinessCache.get(network, userAddress);
+        expect(result?.reason).toBeUndefined();
+      });
+
+      it('clears reason when clearUnifiedAccount is called', () => {
+        TradingReadinessCache.set(network, userAddress, {
+          attempted: true,
+          enabled: false,
+          reason: 'no_hl_account',
+        });
+
+        TradingReadinessCache.clearUnifiedAccount(network, userAddress);
+
+        const result = TradingReadinessCache.get(network, userAddress);
+        expect(result?.reason).toBeUndefined();
+        expect(result?.attempted).toBe(false);
+      });
     });
   });
 

app/controllers/perps/services/TradingReadinessCache.ts

@@ -25,6 +25,7 @@
 type SigningOperationState = {
   attempted: boolean; // Whether we've attempted this operation
   success: boolean; // Whether it succeeded (only valid if attempted=true)
+  reason?: 'no_hl_account' | 'user_rejected' | 'transient'; // optional discriminator
 };
 
 type PerpsSigningCacheEntry = {
@@ -39,6 +40,7 @@ type TradingReadinessCacheEntry = {
   attempted: boolean;
   enabled: boolean;
   timestamp: number;
+  reason?: 'no_hl_account' | 'user_rejected' | 'transient';
 };
 
 class PerpsSigningCacheManager {
@@ -149,6 +151,7 @@ class PerpsSigningCacheManager {
       attempted: entry.unifiedAccount.attempted,
       enabled: entry.unifiedAccount.success,
       timestamp: entry.timestamp,
+      reason: entry.unifiedAccount.reason,
     };
   }
 
@@ -160,14 +163,23 @@ class PerpsSigningCacheManager {
    * @param data - The transaction data payload.
    * @param data.attempted - Whether the operation was attempted.
    * @param data.enabled - Whether the feature is enabled.
+   * @param data.reason - Optional discriminator for why the operation ended in this state.
    */
   public set(
     network: 'mainnet' | 'testnet',
     userAddress: string,
-    data: { attempted: boolean; enabled: boolean },
+    data: {
+      attempted: boolean;
+      enabled: boolean;
+      reason?: 'no_hl_account' | 'user_rejected' | 'transient';
+    },
   ): void {
     const entry = this.#getOrCreateEntry(network, userAddress);
-    entry.unifiedAccount = { attempted: data.attempted, success: data.enabled };
+    entry.unifiedAccount = {
+      attempted: data.attempted,
+      success: data.enabled,
+      reason: data.reason,
+    };
     entry.timestamp = Date.now();
   }
 
@@ -257,7 +269,11 @@ class PerpsSigningCacheManager {
     const key = this.#getCacheKey(network, userAddress);
     const entry = this.#cache.get(key);
     if (entry) {
-      entry.unifiedAccount = { attempted: false, success: false };
+      entry.unifiedAccount = {
+        attempted: false,
+        success: false,
+        reason: undefined,
+      };
       entry.timestamp = Date.now();
     }
   }

app/controllers/perps/utils/errorUtils.test.ts

@@ -1,6 +1,59 @@
-import { isAbortError, ensureError } from './errorUtils';
+import {
+  isAbortError,
+  ensureError,
+  isHyperLiquidUserNotFoundError,
+} from './errorUtils';
 
 describe('errorUtils', () => {
+  describe('isHyperLiquidUserNotFoundError', () => {
+    it('returns true for the canonical HL error message', () => {
+      const error = new Error(
+        'User or API Wallet 0x8e05901d9ef496a220067a0d0841a1728269fc8f does not exist.',
+      );
+      expect(isHyperLiquidUserNotFoundError(error)).toBe(true);
+    });
+
+    it('returns true for a short address variant', () => {
+      const error = new Error(
+        'User or API Wallet 0x0000000000000000000000000000000000000000 does not exist.',
+      );
+      expect(isHyperLiquidUserNotFoundError(error)).toBe(true);
+    });
+
+    it('is case-insensitive', () => {
+      const error = new Error('user or api wallet 0xabc does not exist');
+      expect(isHyperLiquidUserNotFoundError(error)).toBe(true);
+    });
+
+    it('returns false for an unrelated API error', () => {
+      const error = new Error('Insufficient margin');
+      expect(isHyperLiquidUserNotFoundError(error)).toBe(false);
+    });
+
+    it('returns false for a generic network error', () => {
+      const error = new Error('Network request failed');
+      expect(isHyperLiquidUserNotFoundError(error)).toBe(false);
+    });
+
+    it('returns false for null', () => {
+      expect(isHyperLiquidUserNotFoundError(null)).toBe(false);
+    });
+
+    it('returns false for undefined', () => {
+      expect(isHyperLiquidUserNotFoundError(undefined)).toBe(false);
+    });
+
+    it('returns false for a plain string that does not match', () => {
+      expect(isHyperLiquidUserNotFoundError('some random error')).toBe(false);
+    });
+
+    it('returns false for a non-Error object', () => {
+      expect(
+        isHyperLiquidUserNotFoundError({ message: 'does not exist' }),
+      ).toBe(false);
+    });
+  });
+
   describe('isAbortError', () => {
     it('returns true for Error with name AbortError', () => {
       const error = new Error('The operation was aborted');