@nadohq/mobile-client 0.64.0 → 0.66.0

package/src/types/serverQueryTypes.ts

@@ -1,24 +1,64 @@
 import { Hex } from 'viem';
 import { MobileServerSuccessResponse } from './serverBaseTypes';
 import {
-  MobileNotificationPlatform,
   MobileServerAvatarPreset,
   MobileServerFeedTrade,
   MobileServerFollowListAccount,
+  MobileServerNotificationCapabilities,
+  MobileServerNotificationDeviceMetadata,
+  MobileServerNotificationInboxItem,
   MobileServerNotificationPreferences,
+  MobileServerNotificationSettings,
   MobileServerProfile,
+  MobileServerSocialFeedActionCandidate,
+  MobileServerSocialFeedActionMarker,
+  MobileServerSocialFeedAuthor,
+  MobileServerSocialFeedCandle,
   MobileServerSocialFeedCohort,
+  MobileServerSocialFeedDrawing,
+  MobileServerSocialFeedEstimatedLiquidationLine,
+  MobileServerSocialFeedHistorySummary,
   MobileServerSocialFeedItem,
   MobileServerSocialFeedItemPatch,
+  MobileServerSocialFeedMarket,
+  MobileServerSocialFeedPositionHistoryCard,
   MobileServerSocialFeedPositionPatch,
+  MobileServerSocialFeedPublishablePosition,
   MobileServerSocialFeedReadSession,
+  MobileServerSocialFeedReply,
+  MobileServerSocialFeedTimelineEntry,
+  MobileServerSocialFeedTradingContext,
+  MobileSocialFeedActionResolution,
+  MobileSocialFeedChartDataQuality,
+  MobileSocialFeedHistoryQuality,
+  MobileSocialFeedPositionResolution,
+  MobileSocialFeedPositionResolutionReason,
   MobileSocialFeedUnavailableTarget,
 } from './serverModelTypes';
 import {
   MobileServerPublicQueryRequestByType,
   MobileServerPublicQueryRequestType,
+  MobileServerSignedQueryRequestType,
 } from './serverRequestTypes';
 
+/**
+ * Success payloads for each signed `query`, keyed by request `type`.
+ */
+export interface MobileServerSignedQueryResponseByType {
+  /** Wallet subscriptions and the signing Identity's bells. */
+  notification_subscriptions: MobileServerNotificationSubscriptionsResponse;
+  /** Private notification page. */
+  notification_inbox_v2: MobileServerNotificationInboxV2Response;
+}
+
+/**
+ * Full success response for a signed `query`, with its payload inlined alongside `status`.
+ */
+export type MobileServerSignedQuerySuccessResponse<
+  T extends MobileServerSignedQueryRequestType =
+    MobileServerSignedQueryRequestType,
+> = MobileServerSuccessResponse & MobileServerSignedQueryResponseByType[T];
+
 /**
  * Unsigned `public_query` request body: a `type` discriminant flattened with its params.
  */
@@ -147,15 +187,58 @@ export interface MobileServerNotificationPreferencesResponse {
   preferences: MobileServerNotificationPreferences;
 }
 
+/**
+ * Payload of the `notification_registration_v2` public query, including legacy registrations.
+ */
+export interface MobileServerNotificationRegistrationV2Response {
+  /** Opaque decimal string; do not convert to a JavaScript number. */
+  registration_generation: string;
+  /** Persisted capabilities of the most recent registration; legacy type/route arrays are empty. */
+  capabilities: MobileServerNotificationCapabilities;
+}
+
+/**
+ * Full settings document returned by both `notification_settings_v2` and `update_notification_settings_v2`.
+ */
+export interface MobileServerNotificationSettingsV2Response {
+  /** Settings schema version. */
+  schema_version: 2;
+  /** Settings revision, independent of the subscription revision. */
+  revision: number;
+  /** Full saved settings. */
+  settings: MobileServerNotificationSettings;
+}
+
+/**
+ * Payload of the `notification_subscriptions` signed query.
+ */
+export interface MobileServerNotificationSubscriptionsResponse {
+  /** Wallet-level subscription revision; read again after every mutation. */
+  revision: number;
+  /** Whether the one-time local favorites import has completed. */
+  favorites_imported: boolean;
+  /** Subscribed market IDs in ascending order. */
+  market_ids: number[];
+  /** Followed subaccounts with bells enabled for the signing Identity. */
+  trader_bells: Hex[];
+}
+
+/**
+ * Payload of the `notification_inbox_v2` signed query, ordered newest first.
+ */
+export interface MobileServerNotificationInboxV2Response {
+  /** Accepted intents owned by the signing wallet. */
+  notifications: MobileServerNotificationInboxItem[];
+  /** Pass unchanged to the next request, or null when pagination is complete. */
+  next_cursor: string | null;
+}
+
 /**
  * Payload of the `registered_wallet` public query success response. Inlined into the envelope rather than
  * nested under a key, matching the backend's `RegisteredWalletResponse`.
  */
-export interface MobileServerRegisteredWalletResponse {
+export interface MobileServerRegisteredWalletResponse extends MobileServerNotificationDeviceMetadata {
   wallet: Hex;
-  platform: MobileNotificationPlatform;
-  locale: string | null;
-  app_version: string | null;
   token_fingerprint_prefix: string;
   last_seen_at: number;
 }
@@ -167,6 +250,26 @@ export interface MobileServerRegisteredWalletResponse {
  * by {@link MobileServerPublicQuerySuccessResponse}.
  */
 export interface MobileServerPublicQueryResponseByType {
+  /** Latest saved device generation and v1/v2 capabilities. */
+  notification_registration_v2: MobileServerNotificationRegistrationV2Response;
+  /** Full settings document with its revision. */
+  notification_settings_v2: MobileServerNotificationSettingsV2Response;
+  /** Open position candidates. */
+  self_feed_positions: MobileServerSocialFeedPositionsResponse;
+  /** Position command resolution. */
+  resolve_feed_position: MobileServerSocialFeedPositionResolutionResponse;
+  /** Trusted order action resolution. */
+  resolve_feed_action: MobileServerSocialFeedActionResolutionResponse;
+  /** Parent drawing and version. */
+  feed_chart_drawing: MobileServerSocialFeedDrawingResponse;
+  /** Comment thread page. */
+  feed_comments: MobileServerSocialFeedCommentsResponse;
+  /** Full lifecycle history. */
+  position_history: MobileServerSocialFeedPositionHistoryResponse;
+  /** Candle page and markers. */
+  position_chart: MobileServerSocialFeedPositionChartResponse;
+  /** Read-only watcher observation. */
+  position_watchers: MobileServerSocialFeedWatchersResponse;
   /** Preset IDs and public image URLs in display order. */
   avatar_presets: MobileServerAvatarPresetsResponse;
   /** For You recommendations. */
@@ -204,3 +307,107 @@ export type MobileServerPublicQuerySuccessResponse<
   T extends MobileServerPublicQueryRequestType =
     MobileServerPublicQueryRequestType,
 > = MobileServerSuccessResponse & MobileServerPublicQueryResponseByType[T];
+
+/** Selected account's current candidates. */
+export interface MobileServerSocialFeedPositionsResponse {
+  /** Position eligibility hints. */
+  positions: MobileServerSocialFeedPublishablePosition[];
+  /** Next bound cursor, or null. */
+  next_cursor: string | null;
+  /** Observation time. */
+  as_of_ms: number;
+}
+
+/** Slash-command resolution, including normal empty outcomes. */
+export interface MobileServerSocialFeedPositionResolutionResponse {
+  /** Resolution status. */
+  resolution: MobileSocialFeedPositionResolution;
+  /** Resolved market, or null. */
+  product: MobileServerSocialFeedMarket | null;
+  /** Current candidates. */
+  candidates: MobileServerSocialFeedPublishablePosition[];
+  /** Explanation for empty candidates. */
+  reason: MobileSocialFeedPositionResolutionReason | null;
+}
+
+/** Authoritative order segments, not an inferred latest trade. */
+export interface MobileServerSocialFeedActionResolutionResponse {
+  /** Requested order. */
+  order_digest: Hex;
+  /** Pending until all confirmed segments are projected. */
+  resolution: MobileSocialFeedActionResolution;
+  /** Trusted actions, empty when pending. */
+  actions: MobileServerSocialFeedActionCandidate[];
+  /** Observation time. */
+  as_of_ms: number;
+}
+
+/** Drawing read result; a readable parent without a drawing succeeds with null. */
+export interface MobileServerSocialFeedDrawingResponse {
+  /** Parent UUID. */
+  item_id: string;
+  /** Display version. */
+  item_version: string;
+  /** Parsed drawing, or null. */
+  drawing: MobileServerSocialFeedDrawing | null;
+}
+
+/** Comment thread, including bidirectional pagination around an optional anchor. */
+export interface MobileServerSocialFeedCommentsResponse {
+  /** Readable comments. */
+  comments: MobileServerSocialFeedReply[];
+  /** Total readable count. */
+  total_count: number;
+  /** Forward cursor. */
+  next_cursor: string | null;
+  /** Backward cursor. */
+  previous_cursor: string | null;
+  /** Requested anchor, or null. */
+  anchor_reply_id: string | null;
+  /** Original or new session. */
+  read_session: MobileServerSocialFeedReadSession;
+}
+
+/** Full position history with additional metrics and trusted trading hints. */
+export interface MobileServerSocialFeedPositionHistoryResponse {
+  /** Current or frozen position and history metrics. */
+  position: MobileServerSocialFeedPositionHistoryCard;
+  /** Counts across the authorized history. */
+  summary: MobileServerSocialFeedHistorySummary;
+  /** Ordered action and take entries. */
+  timeline: MobileServerSocialFeedTimelineEntry[];
+  /** Next history cursor. */
+  next_cursor: string | null;
+  /** History completeness. */
+  history_quality: MobileSocialFeedHistoryQuality;
+  /** Position-mode session. */
+  read_session: MobileServerSocialFeedReadSession;
+  /** Viewing-account state, not authentication. */
+  trading_context: MobileServerSocialFeedTradingContext;
+}
+
+/** Candles and actions, with separate estimated risk-price line. */
+export interface MobileServerSocialFeedPositionChartResponse {
+  /** Descending candle page. */
+  candles: MobileServerSocialFeedCandle[];
+  /** Action markers with explicit price bases. */
+  action_markers: MobileServerSocialFeedActionMarker[];
+  /** Estimated line, if applicable and available. */
+  estimated_liquidation_line: MobileServerSocialFeedEstimatedLiquidationLine | null;
+  /** Exclusive next-page bound. */
+  next_before_ms: number | null;
+  /** Observation time. */
+  as_of_ms: number;
+  /** Overall source quality. */
+  data_quality: MobileSocialFeedChartDataQuality;
+}
+
+/** Read-only watcher observation; account previews are self-reported. */
+export interface MobileServerSocialFeedWatchersResponse {
+  /** Distinct active browsing credentials. */
+  watcher_count: number;
+  /** Deduplicated public account previews. */
+  watcher_preview: MobileServerSocialFeedAuthor[];
+  /** Observation time. */
+  as_of_ms: number;
+}

package/src/types/serverRequestTypes.ts

@@ -1,10 +1,73 @@
 import { Hex } from 'viem';
 import { MobileSignedInner } from '../signing/types';
 import {
+  MobileNotificationRouteName,
+  MobileNotificationTypeId,
+  MobileServerNotificationDeviceMetadata,
   MobileServerNotificationPreferences,
+  MobileServerNotificationSettings,
+  MobileServerSocialFeedChartRange,
+  MobileSocialFeedChartInterval,
   MobileSocialFeedMarketCategory,
+  MobileSocialFeedPresenceState,
   MobileSocialFeedType,
 } from './serverModelTypes';
+import type { MobileServerSignedQueryResponseByType } from './serverQueryTypes';
+
+/**
+ * Common wire-format credential for token-authenticated notification requests.
+ * Unregistration also accepts an inactive or unknown well-formed token.
+ */
+export interface MobileServerWithExpoTokenParams {
+  /** Expo push token; never expose it to another user. */
+  expo_token: string;
+}
+
+/**
+ * Registration fields shared by v1 and v2 signed inner payloads.
+ * Nullable metadata keys remain present when signing so the MessagePack hash matches the backend.
+ */
+export interface MobileServerRegisterExpoTokenParams
+  extends
+    MobileServerWithExpoTokenParams,
+    MobileServerNotificationDeviceMetadata {}
+
+/** Registration request with a v2-only capability declaration. */
+export interface MobileServerRegisterExpoTokenV2Params extends MobileServerRegisterExpoTokenParams {
+  /** Actual notification features supported by the device. */
+  capabilities: {
+    /** Registration accepts only the v2 protocol. */
+    payload_versions: [2];
+    /** Supported notification types. */
+    type_ids: MobileNotificationTypeId[];
+    /** Supported navigation destinations. */
+    routes: MobileNotificationRouteName[];
+  };
+}
+
+/**
+ * One subscription operation; exactly one operation is non-null and unused operations must be null.
+ */
+export interface MobileServerNotificationSubscriptionsUpdate {
+  /** Latest subscription revision, not the settings revision. */
+  expected_revision: number;
+  /** Set one bell; enabling requires an existing follow relationship. */
+  trader_bell: {
+    /** Target non-isolated subaccount belonging to another wallet. */
+    subaccount: Hex;
+    /** Desired bell state. */
+    enabled: boolean;
+  } | null;
+  /** Subscribe or unsubscribe one known market. */
+  market: {
+    /** Positive market product ID. */
+    product_id: number;
+    /** Desired subscription state. */
+    subscribed: boolean;
+  } | null;
+  /** One-time merge of up to 500 local market IDs; mutually exclusive with the other operations. */
+  import_markets: number[] | null;
+}
 
 /**
  * Opt-in extras for a `profiles` query. Each one costs extra rate-limit weight per profile and adds fields
@@ -65,7 +128,7 @@ export interface MobileServerSocialFeedListParams {
   minimum_notional?: number;
   /** Page size, 1–50; defaults to 20. */
   limit?: number;
-  /** Fixed 15-minute reading session; required with cursor. */
+  /** Original reading session; required with cursor. Legitimate requests renew its idle expiration. */
   session_id?: string;
   /** Opaque pagination cursor, distinct from update_cursor and watermark. */
   cursor?: string;
@@ -92,6 +155,88 @@ export interface MobileServerSocialFeedReadParams {
  * Params for each unsigned `public_query`, keyed by request `type`.
  */
 export interface MobileServerPublicQueryRequestByType {
+  /** Selected account's open position candidates. */
+  self_feed_positions: {
+    /** Full identity. */
+    view_as: Hex;
+    /** Market filter. */
+    product_id?: number;
+    /** Bound pagination cursor. */
+    cursor?: string;
+    /** Page size, 1-50. */
+    limit?: number;
+  };
+  /** Resolve a position command without signing. */
+  resolve_feed_position: {
+    /** Full identity. */
+    view_as: Hex;
+    /** Unmodified command text. */
+    input: string;
+    /** Optional market disambiguation. */
+    product_id?: number;
+  };
+  /** Resolve an order's complete trusted lifecycle segments. */
+  resolve_feed_action: {
+    /** Order-owning identity. */
+    view_as: Hex;
+    /** Trading order digest. */
+    order_digest: Hex;
+  };
+  /** Read a drawing within the parent item's visibility. */
+  feed_chart_drawing: MobileServerSocialFeedReadParams & {
+    /** Parent UUID. */
+    item_id: string;
+    /** Original session, paired with viewer_token. */
+    session_id?: string;
+  };
+  /** Read or navigate a comment thread. */
+  feed_comments: MobileServerSocialFeedReadParams & {
+    /** Root UUID. */
+    root_item_id: string;
+    /** Thread cursor. */
+    cursor?: string;
+    /** Page size, 1-50. */
+    limit?: number;
+    /** First-page anchor, mutually exclusive with cursor. */
+    anchor_reply_id?: string;
+    /** Original reading session. */
+    session_id?: string;
+  };
+  /** Full lifecycle history rather than published feed items alone. */
+  position_history: MobileServerSocialFeedReadParams & {
+    /** Lifecycle UUID. */
+    position_id: string;
+    /** Filter to published takes. */
+    takes_only?: boolean;
+    /** History cursor. */
+    cursor?: string;
+    /** Page size, 1-50. */
+    limit?: number;
+    /** Original position-mode session. */
+    session_id?: string;
+  };
+  /** Market candles and independently priced action markers. */
+  position_chart: MobileServerSocialFeedReadParams & {
+    /** Lifecycle UUID. */
+    position_id: string;
+    /** Original session, paired with viewer_token. */
+    session_id?: string;
+    /** Candle interval. */
+    interval: MobileSocialFeedChartInterval;
+    /** Half-open time interval. */
+    range: MobileServerSocialFeedChartRange;
+    /** Exclusive next-page bound. */
+    before_ms?: number;
+    /** Page size, 1-500. */
+    limit?: number;
+  };
+  /** Watcher query; does not register presence. */
+  position_watchers: {
+    /** Lifecycle UUID. */
+    position_id: string;
+    /** Relationship perspective only. */
+    view_as?: Hex;
+  };
   /** Ordered server-owned avatar catalogue. */
   avatar_presets: Record<never, never>;
   /** Public recommendations with optional relationship perspective. */
@@ -128,6 +273,8 @@ export interface MobileServerPublicQueryRequestByType {
   feed_item: MobileServerSocialFeedReadParams & {
     /** Target item UUID. */
     item_id: string;
+    /** Detail-visit event; omit for prefetch. Does not increment the count alone. */
+    view_event_id?: string;
     /** Preview size, 0-3. */
     comment_preview_limit?: number;
     /** Omit to create a new reading session. */
@@ -178,8 +325,12 @@ export interface MobileServerPublicQueryRequestByType {
      */
     cursor?: string;
   };
-  notification_preferences: { expo_token: string };
-  registered_wallet: { expo_token: string };
+  notification_preferences: MobileServerWithExpoTokenParams;
+  /** Persisted device generation and capabilities. */
+  notification_registration_v2: MobileServerWithExpoTokenParams;
+  /** Versioned notification settings. */
+  notification_settings_v2: MobileServerWithExpoTokenParams;
+  registered_wallet: MobileServerWithExpoTokenParams;
 }
 
 /**
@@ -189,12 +340,48 @@ export type MobileServerPublicQueryRequestType =
   keyof MobileServerPublicQueryRequestByType;
 
 /**
- * Params for each unsigned `public_execute`, keyed by request `type`. Possession of an active Expo push token
- * authorizes these notification-only mutations: the backend resolves the token's owning wallet and mutates
- * its state, so no signature, sender, or nonce is sent. Ordering is the backend's last-write-wins commit
- * order, so callers must serialize their own writes.
+ * Params for each unsigned `public_execute`, keyed by request `type`. No signature, sender, or nonce is sent.
+ * `record_feed_views` and `position_presence` are authorized by the original reading session (`session_id`)
+ * and browser credential (`viewer_token`), not an Expo push token.
+ * For `unregister_expo_token` and `update_preferences`, possession of an active Expo push token authorizes
+ * the notification mutation: the backend resolves the token's owning wallet and mutates its state. These
+ * notification writes use the backend's last-write-wins commit order, so callers must serialize them.
  */
 export interface MobileServerPublicExecuteRequestByType {
+  /** Full settings replacement with optimistic concurrency control. */
+  update_notification_settings_v2: MobileServerWithExpoTokenParams & {
+    /** Latest settings revision. */
+    expected_revision: number;
+    /** Complete settings document. */
+    settings: MobileServerNotificationSettings;
+  };
+
+  /** Explicit detail-visit report using the original browsing credential. */
+  record_feed_views: {
+    /** Original reading session. */
+    session_id: string;
+    /** Original credential. */
+    viewer_token: string;
+    /** Detail-visit event previously registered on feed_item. */
+    view_event_id: string;
+    /** Exactly one fully delivered detail-target item. */
+    item_ids: string[];
+  };
+  /** Per-page visitor lease; no wallet signature. */
+  position_presence: {
+    /** Lifecycle UUID. */
+    position_id: string;
+    /** Original reading session. */
+    session_id: string;
+    /** Page-scoped UUID. */
+    view_session_id: string;
+    /** Lease lifecycle state. */
+    state: MobileSocialFeedPresenceState;
+    /** Original browsing credential. */
+    viewer_token: string;
+    /** Omission preserves the display account; null clears it. */
+    watcher_subaccount?: Hex | null;
+  };
   unregister_expo_token: { expo_token: string };
   update_preferences: {
     expo_token: string;
@@ -209,20 +396,33 @@ export type MobileServerPublicExecuteRequestType =
   keyof MobileServerPublicExecuteRequestByType;
 
 /**
- * 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
+ * Discriminant `type` values for signed `execute` requests, excluding signed queries. 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'];
+export type MobileServerExecuteRequestType = Exclude<
+  MobileSignedInner['type'],
+  MobileServerSignedQueryRequestType
+>;
+
+/**
+ * Discriminant `type` values for signed `query` requests, distinct from unsigned `public_query` requests.
+ */
+export type MobileServerSignedQueryRequestType =
+  keyof MobileServerSignedQueryResponseByType;
 
 /**
  * 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`). The prefix names the route, so it never carries the `mobile:` prefix
- * that the EIP-712 method does.
+ * writes (e.g. `execute_set_username`), or `query_*` for signed reads. Unlike the EIP-712 method,
+ * these values never carry the `mobile:` prefix. Protected image reads use `feed_image` or
+ * `feed_comment_image` without a route prefix; malformed multipart uploads use `execute_image_upload`.
  */
 export type MobileServerRequestType =
+  | 'feed_image'
+  | 'feed_comment_image'
+  | 'execute_image_upload'
+  | `query_${MobileServerSignedQueryRequestType}`
   | `public_query_${MobileServerPublicQueryRequestType}`
   | `public_execute_${MobileServerPublicExecuteRequestType}`
   | `execute_${MobileServerExecuteRequestType}`;

package/src/utils/buildMobileFeedImageMultipart.test.ts

@@ -0,0 +1,45 @@
+import { afterEach, describe, expect, it, jest } from '@jest/globals';
+import { buildMobileFeedImageMultipart } from './buildMobileFeedImageMultipart';
+
+describe('buildMobileFeedImageMultipart', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('keeps multipart overhead fixed across timestamp and random boundary lengths', () => {
+    const payload = '{"type":"create_feed_post_image_uploads"}';
+    const fileBytes = new Uint8Array([0, 1, 255]);
+    const expected = buildMobileFeedImageMultipart(payload, fileBytes);
+    for (const timestamp of [0, 1_700_000_000_000, 8_640_000_000_000_000]) {
+      for (const random of [0, 0.000001, 0.5, 0.999999]) {
+        jest.spyOn(Date, 'now').mockReturnValue(timestamp);
+        jest.spyOn(Math, 'random').mockReturnValue(random);
+        const actual = buildMobileFeedImageMultipart(payload, fileBytes);
+        expect(actual.body.byteLength).toBe(expected.body.byteLength);
+        expect(actual.contentType.length).toBe(expected.contentType.length);
+      }
+    }
+  });
+
+  it('emits payload and file parts with a boundary Content-Type', () => {
+    const fileBytes = new Uint8Array([0, 1, 127, 128, 255, 13, 10]);
+    const { body, contentType } = buildMobileFeedImageMultipart(
+      '{"type":"create_feed_post_image_uploads"}',
+      fileBytes,
+    );
+    const text = String.fromCharCode(...body);
+    expect(contentType.startsWith('multipart/form-data; boundary=')).toBe(true);
+    expect(text).toContain('name="payload"');
+    expect(text).toContain('name="file"; filename="image"');
+    expect(text).toContain('{"type":"create_feed_post_image_uploads"}');
+    const boundary = contentType.split('boundary=')[1];
+    const fileStart = text.indexOf('\r\n\r\n', text.indexOf('name="file"')) + 4;
+    expect(body.slice(fileStart, fileStart + fileBytes.length)).toEqual(
+      fileBytes,
+    );
+    expect(text.slice(fileStart + fileBytes.length)).toBe(
+      `\r\n--${boundary}--\r\n`,
+    );
+    expect(text.startsWith(`--${boundary}\r\n`)).toBe(true);
+  });
+});

package/src/utils/buildMobileFeedImageMultipart.ts

@@ -0,0 +1,36 @@
+import { concatBytes, stringToBytes } from 'viem';
+
+/**
+ * Builds a multipart/form-data body for feed image uploads without relying on DOM FormData/Blob.
+ * Parts are exactly `payload` (JSON text) and `file` (raw bytes), matching the mobile execute contract.
+ * @param payloadJson - Stringified signed execute body.
+ * @param fileBytes - Original image bytes.
+ * @returns Raw multipart body and its Content-Type header value including boundary.
+ */
+export function buildMobileFeedImageMultipart(
+  payloadJson: string,
+  fileBytes: Uint8Array,
+): { body: Uint8Array; contentType: string } {
+  // Fixed-length boundaries keep multipart overhead identical for the pre-signing size check and upload.
+  const boundary = `----nadoFeedImage${Date.now().toString(16).padStart(14, '0')}${Math.floor(
+    Math.random() * 1e6,
+  )
+    .toString(16)
+    .padStart(5, '0')}`;
+  const preamble =
+    `--${boundary}\r\n` +
+    'Content-Disposition: form-data; name="payload"\r\n' +
+    'Content-Type: application/json\r\n\r\n' +
+    `${payloadJson}\r\n` +
+    `--${boundary}\r\n` +
+    'Content-Disposition: form-data; name="file"; filename="image"\r\n' +
+    'Content-Type: application/octet-stream\r\n\r\n';
+  return {
+    body: concatBytes([
+      stringToBytes(preamble),
+      fileBytes,
+      stringToBytes(`\r\n--${boundary}--\r\n`),
+    ]),
+    contentType: `multipart/form-data; boundary=${boundary}`,
+  };
+}

package/src/utils/feed.ts

@@ -4,6 +4,9 @@
  */
 export const MOBILE_FEED_MAX_PAGE_SIZE = 50;
 
+/** Maximum feed image upload request size, including the signed payload and multipart framing (2 MiB). */
+export const MOBILE_FEED_IMAGE_MAX_REQUEST_BYTES = 2 * 1024 * 1024;
+
 /**
  * Lowest minimum notional the backend accepts, in whole dollars. Filtered requests below this fail with
  * `INVALID_FEED_FILTER`; omitting the filter entirely returns the unfiltered feed.