@metamask/social-controllers 3.5.0 → 3.7.0

package/dist/SocialService.js

@@ -33,10 +33,13 @@ const PositionStruct = structType({
     chain: string(),
     positionAmount: number(),
     isOpen: optional(boolean()),
-    boughtUsd: number(),
-    soldUsd: number(),
-    realizedPnl: number(),
-    costBasis: number(),
+    // Incomplete Clicker metrics serialize these as `null` (`undefined + n`
+    // becomes `NaN`, then JSON `null`). Rejecting the field used to fail the
+    // entire feed page, so they are nullable here.
+    boughtUsd: nullable(number()),
+    soldUsd: nullable(number()),
+    realizedPnl: nullable(number()),
+    costBasis: nullable(number()),
     trades: array(TradeStruct),
     lastTradeAt: number(),
     tokenImageUrl: optional(nullable(string())),
@@ -182,6 +185,34 @@ const FeedResponseStruct = structType({
     items: array(FeedItemStruct),
     pagination: FeedPaginationStruct,
 });
+/**
+ * One malformed feed item must not blank the page. When the envelope is
+ * well-shaped, keep items that match {@link FeedItemStruct} and drop the rest.
+ * Still throw when `items` or `pagination` themselves are unusable.
+ *
+ * @param feedData - Parsed JSON body from a feed endpoint.
+ * @param invalidMessage - Error message to throw when the envelope is unusable.
+ * @returns The validated feed response, possibly with invalid items dropped.
+ */
+const parseFeedResponse = (feedData, invalidMessage) => {
+    if (is(feedData, FeedResponseStruct)) {
+        return feedData;
+    }
+    if (typeof feedData !== 'object' ||
+        feedData === null ||
+        !('items' in feedData) ||
+        !('pagination' in feedData)) {
+        throw new Error(invalidMessage);
+    }
+    const { items, pagination } = feedData;
+    if (!Array.isArray(items) || !is(pagination, FeedPaginationStruct)) {
+        throw new Error(invalidMessage);
+    }
+    return {
+        items: items.filter((item) => is(item, FeedItemStruct)),
+        pagination,
+    };
+};
 const FollowersResponseStruct = structType({
     followers: array(ProfileSummaryStruct),
     count: number(),
@@ -196,6 +227,28 @@ const FollowResponseStruct = structType({
 const UnfollowResponseStruct = structType({
     unfollowed: array(ProfileSummaryStruct),
 });
+const BlockedProfileStruct = structType({
+    blockedAt: number(),
+    reason: nullable(string()),
+    profile: ProfileSummaryStruct,
+});
+const BlockedProfilesResponseStruct = structType({
+    items: array(BlockedProfileStruct),
+    cursor: nullable(string()),
+});
+const BlockedContentStruct = structType({
+    blockedAt: number(),
+    reason: nullable(string()),
+    type: enums(['comment', 'reply']),
+    id: string(),
+    text: string(),
+    createdAt: number(),
+    author: nullable(ProfileSummaryStruct),
+});
+const BlockedContentResponseStruct = structType({
+    items: array(BlockedContentStruct),
+    cursor: nullable(string()),
+});
 // ---------------------------------------------------------------------------
 // Messenger types
 // ---------------------------------------------------------------------------
@@ -205,7 +258,10 @@ const MESSENGER_EXPOSED_METHODS = [
     'fetchOpenPositions',
     'fetchClosedPositions',
     'fetchFollowers',
+    'fetchTraderFollowing',
     'fetchFollowing',
+    'fetchMyFollowing',
+    'fetchMyFollowers',
     'fetchPositionById',
     'fetchFeed',
     'fetchTraderFeed',
@@ -218,6 +274,9 @@ const MESSENGER_EXPOSED_METHODS = [
     'optOutOfLeaderboard',
     'optInToLeaderboard',
     'refreshNotificationPreferencesCache',
+    'block',
+    'fetchBlockedProfiles',
+    'fetchBlockedContent',
 ];
 // ---------------------------------------------------------------------------
 // Service
@@ -289,7 +348,7 @@ export class SocialService extends BaseDataService {
                     headers: authHeaders,
                 });
                 _a.#throwIfNotOk(response, SocialServiceErrorMessage.FETCH_LEADERBOARD_FAILED);
-                const leaderboardData = await response.json();
+                const leaderboardData = (await response.json());
                 if (!is(leaderboardData, LeaderboardResponseStruct)) {
                     throw new Error(SocialServiceErrorMessage.FETCH_LEADERBOARD_INVALID_RESPONSE);
                 }
@@ -316,7 +375,7 @@ export class SocialService extends BaseDataService {
                 const authHeaders = await this.#getAuthHeaders();
                 const response = await fetch(url, { headers: authHeaders });
                 _a.#throwIfNotOk(response, SocialServiceErrorMessage.FETCH_TRADER_PROFILE_FAILED);
-                const traderProfileData = await response.json();
+                const traderProfileData = (await response.json());
                 if (!is(traderProfileData, TraderProfileResponseStruct)) {
                     throw new Error(SocialServiceErrorMessage.FETCH_TRADER_PROFILE_INVALID_RESPONSE);
                 }
@@ -360,22 +419,31 @@ export class SocialService extends BaseDataService {
     /**
      * Fetches a trader's MetaMask followers.
      *
-     * Calls `GET ${baseUrl}/traders/${addressOrId}/followers`.
+     * Calls `GET ${baseUrl}/traders/${addressOrId}/followers`. Pass
+     * `mutuals: true` to append `?mutuals=true` (profiles that follow both this
+     * trader and the authenticated user; `count` is the mutual total). Requires a
+     * bearer token; the trader is identified by `addressOrId`, not the JWT
+     * subject (see {@link fetchMyFollowers} for the current user's inbound list).
      *
      * @param options - Options bag.
      * @param options.addressOrId - Wallet address or Clicker profile ID.
+     * @param options.mutuals - When true, request mutual followers only.
      * @returns The followers response.
      */
     async fetchFollowers(options) {
-        const { addressOrId } = options;
+        const { addressOrId, mutuals } = options;
+        const mutualsOnly = mutuals === true;
         const followersResponse = await this.fetchQuery({
-            queryKey: [`${this.name}:fetchFollowers`, addressOrId],
+            queryKey: [`${this.name}:fetchFollowers`, addressOrId, mutualsOnly],
             queryFn: async () => {
-                const url = `${this.#v1Url}/traders/${encodeURIComponent(addressOrId)}/followers`;
+                const url = new URL(`${this.#v1Url}/traders/${encodeURIComponent(addressOrId)}/followers`);
+                if (mutualsOnly) {
+                    url.searchParams.append('mutuals', 'true');
+                }
                 const authHeaders = await this.#getAuthHeaders();
-                const response = await fetch(url, { headers: authHeaders });
+                const response = await fetch(url.toString(), { headers: authHeaders });
                 _a.#throwIfNotOk(response, SocialServiceErrorMessage.FETCH_FOLLOWERS_FAILED);
-                const followersData = await response.json();
+                const followersData = (await response.json());
                 if (!is(followersData, FollowersResponseStruct)) {
                     throw new Error(SocialServiceErrorMessage.FETCH_FOLLOWERS_INVALID_RESPONSE);
                 }
@@ -384,6 +452,35 @@ export class SocialService extends BaseDataService {
         });
         return followersResponse;
     }
+    /**
+     * Fetches the list of traders a profile follows.
+     *
+     * Calls `GET ${baseUrl}/traders/${addressOrId}/following`. Requires a bearer
+     * token; the trader is identified by `addressOrId`, not the JWT subject (see
+     * {@link fetchFollowing} for the current user's outbound list).
+     *
+     * @param options - Options bag.
+     * @param options.addressOrId - Wallet address or Clicker profile ID.
+     * @returns The following response.
+     */
+    async fetchTraderFollowing(options) {
+        const { addressOrId } = options;
+        const followingResponse = await this.fetchQuery({
+            queryKey: [`${this.name}:fetchTraderFollowing`, addressOrId],
+            queryFn: async () => {
+                const url = `${this.#v1Url}/traders/${encodeURIComponent(addressOrId)}/following`;
+                const authHeaders = await this.#getAuthHeaders();
+                const response = await fetch(url, { headers: authHeaders });
+                _a.#throwIfNotOk(response, SocialServiceErrorMessage.FETCH_TRADER_FOLLOWING_FAILED);
+                const followingData = (await response.json());
+                if (!is(followingData, FollowingResponseStruct)) {
+                    throw new Error(SocialServiceErrorMessage.FETCH_TRADER_FOLLOWING_INVALID_RESPONSE);
+                }
+                return followingData;
+            },
+        });
+        return followingResponse;
+    }
     /**
      * Fetches a single position by its unique ID.
      *
@@ -402,7 +499,7 @@ export class SocialService extends BaseDataService {
                 const authHeaders = await this.#getAuthHeaders();
                 const response = await fetch(url, { headers: authHeaders });
                 _a.#throwIfNotOk(response, SocialServiceErrorMessage.FETCH_POSITION_BY_ID_FAILED);
-                const positionData = await response.json();
+                const positionData = (await response.json());
                 if (!is(positionData, PositionStruct)) {
                     throw new Error(SocialServiceErrorMessage.FETCH_POSITION_BY_ID_INVALID_RESPONSE);
                 }
@@ -459,11 +556,8 @@ export class SocialService extends BaseDataService {
                     headers: authHeaders,
                 });
                 _a.#throwIfNotOk(response, SocialServiceErrorMessage.FETCH_FEED_FAILED);
-                const feedData = await response.json();
-                if (!is(feedData, FeedResponseStruct)) {
-                    throw new Error(SocialServiceErrorMessage.FETCH_FEED_INVALID_RESPONSE);
-                }
-                return feedData;
+                const feedData = (await response.json());
+                return parseFeedResponse(feedData, SocialServiceErrorMessage.FETCH_FEED_INVALID_RESPONSE);
             },
         });
         return feedResponse;
@@ -516,11 +610,8 @@ export class SocialService extends BaseDataService {
                     headers: authHeaders,
                 });
                 _a.#throwIfNotOk(response, SocialServiceErrorMessage.FETCH_TRADER_FEED_FAILED);
-                const feedData = await response.json();
-                if (!is(feedData, FeedResponseStruct)) {
-                    throw new Error(SocialServiceErrorMessage.FETCH_TRADER_FEED_INVALID_RESPONSE);
-                }
-                return feedData;
+                const feedData = (await response.json());
+                return parseFeedResponse(feedData, SocialServiceErrorMessage.FETCH_TRADER_FEED_INVALID_RESPONSE);
             },
         });
         return traderFeedResponse;
@@ -575,10 +666,7 @@ export class SocialService extends BaseDataService {
                 });
                 _a.#throwIfNotOk(response, SocialServiceErrorMessage.FETCH_TOKEN_FEED_FAILED);
                 const feedData = (await response.json());
-                if (!is(feedData, FeedResponseStruct)) {
-                    throw new Error(SocialServiceErrorMessage.FETCH_TOKEN_FEED_INVALID_RESPONSE);
-                }
-                return feedData;
+                return parseFeedResponse(feedData, SocialServiceErrorMessage.FETCH_TOKEN_FEED_INVALID_RESPONSE);
             },
         });
         return tokenFeedResponse;
@@ -608,7 +696,7 @@ export class SocialService extends BaseDataService {
                     body: JSON.stringify({ emotion }),
                 });
                 _a.#throwIfNotOk(response, SocialServiceErrorMessage.REACT_TO_COMMENT_FAILED);
-                const metrics = await response.json();
+                const metrics = (await response.json());
                 if (!is(metrics, CommentEngagementStruct)) {
                     throw new Error(SocialServiceErrorMessage.REACT_TO_COMMENT_INVALID_RESPONSE);
                 }
@@ -639,7 +727,7 @@ export class SocialService extends BaseDataService {
                     headers: authHeaders,
                 });
                 _a.#throwIfNotOk(response, SocialServiceErrorMessage.REMOVE_COMMENT_REACTION_FAILED);
-                const metrics = await response.json();
+                const metrics = (await response.json());
                 if (!is(metrics, CommentEngagementStruct)) {
                     throw new Error(SocialServiceErrorMessage.REMOVE_COMMENT_REACTION_INVALID_RESPONSE);
                 }
@@ -704,6 +792,10 @@ export class SocialService extends BaseDataService {
      * Calls `GET ${baseUrl}/users/me/following`. The caller is identified
      * server-side from the JWT sub claim carried in the Authorization header.
      *
+     * Prefer {@link fetchMyFollowing} in new code (pairs with
+     * {@link fetchMyFollowers}). This method is unchanged and remains the
+     * `/users/me/following` read.
+     *
      * @returns The following response.
      */
     async fetchFollowing() {
@@ -715,7 +807,7 @@ export class SocialService extends BaseDataService {
                 const authHeaders = await this.#getAuthHeaders();
                 const response = await fetch(url, { headers: authHeaders });
                 _a.#throwIfNotOk(response, SocialServiceErrorMessage.FETCH_FOLLOWING_FAILED);
-                const followingData = await response.json();
+                const followingData = (await response.json());
                 if (!is(followingData, FollowingResponseStruct)) {
                     throw new Error(SocialServiceErrorMessage.FETCH_FOLLOWING_INVALID_RESPONSE);
                 }
@@ -724,6 +816,43 @@ export class SocialService extends BaseDataService {
         });
         return followingResponse;
     }
+    /**
+     * Fetches the list of traders the current user is following.
+     *
+     * Alias of {@link fetchFollowing}. Calls `GET ${baseUrl}/users/me/following`.
+     * Preferred name in new code so `/users/me` reads are both `fetchMy*`.
+     *
+     * @returns The following response.
+     */
+    async fetchMyFollowing() {
+        return this.fetchFollowing();
+    }
+    /**
+     * Fetches the list of traders following the current user.
+     *
+     * Calls `GET ${baseUrl}/users/me/followers`. The caller is identified
+     * server-side from the JWT sub claim carried in the Authorization header.
+     *
+     * @returns The followers response.
+     */
+    async fetchMyFollowers() {
+        const followersResponse = await this.fetchQuery({
+            queryKey: [`${this.name}:fetchMyFollowers`],
+            staleTime: 0,
+            queryFn: async () => {
+                const url = `${this.#v1Url}/users/me/followers`;
+                const authHeaders = await this.#getAuthHeaders();
+                const response = await fetch(url, { headers: authHeaders });
+                _a.#throwIfNotOk(response, SocialServiceErrorMessage.FETCH_MY_FOLLOWERS_FAILED);
+                const followersData = (await response.json());
+                if (!is(followersData, FollowersResponseStruct)) {
+                    throw new Error(SocialServiceErrorMessage.FETCH_MY_FOLLOWERS_INVALID_RESPONSE);
+                }
+                return followersData;
+            },
+        });
+        return followersResponse;
+    }
     /**
      * Follows one or more traders on behalf of the current user.
      *
@@ -748,7 +877,7 @@ export class SocialService extends BaseDataService {
                     body: JSON.stringify({ targets }),
                 });
                 _a.#throwIfNotOk(response, SocialServiceErrorMessage.FOLLOW_FAILED);
-                const followData = await response.json();
+                const followData = (await response.json());
                 if (!is(followData, FollowResponseStruct)) {
                     throw new Error(SocialServiceErrorMessage.FOLLOW_INVALID_RESPONSE);
                 }
@@ -785,7 +914,7 @@ export class SocialService extends BaseDataService {
                     headers: authHeaders,
                 });
                 _a.#throwIfNotOk(response, SocialServiceErrorMessage.UNFOLLOW_FAILED);
-                const unfollowData = await response.json();
+                const unfollowData = (await response.json());
                 if (!is(unfollowData, UnfollowResponseStruct)) {
                     throw new Error(SocialServiceErrorMessage.UNFOLLOW_INVALID_RESPONSE);
                 }
@@ -864,6 +993,105 @@ export class SocialService extends BaseDataService {
             },
         });
     }
+    /**
+     * Blocks a trader, swap comment, or reply for the current user.
+     *
+     * Calls `PUT ${baseUrl}/moderation/block`. Provide exactly one of
+     * `profileId`, `commentId`, or `replyId`. Blocking the same target again
+     * replaces `reason` when one is given. The caller is identified server-side
+     * from the JWT sub claim carried in the Authorization header.
+     *
+     * @param options - Options bag. Exactly one target, plus an optional reason.
+     * @param options.profileId - Profile id (UUID) of the trader to block.
+     * @param options.commentId - Swap comment to block.
+     * @param options.replyId - Comment reply to block.
+     * @param options.reason - Free-form reason stored on the block.
+     */
+    async block(options) {
+        await this.fetchQuery({
+            queryKey: [`${this.name}:block`, options],
+            staleTime: 0,
+            queryFn: async () => {
+                const url = `${this.#v1Url}/moderation/block`;
+                const authHeaders = await this.#getAuthHeaders();
+                const response = await fetch(url, {
+                    method: 'PUT',
+                    headers: { ...authHeaders, 'Content-Type': 'application/json' },
+                    body: JSON.stringify(options),
+                });
+                _a.#throwIfNotOk(response, SocialServiceErrorMessage.BLOCK_FAILED);
+                return null;
+            },
+        });
+    }
+    /**
+     * Fetches traders the current user has blocked.
+     *
+     * Calls `GET ${baseUrl}/moderation/blocks/profiles`. Results are most
+     * recently blocked first, 250 per page. The caller is identified
+     * server-side from the JWT sub claim carried in the Authorization header.
+     *
+     * @param options - Options bag.
+     * @param options.cursor - Cursor from the previous page. Omit for the first page.
+     * @returns The blocked profiles page.
+     */
+    async fetchBlockedProfiles(options) {
+        const cursor = options?.cursor;
+        return await this.fetchQuery({
+            queryKey: [`${this.name}:fetchBlockedProfiles`, cursor ?? null],
+            staleTime: 0,
+            queryFn: async () => {
+                const url = new URL(`${this.#v1Url}/moderation/blocks/profiles`);
+                if (cursor) {
+                    url.searchParams.append('cursor', cursor);
+                }
+                const authHeaders = await this.#getAuthHeaders();
+                const response = await fetch(url.toString(), {
+                    headers: authHeaders,
+                });
+                _a.#throwIfNotOk(response, SocialServiceErrorMessage.FETCH_BLOCKED_PROFILES_FAILED);
+                const blockedProfiles = (await response.json());
+                if (!is(blockedProfiles, BlockedProfilesResponseStruct)) {
+                    throw new Error(SocialServiceErrorMessage.FETCH_BLOCKED_PROFILES_INVALID_RESPONSE);
+                }
+                return blockedProfiles;
+            },
+        });
+    }
+    /**
+     * Fetches comments and replies the current user has blocked.
+     *
+     * Calls `GET ${baseUrl}/moderation/blocks/content`. Results are most
+     * recently blocked first, 250 per page. The caller is identified
+     * server-side from the JWT sub claim carried in the Authorization header.
+     *
+     * @param options - Options bag.
+     * @param options.cursor - Cursor from the previous page. Omit for the first page.
+     * @returns The blocked content page.
+     */
+    async fetchBlockedContent(options) {
+        const cursor = options?.cursor;
+        return await this.fetchQuery({
+            queryKey: [`${this.name}:fetchBlockedContent`, cursor ?? null],
+            staleTime: 0,
+            queryFn: async () => {
+                const url = new URL(`${this.#v1Url}/moderation/blocks/content`);
+                if (cursor) {
+                    url.searchParams.append('cursor', cursor);
+                }
+                const authHeaders = await this.#getAuthHeaders();
+                const response = await fetch(url.toString(), {
+                    headers: authHeaders,
+                });
+                _a.#throwIfNotOk(response, SocialServiceErrorMessage.FETCH_BLOCKED_CONTENT_FAILED);
+                const blockedContent = (await response.json());
+                if (!is(blockedContent, BlockedContentResponseStruct)) {
+                    throw new Error(SocialServiceErrorMessage.FETCH_BLOCKED_CONTENT_INVALID_RESPONSE);
+                }
+                return blockedContent;
+            },
+        });
+    }
     /**
      * Shared helper for fetching open/closed positions.
      *
@@ -911,7 +1139,7 @@ export class SocialService extends BaseDataService {
                     headers: authHeaders,
                 });
                 _a.#throwIfNotOk(response, failedMessage);
-                const positionsData = await response.json();
+                const positionsData = (await response.json());
                 if (!is(positionsData, PositionsResponseStruct)) {
                     throw new Error(invalidMessage);
                 }