@nadohq/mobile-client 0.53.0 → 0.55.0

package/src/types/serverModelTypes.ts

@@ -196,3 +196,391 @@ export interface MobileServerNotificationPreferences {
   schema_version: 1;
   categories: MobileServerNotificationCategoryPreference[];
 }
+
+/** Content filters accepted by the six social feed lists. Empty or omitted means all. */
+export type MobileSocialFeedType =
+  | 'open'
+  | 'close'
+  | 'size_change'
+  | 'thoughts'
+  | 'analysis'
+  | 'comments';
+
+/** Market category used by the social feed. */
+export type MobileSocialFeedMarketCategory = 'crypto' | 'finance';
+
+/** Qualification tier for an account-level PnL badge. */
+export type MobileSocialFeedTraderBadgeCode = 'shark' | 'whale';
+
+/** Availability of the current or last successful qualification snapshot. */
+export type MobileSocialFeedCohortStatus = 'ready' | 'stale';
+
+/** Availability of an author's qualification data. */
+export type MobileSocialFeedTraderDataStatus =
+  | MobileSocialFeedCohortStatus
+  | 'unavailable';
+
+/** Category from the authoritative market source. */
+export type MobileSocialFeedSourceCategory =
+  | 'crypto'
+  | 'stocks'
+  | 'forex'
+  | 'commodities';
+
+/** Accounting basis used for position PnL. */
+export type MobileSocialFeedPnlBasis =
+  | 'unrealized_excl_fees_funding'
+  | 'realized_incl_fees_funding';
+
+/** Whether position PnL is live or frozen at close. */
+export type MobileSocialFeedPnlMode = 'live' | 'frozen';
+
+/** Completeness of position PnL accounting. */
+export type MobileSocialFeedPnlQuality = 'ready' | 'pending' | 'unavailable';
+
+/** Source of the displayed position size and entry price. */
+export type MobileSocialFeedPositionDisplayBasis =
+  | 'current_position'
+  | 'closing_snapshot';
+
+/** Current state of a position lifecycle. */
+export type MobileSocialFeedPositionState = 'open' | 'closed';
+
+/** Completeness of the available position history. */
+export type MobileSocialFeedHistoryQuality = 'complete' | 'partial';
+
+/** Trading action represented by an ordinary size-change row. */
+export type MobileSocialFeedTradeSizeChangeAction = 'increased' | 'reduced';
+
+/** Trading action represented by an automatic trade card. */
+export type MobileSocialFeedTradeCardAction =
+  | 'opened'
+  | 'closed'
+  | MobileSocialFeedTradeSizeChangeAction;
+
+/** Whether a reading session was created for a list or a direct item. */
+export type MobileSocialFeedReadSessionMode = 'feed' | 'item';
+
+/** Kind of feed update target. */
+export type MobileSocialFeedTargetType = 'item' | 'position';
+
+/** Official account-level 30-day PnL badge, independent of position PnL. */
+export interface MobileServerSocialFeedTraderBadge {
+  /** Qualification tier. */
+  code: MobileSocialFeedTraderBadgeCode;
+  /** Signed integer in x18 units. */
+  pnl_x18: string;
+  /** Stable compatibility identifier for the official Portfolio month result. */
+  metric_key: 'account_pnl_30d_equity';
+  /** PnL window label. */
+  window: '30d';
+  /** Official source timestamp in Unix milliseconds. */
+  source_as_of_ms: number;
+  /** Fetch completion timestamp in Unix milliseconds. */
+  fetched_at_ms: number;
+  /** Qualification snapshot UUID. */
+  snapshot_id: string;
+}
+
+/** Public author identity and the selected viewing account's follow state. */
+export interface MobileServerSocialFeedAuthor extends MobileServerIdentitySummary {
+  /** Selected view_as account's follow state; null without a viewing account. */
+  is_following: boolean | null;
+  /** Null when no qualifying badge is available. */
+  trader_badge: MobileServerSocialFeedTraderBadge | null;
+  /** Stale means the last successful cohort is used after a refresh failure. */
+  trader_data_status: MobileSocialFeedTraderDataStatus;
+}
+
+/** Market metadata from the service's authoritative market source. */
+export interface MobileServerSocialFeedMarket {
+  /** Market product ID. */
+  product_id: number;
+  /** Market symbol. */
+  symbol: string;
+  /** Logo URL when available. */
+  logo_url: string | null;
+  /** Social feed category when known. */
+  category: MobileSocialFeedMarketCategory | null;
+  /** Original market categories. */
+  source_categories: MobileSocialFeedSourceCategory[];
+}
+
+/** Leverage display value; unknown isolated leverage differs from inapplicable cross leverage. */
+export interface MobileSocialFeedLeverage {
+  /** Rounded whole-number string, or null. Never an estimated replacement. */
+  value: string | null;
+  /** Cross margin uses not_applicable. */
+  basis: 'effective' | 'unknown' | 'not_applicable';
+}
+
+/** Position PnL with explicit accounting basis and data quality. */
+export interface MobileServerSocialFeedPnl {
+  /** Signed x18 integer; null means unknown, not zero. */
+  amount_x18: string | null;
+  /** Open positions exclude fees/funding; closed results include them. */
+  basis: MobileSocialFeedPnlBasis;
+  /** Closed positions use frozen results. */
+  mode: MobileSocialFeedPnlMode;
+  /** Source timestamp in Unix milliseconds. */
+  as_of_ms: number;
+  /** Whether accounting is complete, pending, or unavailable. */
+  quality: MobileSocialFeedPnlQuality;
+}
+
+/** Complete mutable position fields delivered together at one version. */
+export interface MobileServerSocialFeedPositionPatch {
+  /** Position lifecycle UUID. */
+  position_id: string;
+  /** Positive integer string; compare as integers without Number conversion. */
+  position_version: string;
+  /** Position state timestamp in Unix milliseconds. */
+  state_as_of_ms: number;
+  /** Remaining average entry cost, frozen on close; x18 or null. */
+  entry_price_x18: string | null;
+  /** Basis of the displayed size and entry price. */
+  display_basis: MobileSocialFeedPositionDisplayBasis;
+  /** Closing snapshot reference time, or null. */
+  snapshot_at_ms: number | null;
+  /** Absolute quantity in x18 units. */
+  quantity_x18: string;
+  /** Notional value in x18 units. */
+  notional_x18: string;
+  /** Current lifecycle state. */
+  state: MobileSocialFeedPositionState;
+  /** Completeness of the available historical facts. */
+  history_quality: MobileSocialFeedHistoryQuality;
+  /** Margin mode. */
+  margin_mode: MobileFeedMarginMode;
+  /** Current or closing leverage. */
+  leverage: MobileSocialFeedLeverage;
+  /** Leverage reference time; null when unknown or inapplicable. */
+  leverage_at_ms: number | null;
+  /** Current remaining PnL or the closed lifecycle's net result. */
+  pnl: MobileServerSocialFeedPnl;
+}
+
+/** Position displayed inside an automatic trade card. */
+export interface MobileServerSocialFeedPositionCard extends MobileServerSocialFeedPositionPatch {
+  /** Market product ID. */
+  product_id: number;
+  /** Market display metadata. */
+  market: MobileServerSocialFeedMarket;
+  /** Position direction. */
+  direction: MobileFeedTradePositionDirection;
+}
+
+/** Interaction counters; interaction writes are not currently available. */
+export interface MobileServerSocialFeedInteraction {
+  /** Number of likes. */
+  like_count: number;
+  /** Number of comments. */
+  comment_count: number;
+  /** Number of recorded views. */
+  view_count: number;
+  /** Null while likes are unavailable, including with a viewing account. */
+  liked_by_me: boolean | null;
+}
+
+/** Capability flags for a social feed item. */
+export interface MobileServerSocialFeedCapabilities {
+  /** Whether liking is available. */
+  can_like: boolean;
+  /** Whether commenting is available. */
+  can_comment: boolean;
+  /** Whether exposure recording is available. */
+  can_record_view: boolean;
+}
+
+/** Comment preview metadata for a social trade card. */
+export interface MobileServerSocialFeedCommentPreview {
+  /** Currently empty. */
+  items: never[];
+  /** Comment count. */
+  total_count: number;
+  /** Comment cursor, if available. */
+  next_cursor: string | null;
+}
+
+/** Exposure requirements associated with a reading session. */
+export interface MobileServerSocialFeedViewTracking {
+  /** Required visible fraction. */
+  min_visible_ratio: number;
+  /** Required visible duration in milliseconds. */
+  min_duration_ms: number;
+}
+
+/** Coverage of the candidate authors in a qualification snapshot. */
+export interface MobileServerSocialFeedCohortCoverage {
+  /** Coverage domain. */
+  scope: 'eligible_content_candidates';
+  /** Candidate author count. */
+  total_authors: number;
+  /** Authors queried for this snapshot. */
+  queried_authors: number;
+  /** A successful response requires complete coverage. */
+  complete: true;
+}
+
+/** Shared qualification snapshot used for Top Traders eligibility and badges. */
+export interface MobileServerSocialFeedCohort {
+  /** Cohort UUID. */
+  snapshot_id: string;
+  /** Ready or the previous successful snapshot after a refresh failure. */
+  status: MobileSocialFeedCohortStatus;
+  /** Coverage of all eligible candidate authors. */
+  coverage: MobileServerSocialFeedCohortCoverage;
+}
+
+/** Metadata shared by the automatic trade cards and rows available from the social feed. */
+export interface MobileServerSocialFeedItemBase {
+  /** Item UUID. */
+  id: string;
+  /** Whether authored analysis exists. */
+  has_analysis: boolean;
+  /** Drawings are not currently available. */
+  drawing: null;
+  /** Author identity, badge, and follow perspective. */
+  author: MobileServerSocialFeedAuthor;
+  /** Creation time in Unix milliseconds. */
+  created_at_ms: number;
+  /** Sorting time in Unix milliseconds. */
+  display_at_ms: number;
+  /** Positive integer version string. */
+  version: string;
+  /** Market metadata. */
+  market: MobileServerSocialFeedMarket;
+  /** Server capability flags; currently all false. */
+  capabilities: MobileServerSocialFeedCapabilities;
+}
+
+/** Automatic trade card returned by the social feed. */
+export interface MobileServerSocialFeedTradeCard extends MobileServerSocialFeedItemBase {
+  /** Card discriminant. */
+  kind: 'trade_card';
+  /** Trading action. */
+  action: MobileSocialFeedTradeCardAction;
+  /** Card text, empty for automatic cards. */
+  text: string;
+  /** Automatic cards have no mentions. */
+  mentions: never[];
+  /** Current or frozen position display. */
+  position: MobileServerSocialFeedPositionCard;
+  /** Interaction counters. */
+  interaction: MobileServerSocialFeedInteraction;
+  /** Comment content is not currently available. */
+  comment_preview: MobileServerSocialFeedCommentPreview;
+}
+
+/** Fields shared by size-change and liquidation trade rows. */
+export interface MobileServerSocialFeedTradeRowBase extends MobileServerSocialFeedItemBase {
+  /** Row discriminant. */
+  kind: 'trade_row';
+  /** Associated lifecycle UUID. */
+  position_id: string;
+  /** Position direction. */
+  direction: MobileFeedTradePositionDirection;
+  /** Historical margin mode. */
+  margin_mode: MobileFeedMarginMode;
+  /** Historical action leverage, not the position's current leverage. */
+  leverage: MobileSocialFeedLeverage;
+  /** Historical leverage reference time. */
+  leverage_at_ms: number | null;
+  /** Number of aggregated trades. */
+  trade_count: number;
+  /** Absolute traded quantity in x18 units. */
+  quantity_x18: string;
+  /** Actual execution price in x18 units, never an Oracle substitution. */
+  average_price_x18: string | null;
+}
+
+/** A size-change row or liquidation row with independently nullable financial facts. */
+export type MobileServerSocialFeedTradeRow =
+  MobileServerSocialFeedTradeRowBase &
+    (
+      | {
+          /** Ordinary size-change action. */
+          action: MobileSocialFeedTradeSizeChangeAction;
+          /** Executed notional in x18 units. */
+          notional_x18: string;
+        }
+      | {
+          /** Liquidation discriminant. */
+          action: 'liquidated';
+          /** Quantity times event Oracle; null if that Oracle is unknown. */
+          notional_x18: string | null;
+          /** Entry cost immediately before the event, in x18 units. */
+          entry_price_x18: string | null;
+          /** Event Oracle used for display and size filtering. */
+          liquidation_oracle_price_x18: string | null;
+          /** Actual execution price, independent of Oracle. */
+          liquidation_execution_price_x18: string | null;
+          /** Signed action PnL excluding ordinary fees/funding, or null. */
+          realized_pnl_delta_x18: string | null;
+        }
+    );
+
+/** Automatic feed content; excludes posts, replies, drawings, and interaction writes. */
+export type MobileServerSocialFeedItem =
+  | MobileServerSocialFeedTradeCard
+  | MobileServerSocialFeedTradeRow;
+
+/** Fixed-duration social feed reading session. Credentials and cursors must be returned unchanged. */
+export interface MobileServerSocialFeedReadSession {
+  /** Session identifier. */
+  session_id: string;
+  /** Feed or direct item session. */
+  mode: MobileSocialFeedReadSessionMode;
+  /** Fixed expiration time in Unix milliseconds; pagination does not extend it. */
+  expires_at_ms: number;
+  /** Exposure metadata only; recording is not available from the social feed. */
+  view_tracking: MobileServerSocialFeedViewTracking;
+  /** Initial update baseline, distinct from the page cursor. */
+  update_cursor: string | null;
+  /** Credential for this reading session. Do not log or cache publicly. */
+  viewer_token: string;
+}
+
+/** Item delta: omitted means unchanged; explicit null clears a prior value. */
+export interface MobileServerSocialFeedItemPatch {
+  /** Current author identity, follow state, and qualification badge. */
+  author: MobileServerSocialFeedAuthor;
+  /** Target item UUID. */
+  item_id: string;
+  /** Positive integer version string. */
+  version: string;
+  /** Updated interaction counters. */
+  interaction?: MobileServerSocialFeedInteraction;
+  /** Updated display timestamp; does not reorder the current list. */
+  display_at_ms: number;
+  /** Updated aggregate count. */
+  trade_count?: number;
+  /** Updated quantity in x18 units. */
+  quantity_x18?: string;
+  /** Updated notional; liquidation Oracle may be unknown. */
+  notional_x18?: string | null;
+  /** Updated actual execution price. */
+  average_price_x18?: string | null;
+  /** Historical liquidation entry cost. */
+  entry_price_x18?: string | null;
+  /** Updated liquidation Oracle. */
+  liquidation_oracle_price_x18?: string | null;
+  /** Updated actual liquidation execution price. */
+  liquidation_execution_price_x18?: string | null;
+  /** Updated signed action PnL. */
+  realized_pnl_delta_x18?: string | null;
+  /** Updated historical row leverage. */
+  leverage?: MobileSocialFeedLeverage;
+  /** Updated historical leverage reference time. */
+  leverage_at_ms?: number | null;
+}
+
+/** A previously authorized target that can no longer be read; shared by wire and client responses. */
+export interface MobileSocialFeedUnavailableTarget {
+  /** Target kind. */
+  type: MobileSocialFeedTargetType;
+  /** Target UUID. */
+  id: string;
+  /** Uniform reason prevents leaking inaccessible content. */
+  reason: 'unavailable';
+}

package/src/types/serverQueryTypes.ts

@@ -6,6 +6,12 @@ import {
   MobileServerFollowListAccount,
   MobileServerNotificationPreferences,
   MobileServerProfile,
+  MobileServerSocialFeedCohort,
+  MobileServerSocialFeedItem,
+  MobileServerSocialFeedItemPatch,
+  MobileServerSocialFeedPositionPatch,
+  MobileServerSocialFeedReadSession,
+  MobileSocialFeedUnavailableTarget,
 } from './serverModelTypes';
 import {
   MobileServerPublicQueryRequestByType,
@@ -63,6 +69,58 @@ export interface MobileServerFeedResponse {
   next_cursor: string | null;
 }
 
+/** Fixed-window list response; an empty page can still have a next cursor. */
+export interface MobileServerSocialFeedResponse {
+  /** Reading session and its browser credential. */
+  read_session: MobileServerSocialFeedReadSession;
+  /** Visible items in server order; deduplicate by ID without local reordering. */
+  items: MobileServerSocialFeedItem[];
+  /** Opaque cursor; null only when pagination is complete. */
+  next_cursor: string | null;
+  /** New-content baseline, not a pagination or update cursor. */
+  watermark: string;
+}
+
+/** Main-feed page with its ordering version. */
+export interface MobileServerSocialFeedRankedResponse extends MobileServerSocialFeedResponse {
+  /** Current ordering contract: chronological-v1. */
+  ranking_version: string;
+}
+
+/** Top Traders page, with one shared qualification snapshot for eligibility and badges. */
+export interface MobileServerSocialFeedTopTradersResponse extends MobileServerSocialFeedRankedResponse {
+  /** Author eligibility snapshot. */
+  cohort: MobileServerSocialFeedCohort;
+}
+
+/** Item details with either a new item session or the reused authorized session. */
+export interface MobileServerSocialFeedItemResponse {
+  /** Full visible item. */
+  item: MobileServerSocialFeedItem;
+  /** Session authorized for subsequent updates. */
+  read_session: MobileServerSocialFeedReadSession;
+}
+
+/** Batched viewport updates; apply only the current viewport's latest request sequence. */
+export interface MobileServerSocialFeedUpdatesResponse {
+  /** Item deltas, independent of current-position patches. */
+  item_patches: MobileServerSocialFeedItemPatch[];
+  /** Complete mutable position facts at one version. */
+  position_patches: MobileServerSocialFeedPositionPatch[];
+  /** Previously authorized targets that can no longer be read. */
+  unavailable_targets: MobileSocialFeedUnavailableTarget[];
+  /** New-content hint; always zero for directly created item sessions. */
+  new_items_count: number;
+  /** Baseline to use for the next update call with the same viewport. */
+  update_cursor: string;
+  /** Full snapshot of applicable mutable fields; currently always true. Apply author updates even when the item version is unchanged. */
+  reset: boolean;
+  /** Echoed viewport revision. */
+  viewport_revision: number;
+  /** Echoed request sequence. */
+  request_seq: number;
+}
+
 /**
  * Payload of the `notification_preferences` public query success response.
  */
@@ -90,6 +148,22 @@ export interface MobileServerRegisteredWalletResponse {
  * by {@link MobileServerPublicQuerySuccessResponse}.
  */
 export interface MobileServerPublicQueryResponseByType {
+  /** For You recommendations. */
+  for_you_feed: MobileServerSocialFeedRankedResponse;
+  /** Qualified authors and cohort metadata. */
+  top_traders_feed: MobileServerSocialFeedTopTradersResponse;
+  /** Public content from followed authors. */
+  friends_feed: MobileServerSocialFeedRankedResponse;
+  /** Published author content. */
+  profile_feed: MobileServerSocialFeedResponse;
+  /** Published market content. */
+  market_feed: MobileServerSocialFeedResponse;
+  /** Published position activity. */
+  position_feed: MobileServerSocialFeedResponse;
+  /** Item details and reading session. */
+  feed_item: MobileServerSocialFeedItemResponse;
+  /** Authorized viewport changes. */
+  feed_updates: MobileServerSocialFeedUpdatesResponse;
   username_availability: MobileServerUsernameAvailabilityResponse;
   profiles: MobileServerProfilesResponse;
   followers: MobileServerFollowListResponse;

package/src/types/serverRequestTypes.ts

@@ -1,6 +1,10 @@
 import { Hex } from 'viem';
 import { MobileSignedInner } from '../signing/types';
-import { MobileServerNotificationPreferences } from './serverModelTypes';
+import {
+  MobileServerNotificationPreferences,
+  MobileSocialFeedMarketCategory,
+  MobileSocialFeedType,
+} from './serverModelTypes';
 
 /**
  * Opt-in extras for a `profiles` query. Each one costs extra rate-limit weight per profile and adds fields
@@ -36,10 +40,99 @@ export interface MobileServerFollowListRequest {
   limit?: number;
 }
 
+/** Common filters and pagination for social feed lists. */
+export interface MobileServerSocialFeedListParams {
+  /** OR-ed content filters; combined with other filters using AND. */
+  feed_types?: MobileSocialFeedType[];
+  /** Strict lower bound in whole dollars, 1 through Number.MAX_SAFE_INTEGER. */
+  minimum_notional?: number;
+  /** Page size, 1–50; defaults to 20. */
+  limit?: number;
+  /** Fixed 15-minute reading session; required with cursor. */
+  session_id?: string;
+  /** Opaque pagination cursor, distinct from update_cursor and watermark. */
+  cursor?: string;
+}
+
+/** List fields for main feeds and author feeds. */
+export interface MobileServerSocialFeedCategorizedParams extends MobileServerSocialFeedListParams {
+  /** Omit to read all market categories. */
+  market_category?: MobileSocialFeedMarketCategory;
+}
+
+/** Unsigned browsing context; the viewing account is not proof of wallet ownership. */
+export interface MobileServerSocialFeedReadParams {
+  /**
+   * Complete non-isolated viewing account. Profile, position, and item reads include this account's
+   * own hidden content under account_view, in addition to resolving relationship state.
+   */
+  view_as?: Hex;
+  /** Original browsing credential when reusing a session. */
+  viewer_token?: string;
+}
+
 /**
  * Params for each unsigned `public_query`, keyed by request `type`.
  */
 export interface MobileServerPublicQueryRequestByType {
+  /** Public recommendations with optional relationship perspective. */
+  for_you_feed: MobileServerSocialFeedCategorizedParams &
+    MobileServerSocialFeedReadParams;
+  /** Public content from qualified authors. */
+  top_traders_feed: MobileServerSocialFeedCategorizedParams &
+    MobileServerSocialFeedReadParams;
+  /** Public content from authors followed by view_as. */
+  friends_feed: MobileServerSocialFeedCategorizedParams &
+    MobileServerSocialFeedReadParams & {
+      /** Complete non-isolated identity subaccount; required on every request. */
+      view_as: Hex;
+    };
+  /** Author content visible to view_as; the target is separate from the viewing account. */
+  profile_feed: MobileServerSocialFeedCategorizedParams &
+    MobileServerSocialFeedReadParams & {
+      /** Target author identity, independent of view_as. */
+      subaccount: Hex;
+    };
+  /** Public market content. */
+  market_feed: MobileServerSocialFeedListParams &
+    MobileServerSocialFeedReadParams & {
+      /** Target product. */
+      product_id: number;
+    };
+  /** Published activity in one lifecycle, including hidden content owned by view_as. */
+  position_feed: MobileServerSocialFeedListParams &
+    MobileServerSocialFeedReadParams & {
+      /** Target position UUID. */
+      position_id: string;
+    };
+  /** Item details visible to view_as, optionally reusing a reading session. */
+  feed_item: MobileServerSocialFeedReadParams & {
+    /** Target item UUID. */
+    item_id: string;
+    /** Preview size, 0-3. */
+    comment_preview_limit?: number;
+    /** Omit to create a new reading session. */
+    session_id?: string;
+  };
+  /** Updates inherit the original public session's viewing account. */
+  feed_updates: {
+    /** Original reading session. */
+    session_id: string;
+    /** Previously delivered item UUIDs. */
+    visible_item_ids: string[];
+    /** Authorized position UUIDs. */
+    visible_position_ids: string[];
+    /** Baseline from the last accepted update. */
+    update_cursor?: string | null;
+    /** Current viewport version. */
+    viewport_revision: number;
+    /** Request sequence increasing across the entire session, including viewport changes. */
+    request_seq: number;
+    /** Original public browsing credential. */
+    viewer_token: string;
+    /** The viewing account cannot be changed by an update. */
+    view_as?: never;
+  };
   username_availability: { display_name: string };
   profiles: {
     /**

package/dist/MobileClient-CEVEYnV1.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"MobileClient-CEVEYnV1.cjs","names":["subaccountToHex","mapMobileProfilesIncludeToServer","mapMobilePublicProfile","mapMobileFollowListParamsToServer","mapMobileFollowListPage","mapMobileFeedPage","mapMobileNotificationPreferences","mapMobileRegisteredWallet","mapMobileNotificationPreferencesToServer","mapMobileFollowMutationResult","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  mapMobileFollowListPage,\n  mapMobileFollowListParamsToServer,\n  mapMobileFollowMutationResult,\n  mapMobileNotificationPreferences,\n  mapMobileNotificationPreferencesToServer,\n  mapMobileProfilesIncludeToServer,\n  mapMobilePublicProfile,\n  mapMobileRegisteredWallet,\n} from './dataMappers';\nimport {\n  buildSignedMobileRequest,\n  MobileSignedInner,\n  MobileSignedInnerByType,\n  MobileSignedInnerParams,\n  MobileSignedRequest,\n} from './signing';\nimport {\n  GetMobileFeedParams,\n  GetMobileFollowersParams,\n  GetMobileFollowingParams,\n  GetMobileNotificationPreferencesParams,\n  GetMobileProfilesParams,\n  GetMobileRegisteredWalletParams,\n  GetMobileUsernameAvailabilityParams,\n  MobileFeedPage,\n  MobileFollowListPage,\n  MobileFollowMutationResult,\n  MobileNotificationPreferences,\n  MobilePublicProfile,\n  MobileRegisteredWallet,\n  MobileRegisterExpoTokenParams,\n  MobileSetFollowParams,\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  MobileServerExecuteSuccessResponse,\n  MobileServerPublicExecuteRequest,\n} from './types/serverExecuteTypes';\nimport {\n  MobileServerPublicQueryRequest,\n  MobileServerPublicQuerySuccessResponse,\n} from './types/serverQueryTypes';\nimport {\n  MobileServerExecuteRequestType,\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, the\n * follower/following graph, privacy 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 public profiles, optionally with follower totals and a follow summary. Returns one profile per\n   * requested subaccount, in the requested order, so callers can correlate positionally. Every non-isolated\n   * subaccount resolves, with `username` and `displayName` `null` until a username is claimed. Private Mode\n   * does not hide the profile itself, only the account's activity.\n   *\n   * This is the only profile route, so use it for a single subaccount too. It is unsigned, which means\n   * `include.followSummary.viewAs` is an unauthenticated claim.\n   *\n   * @throws {MobileServerFailureError} With error code `INVALID_PROFILES_REQUEST` if `subaccounts` is empty,\n   * holds duplicates, or exceeds `MOBILE_PROFILES_MAX_BATCH_SIZE` (25), or `PROFILE_NOT_FOUND` if any\n   * requested subaccount — or the follow summary's `viewAs` — is in the engine-created isolated namespace.\n   * One isolated member fails the whole batch rather than being omitted.\n   */\n  async getProfiles(\n    params: GetMobileProfilesParams,\n  ): Promise<MobilePublicProfile[]> {\n    const body: MobileServerPublicQueryRequest<'profiles'> = {\n      type: 'profiles',\n      subaccounts: params.subaccounts.map(subaccountToHex),\n      include: params.include\n        ? mapMobileProfilesIncludeToServer(params.include)\n        : undefined,\n    };\n    const data = await this.publicQuery(body);\n    return data.profiles.map(mapMobilePublicProfile);\n  }\n\n  /**\n   * Fetches a page of the accounts that follow the given Profile.\n   *\n   * Ordering depends on `viewAs`. With it, accounts the Viewer already follows come first, unfamiliar\n   * accounts second, and every row carries an `isFollowing`. Without it, the page is ordered by the listed\n   * relationship alone and no row carries an `isFollowing`. In both cases the newest listed relationship\n   * comes first within a group, with a bytes32 tie-break. The grouping is evaluated per request against the\n   * live graph, so following an account from inside the list moves it between groups on the next page —\n   * deduplicate by subaccount and do not re-sort locally.\n   *\n   * @throws {MobileServerFailureError} With error code `PROFILE_NOT_FOUND` if the viewed Profile or `viewAs`\n   * is isolated, `INVALID_FOLLOW_CURSOR` if the cursor is malformed or was issued for a different `viewAs`,\n   * Profile, or list direction (discard it and restart from the first page), or `INVALID_FOLLOW_LIMIT` if\n   * `limit` is outside 1–50.\n   */\n  async getFollowers(\n    params: GetMobileFollowersParams,\n  ): Promise<MobileFollowListPage> {\n    const body: MobileServerPublicQueryRequest<'followers'> = {\n      type: 'followers',\n      ...mapMobileFollowListParamsToServer(params),\n    };\n    const data = await this.publicQuery(body);\n    return mapMobileFollowListPage(data);\n  }\n\n  /**\n   * Fetches a page of the accounts the given Profile follows. Ordering, cursor rules, and errors match\n   * {@link MobileClient.getFollowers}. When `viewAs` reads its own Following list every row is familiar, so\n   * every `isFollowing` is `true`.\n   */\n  async getFollowing(\n    params: GetMobileFollowingParams,\n  ): Promise<MobileFollowListPage> {\n    const body: MobileServerPublicQueryRequest<'following'> = {\n      type: 'following',\n      ...mapMobileFollowListParamsToServer(params),\n    };\n    const data = await this.publicQuery(body);\n    return mapMobileFollowListPage(data);\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   * Sets whether the signing subaccount follows a Profile. Both directions are idempotent: following again\n   * keeps the original relationship creation time, so it does not move the account in recency order, and\n   * unfollowing a relationship that does not exist succeeds with `isFollowing: false`. Unfollowing deletes\n   * the relationship rather than deactivating it, so a later follow gets a new creation time and moves the\n   * account to the front of recency order.\n   *\n   * Only `isFollowing: true` is checked against the canonical Query DB subaccount index, so unfollowing still\n   * works while that index lags.\n   *\n   * @throws {MobileServerFailureError} With error code `INVALID_FOLLOW_TARGET` if the target is the sender or\n   * either party is isolated, `FOLLOWER_NOT_ELIGIBLE` if the sender is not yet in the canonical Query DB\n   * subaccount index, or `FOLLOWING_NOT_FOUND` if the target is not. Both index errors are transient for an\n   * account that is being recorded, so they are retryable after catch-up — unlike `INVALID_FOLLOW_TARGET`.\n   */\n  async setFollow(\n    params: MobileSetFollowParams,\n  ): Promise<MobileFollowMutationResult> {\n    const signedRequest = await this.getSignedRequest('set_follow', params, {\n      subaccount: subaccountToHex(params.target),\n      is_following: params.isFollowing,\n    });\n    const data = await this.execute(signedRequest);\n    return mapMobileFollowMutationResult(data);\n  }\n\n  /*\n  Base Fns\n   */\n\n  // Returns the request narrowed to `type` so `execute` can infer its response from the request it is given,\n  // instead of being told the type a second time at the call site.\n  protected async getSignedRequest<T extends MobileSignedInner['type']>(\n    type: T,\n    params: MobileSignedRequestParams,\n    innerParams: MobileSignedInnerParams<T>,\n  ): Promise<MobileSignedRequest<MobileSignedInnerByType<T>>> {\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 = {\n      type,\n      ...innerParams,\n    } as unknown as MobileSignedInnerByType<T>;\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}/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}/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  // `T` is inferred from the body's `type` rather than declared by the caller, for the same reason\n  // `publicQuery` spells its body out as an intersection: an indexed access is not an inference site.\n  protected async execute<T extends MobileServerExecuteRequestType>(\n    body: MobileSignedRequest & { type: T },\n  ): Promise<MobileServerExecuteSuccessResponse<T>> {\n    const response = await this.axiosInstance.post<MobileServerExecuteResult>(\n      `${this.opts.url}/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 MobileServerExecuteSuccessResponse<T>;\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-OYR35XMP.d.cts.map

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

package/dist/canonicalize-T4ShepBu.d.ts.map

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