@nadohq/mobile-client 0.36.0 → 0.38.0

package/src/types/clientTypes.ts

@@ -9,7 +9,11 @@ import {
 
 /**
  * A subaccount's public profile, as returned by an unsigned profile lookup. Private Mode hides the account's
- * activity, not its profile, so `privateMode` is exposed here too.
+ * activity, not its profile, so `privateMode` is exposed here too. A subaccount with no identity row still
+ * yields a profile, with `null` names and `privateMode: false`.
+ *
+ * The last three fields are `undefined` unless the matching {@link MobileProfilesInclude} asked for them —
+ * absent means "not requested" rather than "none".
  */
 export interface MobilePublicProfile {
   subaccount: Hex;
@@ -18,6 +22,82 @@ export interface MobilePublicProfile {
   /** User-facing name as claimed, or `null` if no username has been claimed. */
   displayName: string | null;
   privateMode: boolean;
+  /**
+   * Exact count at query time rather than a cached counter, including unnamed and private accounts — Private
+   * Mode hides activity, not relationships. Requires the `followCounts` include.
+   */
+  followerCount?: number;
+  followingCount?: number;
+  /** Requires the `followSummary` include, and is relative to that include's `viewAs`. */
+  followSummary?: MobileFollowSummary;
+}
+
+/**
+ * The identity fields the backend attaches to a subaccount wherever it surfaces one alongside other data.
+ * Resolved at read time, so a rename shows up on the next read without any change to the surrounding record.
+ */
+export interface MobileIdentitySummary {
+  subaccount: Hex;
+  /** `null` when the account has not claimed a username; render a local fallback label from `subaccount`. */
+  username: string | null;
+  /** `null` when the account has not claimed a username; render a local fallback label from `subaccount`. */
+  displayName: string | null;
+  /** Reserved for a future avatar source; `null` until one is implemented. */
+  avatarUrl: string | null;
+}
+
+/**
+ * A viewer's relationship with one Profile, plus the Followed By preview: accounts the viewer follows that
+ * also follow that Profile. Every preview entry is therefore already familiar to the viewer, which is why it
+ * carries no `isFollowing` of its own.
+ */
+export interface MobileFollowSummary {
+  /** The direct `viewer -> viewed Profile` relationship. */
+  isFollowing: boolean;
+  /** Exact size of the two-edge intersection, independent of how many previews came back. */
+  followedByCount: number;
+  /**
+   * Newest `preview -> viewed Profile` relationship first, with a bytes32 tie-break. Capped at
+   * `MOBILE_FOLLOWED_BY_PREVIEW_LIMIT` (2) by the backend and not client-configurable.
+   */
+  followedBy: MobileIdentitySummary[];
+}
+
+/**
+ * One row of a Followers or Following page.
+ */
+export interface MobileFollowListAccount {
+  identity: MobileIdentitySummary;
+  /**
+   * Whether the `viewAs` Viewer follows this account — not the listed relationship that put it in the page.
+   * The Viewer can appear in another Profile's list, and does not follow themself, so their own row is
+   * `false`. `undefined` when the request named no `viewAs`, which is a missing perspective rather than a
+   * known "not following".
+   */
+  isFollowing?: boolean;
+  /** This account's own follower count. */
+  followerCount: number;
+}
+
+/**
+ * A page of Followers or Following. Pagination is live rather than snapshot: a Follow or Unfollow between
+ * pages can move an account, so an account can appear twice or not at all across one session. Deduplicate by
+ * {@link MobileIdentitySummary.subaccount} and restart from `cursor: undefined` on refresh.
+ */
+export interface MobileFollowListPage {
+  accounts: MobileFollowListAccount[];
+  /** `null` means the list is complete. */
+  nextCursor: string | null;
+}
+
+/**
+ * Post-commit state of a follow or unfollow. The mutation and its count share one database transaction, so
+ * these values are authoritative — apply them rather than re-reading.
+ */
+export interface MobileFollowMutationResult {
+  isFollowing: boolean;
+  /** The *target's* follower count after the mutation, not the sender's. */
+  followerCount: number;
 }
 
 /**
@@ -43,16 +123,9 @@ export interface MobileFeedMargin {
  * (a rename can change an already-fetched trade on the next read). Amounts are display-oriented human-unit
  * numbers — do not use them for accounting, order construction, or exact threshold decisions.
  */
-export interface MobileFeedTrade {
+export interface MobileFeedTrade extends MobileIdentitySummary {
   /** Order digest this trade is keyed by; the stable id for reconciling live pagination. */
   orderDigest: Hex;
-  subaccount: Hex;
-  /** `null` when the trader has not claimed a username; render a local fallback label from `subaccount`. */
-  username: string | null;
-  /** `null` when the trader has not claimed a username; render a local fallback label from `subaccount`. */
-  displayName: string | null;
-  /** Reserved for a future avatar source; `null` until one is implemented. */
-  avatarUrl: string | null;
   productId: number;
   /** Executed quantity in human units. */
   quantity: number;
@@ -155,9 +228,30 @@ export interface GetMobileUsernameAvailabilityParams {
 }
 
 /**
- * Params for {@link MobileClient.getPublicProfile}.
+ * Opt-in extras for a profiles lookup. Each one adds fields that are otherwise absent from every returned
+ * profile, and costs extra rate-limit weight per profile, so ask only for what the UI shows.
  */
-export type GetMobilePublicProfileParams = Subaccount;
+export interface MobileProfilesInclude {
+  /** Populates `followerCount` and `followingCount`. */
+  followCounts?: boolean;
+  /**
+   * Populates `followSummary`, relative to `viewAs`. This viewer identity is an unauthenticated claim — the
+   * route takes no signature — so do not treat the result as proof of who is asking.
+   */
+  followSummary?: { viewAs: Subaccount };
+}
+
+/**
+ * Params for {@link MobileClient.getProfiles}.
+ */
+export interface GetMobileProfilesParams {
+  /**
+   * 1–`MOBILE_PROFILES_MAX_BATCH_SIZE` (25) distinct subaccounts. Duplicates and an empty list are rejected
+   * rather than deduplicated, and results come back in this exact order.
+   */
+  subaccounts: Subaccount[];
+  include?: MobileProfilesInclude;
+}
 
 /**
  * Params for {@link MobileClient.getFeed}.
@@ -192,6 +286,53 @@ export interface MobileSetPrivateModeParams extends MobileSignedRequestParams {
   privateMode: boolean;
 }
 
+/**
+ * Params for {@link MobileClient.setFollow}. The subaccount carried by {@link MobileSignedRequestParams} is
+ * the signing Follower; `target` is the Profile on the other end of the relationship.
+ */
+export interface MobileSetFollowParams extends MobileSignedRequestParams {
+  /** The Profile being followed or unfollowed. Must not be the signing subaccount. */
+  target: Subaccount;
+  /** `true` follows the target, `false` unfollows it. Both directions are idempotent. */
+  isFollowing: boolean;
+}
+
+/**
+ * Common params for a Followers or Following page.
+ */
+export interface GetMobileFollowListParams {
+  /** The Profile whose Followers or Following are being listed. */
+  target: Subaccount;
+  /**
+   * Viewer to resolve the page against, which turns on familiar-first ordering and populates every row's
+   * {@link MobileFollowListAccount.isFollowing}. Omit it for a plain recency-ordered list with no
+   * `isFollowing` at all. The route is unsigned, so this is an unauthenticated claim rather than proof of
+   * who is asking.
+   */
+  viewAs?: Subaccount;
+  /**
+   * Opaque cursor from the previous page's {@link MobileFollowListPage.nextCursor}. Omit for the first page.
+   * A cursor is bound to its `viewAs` (including its absence), Profile, and list direction — reusing it
+   * elsewhere fails with `INVALID_FOLLOW_CURSOR`.
+   */
+  cursor?: string;
+  /**
+   * Page size, 1–`MOBILE_FOLLOW_LIST_MAX_PAGE_SIZE` (50); the backend defaults to
+   * `MOBILE_FOLLOW_LIST_DEFAULT_PAGE_SIZE` (25) when omitted.
+   */
+  limit?: number;
+}
+
+/**
+ * Params for {@link MobileClient.getFollowers}.
+ */
+export type GetMobileFollowersParams = GetMobileFollowListParams;
+
+/**
+ * Params for {@link MobileClient.getFollowing}.
+ */
+export type GetMobileFollowingParams = GetMobileFollowListParams;
+
 /**
  * Params for {@link MobileClient.registerExpoToken}.
  */

package/src/types/mobileErrorCodes.ts

@@ -13,6 +13,18 @@ export const MOBILE_ERROR_CODES = {
   /** Another identity write for the subaccount committed with a later nonce. Re-read before retrying. */
   STALE_IDENTITY_UPDATE: 6105,
   PROFILE_NOT_FOUND: 6106,
+  /** Profiles lookup is empty, holds duplicates, or exceeds the batch maximum. Do not retry unchanged. */
+  INVALID_PROFILES_REQUEST: 6107,
+  /** Follow mutation names the same source and target, or an isolated participant. Do not retry unchanged. */
+  INVALID_FOLLOW_TARGET: 6110,
+  /** Signed follower is not yet in the canonical Query DB subaccount index. Retry after index catch-up. */
+  FOLLOWER_NOT_ELIGIBLE: 6111,
+  /** Follow target is not yet in the canonical Query DB subaccount index. Refresh after a new record. */
+  FOLLOWING_NOT_FOUND: 6112,
+  /** Follow list cursor is malformed or bound to a different list request. Restart from `cursor: null`. */
+  INVALID_FOLLOW_CURSOR: 6113,
+  /** A follow list or followed-by limit is outside its accepted range. Fix it; do not retry unchanged. */
+  INVALID_FOLLOW_LIMIT: 6114,
   INVALID_EXPO_TOKEN: 6200,
   INVALID_DEVICE_METADATA: 6201,
   INVALID_PREFERENCES: 6202,

package/src/types/serverExecuteTypes.ts

@@ -3,6 +3,7 @@ import {
   MobileServerSuccessResponse,
 } from './serverBaseTypes';
 import {
+  MobileServerExecuteRequestType,
   MobileServerPublicExecuteRequestByType,
   MobileServerPublicExecuteRequestType,
 } from './serverRequestTypes';
@@ -21,8 +22,45 @@ export type MobileServerPublicExecuteRequest<
 }[T];
 
 /**
- * Discriminated `execute` result union. Mobile execute routes return no payload beyond the success
- * discriminant, so the success arm is the base success envelope; failures use the uniform failure envelope.
+ * Payload the `set_follow` execute returns alongside the success envelope. The mutation and the count commit
+ * in one database transaction, so these are the authoritative post-mutation values — prefer them over
+ * re-reading, and note that overlapping toggles for the same pair can respond out of arrival order.
+ */
+export interface MobileServerFollowMutationResponse {
+  is_following: boolean;
+  /** The *target's* follower count after the mutation, not the sender's. */
+  follower_count: number;
+}
+
+/**
+ * Payload of an execute route that returns nothing beyond the success discriminant. Spelled `Record<never,
+ * never>` rather than `Record<string, never>` because the latter's index signature would collapse `status` to
+ * `never` when intersected with the success envelope.
+ */
+export type MobileServerEmptyExecuteResponse = Record<never, never>;
+
+/**
+ * Success payloads for each signed `execute`, keyed by request `type`. Most execute routes carry no payload
+ * beyond the success discriminant and so map to an empty object; `set_follow` returns its post-commit
+ * relationship state.
+ */
+export interface MobileServerExecuteResponseByType {
+  set_username: MobileServerEmptyExecuteResponse;
+  set_private_mode: MobileServerEmptyExecuteResponse;
+  register_expo_token: MobileServerEmptyExecuteResponse;
+  set_follow: MobileServerFollowMutationResponse;
+}
+
+/**
+ * Full success response for a signed `execute`: the {@link MobileServerSuccessResponse} envelope with the
+ * route's payload inlined alongside `status`, matching how the query routes inline theirs.
+ */
+export type MobileServerExecuteSuccessResponse<
+  T extends MobileServerExecuteRequestType = MobileServerExecuteRequestType,
+> = MobileServerSuccessResponse & MobileServerExecuteResponseByType[T];
+
+/**
+ * Discriminated `execute` result union used at the transport boundary, before the envelope is narrowed.
  */
 export type MobileServerExecuteResult =
   | MobileServerSuccessResponse

package/src/types/serverModelTypes.ts

@@ -18,14 +18,69 @@ export type MobileNotificationCategory =
   | 'announcement';
 
 /**
- * Server-side public profile shape (snake_case). Name fields are `null` until the subaccount claims a
- * username.
+ * Server-side identity summary (snake_case): the read-time identity fields the backend attaches to a
+ * subaccount wherever it surfaces one alongside other data. Name fields are `null` until the subaccount
+ * claims a username, and a rename shows up on the next read without any change to the surrounding record.
+ */
+export interface MobileServerIdentitySummary {
+  subaccount: Hex;
+  username: string | null;
+  display_name: string | null;
+  /** Reserved for a future avatar source; `null` until one is implemented. */
+  avatar_url: string | null;
+}
+
+/**
+ * Server-side follow summary (snake_case), nested in a `profiles` entry when the `follow_summary` include is
+ * requested. `is_following` is the direct `view_as -> this profile` relationship; every `followed_by` entry
+ * satisfies both `view_as -> entry` and `entry -> this profile`, so each one is already familiar to the
+ * viewer and carries no `is_following` of its own.
+ */
+export interface MobileServerFollowSummary {
+  is_following: boolean;
+  /** Exact size of the two-edge intersection, independent of how many previews came back. */
+  followed_by_count: number;
+  /** Capped at `MOBILE_FOLLOWED_BY_PREVIEW_LIMIT` (2) by the backend; not client-configurable. */
+  followed_by: MobileServerIdentitySummary[];
+}
+
+/**
+ * Server-side public profile shape (snake_case), shared by the singular `profile` and batched `profiles`
+ * queries. Name fields are `null` until the subaccount claims a username; a subaccount with no identity row
+ * still yields an entry, with `null` names and `private_mode: false`.
+ *
+ * The three optional fields are omitted from the wire entirely unless the matching `profiles` include asked
+ * for them, which is why they are optional rather than nullable — absent means "not requested", not "none".
+ * The singular `profile` query never returns any of them.
  */
 export interface MobileServerProfile {
   subaccount: Hex;
   username: string | null;
   display_name: string | null;
   private_mode: boolean;
+  /**
+   * Exact count at query time — the backend counts rather than reading a cached counter. Unnamed and private
+   * accounts are included: Private Mode hides activity, not relationships. Requires `follow_counts`.
+   */
+  follower_count?: number;
+  following_count?: number;
+  /** Requires the `follow_summary` include, and is relative to that include's `view_as`. */
+  follow_summary?: MobileServerFollowSummary;
+}
+
+/**
+ * Server-side row of a Followers or Following page (snake_case).
+ */
+export interface MobileServerFollowListAccount {
+  identity: MobileServerIdentitySummary;
+  /**
+   * The `view_as` Viewer's relationship to this account, not the listed relationship that put it in the
+   * page, so it is `false` on the Viewer's own row. Omitted entirely when the request named no `view_as`,
+   * rather than being sent as a misleading `false`.
+   */
+  is_following?: boolean;
+  /** The listed account's own follower count, exact at query time. */
+  follower_count: number;
 }
 
 /**
@@ -97,14 +152,9 @@ export interface MobileServerFeedMargin {
  * trader's current identity. Amounts are display-oriented human-unit JSON numbers — do not use them for
  * accounting, order construction, or exact threshold decisions.
  */
-export interface MobileServerFeedTrade {
+export interface MobileServerFeedTrade extends MobileServerIdentitySummary {
   /** Order digest this row is keyed by; the stable id clients use to reconcile live pagination. */
   order_digest: Hex;
-  subaccount: Hex;
-  username: string | null;
-  display_name: string | null;
-  /** Reserved for a future avatar source; `null` until one is implemented. */
-  avatar_url: string | null;
   product_id: number;
   /** Executed quantity in human units. */
   quantity: number;

package/src/types/serverQueryTypes.ts

@@ -3,6 +3,7 @@ import { MobileServerSuccessResponse } from './serverBaseTypes';
 import {
   MobileNotificationPlatform,
   MobileServerFeedTrade,
+  MobileServerFollowListAccount,
   MobileServerNotificationPreferences,
   MobileServerProfile,
 } from './serverModelTypes';
@@ -32,10 +33,21 @@ export interface MobileServerUsernameAvailabilityResponse {
 }
 
 /**
- * Payload of the `profile` public query success response.
+ * Payload of the `profiles` public query success response. One entry per requested subaccount, in the exact
+ * order they were requested, so callers can correlate positionally as well as by `subaccount`.
  */
-export interface MobileServerProfileResponse {
-  profile: MobileServerProfile;
+export interface MobileServerProfilesResponse {
+  profiles: MobileServerProfile[];
+}
+
+/**
+ * Payload of the `followers` and `following` public query success responses. Both list directions share one
+ * shape; only the relationship that selected the rows differs.
+ */
+export interface MobileServerFollowListResponse {
+  accounts: MobileServerFollowListAccount[];
+  /** `null` means the list is complete. */
+  next_cursor: string | null;
 }
 
 /**
@@ -79,7 +91,9 @@ export interface MobileServerRegisteredWalletResponse {
  */
 export interface MobileServerPublicQueryResponseByType {
   username_availability: MobileServerUsernameAvailabilityResponse;
-  profile: MobileServerProfileResponse;
+  profiles: MobileServerProfilesResponse;
+  followers: MobileServerFollowListResponse;
+  following: MobileServerFollowListResponse;
   feed: MobileServerFeedResponse;
   notification_preferences: MobileServerNotificationPreferencesResponse;
   registered_wallet: MobileServerRegisteredWalletResponse;

package/src/types/serverRequestTypes.ts

@@ -2,12 +2,55 @@ import { Hex } from 'viem';
 import { MobileSignedInner } from '../signing/types';
 import { MobileServerNotificationPreferences } from './serverModelTypes';
 
+/**
+ * Opt-in extras for a `profiles` query. Each one costs extra rate-limit weight per profile and adds fields
+ * that are otherwise absent from the response, so the backend gates them behind an explicit request rather
+ * than always resolving the follow graph on a public route.
+ */
+export interface MobileServerProfilesInclude {
+  /** Adds `follower_count` and `following_count` to every entry. Omitted or `false` leaves both absent. */
+  follow_counts?: boolean;
+  /**
+   * Adds `follow_summary` to every entry, relative to the `view_as` subaccount. As on every public route,
+   * `view_as` is an unauthenticated claim.
+   */
+  follow_summary?: { view_as: Hex };
+}
+
+/**
+ * Params shared by the `followers` and `following` public queries: only the relationship that selects the
+ * rows differs between the two.
+ */
+export interface MobileServerFollowListRequest {
+  /** The viewed Profile, i.e. the account whose Followers or Following are being listed. */
+  subaccount: Hex;
+  /**
+   * Viewer perspective the rows are resolved against. Omitted asks for no perspective, which drops
+   * `is_following` from every row and falls back to plain recency order. Like the `profiles` query's
+   * `view_as`, this is an unauthenticated claim on an unsigned route.
+   */
+  view_as?: Hex;
+  /** Opaque keyset cursor from a prior page's `next_cursor`. Omitted requests the first page. */
+  cursor?: string;
+  /** Page size, 1–50; the backend defaults to 25 when omitted. */
+  limit?: number;
+}
+
 /**
  * Params for each unsigned `public_query`, keyed by request `type`.
  */
 export interface MobileServerPublicQueryRequestByType {
   username_availability: { display_name: string };
-  profile: { subaccount: Hex };
+  profiles: {
+    /**
+     * 1–`MOBILE_PROFILES_MAX_BATCH_SIZE` (25) distinct subaccounts. Results come back in this exact order,
+     * one entry per request slot.
+     */
+    subaccounts: Hex[];
+    include?: MobileServerProfilesInclude;
+  };
+  followers: MobileServerFollowListRequest;
+  following: MobileServerFollowListRequest;
   feed: {
     /**
      * Minimum notional as a whole-dollar JSON integer (NOT an x18 string), at least $1,000. Omitted or
@@ -53,15 +96,18 @@ export type MobileServerPublicExecuteRequestType =
   keyof MobileServerPublicExecuteRequestByType;
 
 /**
- * Discriminant `type` values for signed `execute` requests: the write subset of {@link MobileSignedInner}
- * tags. With no signed queries remaining, every signed inner type is an execute.
+ * Discriminant `type` values for signed `execute` requests. Every signed route the SDK calls is a write, so
+ * this is the full set of {@link MobileSignedInner} tags. Unlike the public queries these carry no separate
+ * params map — a signed request body *is* its inner payload flattened with the envelope, so
+ * {@link MobileSignedInner} is the single source of truth for both the fields and their significant order.
  */
 export type MobileServerExecuteRequestType = MobileSignedInner['type'];
 
 /**
  * Wire `request_type` the backend echoes on failure envelopes, prefixed by the route that produced it:
  * `public_query_*` for unsigned queries, `public_execute_*` for unsigned writes, and `execute_*` for signed
- * writes (e.g. `execute_set_username`).
+ * writes (e.g. `execute_set_username`). The prefix names the route, so it never carries the `mobile:` prefix
+ * that the EIP-712 method does.
  */
 export type MobileServerRequestType =
   | `public_query_${MobileServerPublicQueryRequestType}`

package/src/utils/follow.ts

@@ -0,0 +1,22 @@
+/**
+ * Maximum Followers/Following page size the backend accepts. Requests outside 1–50 fail with
+ * `INVALID_FOLLOW_LIMIT`.
+ */
+export const MOBILE_FOLLOW_LIST_MAX_PAGE_SIZE = 50;
+
+/**
+ * Page size the backend uses when `limit` is omitted from a Followers or Following request.
+ */
+export const MOBILE_FOLLOW_LIST_DEFAULT_PAGE_SIZE = 25;
+
+/**
+ * Number of Followed By preview identities a follow summary carries. Fixed by the backend rather than
+ * requested, so use it to size the preview UI; `followedByCount` still reports the full intersection.
+ */
+export const MOBILE_FOLLOWED_BY_PREVIEW_LIMIT = 2;
+
+/**
+ * Maximum number of subaccounts a single profiles lookup accepts. An empty list, a duplicate, or more than
+ * this many fail with `INVALID_PROFILES_REQUEST`.
+ */
+export const MOBILE_PROFILES_MAX_BATCH_SIZE = 25;

package/src/utils/index.ts

@@ -1,3 +1,4 @@
 export * from './feed';
+export * from './follow';
 export * from './patterns';
 export * from './serverResponseGuards';

package/dist/MobileClient-D5TNTnLx.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"MobileClient-D5TNTnLx.cjs","names":["mapMobilePublicProfile","mapMobileFeedPage","mapMobileNotificationPreferences","mapMobileRegisteredWallet","mapMobileNotificationPreferencesToServer","WalletNotProvidedError","buildSignedMobileRequest","isMobileServerFailureResponse","MobileServerFailureError","isMobileServerSuccessResponse"],"sources":["../src/MobileClient.ts"],"sourcesContent":["import {\n  getNadoClientTypeHeaders,\n  subaccountToHex,\n  WalletClientWithAccount,\n  WalletNotProvidedError,\n} from '@nadohq/shared';\nimport axios, { AxiosInstance, AxiosResponse } from 'axios';\nimport {\n  mapMobileFeedPage,\n  mapMobileNotificationPreferences,\n  mapMobileNotificationPreferencesToServer,\n  mapMobilePublicProfile,\n  mapMobileRegisteredWallet,\n} from './dataMappers';\nimport {\n  buildSignedMobileRequest,\n  MobileSignedInner,\n  MobileSignedInnerParams,\n  MobileSignedRequest,\n} from './signing';\nimport {\n  GetMobileFeedParams,\n  GetMobileNotificationPreferencesParams,\n  GetMobilePublicProfileParams,\n  GetMobileRegisteredWalletParams,\n  GetMobileUsernameAvailabilityParams,\n  MobileFeedPage,\n  MobileNotificationPreferences,\n  MobilePublicProfile,\n  MobileRegisteredWallet,\n  MobileRegisterExpoTokenParams,\n  MobileSetPrivateModeParams,\n  MobileSetUsernameParams,\n  MobileSignedRequestParams,\n  MobileUnregisterExpoTokenParams,\n  MobileUpdateNotificationPreferencesParams,\n  MobileUsernameAvailability,\n} from './types/clientTypes';\nimport { MobileServerFailureError } from './types/MobileServerFailureError';\nimport { MobileServerSuccessResponse } from './types/serverBaseTypes';\nimport {\n  MobileServerExecuteResult,\n  MobileServerPublicExecuteRequest,\n} from './types/serverExecuteTypes';\nimport {\n  MobileServerPublicQueryRequest,\n  MobileServerPublicQuerySuccessResponse,\n} from './types/serverQueryTypes';\nimport {\n  MobileServerPublicQueryRequestByType,\n  MobileServerPublicQueryRequestType,\n} from './types/serverRequestTypes';\nimport {\n  isMobileServerFailureResponse,\n  isMobileServerSuccessResponse,\n} from './utils/serverResponseGuards';\n\n/**\n * Options for constructing a {@link MobileClient}.\n */\nexport interface MobileClientOpts {\n  /**\n   * Base URL of the mobile service API, e.g. {@link MOBILE_CLIENT_ENDPOINTS}.\n   */\n  url: string;\n  /**\n   * Wallet client used to sign requests.\n   */\n  walletClient?: WalletClientWithAccount;\n  /**\n   * If provided, this signer is used instead of `walletClient` for all signed requests.\n   */\n  linkedSignerWalletClient?: WalletClientWithAccount;\n  /**\n   * If provided, identifies the calling client, sent as a header with every request.\n   */\n  clientType?: string;\n}\n\n/**\n * Client for the Nado mobile service API: usernames, public profile lookups, the global trade feed, privacy\n * settings, and push notification device/preference management.\n */\nexport class MobileClient {\n  readonly opts: MobileClientOpts;\n  readonly axiosInstance: AxiosInstance;\n\n  constructor(opts: MobileClientOpts) {\n    this.opts = opts;\n    this.axiosInstance = axios.create({\n      withCredentials: true,\n      // We have custom logic to validate response status and create an appropriate error\n      validateStatus: () => true,\n      headers: getNadoClientTypeHeaders(opts.clientType),\n    });\n  }\n\n  /**\n   * Sets the linked signer for requests\n   *\n   * @param linkedSignerWalletClient The linkedSigner to use for all signatures. Set to null to revert to the chain signer\n   */\n  public setLinkedSigner(\n    linkedSignerWalletClient: WalletClientWithAccount | null,\n  ) {\n    this.opts.linkedSignerWalletClient = linkedSignerWalletClient ?? undefined;\n  }\n\n  /*\n  Public queries\n   */\n\n  /**\n   * Checks whether a username derived from the given display name is available to claim.\n   */\n  async getUsernameAvailability(\n    params: GetMobileUsernameAvailabilityParams,\n  ): Promise<MobileUsernameAvailability> {\n    const body: MobileServerPublicQueryRequest<'username_availability'> = {\n      type: 'username_availability',\n      display_name: params.displayName,\n    };\n    const data = await this.publicQuery(body);\n    return { username: data.username, available: data.available };\n  }\n\n  /**\n   * Looks up a subaccount's public profile. Every non-isolated subaccount resolves, with `username` and\n   * `displayName` `null` until a username is claimed. Private Mode does not hide the profile itself, only the\n   * account's activity.\n   *\n   * @throws {MobileServerFailureError} With error code `PROFILE_NOT_FOUND` if the subaccount is in the\n   * engine-created isolated namespace, which cannot own a profile.\n   */\n  async getPublicProfile(\n    params: GetMobilePublicProfileParams,\n  ): Promise<MobilePublicProfile> {\n    const body: MobileServerPublicQueryRequest<'profile'> = {\n      type: 'profile',\n      subaccount: subaccountToHex(params),\n    };\n    const data = await this.publicQuery(body);\n    return mapMobilePublicProfile(data.profile);\n  }\n\n  /**\n   * Fetches a page of the global trade feed: public perpetual trades, newest first, optionally filtered by a\n   * whole-dollar minimum notional (omitted means unfiltered). Trades by subaccounts that have not claimed a\n   * username are included with `null` name fields; only private accounts are filtered out. The feed is\n   * best-effort rather than authoritative history, and pagination is live (not snapshot), so deduplicate pages\n   * by {@link MobileFeedTrade.orderDigest}.\n   *\n   * @throws {MobileServerFailureError} With error code `INVALID_FEED_FILTER` if `minimumNotional` or\n   * `limit` is outside its allowed domain (fix the request; do not retry unchanged), or\n   * `INVALID_FEED_CURSOR` if the cursor is malformed or was issued for a different `minimumNotional`\n   * (discard the cursor and restart from the first page).\n   */\n  async getFeed(params: GetMobileFeedParams = {}): Promise<MobileFeedPage> {\n    const body: MobileServerPublicQueryRequest<'feed'> = {\n      type: 'feed',\n      minimum_notional: params.minimumNotional,\n      limit: params.limit,\n      cursor: params.cursor,\n    };\n    const data = await this.publicQuery(body);\n    return mapMobileFeedPage(data);\n  }\n\n  /**\n   * Fetches the push notification preferences of the wallet that owns the given Expo push token. Unsigned —\n   * the token identifies the wallet on its own. Falls back to the backend's defaults if the wallet has never\n   * updated its preferences.\n   *\n   * @throws {MobileServerFailureError} With error code `INVALID_EXPO_TOKEN` if the token is malformed, or is\n   * not currently registered to a wallet.\n   */\n  async getNotificationPreferences(\n    params: GetMobileNotificationPreferencesParams,\n  ): Promise<MobileNotificationPreferences> {\n    const body: MobileServerPublicQueryRequest<'notification_preferences'> = {\n      type: 'notification_preferences',\n      expo_token: params.expoToken,\n    };\n    const data = await this.publicQuery(body);\n    return mapMobileNotificationPreferences(data.preferences);\n  }\n\n  /**\n   * Resolves the wallet that an Expo push token is currently registered to, along with the redacted metadata\n   * of the device that registered it. Unsigned — the token identifies the wallet on its own. Use it to check\n   * whether a locally held token is still active and which wallet currently owns it, since registering the\n   * same token under another wallet transfers ownership.\n   *\n   * @throws {MobileServerFailureError} With error code `INVALID_EXPO_TOKEN` if the token is malformed, or is\n   * not currently registered to a wallet — including a token that was unregistered. The backend does not\n   * distinguish those cases.\n   */\n  async getRegisteredWallet(\n    params: GetMobileRegisteredWalletParams,\n  ): Promise<MobileRegisteredWallet> {\n    const body: MobileServerPublicQueryRequest<'registered_wallet'> = {\n      type: 'registered_wallet',\n      expo_token: params.expoToken,\n    };\n    const data = await this.publicQuery(body);\n    return mapMobileRegisteredWallet(data);\n  }\n\n  /*\n  Public executes\n   */\n\n  /**\n   * Unregisters an Expo push token, stopping delivery to that device. Unsigned, so it still works at logout\n   * when a wallet signature may no longer be obtainable. Idempotent: unregistering an inactive or unknown\n   * well-formed token succeeds.\n   *\n   * A registration that commits after this call re-activates the token, so stop or await any in-flight\n   * {@link MobileClient.registerExpoToken} before unregistering.\n   *\n   * @throws {MobileServerFailureError} With error code `INVALID_EXPO_TOKEN` if the token is malformed.\n   */\n  async unregisterExpoToken(\n    params: MobileUnregisterExpoTokenParams,\n  ): Promise<MobileServerSuccessResponse> {\n    const body: MobileServerPublicExecuteRequest<'unregister_expo_token'> = {\n      type: 'unregister_expo_token',\n      expo_token: params.expoToken,\n    };\n    return this.publicExecute(body);\n  }\n\n  /**\n   * Replaces the push notification preferences of the wallet that owns the given Expo push token. Possession\n   * of an active token is the credential rather than a signature, so anyone holding the token can overwrite\n   * that wallet's preferences. The backend requires `schemaVersion` of 1, exactly one entry per known\n   * category, and empty `scopes` on every entry.\n   *\n   * Writes are last-write-wins on commit order rather than ordered by a client nonce, so callers must\n   * serialize their own preference writes.\n   *\n   * @throws {MobileServerFailureError} With error code `INVALID_PREFERENCES` if those rules are violated, or\n   * `INVALID_EXPO_TOKEN` if the token is malformed or is not currently registered to a wallet.\n   */\n  async updateNotificationPreferences(\n    params: MobileUpdateNotificationPreferencesParams,\n  ): Promise<MobileServerSuccessResponse> {\n    const body: MobileServerPublicExecuteRequest<'update_preferences'> = {\n      type: 'update_preferences',\n      expo_token: params.expoToken,\n      preferences: mapMobileNotificationPreferencesToServer(params.preferences),\n    };\n    return this.publicExecute(body);\n  }\n\n  /*\n  Signed executes\n   */\n\n  /**\n   * Sets a subaccount's username, derived from the given display name. Upserts: the same call claims a first\n   * username and renames an existing one, so callers never need to read the current identity first.\n   *\n   * @throws {MobileServerFailureError} With error code `INVALID_DISPLAY_NAME` if the display name violates\n   * `MOBILE_DISPLAY_NAME_PATTERN`, `USERNAME_UNAVAILABLE` if the derived username is reserved or already\n   * taken by another subaccount, `INVALID_IDENTITY_TARGET` if the sender is in the engine-created isolated\n   * namespace, or `STALE_IDENTITY_UPDATE` if another identity write for this subaccount committed with a\n   * later nonce (re-read the identity before retrying).\n   */\n  async setUsername(\n    params: MobileSetUsernameParams,\n  ): Promise<MobileServerSuccessResponse> {\n    const signedRequest = await this.getSignedRequest('set_username', params, {\n      display_name: params.displayName,\n    });\n    return this.execute(signedRequest);\n  }\n\n  /**\n   * Sets whether a subaccount's profile is private.\n   */\n  async setPrivateMode(\n    params: MobileSetPrivateModeParams,\n  ): Promise<MobileServerSuccessResponse> {\n    const signedRequest = await this.getSignedRequest(\n      'set_private_mode',\n      params,\n      { private_mode: params.privateMode },\n    );\n    return this.execute(signedRequest);\n  }\n\n  /**\n   * Registers an Expo push token for the wallet, transferring active ownership of the token if another\n   * wallet had registered it. Idempotent per `(wallet, token)`.\n   *\n   * @throws {MobileServerFailureError} With error code `INVALID_EXPO_TOKEN` if the token is not a valid Expo\n   * push token, or `INVALID_DEVICE_METADATA` if `locale` (max 35 chars) or `appVersion` (max 64 chars) is\n   * too long.\n   */\n  async registerExpoToken(\n    params: MobileRegisterExpoTokenParams,\n  ): Promise<MobileServerSuccessResponse> {\n    const signedRequest = await this.getSignedRequest(\n      'register_expo_token',\n      params,\n      {\n        expo_token: params.expoToken,\n        platform: params.platform,\n        locale: params.locale ?? null,\n        app_version: params.appVersion ?? null,\n      },\n    );\n    return this.execute(signedRequest);\n  }\n\n  /*\n  Base Fns\n   */\n\n  protected async getSignedRequest<T extends MobileSignedInner['type']>(\n    type: T,\n    params: MobileSignedRequestParams,\n    innerParams: MobileSignedInnerParams<T>,\n  ): Promise<MobileSignedRequest> {\n    // Use the linked signer if provided, otherwise use the default signer provided to the client\n    const walletClient =\n      this.opts.linkedSignerWalletClient ?? this.opts.walletClient;\n\n    if (walletClient == null) {\n      throw new WalletNotProvidedError();\n    }\n\n    const inner = { type, ...innerParams } as unknown as MobileSignedInner;\n    return buildSignedMobileRequest({ ...params, walletClient, inner });\n  }\n\n  // Spelled out as an intersection rather than `MobileServerPublicQueryRequest<T>`: the latter is an indexed\n  // access on a mapped type, which is not an inference site, so `T` would always widen to the full union.\n  protected async publicQuery<T extends MobileServerPublicQueryRequestType>(\n    body: { type: T } & MobileServerPublicQueryRequestByType[T],\n  ): Promise<MobileServerPublicQuerySuccessResponse<T>> {\n    const response = await this.axiosInstance.post<unknown>(\n      `${this.opts.url}/mobile/public_query`,\n      body,\n    );\n\n    this.checkResponseStatus(response);\n    this.checkServerStatus(response);\n\n    // checkServerStatus throws on failure responses so the cast to the success response is acceptable here\n    return response.data as MobileServerPublicQuerySuccessResponse<T>;\n  }\n\n  protected async publicExecute(\n    body: MobileServerPublicExecuteRequest,\n  ): Promise<MobileServerSuccessResponse> {\n    const response = await this.axiosInstance.post<MobileServerExecuteResult>(\n      `${this.opts.url}/mobile/public_execute`,\n      body,\n    );\n\n    this.checkResponseStatus(response);\n    this.checkServerStatus(response);\n\n    // checkServerStatus catches the failure result and throws the error, so the cast to the success response is acceptable here\n    return response.data as MobileServerSuccessResponse;\n  }\n\n  protected async execute(\n    body: MobileSignedRequest,\n  ): Promise<MobileServerSuccessResponse> {\n    const response = await this.axiosInstance.post<MobileServerExecuteResult>(\n      `${this.opts.url}/mobile/execute`,\n      body,\n    );\n\n    this.checkResponseStatus(response);\n    this.checkServerStatus(response);\n\n    // checkServerStatus catches the failure result and throws the error, so the cast to the success response is acceptable here\n    return response.data as MobileServerSuccessResponse;\n  }\n\n  /**\n   * Validates the HTTP status before interpreting the body. Unlike the engine, the mobile backend returns\n   * failure envelopes with non-2xx statuses (e.g. 404 for `PROFILE_NOT_FOUND`), so a non-2xx response with a\n   * failure envelope still throws the typed error; anything else is a transport-level error.\n   */\n  private checkResponseStatus(response: AxiosResponse<unknown>) {\n    if (response.status >= 200 && response.status < 300) {\n      return;\n    }\n    if (isMobileServerFailureResponse(response.data)) {\n      throw new MobileServerFailureError(response.data, response.status);\n    }\n    throw new Error(\n      `Unexpected response from mobile service: ${response.status} ${response.statusText}. Data: ${JSON.stringify(response.data)}`,\n    );\n  }\n\n  private checkServerStatus(response: AxiosResponse<unknown>) {\n    const { data } = response;\n\n    if (isMobileServerFailureResponse(data)) {\n      throw new MobileServerFailureError(data, response.status);\n    }\n    if (!isMobileServerSuccessResponse(data)) {\n      throw new Error(\n        `Unexpected response from mobile service: missing success envelope. Data: ${JSON.stringify(data)}`,\n      );\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/canonicalize-CQ-pMYIt.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"canonicalize-CQ-pMYIt.d.ts","names":[],"sources":["../src/signing/src/signing/canonicalize.ts"],"mappings":";;;;;AASA;;;;;iBAAgB,uBAAA,CACd,KAAA,EAAO,iBAAA,GACN,iBAAiB"}

package/dist/canonicalize-hzhboB-C.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"canonicalize-hzhboB-C.d.cts","names":[],"sources":["../src/signing/src/signing/canonicalize.ts"],"mappings":";;;;;AASA;;;;;iBAAgB,uBAAA,CACd,KAAA,EAAO,iBAAA,GACN,iBAAiB"}

package/dist/clientTypes-BwakovWk.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"clientTypes-BwakovWk.d.cts","names":[],"sources":["../src/types/src/types/clientTypes.ts"],"mappings":";;;;;;;AAaA;;UAAiB,mBAAA;EACf,UAAA,EAAY,GAAG;EAAf;EAEA,QAAA;EAAA;EAEA,WAAA;EACA,WAAA;AAAA;AAAW;AAMb;;AANa,UAMI,0BAAA;EACf,QAAA;EACA,SAAS;AAAA;;;;;;UAQM,gBAAA;EACf,IAAA,EAAM,oBAAoB;EAC1B,iBAAA;AAAA;;;;;;UAQe,eAAA;EAmBkB;EAjBjC,WAAA,EAAa,GAAA;EACb,UAAA,EAAY,GAAA;EADC;EAGb,QAAA;EAFY;EAIZ,WAAA;EAAA;EAEA,SAAA;EACA,SAAA;EAEA;EAAA,QAAA;EAIA;EAFA,QAAA;EAGQ;EADR,YAAA;EACA,MAAA,EAAQ,gBAAA;EAIR;EAFA,QAAA,EAAU,uBAAA;EAIF;EAFR,WAAA;EAWe;EATf,QAAA;AAAA;;;;;;AAWU;UAFK,cAAA;EACf,MAAA,EAAQ,eAAe;EACvB,UAAA;AAAA;;;;;KAOU,iCAAA;EACN,IAAA;EAAoB,UAAA,EAAY,GAAG;AAAA;EACnC,IAAA;EAAiB,SAAA;AAAA;;;;UAKN,oCAAA;EACf,QAAA,EAAU,0BAAA;EACV,OAAA;EACA,MAAA,EAAQ,iCAAiC;AAAA;;;;;UAO1B,6BAAA;EAGH;EADZ,aAAA;EACA,UAAA,EAAY,oCAAoC;AAAA;;;;;UAOjC,sBAAA;EAIf;EAFA,MAAA,EAAQ,GAAA;EAIR;EAFA,QAAA,EAAU,0BAA0B;EASpC;EAPA,MAAA;EAWU;EATV,UAAA;EAee;;;;EAVf,sBAAA;EAkBe;;;EAdf,UAAA;AAAA;AAsBF;;;AAAA,UAhBiB,yBAAA,SACP,UAAA,EAAY,eAAe;AAsBrC;;;;AAAqD;AAArD,UAfiB,yBAAA;EAoBmB;EAlBlC,SAAS;AAAA;;;;UAMM,mCAAA;EACf,WAAW;AAAA;;;;KAMD,4BAAA,GAA+B,UAAU;AA+BrD;;;AAAA,UA1BiB,mBAAA;EA2BJ;AAMb;;;EA5BE,eAAA;EA4BqD;EA1BrD,KAAA;EA+BA;;;;EA1BA,MAAA;AAAA;AAwCF;;;AAAA,UAlCiB,uBAAA,SAAgC,yBAAyB;EAkCH;EAhCrE,WAAW;AAAA;;;;UAMI,0BAAA,SAAmC,yBAAyB;EAC3E,WAAW;AAAA;AA+B+B;AAM5C;;AAN4C,UAzB3B,6BAAA,SAAsC,yBAAyB;EA+BF;AAAA;AAK9E;EAhCE,SAAA;EACA,QAAA,EAAU,0BAAA;EA+B2D;AAAA;;EA3BrE,MAAA;;;;EAIA,UAAA;AAAA;;;;KAMU,+BAAA,GAAkC,yBAAyB;;;;UAKtD,yCAAA,SAAkD,yBAAyB;EAC1F,WAAA,EAAa,6BAAA;AAAA;;;;KAMH,sCAAA,GAAyC,yBAAyB;;;;KAKlE,+BAAA,GAAkC,yBAAyB"}

package/dist/clientTypes-D-o1_2Yc.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"clientTypes-D-o1_2Yc.d.ts","names":[],"sources":["../src/types/src/types/clientTypes.ts"],"mappings":";;;;;;;AAaA;;UAAiB,mBAAA;EACf,UAAA,EAAY,GAAG;EAAf;EAEA,QAAA;EAAA;EAEA,WAAA;EACA,WAAA;AAAA;AAAW;AAMb;;AANa,UAMI,0BAAA;EACf,QAAA;EACA,SAAS;AAAA;;;;;;UAQM,gBAAA;EACf,IAAA,EAAM,oBAAoB;EAC1B,iBAAA;AAAA;;;;;;UAQe,eAAA;EAmBkB;EAjBjC,WAAA,EAAa,GAAA;EACb,UAAA,EAAY,GAAA;EADC;EAGb,QAAA;EAFY;EAIZ,WAAA;EAAA;EAEA,SAAA;EACA,SAAA;EAEA;EAAA,QAAA;EAIA;EAFA,QAAA;EAGQ;EADR,YAAA;EACA,MAAA,EAAQ,gBAAA;EAIR;EAFA,QAAA,EAAU,uBAAA;EAIF;EAFR,WAAA;EAWe;EATf,QAAA;AAAA;;;;;;AAWU;UAFK,cAAA;EACf,MAAA,EAAQ,eAAe;EACvB,UAAA;AAAA;;;;;KAOU,iCAAA;EACN,IAAA;EAAoB,UAAA,EAAY,GAAG;AAAA;EACnC,IAAA;EAAiB,SAAA;AAAA;;;;UAKN,oCAAA;EACf,QAAA,EAAU,0BAAA;EACV,OAAA;EACA,MAAA,EAAQ,iCAAiC;AAAA;;;;;UAO1B,6BAAA;EAGH;EADZ,aAAA;EACA,UAAA,EAAY,oCAAoC;AAAA;;;;;UAOjC,sBAAA;EAIf;EAFA,MAAA,EAAQ,GAAA;EAIR;EAFA,QAAA,EAAU,0BAA0B;EASpC;EAPA,MAAA;EAWU;EATV,UAAA;EAee;;;;EAVf,sBAAA;EAkBe;;;EAdf,UAAA;AAAA;AAsBF;;;AAAA,UAhBiB,yBAAA,SACP,UAAA,EAAY,eAAe;AAsBrC;;;;AAAqD;AAArD,UAfiB,yBAAA;EAoBmB;EAlBlC,SAAS;AAAA;;;;UAMM,mCAAA;EACf,WAAW;AAAA;;;;KAMD,4BAAA,GAA+B,UAAU;AA+BrD;;;AAAA,UA1BiB,mBAAA;EA2BJ;AAMb;;;EA5BE,eAAA;EA4BqD;EA1BrD,KAAA;EA+BA;;;;EA1BA,MAAA;AAAA;AAwCF;;;AAAA,UAlCiB,uBAAA,SAAgC,yBAAyB;EAkCH;EAhCrE,WAAW;AAAA;;;;UAMI,0BAAA,SAAmC,yBAAyB;EAC3E,WAAW;AAAA;AA+B+B;AAM5C;;AAN4C,UAzB3B,6BAAA,SAAsC,yBAAyB;EA+BF;AAAA;AAK9E;EAhCE,SAAA;EACA,QAAA,EAAU,0BAAA;EA+B2D;AAAA;;EA3BrE,MAAA;;;;EAIA,UAAA;AAAA;;;;KAMU,+BAAA,GAAkC,yBAAyB;;;;UAKtD,yCAAA,SAAkD,yBAAyB;EAC1F,WAAA,EAAa,6BAAA;AAAA;;;;KAMH,sCAAA,GAAyC,yBAAyB;;;;KAKlE,+BAAA,GAAkC,yBAAyB"}

package/dist/eip712MethodByType-3aiJkrHj.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"eip712MethodByType-3aiJkrHj.d.cts","names":[],"sources":["../src/signing/src/signing/eip712MethodByType.ts"],"mappings":";;;;;AAKA;cAAa,4BAAA,EAA8B,MAAM,CAC/C,iBAAA"}

package/dist/eip712MethodByType-zNvZukU7.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"eip712MethodByType-zNvZukU7.d.ts","names":[],"sources":["../src/signing/src/signing/eip712MethodByType.ts"],"mappings":";;;;;AAKA;cAAa,4BAAA,EAA8B,MAAM,CAC/C,iBAAA"}

package/dist/mobileErrorCodes-CuQ5lyBV.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mobileErrorCodes-CuQ5lyBV.d.ts","names":[],"sources":["../src/types/src/types/mobileErrorCodes.ts"],"mappings":";;AAOA;;;;cAAa,kBAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;AAqBgD;;KADjD,eAAA,WACF,kBAAA,eAAiC,kBAAkB"}

package/dist/mobileErrorCodes-D_SyBm0k.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mobileErrorCodes-D_SyBm0k.d.cts","names":[],"sources":["../src/types/src/types/mobileErrorCodes.ts"],"mappings":";;AAOA;;;;cAAa,kBAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;AAqBgD;;KADjD,eAAA,WACF,kBAAA,eAAiC,kBAAkB"}

package/dist/patterns-B5gi7OfV.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"patterns-B5gi7OfV.d.ts","names":[],"sources":["../src/utils/src/utils/patterns.ts"],"mappings":";;AAGA;;cAAa,2BAAA,EAA2B,MAA0B"}

package/dist/patterns-Db6fgz8i.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"patterns-Db6fgz8i.d.cts","names":[],"sources":["../src/utils/src/utils/patterns.ts"],"mappings":";;AAGA;;cAAa,2BAAA,EAA2B,MAA0B"}

package/dist/payloadHash-BxL26uwq.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"payloadHash-BxL26uwq.d.ts","names":[],"sources":["../src/signing/src/signing/payloadHash.ts"],"mappings":";;;;;;AASA;;;iBAAgB,oBAAA,CAAqB,KAAA,EAAO,iBAAA,GAAoB,GAAG"}

package/dist/payloadHash-DVkEt-Rg.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"payloadHash-DVkEt-Rg.d.cts","names":[],"sources":["../src/signing/src/signing/payloadHash.ts"],"mappings":";;;;;;AASA;;;iBAAgB,oBAAA,CAAqB,KAAA,EAAO,iBAAA,GAAoB,GAAG"}

package/dist/serverExecuteTypes-Cb5v7y0A.d.cts

@@ -1,19 +0,0 @@
-import { n as MobileServerPublicExecuteRequestByType, r as MobileServerPublicExecuteRequestType } from "./serverRequestTypes-GAtVYIda.cjs";
-import { n as MobileServerSuccessResponse, t as MobileServerFailureResponse } from "./serverBaseTypes-C8KjE9Fm.cjs";
-
-//#region src/types/serverExecuteTypes.d.ts
-/**
- * Unsigned `public_execute` request body: a `type` discriminant flattened with its params, mirroring
- * {@link MobileServerPublicQueryRequest}.
- */
-type MobileServerPublicExecuteRequest<T extends MobileServerPublicExecuteRequestType = MobileServerPublicExecuteRequestType> = { [K in MobileServerPublicExecuteRequestType]: {
-  type: K;
-} & MobileServerPublicExecuteRequestByType[K] }[T];
-/**
- * Discriminated `execute` result union. Mobile execute routes return no payload beyond the success
- * discriminant, so the success arm is the base success envelope; failures use the uniform failure envelope.
- */
-type MobileServerExecuteResult = MobileServerSuccessResponse | MobileServerFailureResponse;
-//#endregion
-export { MobileServerPublicExecuteRequest as n, MobileServerExecuteResult as t };
-//# sourceMappingURL=serverExecuteTypes-Cb5v7y0A.d.cts.map

package/dist/serverExecuteTypes-Cb5v7y0A.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"serverExecuteTypes-Cb5v7y0A.d.cts","names":[],"sources":["../src/types/src/types/serverExecuteTypes.ts"],"mappings":";;;;;;AAaA;;KAAY,gCAAA,WACA,oCAAA,GACR,oCAAA,YAEI,oCAAA;EACJ,IAAA,EAAM,CAAA;AAAA,IACJ,sCAAA,CAAuC,CAAA,IAC3C,CAAA;;;;;KAMU,yBAAA,GACR,2BAAA,GACA,2BAA2B"}