@metamask/social-controllers 3.6.0 → 3.8.0

package/dist/SocialService.js

@@ -1,7 +1,7 @@
 var _a;
 import { BaseDataService } from '@metamask/base-data-service';
 import { HttpError } from '@metamask/controller-utils';
-import { array, assign, boolean, enums, is, nullable, number, optional, record, string, type as structType, } from '@metamask/superstruct';
+import { array, assign, boolean, enums, is, literal, nullable, number, optional, record, string, type as structType, union, } from '@metamask/superstruct';
 import { serviceName, SocialServiceErrorMessage } from './social-constants.js';
 import { TRADER_RANKING_TAGS, TradeStruct } from './social-types.js';
 // ---------------------------------------------------------------------------
@@ -33,16 +33,20 @@ 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())),
     currentValueUSD: optional(nullable(number())),
     pnlValueUsd: optional(nullable(number())),
     pnlPercent: optional(nullable(number())),
+    copyCount: optional(number()),
     perpPositionType: optional(nullable(enums(['long', 'short']))),
     perpLeverage: optional(nullable(number())),
     positionAmountWithLeverage: optional(nullable(number())),
@@ -164,12 +168,35 @@ const SwapCommentResponseStruct = structType({
     isAppUserComment: boolean(),
     metrics: CommentEngagementStruct,
 });
+const CopyTradeAccountStruct = structType({
+    profileId: string(),
+    caip10: string(),
+});
+const CopyTradeIntentResponseStruct = structType({
+    id: string(),
+    origin: structType({
+        kind: literal('comment'),
+        id: string(),
+    }),
+    copierAccount: CopyTradeAccountStruct,
+    sourceAccount: nullable(CopyTradeAccountStruct),
+    execution: union([
+        structType({ product: literal('swaps'), quoteId: string() }),
+        structType({ product: literal('perps'), oid: string() }),
+    ]),
+    payoutEligibility: structType({
+        status: enums(['payable', 'non_payable']),
+        reason: string(),
+    }),
+    createdAt: string(),
+});
 const FeedItemStruct = assign(PositionStruct, structType({
     actor: FeedActorStruct,
     timestamp: number(),
     authorComment: optional(nullable(AuthorCommentStruct)),
     commentCount: optional(number()),
     replyCount: optional(number()),
+    copyCount: optional(number()),
     firstTradeAt: optional(nullable(number())),
     holdTimeMs: optional(nullable(number())),
     entryPriceUsd: optional(nullable(number())),
@@ -182,6 +209,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(),
@@ -227,7 +282,10 @@ const MESSENGER_EXPOSED_METHODS = [
     'fetchOpenPositions',
     'fetchClosedPositions',
     'fetchFollowers',
+    'fetchTraderFollowing',
     'fetchFollowing',
+    'fetchMyFollowing',
+    'fetchMyFollowers',
     'fetchPositionById',
     'fetchFeed',
     'fetchTraderFeed',
@@ -235,6 +293,7 @@ const MESSENGER_EXPOSED_METHODS = [
     'reactToComment',
     'removeCommentReaction',
     'createSwapComment',
+    'createCopyTradeIntent',
     'follow',
     'unfollow',
     'optOutOfLeaderboard',
@@ -314,7 +373,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);
                 }
@@ -341,7 +400,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);
                 }
@@ -385,22 +444,32 @@ 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],
+            staleTime: 0,
             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);
                 }
@@ -409,6 +478,36 @@ 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],
+            staleTime: 0,
+            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.
      *
@@ -427,7 +526,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);
                 }
@@ -484,11 +583,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;
@@ -541,11 +637,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;
@@ -600,10 +693,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;
@@ -633,7 +723,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);
                 }
@@ -664,7 +754,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);
                 }
@@ -723,12 +813,57 @@ export class SocialService extends BaseDataService {
             },
         });
     }
+    /**
+     * Records that the current user is copying a trade from a social post, so
+     * the copy can be detected and attributed to the post's author.
+     *
+     * Calls `POST ${baseUrl}/copy-trade-intents`. Send swaps before submission
+     * with the Bridge quote id, and perps right after submission with the
+     * returned order id. The endpoint is idempotent per profile, origin, and
+     * execution id: it answers 201 for a new intent and 200 with the existing
+     * one on a retry.
+     *
+     * @param options - Options bag.
+     * @param options.origin - Comment the trade was copied from.
+     * @param options.copierAccount - CAIP-10 account placing the trade.
+     * @param options.execution - Swap quote id or perps order id.
+     * @returns The created or existing copy-trade intent.
+     */
+    async createCopyTradeIntent(options) {
+        const { origin, copierAccount, execution } = options;
+        return await this.fetchQuery({
+            queryKey: [
+                `${this.name}:createCopyTradeIntent`,
+                { origin, copierAccount, execution },
+            ],
+            staleTime: 0,
+            queryFn: async () => {
+                const url = `${this.#v1Url}/copy-trade-intents`;
+                const authHeaders = await this.#getAuthHeaders();
+                const response = await fetch(url, {
+                    method: 'POST',
+                    headers: { ...authHeaders, 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ origin, copierAccount, execution }),
+                });
+                _a.#throwIfNotOk(response, SocialServiceErrorMessage.CREATE_COPY_TRADE_INTENT_FAILED);
+                const intent = (await response.json());
+                if (!is(intent, CopyTradeIntentResponseStruct)) {
+                    throw new Error(SocialServiceErrorMessage.CREATE_COPY_TRADE_INTENT_INVALID_RESPONSE);
+                }
+                return intent;
+            },
+        });
+    }
     /**
      * Fetches the list of traders the current user is following.
      *
      * 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() {
@@ -740,7 +875,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);
                 }
@@ -749,6 +884,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.
      *
@@ -773,7 +945,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);
                 }
@@ -810,7 +982,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);
                 }
@@ -1035,7 +1207,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);
                 }