@nadohq/mobile-client 0.65.0 → 0.66.0

package/README.md

@@ -52,6 +52,10 @@ await mobile.setUsername({
 `getSelfFeedPositions`, `resolveFeedPosition`, `resolveFeedAction`, `getFeedChartDrawing`, `getFeedComments`,
 `getPositionHistory`, `getPositionChart`, `getPositionWatchers`.
 
+`getNotificationRegistrationV2` and `getNotificationSettingsV2` use an active Expo token as their credential,
+not a wallet signature. Before displaying wallet settings, compare the wallet returned by `getRegisteredWallet`
+with the connected wallet (case-insensitively).
+
 `getProfiles` is the only profile route: it batches up to 25 subaccounts, returns them in the requested order,
 and carries follower totals (`include.followCounts`) and a follow summary (`include.followSummary.viewAs`) as
 opt-in includes, so use it for a single subaccount too. The backend still serves the older singular `profile`
@@ -70,10 +74,12 @@ page is ordered by the listed relationship alone and `isFollowing` is absent rat
 
 `getFeed` returns the global trade feed. Session-based feeds include `getForYouFeed`, `getTopTradersFeed`,
 and `getFriendsFeed` (requires `viewAs`), plus `getProfileFeed`, `getMarketFeed`, and `getPositionFeed`.
-`getFeedItem` reads one item; `getFeedUpdates` polls session patches using the returned `viewerToken`.
-All are unsigned. Profile, position, and item reads include the `viewAs` account's own hidden content under
-`account_view`; the viewing account is not proof of wallet ownership. Prices are decimal `BigNumber` values;
-quantities, notionals, and PnL retain x18 units. See method and parameter JSDoc for session and polling rules.
+`getFeedItem` reads one item; pass `viewEventId` when the user navigates into the detail so a later
+`recordFeedViews` can count that visit, and omit it for prefetch. `getFeedUpdates` polls session patches
+using the returned `viewerToken`. All are unsigned. Profile, position, and item reads include the `viewAs`
+account's own hidden content under `account_view`; the viewing account is not proof of wallet ownership.
+Prices are decimal `BigNumber` values; quantities, notionals, and PnL retain x18 units. See method and
+parameter JSDoc for session and polling rules.
 
 `getSelfFeedPositions`, `resolveFeedPosition`, and `resolveFeedAction` require `viewAs` and return eligibility
 hints for that account, not authenticated permissions. `getFeedComments` supports anchored, bidirectional
@@ -87,18 +93,111 @@ registering presence. Watching account previews are self-reported, not proof of
 
 ### Public Executes
 
-`unregisterExpoToken`, `updateNotificationPreferences`. These are authenticated by possession of an active Expo
+`unregisterExpoToken`, `updateNotificationPreferences`, `updateNotificationSettingsV2`. These are authenticated by possession of an active Expo
 push token rather than a wallet signature, so they still work at logout when a signature may be unobtainable.
 
 `recordFeedViews` and `setPositionPresence` use reading-session credentials rather than wallet signatures.
-See method and parameter JSDoc for exposure reporting and page-scoped presence rules.
+Exposure follows `readSession.viewTracking.mode === 'detail_visit'`: after the primary detail target is shown
+in the foreground, call `recordFeedViews` with the same `viewEventId` previously sent to `getFeedItem`, plus
+that response's `sessionId` / `viewerToken` and exactly one detail-target `itemId`. Reuse the event on retries
+for the same visit; generate a new UUID only after leaving and re-entering. Fetch image bytes with
+`getFeedImageBytes` using the same session credentials and paths from `images` / `thumbnail.url`. Legitimate
+session reads renew the idle expiration; use the latest `expiresAtMs` rather than treating the first value as
+fixed.
+
+For React Native `Image` or expo-image, use `getFeedImageRequest` to pass the authenticated
+URL and headers directly without converting bytes to base64:
+
+```ts
+const { url, headers } = mobile.getFeedImageRequest({
+  path: image.url,
+  sessionId: readSession.sessionId,
+  viewerToken: readSession.viewerToken,
+});
+const source = { uri: url, headers };
+```
 
 ### Signed Executes
 
 `setUsername`, `setBio`, `createAvatarUpload`, `setAvatar`, `setPrivateMode`, `registerExpoToken`, `setFollow`,
-`createFeedPost`, `createFeedComment`, `createFeedChartDrawing`, `updateFeedChartDrawing`, `setFeedLike`.
+`createFeedPost`, `createFeedComment`, `createFeedPostImageUpload`, `createFeedCommentImageUpload`,
+`createFeedChartDrawing`, `updateFeedChartDrawing`, `setFeedLike`, `registerExpoTokenV2`,
+`updateNotificationSubscriptions`, `recordProductEvents`.
+
+Upload images one at a time with the multipart helpers (≤ 2 MiB whole request), then pass ordered ready
+`imageIds` to `createFeedPost` / `createFeedComment`. The SDK throws `RangeError` before requesting a signature or sending a request
+that exceeds `MOBILE_FEED_IMAGE_MAX_REQUEST_BYTES`, including the signed payload and multipart framing.
+Unconfigured image storage returns `SOCIAL_FEED_DATA_UNAVAILABLE` (6320, HTTP 503).
+Posts still require nonblank text or a drawing; comments
+still require nonblank text. See method and parameter JSDoc for publication, retries, mention offsets, drawing
+data, and mutation ordering.
+
+### Signed Queries
+
+`getNotificationSubscriptions` and `getNotificationInboxV2` use wallet authentication on `/query`.
+They do not require an Expo token or system push permission. The configured linked signer is supported.
+
+### Notifications V2
+
+The notification v2 operations are available on `MobileClient`, including `client.context.mobileClient` from
+`@nadohq/client`. Settings, capabilities, subscriptions, inbox data, and product events use camelCase SDK models.
+The SDK maps requests to snake_case wire fields and removes the success envelope from read results.
+
+```ts
+const auth = {
+  subaccountOwner: walletClient.account.address,
+  subaccountName: 'default',
+  chainId: ink.id,
+  verifyingAddr: '0x...' as const,
+};
+
+await mobile.registerExpoTokenV2({
+  ...auth,
+  expoToken,
+  platform: 'ios',
+  capabilities: {
+    payloadVersions: [2],
+    typeIds: ['order_fill', 'new_follower'],
+    routes: ['portfolio', 'profile'],
+  },
+});
+const registration = await mobile.getNotificationRegistrationV2({ expoToken });
+const current = await mobile.getNotificationSettingsV2({ expoToken });
+const saved = await mobile.updateNotificationSettingsV2({
+  expoToken,
+  expectedRevision: current.revision,
+  settings: { ...current.settings, positionThresholds: [25] },
+});
+
+const subscriptions = await mobile.getNotificationSubscriptions(auth);
+await mobile.updateNotificationSubscriptions({
+  ...auth,
+  update: {
+    expectedRevision: subscriptions.revision,
+    market: { productId: 2, subscribed: true },
+  },
+});
+const updatedSubscriptions = await mobile.getNotificationSubscriptions(auth);
+const inbox = await mobile.getNotificationInboxV2({ ...auth, limit: 20 });
+```
 
-See method and parameter JSDoc for publication, retries, mention offsets, drawing data, and mutation ordering.
+- Declare only types/routes the application handles. Re-registration advances the generation and cancels
+  old pending deliveries; calling legacy `registerExpoToken` resets capabilities to v1.
+- Settings replacement requires every field. Settings and subscription revisions are independent.
+  On `MOBILE_ERROR_CODES.NOTIFICATION_REVISION_CONFLICT` (6203), re-read and merge only the current user change.
+- A subscription update selects exactly one operation; omit the other operations and the SDK sends them as `null`. Successful subscription
+  updates return only status, so re-query even after repeated ON/OFF. Favorites import merges once, never replaces.
+- Enabling a bell requires following the target. Unfollowing clears its bell without advancing the subscription
+  revision; refresh subscriptions after follow mutations. Bells are Identity-scoped; markets are wallet-scoped.
+  Pass `traderBell.subaccount` as a `Subaccount` (`subaccountOwner` and `subaccountName`); the SDK encodes it for signing.
+- Inbox pages are accepted intents, not delivery/read receipts. There is no title/body, unread count, mark-read,
+  or delete operation. Do not use the unimplemented legacy `notification_history` route.
+  An unknown destination rejects the page with `MobileUnsupportedNotificationRouteError`.
+- `recordProductEvents({ ...auth, events })` accepts 1-50 events atomically. Provide the fields required by `eventName`,
+  actual millisecond timestamps, and stable `clientEventId` UUIDs across retries. The SDK fills unused wire fields with `null`. Supported
+  names are `notif_opened`, `market_viewed`, `chart_opened`, and `search`; obtain analytics consent first.
+- Legacy preferences remain supported and synchronize overlapping v2 fields. Keep legacy push parsing because
+  order notifications may use a v1 fallback even for v2 registrations.
 
 ### Linked Signers
 

package/dist/{MobileClient-CfVZXTcz.cjs → MobileClient-M4oC4lrX.cjs}

@@ -21,12 +21,16 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 //#endregion
 const require_dataMappers = require("./dataMappers.cjs");
+const require_signing_nonce = require("./signing/nonce.cjs");
 const require_signing_buildSignedMobileRequest = require("./signing/buildSignedMobileRequest.cjs");
 const require_types_MobileServerFailureError = require("./types/MobileServerFailureError.cjs");
+const require_utils_buildMobileFeedImageMultipart = require("./utils/buildMobileFeedImageMultipart.cjs");
+const require_utils_feed = require("./utils/feed.cjs");
 const require_utils_serverResponseGuards = require("./utils/serverResponseGuards.cjs");
 let _nadohq_shared = require("@nadohq/shared");
 let axios = require("axios");
 axios = __toESM(axios, 1);
+let viem = require("viem");
 //#region src/MobileClient.ts
 /**
 * Client for the Nado mobile service API: usernames, bios, avatars, public profile lookups, the global
@@ -277,7 +281,9 @@ var MobileClient = class {
 	/**
 	* Reads one item visible to viewAs, including that account's own hidden content.
 	* Creates an item session directly when sessionId is omitted.
-	* @param params - Item UUID, preview limit, and optional existing session/read identity.
+	* Pass {@link GetMobileFeedItemParams.viewEventId} when the user navigates into the detail so the
+	* subsequent {@link recordFeedViews} call can count that visit; omit it for prefetch.
+	* @param params - Item UUID, optional detail-visit event, preview limit, and optional existing session/read identity.
 	* @returns The complete item and authorized reading session.
 	* @throws {MobileServerFailureError} On inaccessible content or session mismatch/expiry.
 	* @throws {MobileUnsupportedFeedItemError} If the service returns an unsupported item kind.
@@ -286,6 +292,7 @@ var MobileClient = class {
 		const body = {
 			type: "feed_item",
 			item_id: params.itemId,
+			view_event_id: params.viewEventId,
 			comment_preview_limit: params.commentPreviewLimit,
 			session_id: params.sessionId,
 			...require_dataMappers.mapMobileSocialFeedReadParamsToServer(params)
@@ -323,6 +330,7 @@ var MobileClient = class {
 	*
 	* @throws {MobileServerFailureError} With error code `INVALID_EXPO_TOKEN` if the token is malformed, or is
 	* not currently registered to a wallet.
+	* @deprecated Use {@link getNotificationSettingsV2} instead.
 	*/
 	async getNotificationPreferences(params) {
 		const body = {
@@ -415,6 +423,40 @@ var MobileClient = class {
 		return require_dataMappers.mapMobileSocialFeedDrawingResult(await this.publicQuery(body));
 	}
 	/**
+	* Resolves a backend feed image path against this client's mobile gateway URL.
+	* @param path - Backend path from image metadata, rooted at /v1/mobile or the mobile service root.
+	* @returns An absolute URL suitable for authenticated fetches.
+	*/
+	resolveFeedImageUrl(path) {
+		return `${this.opts.url}${path.replace(/^\/v1\/mobile(?=\/)/, "")}`;
+	}
+	/**
+	* Prepares a protected image request for native image components without downloading or encoding bytes.
+	* Does not count as a detail visit or recorded view.
+	* @param params - Image path from metadata plus the original session credentials.
+	* @returns Absolute URL and headers; pass them as the image source's URI and headers.
+	*/
+	getFeedImageRequest(params) {
+		return {
+			url: this.resolveFeedImageUrl(params.path),
+			headers: {
+				"x-feed-session-id": params.sessionId,
+				"x-feed-viewer-token": params.viewerToken
+			}
+		};
+	}
+	/**
+	* Fetches protected feed image bytes using the reading session that fully delivered the parent item.
+	* Does not count as a detail visit or recorded view.
+	* @param params - Image path from metadata plus the original session credentials.
+	* @returns Raw image bytes.
+	* @throws {MobileServerFailureError} On session, permission, or availability errors.
+	*/
+	async getFeedImageBytes(params) {
+		const { url, headers } = this.getFeedImageRequest(params);
+		return this.publicGetBytes(url, headers);
+	}
+	/**
 	* Reads a comment thread with an optional anchor and bidirectional pagination.
 	* Independent reads create a public-only session; reused sessions retain their original scope.
 	* @param params - Root item, optional anchor or cursor (mutually exclusive), page size, and read perspective.
@@ -497,6 +539,57 @@ var MobileClient = class {
 		return require_dataMappers.mapMobileSocialFeedWatchers(await this.publicQuery(body));
 	}
 	/**
+	* Reads the token's latest registration generation and saved capabilities, including legacy v1 registrations.
+	* @param params - Active Expo token credential; no wallet signature is needed.
+	* @returns Saved generation as an opaque string and the complete capability declaration.
+	* @throws {MobileServerFailureError} If the token is invalid or inactive (`INVALID_EXPO_TOKEN`).
+	*/
+	async getNotificationRegistrationV2(params) {
+		return require_dataMappers.mapMobileNotificationRegistrationV2(await this.publicQuery({
+			type: "notification_registration_v2",
+			expo_token: params.expoToken
+		}));
+	}
+	/**
+	* Reads the wallet's full v2 settings document, including legacy preference mappings.
+	* @param params - Active Expo token credential. Before displaying settings, compare the wallet returned by
+	*   {@link MobileClient.getRegisteredWallet} with the connected wallet (case-insensitively).
+	* @returns CamelCase settings with the current settings revision.
+	* @throws {MobileServerFailureError} If the token is invalid or inactive (`INVALID_EXPO_TOKEN`).
+	*/
+	async getNotificationSettingsV2(params) {
+		return require_dataMappers.mapMobileNotificationSettingsV2(await this.publicQuery({
+			type: "notification_settings_v2",
+			expo_token: params.expoToken
+		}));
+	}
+	/**
+	* Reads wallet market subscriptions and the signing Identity's enabled trader bells.
+	* @param params - Wallet authentication context; no Expo token is needed.
+	* @returns Subscriptions, import state, and the independent subscription revision.
+	* @throws {WalletNotProvidedError} If neither a linked signer nor a default wallet is configured.
+	* @throws {MobileServerFailureError} If authentication or the query fails.
+	*/
+	async getNotificationSubscriptions(params) {
+		const request = await this.getSignedRequest("notification_subscriptions", params, {});
+		return require_dataMappers.mapMobileNotificationSubscriptions(await this.query(request));
+	}
+	/**
+	* Reads private accepted notification intents, not delivery receipts or read states.
+	* @param params - Wallet authentication and optional cursor/page size (1-50, default 20).
+	* @returns A camelCase page; discard cached pages and cursors when switching wallets.
+	* @throws {WalletNotProvidedError} If neither a linked signer nor a default wallet is configured.
+	* @throws {MobileServerFailureError} If authentication or pagination validation fails.
+	* @throws {MobileUnsupportedNotificationRouteError} If a notification has an unsupported route name.
+	*/
+	async getNotificationInboxV2(params) {
+		const request = await this.getSignedRequest("notification_inbox_v2", params, {
+			cursor: params.cursor ?? null,
+			limit: params.limit ?? null
+		});
+		return require_dataMappers.mapMobileNotificationInboxV2(await this.query(request));
+	}
+	/**
 	* Unregisters an Expo push token, stopping delivery to that device. Unsigned, so it still works at logout
 	* when a wallet signature may no longer be obtainable. Idempotent: unregistering an inactive or unknown
 	* well-formed token succeeds.
@@ -524,6 +617,7 @@ var MobileClient = class {
 	*
 	* @throws {MobileServerFailureError} With error code `INVALID_PREFERENCES` if those rules are violated, or
 	* `INVALID_EXPO_TOKEN` if the token is malformed or is not currently registered to a wallet.
+	* @deprecated Use {@link updateNotificationSettingsV2} instead.
 	*/
 	async updateNotificationPreferences(params) {
 		const body = {
@@ -534,20 +628,39 @@ var MobileClient = class {
 		return this.publicExecute(body);
 	}
 	/**
-	* Reports qualified exposures without signing. Ordinary reads and root previews do not count as exposures.
-	* The caller must satisfy the session's viewTracking requirements before reporting an item.
-	* @param params - Original reading session and viewer token, plus one to fifty fully delivered, readable,
-	* interactive item IDs. The service deduplicates repeated exposures.
-	* @returns Separate lists of newly accepted and already-counted item IDs.
-	* @throws {MobileServerFailureError} On invalid parameters, session mismatch or expiry, or any ineligible item.
-	* A rejected batch is not partially counted. Acquire a new session after expiry and re-evaluate exposure eligibility.
+	* Replaces all v2 settings fields using optimistic concurrency; legacy overlapping preferences are synced.
+	* @param params - Active Expo token, latest settings revision, and complete replacement settings.
+	* @returns The saved settings document with its incremented revision.
+	* @throws {MobileServerFailureError} On invalid token/settings or revision conflict (`NOTIFICATION_REVISION_CONFLICT`). Re-read and
+	* merge only the user's current change before retrying; never blindly replay a stale document.
+	*/
+	async updateNotificationSettingsV2(params) {
+		return require_dataMappers.mapMobileNotificationSettingsV2(await this.publicExecute({
+			type: "update_notification_settings_v2",
+			expo_token: params.expoToken,
+			expected_revision: params.expectedRevision,
+			settings: require_dataMappers.mapMobileNotificationSettingsToServer(params.settings)
+		}));
+	}
+	/**
+	* Reports a detail visit without signing. Feed-list card impressions and previews do not count.
+	* After the primary detail target is shown in the foreground, send the same viewEventId previously
+	* registered through {@link getFeedItem}, together with that response's sessionId and viewerToken.
+	* Reuse the event ID on retries for the same visit; generate a new one only after leaving and re-entering.
+	* @param params - Original reading session and viewer token, the registered detail-visit event, and exactly
+	* one fully delivered, readable detail-target item ID.
+	* @returns Separate lists of newly accepted and already-counted item IDs for that event.
+	* @throws {MobileServerFailureError} On invalid parameters, an unregistered or rebound event
+	* (`SOCIAL_FEED_VIEW_EVENT_REBOUND`), session mismatch or expiry, or an ineligible item.
+	* Acquire a new session after expiry, re-register the same event via getFeedItem, then retry.
 	*/
 	async recordFeedViews(params) {
 		const body = {
 			type: "record_feed_views",
 			session_id: params.sessionId,
-			item_ids: params.itemIds,
-			viewer_token: params.viewerToken
+			viewer_token: params.viewerToken,
+			view_event_id: params.viewEventId,
+			item_ids: [params.itemId]
 		};
 		return require_dataMappers.mapMobileSocialFeedViewsResult(await this.publicExecute(body));
 	}
@@ -638,11 +751,13 @@ var MobileClient = class {
 	}
 	/**
 	* Registers an Expo push token for the wallet, transferring active ownership of the token if another
-	* wallet had registered it. Idempotent per `(wallet, token)`.
+	* wallet had registered it. Each registration advances its generation and cancels old pending deliveries.
+	* This legacy method replaces capabilities with v1; use registerExpoTokenV2 consistently after upgrading.
 	*
 	* @throws {MobileServerFailureError} With error code `INVALID_EXPO_TOKEN` if the token is not a valid Expo
 	* push token, or `INVALID_DEVICE_METADATA` if `locale` (max 35 chars) or `appVersion` (max 64 chars) is
 	* too long.
+	* @deprecated Use {@link registerExpoTokenV2} instead.
 	*/
 	async registerExpoToken(params) {
 		const signedRequest = await this.getSignedRequest("register_expo_token", params, {
@@ -654,6 +769,47 @@ var MobileClient = class {
 		return this.execute(signedRequest);
 	}
 	/**
+	* Registers a device with its actual v2 capabilities; do not use repeated registration as a heartbeat.
+	* @param params - Wallet authentication, Expo token, metadata, and supported notification types/routes.
+	* @returns Success only; query registration separately for its new generation.
+	* @throws {WalletNotProvidedError} If neither a linked signer nor a default wallet is configured.
+	* @throws {MobileServerFailureError} On `INVALID_EXPO_TOKEN`, `INVALID_DEVICE_METADATA`,
+	* `NOTIFICATION_DEVICE_LIMIT` when the wallet already has 32 active devices, or authentication errors.
+	*/
+	async registerExpoTokenV2(params) {
+		const request = await this.getSignedRequest("register_expo_token_v2", params, {
+			expo_token: params.expoToken,
+			platform: params.platform,
+			locale: params.locale ?? null,
+			app_version: params.appVersion ?? null,
+			capabilities: require_dataMappers.mapMobileNotificationCapabilitiesToServer(params.capabilities)
+		});
+		return this.execute(request);
+	}
+	/**
+	* Applies exactly one bell, market, or one-time favorites-import operation.
+	* @param params - Wallet authentication and subscription update with the latest subscription revision.
+	* @returns Success only; re-query subscriptions for the new revision even after a repeated ON/OFF.
+	* @throws {WalletNotProvidedError} If neither a linked signer nor a default wallet is configured.
+	* @throws {MobileServerFailureError} On `NOTIFICATION_REVISION_CONFLICT`, `INVALID_NOTIFICATION_REQUEST`, or
+	* `INVALID_IDENTITY_TARGET`.
+	*/
+	async updateNotificationSubscriptions(params) {
+		const request = await this.getSignedRequest("update_notification_subscriptions", params, require_dataMappers.mapMobileNotificationSubscriptionsUpdateToServer(params.update));
+		return this.execute(request);
+	}
+	/**
+	* Atomically records 1-50 analytics events after the user has consented to analytics.
+	* @param params - Wallet authentication and events with stable UUIDs and actual millisecond timestamps.
+	* @returns Success only; reuse event IDs on retries. Notification clicks do not mark an inbox item as read.
+	* @throws {WalletNotProvidedError} If neither a linked signer nor a default wallet is configured.
+	* @throws {MobileServerFailureError} If any event, timestamp, batch size, or notification ownership is invalid.
+	*/
+	async recordProductEvents(params) {
+		const request = await this.getSignedRequest("record_product_events", params, { events: params.events.map(require_dataMappers.mapMobileProductEventToServer) });
+		return this.execute(request);
+	}
+	/**
 	* Sets whether the signing subaccount follows a Profile. Both directions are idempotent: following again
 	* keeps the original relationship creation time, so it does not move the account in recency order, and
 	* unfollowing a relationship that does not exist succeeds with `isFollowing: false`. Unfollowing deletes
@@ -718,11 +874,41 @@ var MobileClient = class {
 			action_id: params.actionId,
 			text: params.text,
 			mentions: params.mentions.map(require_dataMappers.mapMobileSocialFeedMentionToServer),
-			drawing_data_json: params.drawingDataJson
+			drawing_data_json: params.drawingDataJson,
+			image_ids: params.imageIds
 		});
 		return require_dataMappers.mapMobileSocialFeedItem((await this.execute(request)).item);
 	}
 	/**
+	* Uploads one static JPEG/PNG for a later {@link createFeedPost} via multipart execute.
+	* The whole HTTP request must stay within 2 MiB including signature overhead; upload one file per call
+	* and bind up to nine ready IDs at publication. There is no complete/PUT step — success means ready.
+	* @param params - Author subaccount and signing options, plus the original file bytes.
+	* @returns Ready image metadata, including original and thumbnail paths.
+	* @throws {WalletNotProvidedError} If neither a linked signer nor a default wallet is configured.
+	* @throws {RangeError} If the complete multipart request exceeds {@link MOBILE_FEED_IMAGE_MAX_REQUEST_BYTES}.
+	* @throws {MobileServerFailureError} On authentication, format/size/hash errors (`INVALID_SOCIAL_FEED_IMAGE`),
+	* or when publishing is disabled (`SERVICE_UNAVAILABLE`), or image storage is unavailable
+	* (`SOCIAL_FEED_DATA_UNAVAILABLE`, 6320, HTTP 503).
+	*/
+	async createFeedPostImageUpload(params) {
+		return this.createFeedImageUpload("create_feed_post_image_uploads", params);
+	}
+	/**
+	* Uploads one static JPEG/PNG for a later {@link createFeedComment} via multipart execute.
+	* Same size and readiness rules as {@link createFeedPostImageUpload}; comment text remains required.
+	* @param params - Author subaccount and signing options, plus the original file bytes.
+	* @returns Ready image metadata, including original and thumbnail paths.
+	* @throws {WalletNotProvidedError} If neither a linked signer nor a default wallet is configured.
+	* @throws {RangeError} If the complete multipart request exceeds {@link MOBILE_FEED_IMAGE_MAX_REQUEST_BYTES}.
+	* @throws {MobileServerFailureError} On authentication, format/size/hash errors (`INVALID_SOCIAL_FEED_IMAGE`),
+	* or when comments are disabled (`SERVICE_UNAVAILABLE`), or image storage is unavailable
+	* (`SOCIAL_FEED_DATA_UNAVAILABLE`, 6320, HTTP 503).
+	*/
+	async createFeedCommentImageUpload(params) {
+		return this.createFeedImageUpload("create_feed_comment_image_uploads", params);
+	}
+	/**
 	* First attaches a drawing to an owned post or trade card while the author still holds its position.
 	* The original JSON is signed unchanged; false and zero are valid drawing documents.
 	* For an exact retry after a timeout, generate a nonce up front with {@link getMobileNonce} and reuse
@@ -778,7 +964,8 @@ var MobileClient = class {
 			reply_to_item_id: params.replyToItemId,
 			text: params.text,
 			mentions: params.mentions.map(require_dataMappers.mapMobileSocialFeedMentionToServer),
-			attached_position_id: params.attachedPositionId
+			attached_position_id: params.attachedPositionId,
+			image_ids: params.imageIds
 		});
 		return require_dataMappers.mapMobileSocialFeedCommentResult(await this.execute(request));
 	}
@@ -820,18 +1007,73 @@ var MobileClient = class {
 		this.checkServerStatus(response);
 		return response.data;
 	}
+	async publicGetBytes(url, headers) {
+		const response = await this.axiosInstance.get(url, {
+			responseType: "arraybuffer",
+			headers
+		});
+		if (response.status < 200 || response.status >= 300) {
+			const responseText = (0, viem.bytesToString)(new Uint8Array(response.data));
+			let errorData;
+			try {
+				errorData = JSON.parse(responseText);
+			} catch {
+				errorData = responseText;
+			}
+			this.checkResponseStatus({
+				...response,
+				data: errorData
+			});
+		}
+		return new Uint8Array(response.data);
+	}
 	async publicExecute(body) {
 		const response = await this.axiosInstance.post(`${this.opts.url}/public_execute`, body);
 		this.checkResponseStatus(response);
 		this.checkServerStatus(response);
 		return response.data;
 	}
-	async execute(body) {
-		const response = await this.axiosInstance.post(`${this.opts.url}/execute`, body);
+	/**
+	* Sends an authenticated read through the signed query route.
+	* @param body - Canonical inner payload with its signature, sender, and nonce.
+	* @returns The successful query envelope and its type-specific payload.
+	* @throws {MobileServerFailureError} For a structured service failure, including non-2xx responses.
+	*/
+	async query(body) {
+		const response = await this.axiosInstance.post(`${this.opts.url}/query`, body);
 		this.checkResponseStatus(response);
 		this.checkServerStatus(response);
 		return response.data;
 	}
+	async execute(body, fileBytes) {
+		const multipart = fileBytes == null ? void 0 : require_utils_buildMobileFeedImageMultipart.buildMobileFeedImageMultipart(JSON.stringify(body), fileBytes);
+		if (multipart) this.checkFeedImageRequestSize(multipart.body.byteLength);
+		const response = await this.axiosInstance.post(`${this.opts.url}/execute`, multipart?.body ?? body, multipart ? { headers: { "Content-Type": multipart.contentType } } : void 0);
+		this.checkResponseStatus(response);
+		this.checkServerStatus(response);
+		return response.data;
+	}
+	async createFeedImageUpload(type, params) {
+		const nonce = params.nonce ?? require_signing_nonce.getMobileNonce();
+		const sizePayload = {
+			type,
+			content_hash: viem.zeroHash,
+			signature: `0x${"00".repeat(65)}`,
+			sender: (0, _nadohq_shared.subaccountToHex)(params),
+			nonce: nonce.toString()
+		};
+		const overhead = require_utils_buildMobileFeedImageMultipart.buildMobileFeedImageMultipart(JSON.stringify(sizePayload), new Uint8Array()).body.byteLength;
+		this.checkFeedImageRequestSize(overhead + params.fileBytes.byteLength);
+		const contentHash = (0, viem.keccak256)(params.fileBytes);
+		const request = await this.getSignedRequest(type, {
+			...params,
+			nonce
+		}, { content_hash: contentHash });
+		return require_dataMappers.mapMobileSocialFeedImage((await this.execute(request, params.fileBytes)).image);
+	}
+	checkFeedImageRequestSize(byteLength) {
+		if (byteLength > 2097152) throw new RangeError(`Feed image upload request exceeds ${require_utils_feed.MOBILE_FEED_IMAGE_MAX_REQUEST_BYTES} bytes (2 MiB).`);
+	}
 	/**
 	* Validates the HTTP status before interpreting the body. Unlike the engine, the mobile backend returns
 	* failure envelopes with non-2xx statuses (e.g. 404 for `PROFILE_NOT_FOUND`), so a non-2xx response with a
@@ -856,4 +1098,4 @@ Object.defineProperty(exports, "MobileClient", {
 	}
 });
 
-//# sourceMappingURL=MobileClient-CfVZXTcz.cjs.map
+//# sourceMappingURL=MobileClient-M4oC4lrX.cjs.map