@nadohq/mobile-client 0.29.0 → 0.31.0

package/src/MobileClient.ts

@@ -1,9 +1,11 @@
 import {
+  subaccountToHex,
   WalletClientWithAccount,
   WalletNotProvidedError,
 } from '@nadohq/shared';
 import axios, { AxiosInstance, AxiosResponse } from 'axios';
 import {
+  mapMobileFeedPage,
   mapMobileIdentity,
   mapMobileNotificationPreferences,
   mapMobileNotificationPreferencesToServer,
@@ -17,36 +19,41 @@ import {
   MobileSignedRequest,
 } from './signing';
 import {
+  GetMobileFeedParams,
   GetMobileNotificationPreferencesParams,
   GetMobilePublicProfileParams,
   GetMobileRegisteredDevicesParams,
   GetMobileSelfIdentityParams,
   GetMobileUsernameAvailabilityParams,
-  MobileClaimUsernameParams,
+  MobileFeedPage,
   MobileIdentity,
   MobileNotificationPreferences,
   MobilePublicProfile,
   MobileRegisteredDevice,
   MobileRegisterExpoTokenParams,
   MobileSetPrivateModeParams,
+  MobileSetUsernameParams,
   MobileSignedRequestParams,
   MobileUnregisterExpoTokenParams,
   MobileUpdateNotificationPreferencesParams,
-  MobileUpdateUsernameParams,
   MobileUsernameAvailability,
 } from './types/clientTypes';
 import { MobileServerFailureError } from './types/MobileServerFailureError';
 import { MobileServerSuccessResponse } from './types/serverBaseTypes';
-import { MobileServerExecuteResult } from './types/serverExecuteTypes';
 import {
-  MobileServerNotificationPreferencesResponse,
-  MobileServerProfileRequest,
-  MobileServerProfileResponse,
-  MobileServerRegisteredDevicesResponse,
-  MobileServerSelfIdentityResponse,
-  MobileServerUsernameAvailabilityRequest,
-  MobileServerUsernameAvailabilityResponse,
+  MobileServerExecuteResult,
+  MobileServerPublicExecuteRequest,
+} from './types/serverExecuteTypes';
+import {
+  MobileServerPublicQueryRequest,
+  MobileServerPublicQuerySuccessResponse,
+  MobileServerSignedQuerySuccessResponse,
 } from './types/serverQueryTypes';
+import {
+  MobileServerPublicQueryRequestByType,
+  MobileServerPublicQueryRequestType,
+  MobileServerSignedQueryRequestType,
+} from './types/serverRequestTypes';
 import {
   isMobileServerFailureResponse,
   isMobileServerSuccessResponse,
@@ -71,8 +78,8 @@ export interface MobileClientOpts {
 }
 
 /**
- * Client for the Nado mobile service API: username claims, public profile lookups, privacy settings, and
- * push notification device/preference management.
+ * Client for the Nado mobile service API: usernames, public profile lookups, the global trade feed, privacy
+ * settings, and push notification device/preference management.
  */
 export class MobileClient {
   readonly opts: MobileClientOpts;
@@ -108,39 +115,133 @@ export class MobileClient {
   async getUsernameAvailability(
     params: GetMobileUsernameAvailabilityParams,
   ): Promise<MobileUsernameAvailability> {
-    const body: MobileServerUsernameAvailabilityRequest = {
+    const body: MobileServerPublicQueryRequest<'username_availability'> = {
       type: 'username_availability',
       display_name: params.displayName,
     };
-    const data =
-      await this.publicQuery<MobileServerUsernameAvailabilityResponse>(body);
+    const data = await this.publicQuery(body);
     return { username: data.username, available: data.available };
   }
 
   /**
-   * Looks up a subaccount's public profile by username.
+   * Looks up a subaccount's public profile. Every non-isolated subaccount resolves, with `username` and
+   * `displayName` `null` until a username is claimed. Private Mode does not hide the profile itself, only the
+   * account's activity.
    *
-   * @throws {MobileServerFailureError} With error code `PROFILE_NOT_FOUND` if no identity has claimed the
-   * username or it is invalid. Private Mode does not hide the profile itself, only the account's activity.
+   * @throws {MobileServerFailureError} With error code `PROFILE_NOT_FOUND` if the subaccount is in the
+   * engine-created isolated namespace, which cannot own a profile.
    */
   async getPublicProfile(
     params: GetMobilePublicProfileParams,
   ): Promise<MobilePublicProfile> {
-    const body: MobileServerProfileRequest = {
+    const body: MobileServerPublicQueryRequest<'profile'> = {
       type: 'profile',
-      username: params.username,
+      subaccount: subaccountToHex(params),
     };
-    const data = await this.publicQuery<MobileServerProfileResponse>(body);
+    const data = await this.publicQuery(body);
     return mapMobilePublicProfile(data.profile);
   }
 
+  /**
+   * Fetches a page of the global trade feed: public perpetual trades, newest first, optionally filtered by a
+   * whole-dollar minimum notional (omitted means unfiltered). Trades by subaccounts that have not claimed a
+   * username are included with `null` name fields; only private accounts are filtered out. The feed is
+   * best-effort rather than authoritative history, and pagination is live (not snapshot), so deduplicate pages
+   * by {@link MobileFeedTrade.orderDigest}.
+   *
+   * @throws {MobileServerFailureError} With error code `INVALID_FEED_FILTER` if `minimumNotional` or
+   * `limit` is outside its allowed domain (fix the request; do not retry unchanged), or
+   * `INVALID_FEED_CURSOR` if the cursor is malformed or was issued for a different `minimumNotional`
+   * (discard the cursor and restart from the first page).
+   */
+  async getFeed(params: GetMobileFeedParams = {}): Promise<MobileFeedPage> {
+    const body: MobileServerPublicQueryRequest<'feed'> = {
+      type: 'feed',
+      minimum_notional: params.minimumNotional,
+      limit: params.limit,
+      cursor: params.cursor,
+    };
+    const data = await this.publicQuery(body);
+    return mapMobileFeedPage(data);
+  }
+
+  /**
+   * Fetches the push notification preferences of the wallet that owns the given Expo push token. Unsigned —
+   * the token identifies the wallet on its own. Falls back to the backend's defaults if the wallet has never
+   * updated its preferences.
+   *
+   * @throws {MobileServerFailureError} With error code `INVALID_EXPO_TOKEN` if the token is malformed, or is
+   * not currently registered to a wallet.
+   */
+  async getNotificationPreferences(
+    params: GetMobileNotificationPreferencesParams,
+  ): Promise<MobileNotificationPreferences> {
+    const body: MobileServerPublicQueryRequest<'notification_preferences'> = {
+      type: 'notification_preferences',
+      expo_token: params.expoToken,
+    };
+    const data = await this.publicQuery(body);
+    return mapMobileNotificationPreferences(data.preferences);
+  }
+
+  /*
+  Public executes
+   */
+
+  /**
+   * Unregisters an Expo push token, stopping delivery to that device. Unsigned, so it still works at logout
+   * when a wallet signature may no longer be obtainable. Idempotent: unregistering an inactive or unknown
+   * well-formed token succeeds.
+   *
+   * A registration that commits after this call re-activates the token, so stop or await any in-flight
+   * {@link MobileClient.registerExpoToken} before unregistering.
+   *
+   * @throws {MobileServerFailureError} With error code `INVALID_EXPO_TOKEN` if the token is malformed.
+   */
+  async unregisterExpoToken(
+    params: MobileUnregisterExpoTokenParams,
+  ): Promise<MobileServerSuccessResponse> {
+    const body: MobileServerPublicExecuteRequest<'unregister_expo_token'> = {
+      type: 'unregister_expo_token',
+      expo_token: params.expoToken,
+    };
+    return this.publicExecute(body);
+  }
+
+  /**
+   * Replaces the push notification preferences of the wallet that owns the given Expo push token. Possession
+   * of an active token is the credential rather than a signature, so anyone holding the token can overwrite
+   * that wallet's preferences. The backend requires `schemaVersion` of 1, exactly one entry per known
+   * category, and empty `scopes` on every entry.
+   *
+   * Writes are last-write-wins on commit order rather than ordered by a client nonce, so callers must
+   * serialize their own preference writes.
+   *
+   * @throws {MobileServerFailureError} With error code `INVALID_PREFERENCES` if those rules are violated, or
+   * `INVALID_EXPO_TOKEN` if the token is malformed or is not currently registered to a wallet.
+   */
+  async updateNotificationPreferences(
+    params: MobileUpdateNotificationPreferencesParams,
+  ): Promise<MobileServerSuccessResponse> {
+    const body: MobileServerPublicExecuteRequest<'update_preferences'> = {
+      type: 'update_preferences',
+      expo_token: params.expoToken,
+      preferences: mapMobileNotificationPreferencesToServer(params.preferences),
+    };
+    return this.publicExecute(body);
+  }
+
   /*
   Signed queries
    */
 
   /**
-   * Fetches the caller's own identity for a subaccount. Returns `null` if the subaccount has not claimed a
-   * username yet — this is normal data, not an error.
+   * Fetches the caller's own identity for a subaccount. Every non-isolated subaccount has an implicit
+   * identity, so this resolves for any valid sender with `username` and `displayName` `null` until a username
+   * is claimed.
+   *
+   * @throws {MobileServerFailureError} With error code `INVALID_IDENTITY_TARGET` if the sender is in the
+   * engine-created isolated namespace, which cannot own an identity.
    */
   async getSelfIdentity(
     params: GetMobileSelfIdentityParams,
@@ -150,30 +251,10 @@ export class MobileClient {
       params,
       {},
     );
-    const data =
-      await this.query<MobileServerSelfIdentityResponse>(signedRequest);
+    const data = await this.query<'self_identity'>(signedRequest);
     return data.identity ? mapMobileIdentity(data.identity) : null;
   }
 
-  /**
-   * Fetches a wallet's push notification preferences. Falls back to the backend's defaults if the wallet has
-   * never updated its preferences.
-   */
-  async getNotificationPreferences(
-    params: GetMobileNotificationPreferencesParams,
-  ): Promise<MobileNotificationPreferences> {
-    const signedRequest = await this.getSignedRequest(
-      'notification_preferences',
-      params,
-      {},
-    );
-    const data =
-      await this.query<MobileServerNotificationPreferencesResponse>(
-        signedRequest,
-      );
-    return mapMobileNotificationPreferences(data.preferences);
-  }
-
   /**
    * Fetches the devices registered for push notifications for a wallet.
    */
@@ -185,8 +266,7 @@ export class MobileClient {
       params,
       {},
     );
-    const data =
-      await this.query<MobileServerRegisteredDevicesResponse>(signedRequest);
+    const data = await this.query<'registered_devices'>(signedRequest);
     return data.devices.map(mapMobileRegisteredDevice);
   }
 
@@ -195,32 +275,21 @@ export class MobileClient {
    */
 
   /**
-   * Claims a username for a subaccount, derived from the given display name.
-   */
-  async claimUsername(
-    params: MobileClaimUsernameParams,
-  ): Promise<MobileServerSuccessResponse> {
-    const signedRequest = await this.getSignedRequest(
-      'claim_username',
-      params,
-      {
-        display_name: params.displayName,
-      },
-    );
-    return this.execute(signedRequest);
-  }
-
-  /**
-   * Updates the display name for a subaccount's already-claimed identity.
+   * Sets a subaccount's username, derived from the given display name. Upserts: the same call claims a first
+   * username and renames an existing one, so callers never need to read the current identity first.
+   *
+   * @throws {MobileServerFailureError} With error code `INVALID_DISPLAY_NAME` if the display name violates
+   * `MOBILE_DISPLAY_NAME_PATTERN`, `USERNAME_UNAVAILABLE` if the derived username is reserved or already
+   * taken by another subaccount, `INVALID_IDENTITY_TARGET` if the sender is in the engine-created isolated
+   * namespace, or `STALE_IDENTITY_UPDATE` if another identity write for this subaccount committed with a
+   * later nonce (re-read the identity before retrying).
    */
-  async updateUsername(
-    params: MobileUpdateUsernameParams,
+  async setUsername(
+    params: MobileSetUsernameParams,
   ): Promise<MobileServerSuccessResponse> {
-    const signedRequest = await this.getSignedRequest(
-      'update_username',
-      params,
-      { display_name: params.displayName },
-    );
+    const signedRequest = await this.getSignedRequest('set_username', params, {
+      display_name: params.displayName,
+    });
     return this.execute(signedRequest);
   }
 
@@ -262,41 +331,6 @@ export class MobileClient {
     return this.execute(signedRequest);
   }
 
-  /**
-   * Unregisters an Expo push token for the wallet. Idempotent — unregistering an unknown token succeeds.
-   */
-  async unregisterExpoToken(
-    params: MobileUnregisterExpoTokenParams,
-  ): Promise<MobileServerSuccessResponse> {
-    const signedRequest = await this.getSignedRequest(
-      'unregister_expo_token',
-      params,
-      { expo_token: params.expoToken },
-    );
-    return this.execute(signedRequest);
-  }
-
-  /**
-   * Replaces the wallet's push notification preferences. The backend requires `schemaVersion` of 1, exactly
-   * one entry per known category, and empty `scopes` on every entry.
-   *
-   * @throws {MobileServerFailureError} With error code `INVALID_PREFERENCES` if those rules are violated.
-   */
-  async updateNotificationPreferences(
-    params: MobileUpdateNotificationPreferencesParams,
-  ): Promise<MobileServerSuccessResponse> {
-    const signedRequest = await this.getSignedRequest(
-      'update_preferences',
-      params,
-      {
-        preferences: mapMobileNotificationPreferencesToServer(
-          params.preferences,
-        ),
-      },
-    );
-    return this.execute(signedRequest);
-  }
-
   /*
   Base Fns
    */
@@ -318,9 +352,11 @@ export class MobileClient {
     return buildSignedMobileRequest({ ...params, walletClient, inner });
   }
 
-  protected async publicQuery<TResponse extends { status: 'success' }>(
-    body: object,
-  ): Promise<TResponse> {
+  // Spelled out as an intersection rather than `MobileServerPublicQueryRequest<T>`: the latter is an indexed
+  // access on a mapped type, which is not an inference site, so `T` would always widen to the full union.
+  protected async publicQuery<T extends MobileServerPublicQueryRequestType>(
+    body: { type: T } & MobileServerPublicQueryRequestByType[T],
+  ): Promise<MobileServerPublicQuerySuccessResponse<T>> {
     const response = await this.axiosInstance.post<unknown>(
       `${this.opts.url}/mobile/public_query`,
       body,
@@ -330,12 +366,27 @@ export class MobileClient {
     this.checkServerStatus(response);
 
     // checkServerStatus throws on failure responses so the cast to the success response is acceptable here
-    return response.data as TResponse;
+    return response.data as MobileServerPublicQuerySuccessResponse<T>;
+  }
+
+  protected async publicExecute(
+    body: MobileServerPublicExecuteRequest,
+  ): Promise<MobileServerSuccessResponse> {
+    const response = await this.axiosInstance.post<MobileServerExecuteResult>(
+      `${this.opts.url}/mobile/public_execute`,
+      body,
+    );
+
+    this.checkResponseStatus(response);
+    this.checkServerStatus(response);
+
+    // checkServerStatus catches the failure result and throws the error, so the cast to the success response is acceptable here
+    return response.data as MobileServerSuccessResponse;
   }
 
-  protected async query<TResponse extends { status: 'success' }>(
+  protected async query<T extends MobileServerSignedQueryRequestType>(
     body: MobileSignedRequest,
-  ): Promise<TResponse> {
+  ): Promise<MobileServerSignedQuerySuccessResponse<T>> {
     const response = await this.axiosInstance.post<unknown>(
       `${this.opts.url}/mobile/query`,
       body,
@@ -345,7 +396,7 @@ export class MobileClient {
     this.checkServerStatus(response);
 
     // checkServerStatus throws on failure responses so the cast to the success response is acceptable here
-    return response.data as TResponse;
+    return response.data as MobileServerSignedQuerySuccessResponse<T>;
   }
 
   protected async execute(

package/src/dataMappers.ts

@@ -1,4 +1,6 @@
 import {
+  MobileFeedPage,
+  MobileFeedTrade,
   MobileIdentity,
   MobileNotificationPreferenceScope,
   MobileNotificationPreferences,
@@ -6,12 +8,14 @@ import {
   MobileRegisteredDevice,
 } from './types/clientTypes';
 import {
+  MobileServerFeedTrade,
   MobileServerIdentity,
   MobileServerNotificationPreferenceScope,
   MobileServerNotificationPreferences,
   MobileServerProfile,
   MobileServerRegisteredDevice,
 } from './types/serverModelTypes';
+import { MobileServerFeedResponse } from './types/serverQueryTypes';
 
 /**
  * Maps a server-side identity (snake_case) to its client-side (camelCase) representation.
@@ -37,6 +41,7 @@ export function mapMobilePublicProfile(
     subaccount: server.subaccount,
     username: server.username,
     displayName: server.display_name,
+    privateMode: server.private_mode,
   };
 }
 
@@ -90,6 +95,42 @@ function mapMobileNotificationPreferenceScopeToServer(
   return { type: 'product', product_id: scope.productId };
 }
 
+/**
+ * Maps a server-side feed trade (snake_case) to its client-side (camelCase) representation.
+ */
+function mapMobileFeedTrade(server: MobileServerFeedTrade): MobileFeedTrade {
+  return {
+    orderDigest: server.order_digest,
+    subaccount: server.subaccount,
+    username: server.username,
+    displayName: server.display_name,
+    avatarUrl: server.avatar_url,
+    productId: server.product_id,
+    quantity: server.quantity,
+    notional: server.notional,
+    averagePrice: server.average_price,
+    margin: {
+      mode: server.margin.mode,
+      estimatedLeverage: server.margin.estimated_leverage,
+    },
+    position: server.position,
+    realizedPnl: server.realized_pnl,
+    filledAt: server.filled_at_ms,
+  };
+}
+
+/**
+ * Maps a server-side feed response to a client-side {@link MobileFeedPage}.
+ */
+export function mapMobileFeedPage(
+  server: MobileServerFeedResponse,
+): MobileFeedPage {
+  return {
+    trades: server.trades.map(mapMobileFeedTrade),
+    nextCursor: server.next_cursor,
+  };
+}
+
 /**
  * Maps a server-side registered device (snake_case) to its client-side (camelCase) representation.
  */

package/src/signing/canonicalize.ts

@@ -1,21 +1,18 @@
-import { MobileServerNotificationPreferences } from '../types/serverModelTypes';
 import { MobileSignedInner } from './types';
 
 /**
  * Rebuilds an inner payload with its keys in the backend's struct declaration order (`type` first, then the
  * remaining fields in the exact order the backend serializes them). msgpack encodes object keys in insertion
  * order and the payload hash must be reproducible regardless of how the caller constructed the object, so
- * every inner payload — and each of its sub-types — is canonicalized here before hashing. This function (with
- * {@link canonicalizeNotificationPreferences} for nested preferences) is the source of truth for that order.
+ * every inner payload — and each of its sub-types — is canonicalized here before hashing. This function is
+ * the source of truth for that order.
  */
 export function canonicalizeMobileInner(
   inner: MobileSignedInner,
 ): MobileSignedInner {
   switch (inner.type) {
-    case 'claim_username':
-      return { type: 'claim_username', display_name: inner.display_name };
-    case 'update_username':
-      return { type: 'update_username', display_name: inner.display_name };
+    case 'set_username':
+      return { type: 'set_username', display_name: inner.display_name };
     case 'set_private_mode':
       return { type: 'set_private_mode', private_mode: inner.private_mode };
     case 'self_identity':
@@ -28,15 +25,6 @@ export function canonicalizeMobileInner(
         locale: inner.locale,
         app_version: inner.app_version,
       };
-    case 'unregister_expo_token':
-      return { type: 'unregister_expo_token', expo_token: inner.expo_token };
-    case 'update_preferences':
-      return {
-        type: 'update_preferences',
-        preferences: canonicalizeNotificationPreferences(inner.preferences),
-      };
-    case 'notification_preferences':
-      return { type: 'notification_preferences' };
     case 'registered_devices':
       return { type: 'registered_devices' };
     default: {
@@ -46,24 +34,3 @@ export function canonicalizeMobileInner(
     }
   }
 }
-
-/**
- * Rebuilds notification preferences with keys in the backend's struct declaration order, so the msgpack
- * encoding matches the backend's `rmp_serde::to_vec_named` output field-for-field.
- */
-function canonicalizeNotificationPreferences(
-  preferences: MobileServerNotificationPreferences,
-): MobileServerNotificationPreferences {
-  return {
-    schema_version: preferences.schema_version,
-    categories: preferences.categories.map((category) => ({
-      category: category.category,
-      enabled: category.enabled,
-      scopes: category.scopes.map((scope) =>
-        scope.type === 'subaccount'
-          ? { type: 'subaccount', subaccount: scope.subaccount }
-          : { type: 'product', product_id: scope.product_id },
-      ),
-    })),
-  };
-}

package/src/signing/eip712MethodByType.ts

@@ -7,13 +7,9 @@ export const MOBILE_EIP712_METHOD_BY_TYPE: Record<
   MobileSignedInner['type'],
   string
 > = {
-  claim_username: 'mobile:execute_claim_username',
-  update_username: 'mobile:execute_update_username',
+  set_username: 'mobile:execute_set_username',
   set_private_mode: 'mobile:execute_set_private_mode',
   self_identity: 'mobile:query_self_identity',
   register_expo_token: 'mobile:execute_register_expo_token',
-  unregister_expo_token: 'mobile:execute_unregister_expo_token',
-  update_preferences: 'mobile:execute_update_preferences',
-  notification_preferences: 'mobile:query_notification_preferences',
   registered_devices: 'mobile:query_registered_devices',
 };

package/src/signing/signing.test.ts

@@ -19,46 +19,30 @@ const FIXED_PRIVATE_KEY =
   '0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b786907' as const;
 const FIXED_VERIFYING_ADDR = '0x0000000000000000000000000000000000000001';
 
+// `set_username`, `set_private_mode`, and `register_expo_token` mirror the backend's pinned fixtures in
+// mobile/src/api/types.rs, so a divergence here is a real wire-format break rather than a stale expectation.
 const PINNED_HASHES = {
-  claim_username:
-    '0xcfbe9e0a546f43f6d68f86b38cf260ffe079af1915800c0e6df8724ddb6f2dff',
-  update_username:
-    '0x92c3831d30de8206f9ee9d4cf29ed2a2fb1612a3b818e2e46121fc1d5eb4edb6',
+  set_username:
+    '0xb4a55d9eb0be4e5c9457761c0c34c75cf39f7c07bd170700d8dd5e9c7de4a659',
   set_private_mode:
     '0x4d12a06234d751e6ddcc01d8f70836bb5b7e207e573641d1efb5aaf2b0f30d10',
   self_identity:
     '0x10e94c4502cade0a0b4d7469717bcc1d266fc6a3b7635236fa1d3600b58c9954',
-  // The three execute hashes below mirror the backend's pinned fixtures in mobile/src/api/types.rs.
   register_expo_token:
     '0x1b9471afc9bde66f9bffd576d3326420e1bade4e16afa3a73ddc65f27155611c',
-  unregister_expo_token:
-    '0xd131071d0898c97496f3d41dfc05f30a5f82c95e550944c4fba47419ddd0ebf3',
-  update_preferences:
-    '0x071b8ac6f3d2518267dd238c8c96e15e07e0552aede3ba32383706bb05726f83',
-  notification_preferences:
-    '0x3694dda0e5732b36eb3b60da6b147ec4e35520fc54529610c69d19d722d4fe97',
   registered_devices:
     '0xe77b42e32d27f054f86d5ed52c9aac7b3eed857eb6209ee883c92f01b84d3334',
 } as const;
 
 describe('[mobile-client]: signing (offline)', () => {
   describe('pinned payload hashes', () => {
-    it('claim_username', () => {
+    it('set_username', () => {
       const inner: MobileSignedInner = {
-        type: 'claim_username',
+        type: 'set_username',
         display_name: 'Alice.One',
       };
       const hash = getMobilePayloadHash(canonicalizeMobileInner(inner));
-      expect(hash).toBe(PINNED_HASHES.claim_username);
-    });
-
-    it('update_username', () => {
-      const inner: MobileSignedInner = {
-        type: 'update_username',
-        display_name: 'Alice.Two',
-      };
-      const hash = getMobilePayloadHash(canonicalizeMobileInner(inner));
-      expect(hash).toBe(PINNED_HASHES.update_username);
+      expect(hash).toBe(PINNED_HASHES.set_username);
     });
 
     it('set_private_mode', () => {
@@ -88,33 +72,6 @@ describe('[mobile-client]: signing (offline)', () => {
       expect(hash).toBe(PINNED_HASHES.register_expo_token);
     });
 
-    it('unregister_expo_token', () => {
-      const inner: MobileSignedInner = {
-        type: 'unregister_expo_token',
-        expo_token: 'ExponentPushToken[abcdef1234567890abcdef]',
-      };
-      const hash = getMobilePayloadHash(canonicalizeMobileInner(inner));
-      expect(hash).toBe(PINNED_HASHES.unregister_expo_token);
-    });
-
-    it('update_preferences', () => {
-      const inner: MobileSignedInner = {
-        type: 'update_preferences',
-        preferences: {
-          schema_version: 1,
-          categories: [{ category: 'order_fill', enabled: true, scopes: [] }],
-        },
-      };
-      const hash = getMobilePayloadHash(canonicalizeMobileInner(inner));
-      expect(hash).toBe(PINNED_HASHES.update_preferences);
-    });
-
-    it('notification_preferences', () => {
-      const inner: MobileSignedInner = { type: 'notification_preferences' };
-      const hash = getMobilePayloadHash(canonicalizeMobileInner(inner));
-      expect(hash).toBe(PINNED_HASHES.notification_preferences);
-    });
-
     it('registered_devices', () => {
       const inner: MobileSignedInner = { type: 'registered_devices' };
       const hash = getMobilePayloadHash(canonicalizeMobileInner(inner));
@@ -134,19 +91,19 @@ describe('[mobile-client]: signing (offline)', () => {
     expect(hash).toBe(PINNED_HASHES.set_private_mode);
   });
 
-  it('canonicalizes nested preference key order regardless of input key order', () => {
-    // Nested preference objects must also be rebuilt in the backend's struct declaration order
-    // (schema_version, categories; category, enabled, scopes) for the msgpack hash to be deterministic.
+  it('canonicalizes multi-field key order regardless of input key order', () => {
+    // register_expo_token is the only signed payload with more than one field, so it is where a caller can
+    // actually get the order wrong; canonicalizeMobileInner must rebuild it in the backend's declaration order.
     const outOfOrderInner = {
-      preferences: {
-        categories: [{ scopes: [], enabled: true, category: 'order_fill' }],
-        schema_version: 1,
-      },
-      type: 'update_preferences',
-    } as unknown as MobileSignedInner;
+      app_version: '1.2.3',
+      locale: 'en-GB',
+      platform: 'ios',
+      expo_token: 'ExponentPushToken[abcdef1234567890abcdef]',
+      type: 'register_expo_token',
+    } as MobileSignedInner;
 
     const hash = getMobilePayloadHash(canonicalizeMobileInner(outOfOrderInner));
-    expect(hash).toBe(PINNED_HASHES.update_preferences);
+    expect(hash).toBe(PINNED_HASHES.register_expo_token);
   });
 
   describe('nonce generation', () => {