@amityco/ts-sdk 6.17.3 → 6.18.0

package/src/channelRepository/observers/getChannel.ts

@@ -32,6 +32,8 @@ import { getChannelMessagePreviewWithUser } from '~/messagePreview/utils';
 import { isEqual } from '~/utils/isEqual';
 import { updateChannelCache } from '../utils/updateChannelCache';
 import { onChannelMarkerUpdated } from '~/marker/events/onChannelMarkerUpdated';
+import { onSubChannelCreated } from '~/subChannelRepository';
+import { onUserFeedMarkerUpdated } from '~/marker/events/onUserFeedMarkerUpdated';
 
 /* begin_public_function
   id: channel.get
@@ -104,8 +106,8 @@ export const getChannel = (
       convertEventPayload(onChannelMarkerFetched, 'entityId', 'channel'),
       convertEventPayload(onChannelMarkerUpdated, 'entityId', 'channel'),
       convertEventPayload(
-        (callback: Amity.Listener<Amity.Message>) => {
-          const updateMessagePreview = async (message: Amity.Message) => {
+        (callback: Amity.Listener<Amity.InternalMessage>) => {
+          const updateMessagePreview = async (message: Amity.InternalMessage) => {
             const messagePreviewSetting = await client.getMessagePreviewSetting(false);
             if (messagePreviewSetting === Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW) return;
 
@@ -129,8 +131,8 @@ export const getChannel = (
         'channel',
       ),
       convertEventPayload(
-        (callback: Amity.Listener<Amity.Message>) => {
-          const updateMessagePreview = async (message: Amity.Message) => {
+        (callback: Amity.Listener<Amity.InternalMessage>) => {
+          const updateMessagePreview = async (message: Amity.InternalMessage) => {
             const messagePreviewSetting = await client.getMessagePreviewSetting(false);
             if (messagePreviewSetting === Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW) return;
 
@@ -154,8 +156,8 @@ export const getChannel = (
         'channel',
       ),
       convertEventPayload(
-        (callback: Amity.Listener<Amity.Message>) => {
-          const updateMessagePreview = async (message: Amity.Message) => {
+        (callback: Amity.Listener<Amity.InternalMessage>) => {
+          const updateMessagePreview = async (message: Amity.InternalMessage) => {
             const channel = pullFromCache<Amity.Channel>(['channel', 'get', channelId])?.data;
             if (!channel || channel.messagePreviewId !== message.messageId) return;
 
@@ -174,8 +176,8 @@ export const getChannel = (
         'channel',
       ),
       convertEventPayload(
-        (callback: Amity.Listener<Amity.Message>) => {
-          const updateMessagePreview = async (message: Amity.Message) => {
+        (callback: Amity.Listener<Amity.InternalMessage>) => {
+          const updateMessagePreview = async (message: Amity.InternalMessage) => {
             const channel = pullFromCache<Amity.Channel>(['channel', 'get', channelId])?.data;
             if (!channel || channel.messagePreviewId !== message.messageId) return;
 
@@ -262,6 +264,8 @@ export const getChannel = (
         'channelId',
         'channel',
       ),
+      convertEventPayload(onSubChannelCreated, 'channelId', 'channel'),
+      convertEventPayload(onUserFeedMarkerUpdated, 'entityId', 'channel'),
     ],
     {
       forceDispatch: true,

package/src/channelRepository/observers/getChannels/ChannelLiveCollectionController.ts

@@ -46,6 +46,8 @@ import { getActiveClient } from '~/client';
 import { prepareChannelPayload } from '~/channelRepository/utils';
 import { ChannelPaginationNoPageController } from './ChannelPagnationNoPageController';
 import { PaginationController } from '~/core/liveCollection/PaginationController';
+import { onUserFeedMarkerUpdated } from '~/marker/events/onUserFeedMarkerUpdated';
+import { onSubChannelCreated } from '~/subChannelRepository';
 
 export class ChannelLiveCollectionController extends LiveCollectionController<
   'channel',
@@ -225,7 +227,7 @@ export class ChannelLiveCollectionController extends LiveCollectionController<
       {
         // TODO: merge this code to another onMessageCreated in this file
         fn: convertEventPayload(
-          (callback: Amity.Listener<Amity.Message>) => {
+          (callback: Amity.Listener<Amity.InternalMessage>) => {
             return onMessageCreatedMqtt(message => {
               const cacheData = pullFromCache<Amity.Channel>([
                 'channel',
@@ -250,7 +252,7 @@ export class ChannelLiveCollectionController extends LiveCollectionController<
       {
         // TODO: merge this code to another onMessageCreated in this file
         fn: convertEventPayload(
-          (callback: Amity.Listener<Amity.Message>) => {
+          (callback: Amity.Listener<Amity.InternalMessage>) => {
             return onMessageCreatedLocal(message => {
               const cacheData = pullFromCache<Amity.Channel>([
                 'channel',
@@ -276,7 +278,30 @@ export class ChannelLiveCollectionController extends LiveCollectionController<
       { fn: onChannelUpdated, action: 'onUpdate' },
       { fn: onChannelMuted, action: 'onMute' },
       { fn: onChannelJoined, action: 'onJoin' },
-      { fn: onChannelLeft, action: 'onLeft' },
+      {
+        fn: (reactor: Amity.Listener<Amity.InternalChannel>) => {
+          const callback = (
+            channel: Amity.InternalChannel,
+            member: Amity.Membership<'channel'>,
+          ) => {
+            const { userId } = getActiveClient();
+            // if query for channel member and user is not a member, remove channelId from curren collection
+            if (this.query.membership === 'member' && userId === member.userId) {
+              const collection = pullFromCache<Amity.ChannelLiveCollectionCache>(
+                this.cacheKey,
+              )?.data;
+
+              pushToCache(this.cacheKey, {
+                ...collection,
+                data: collection?.data.filter(c => c !== channel.channelId) ?? [],
+              });
+            }
+            return reactor(channel);
+          };
+          return onChannelLeft(callback);
+        },
+        action: 'onLeft',
+      },
       { fn: onChannelMemberAdded, action: 'onMemberAdded' },
       { fn: onChannelMemberRemoved, action: 'onMemberRemoved' },
       {
@@ -289,8 +314,8 @@ export class ChannelLiveCollectionController extends LiveCollectionController<
       },
       {
         fn: convertEventPayload(
-          (callback: Amity.Listener<Amity.Message>) => {
-            const updateMessagePreview = async (message: Amity.Message) => {
+          (callback: Amity.Listener<Amity.InternalMessage>) => {
+            const updateMessagePreview = async (message: Amity.InternalMessage) => {
               const messagePreviewSetting =
                 await ChannelLiveCollectionController.getMessagePreviewSetting();
               if (messagePreviewSetting === Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW) return;
@@ -323,8 +348,8 @@ export class ChannelLiveCollectionController extends LiveCollectionController<
       },
       {
         fn: convertEventPayload(
-          (callback: Amity.Listener<Amity.Message>) => {
-            const updateMessagePreview = async (message: Amity.Message) => {
+          (callback: Amity.Listener<Amity.InternalMessage>) => {
+            const updateMessagePreview = async (message: Amity.InternalMessage) => {
               const messagePreviewSetting =
                 await ChannelLiveCollectionController.getMessagePreviewSetting();
               if (messagePreviewSetting === Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW) return;
@@ -357,8 +382,8 @@ export class ChannelLiveCollectionController extends LiveCollectionController<
       },
       {
         fn: convertEventPayload(
-          (callback: Amity.Listener<Amity.Message>) => {
-            const updateMessagePreview = async (message: Amity.Message) => {
+          (callback: Amity.Listener<Amity.InternalMessage>) => {
+            const updateMessagePreview = async (message: Amity.InternalMessage) => {
               const messagePreviewSetting =
                 await ChannelLiveCollectionController.getMessagePreviewSetting();
               if (messagePreviewSetting === Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW) return;
@@ -379,8 +404,8 @@ export class ChannelLiveCollectionController extends LiveCollectionController<
       },
       {
         fn: convertEventPayload(
-          (callback: Amity.Listener<Amity.Message>) => {
-            const updateMessagePreview = async (message: Amity.Message) => {
+          (callback: Amity.Listener<Amity.InternalMessage>) => {
+            const updateMessagePreview = async (message: Amity.InternalMessage) => {
               const messagePreviewSetting =
                 await ChannelLiveCollectionController.getMessagePreviewSetting();
 
@@ -464,6 +489,14 @@ export class ChannelLiveCollectionController extends LiveCollectionController<
         ),
         action: 'onUpdate',
       },
+      {
+        fn: convertEventPayload(onUserFeedMarkerUpdated, 'entityId', 'channel'),
+        action: 'onUpdate',
+      },
+      {
+        fn: convertEventPayload(onSubChannelCreated, 'channelId', 'channel'),
+        action: 'onUpdate',
+      },
     ];
 
     if (this.paginationController instanceof PaginationController) {

package/src/channelRepository/observers/getChannels/ChannelQueryStreamController.ts

@@ -69,7 +69,10 @@ export class ChannelQueryStreamController extends QueryStreamController<
       const collection = pullFromCache<Amity.ChannelLiveCollectionCache>(this.cacheKey)?.data;
       if (!collection) return;
 
-      if (this.paginationController instanceof ChannelPaginationController) {
+      if (
+        this.paginationController instanceof ChannelPaginationController &&
+        action === 'onCreate'
+      ) {
         collection.data = [...new Set([payload.channelId, ...collection.data])];
         pushToCache(this.cacheKey, collection);
       }

package/src/channelRepository/utils/getChannelIsMentioned.ts

@@ -0,0 +1,42 @@
+import { pullFromCache } from '~/cache/api/pullFromCache';
+import { getActiveClient } from '~/client/api/activeClient';
+import { getActiveUser } from '~/client/api/activeUser';
+import { getResolver } from '~/core/model';
+
+const getCachedMarker = (entityId: string) => {
+  const key = {
+    entityId,
+    userId: getActiveUser()._id,
+  };
+
+  return pullFromCache<Amity.ChannelMarker>([
+    'channelMarker',
+    'get',
+    getResolver('channelMarker')(key),
+  ])?.data;
+};
+
+const getUnreadInfoCached = (channelId: Amity.RawChannel['channelId']) => {
+  return pullFromCache<Amity.ChannelUnreadInfo>(['channelUnreadInfo', 'get', channelId])?.data;
+};
+
+/**
+ * The function use to get value of hasMentioned or isMentioned field.
+ * function will get the value from marker params first, if there is no hasMentioned field, will look in to the cache.
+ *
+ * If consistent mode is enabled, the function will return the value from the channelUnreadCountInfo cache.
+ * If not, the function will return the value from the channelMarker cache.
+ * If not found in the both cache, use `false` as defaul value.
+ */
+
+export const getChannelIsMentioned = (channel: Amity.RawChannel, marker?: Amity.ChannelMarker) => {
+  const client = getActiveClient();
+
+  if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
+    return getUnreadInfoCached(channel.channelId)?.isMentioned ?? false;
+  }
+
+  return marker?.hasMentioned !== undefined
+    ? marker?.hasMentioned
+    : getCachedMarker(channel.channelId)?.hasMentioned ?? false;
+};

package/src/channelRepository/utils/getSubChannelsUnreadCount.ts

@@ -0,0 +1,50 @@
+import { pullFromCache } from '~/cache/api/pullFromCache';
+import { getActiveClient } from '~/client/api/activeClient';
+import { getActiveUser } from '~/client/api/activeUser';
+import { getResolver } from '~/core/model';
+
+const getCachedMarker = (entityId: string) => {
+  const key = {
+    entityId,
+    userId: getActiveUser()._id,
+  };
+
+  return pullFromCache<Amity.ChannelMarker>([
+    'channelMarker',
+    'get',
+    getResolver('channelMarker')(key),
+  ])?.data;
+};
+
+const getUnreadInfoCached = (channelId: Amity.RawChannel['channelId']) => {
+  return pullFromCache<Amity.ChannelUnreadInfo>(['channelUnreadInfo', 'get', channelId])?.data;
+};
+
+/**
+ * The function use to get value of unreadCount field.
+ * function will get the value from marker params first, if there is no hasMentioned field, will look in to the cache.
+ *
+ * If consistent mode is enabled, the function will return the value from the channelUnreadCountInfo cache.
+ * If not, the function will return the value from the channelMarker cache.
+ * If not found in the both cache, use `0` as defaul value.
+ */
+
+export const getSubChannelsUnreadCount = (
+  channel: Amity.RawChannel,
+  marker?: Amity.ChannelMarker,
+) => {
+  const client = getActiveClient();
+
+  if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
+    return getUnreadInfoCached(channel.channelId)?.unreadCount ?? 0;
+  }
+
+  if (marker?.isDeleted) {
+    // NOTE: This is a temporary solution to handle the channel marker when the user is forced to
+    // leave the channel because currently backend can't handle this, so every time a user is banned
+    // from a channel or the channel is deleted the channel's unread count will reset to zero
+    return 0;
+  }
+
+  return marker?.unreadCount ?? getCachedMarker(channel.channelId)?.unreadCount ?? 0;
+};

package/src/channelRepository/utils/prepareChannelPayload.ts

@@ -2,11 +2,13 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 import { withUsers } from '~/group/utils/withUser';
 import { getChannelMarkers } from '~/marker/api/getChannelMarkers';
 
-import { getChannelUnreadCount } from './getChannelUnreadCount';
-import { getChannelHasMentioned } from './getChannelHasMentioned';
 import { updateChannelMessagePreviewCache } from '~/messagePreview/utils';
 import { getActiveClient } from '~/client/api/activeClient';
 import { pullFromCache } from '~/cache/api/pullFromCache';
+import { getSubChannelsUnreadCount } from './getSubChannelsUnreadCount';
+import { getChannelIsMentioned } from './getChannelIsMentioned';
+import { getUserMessageFeedMakers } from '~/marker/api/getUserMessageFeedMarkers';
+import { persistUnreadCountInfo } from '~/marker/utils/persistUnreadCountInfo';
 
 export const MARKER_INCLUDED_CHANNEL_TYPE = ['broadcast', 'conversation', 'community'];
 export const isUnreadCountSupport = ({ type }: Pick<Amity.RawChannel, 'type'>) =>
@@ -30,10 +32,16 @@ export function convertFromRaw(
 
   return {
     get unreadCount() {
-      return getChannelUnreadCount(channel);
+      return getSubChannelsUnreadCount(channel);
     },
     get hasMentioned() {
-      return getChannelHasMentioned(channel);
+      return getChannelIsMentioned(channel);
+    },
+    get isMentioned() {
+      return getChannelIsMentioned(channel);
+    },
+    get subChannelsUnreadCount() {
+      return getSubChannelsUnreadCount(channel);
     },
     ...channel,
     defaultSubChannelId: channel._id,
@@ -60,6 +68,19 @@ export const prepareChannelPayload = async (
   const client = getActiveClient();
   const networkPreviewSetting = await client.getMessagePreviewSetting(false);
 
+  // if consistent mode is enabled, persist the unread count info to the cache
+  if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
+    const queryPayload = await getUserMessageFeedMakers(
+      rawPayload.channels.map(({ channelId }) => channelId),
+    );
+
+    const { feedMarkers, userFeedMarkers } = queryPayload;
+    persistUnreadCountInfo({
+      feedMarkers,
+      userFeedMarkers,
+    });
+  }
+
   if (
     options.isMessagePreviewUpdated &&
     networkPreviewSetting !== Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW &&

package/src/channelRepository/utils/tests/prepareChannelPayload.test.ts

@@ -61,6 +61,8 @@ const convertedChannelPayload: Amity.ProcessedChannelPayload = {
       unreadCount: channelMarker1.unreadCount,
       hasMentioned: channelMarker1.hasMentioned,
       messagePreviewId: undefined,
+      subChannelsUnreadCount: channelMarker1.unreadCount,
+      isMentioned: channelMarker1.hasMentioned,
     },
     {
       ...liveChannel,
@@ -69,6 +71,8 @@ const convertedChannelPayload: Amity.ProcessedChannelPayload = {
       unreadCount: 0,
       hasMentioned: false,
       messagePreviewId: undefined,
+      subChannelsUnreadCount: 0,
+      isMentioned: false,
     },
     {
       ...conversationChannel,
@@ -76,7 +80,9 @@ const convertedChannelPayload: Amity.ProcessedChannelPayload = {
       isUnreadCountSupport: true,
       unreadCount: channelMarker2.unreadCount,
       hasMentioned: channelMarker2.hasMentioned,
+      isMentioned: channelMarker2.hasMentioned,
       messagePreviewId: undefined,
+      subChannelsUnreadCount: channelMarker2.unreadCount,
     },
   ],
   channelUsers: [channelUser],

package/src/client/api/accessTokenExpiryWatcher.ts

@@ -3,6 +3,7 @@ import { scheduleTask } from '~/core/microtasks';
 import { MINUTE, ACCESS_TOKEN_WATCHER_INTERVAL } from '~/utils/constants';
 
 import { renewal } from './renewal';
+import { getActiveClient } from './activeClient';
 
 const ABOUT_TO_EXPIRE_THRESHOLD = 80 / 100;
 const COMPENSATED_DELAY = 5 * MINUTE;
@@ -50,11 +51,15 @@ export const isAboutToExpire = (params: {
  * @category private
  */
 export const accessTokenExpiryWatcher = (
-  expiresAt: Amity.Tokens['expiresAt'],
-  issuedAt: Amity.Tokens['issuedAt'],
   sessionHandler: Amity.SessionHandler,
 ): Amity.Unsubscriber => {
   const interval: ReturnType<typeof setInterval> = setInterval(() => {
+    const client = getActiveClient();
+
+    if (!client.token) return;
+
+    const { issuedAt, expiresAt } = client.token;
+
     if (isExpired(expiresAt)) {
       /*
        * the event handler will take care of updating session state

package/src/client/api/createClient.ts

@@ -14,10 +14,13 @@ import { createEventEmitter } from '~/core/events';
 import { getMessagePreviewSetting } from '~/client/utils/messagePreviewEngine';
 import { getSocialSettings } from '~/client/api/getSocialSettings';
 import { hasPermission } from '~/client/utils/hasPermission';
+import { validateUrls } from './validateUrls';
+import { validateTexts } from './validateTexts';
 import { getActiveClient, setActiveClient } from './activeClient';
 import { getFeedSettings } from './getFeedSettings';
 
 import { accessTokenExpiryWatcher } from './accessTokenExpiryWatcher';
+import { getMarkerSyncConsistentMode } from '../utils/markerSyncEngine';
 
 const DEFAULT_DEBUG_SESSION = 'amity';
 
@@ -72,6 +75,8 @@ export const createClient = (
   const sessionState = Amity.SessionStates.NOT_LOGGED_IN;
   const sessionHandler = undefined;
 
+  const isUnreadCountEnabled = false;
+
   const client = {
     version: `${VERSION}`,
     apiKey,
@@ -98,11 +103,17 @@ export const createClient = (
     sessionHandler,
 
     hasPermission,
+    validateUrls,
+    validateTexts,
     getFeedSettings,
     getSocialSettings,
     getMessagePreviewSetting,
 
     use: () => setActiveClient(client),
+
+    isUnreadCountEnabled,
+
+    getMarkerSyncConsistentMode,
   };
 
   try {

package/src/client/api/enableUnreadCount.ts

@@ -0,0 +1,24 @@
+import { ASCError } from '~/core/errors';
+import { getActiveClient } from './activeClient';
+
+export const enableUnreadCount = () => {
+  const client = getActiveClient();
+
+  client.log('client/api/isUnreadCountEnabled', client.isUnreadCountEnabled);
+
+  if (!client) {
+    throw new ASCError(
+      'There is no active client',
+      Amity.ClientError.UNKNOWN_ERROR,
+      Amity.ErrorLevel.FATAL,
+    );
+  }
+
+  if (client.isUnreadCountEnabled) return false;
+
+  client.isUnreadCountEnabled = true;
+
+  client.emitter.emit('unreadCountEnabled', true);
+
+  return true;
+};

package/src/client/api/index.ts

@@ -13,3 +13,5 @@ export * from './getFeedSettings';
 export * from './renewal';
 
 export * from './markerSync';
+
+export * from './enableUnreadCount';

package/src/client/api/login.ts

@@ -10,6 +10,7 @@ import { markReadEngineOnLoginHandler } from '~/subChannelRepository/utils/markR
 import { onUserDeleted } from '~/userRepository/events/onUserDeleted';
 
 import analyticsEngineOnLoginHandler from '~/analytic/utils/analyticsEngineOnLoginHandler';
+import readReceiptSyncEngineOnLoginHandler from '../utils/ReadReceiptSync/readReceiptSyncEngineOnLoginHandler';
 import { logout } from './logout';
 
 import { getActiveClient } from './activeClient';
@@ -25,6 +26,7 @@ import { onTokenTerminated } from '../events/onTokenTerminated';
 import { setClientToken } from '../utils/setClientToken';
 import { removeChannelMarkerCache } from '../utils/removeChannelMarkerCache';
 import { initializeMessagePreviewSetting } from '../utils/messagePreviewEngine';
+import { startMarkerSync } from '../utils/markerSyncEngine';
 import { ASCError } from '~/core/errors';
 
 /*
@@ -130,11 +132,7 @@ export const login = async (
      * Cannot push to subscriptions as watcher needs to continue working even if
      * token expires
      */
-    unsubWatcher = client.accessTokenExpiryWatcher(
-      client.token?.expiresAt!,
-      client.token?.issuedAt!,
-      sessionHandler!,
-    );
+    unsubWatcher = client.accessTokenExpiryWatcher(sessionHandler);
 
     setActiveUser(user);
   } catch (error) {
@@ -199,7 +197,11 @@ export const login = async (
 
       markReadEngineOnLoginHandler(),
       analyticsEngineOnLoginHandler(),
+      readReceiptSyncEngineOnLoginHandler(),
     );
+
+    const markerSyncUnsubscriber = await startMarkerSync();
+    subscriptions.push(markerSyncUnsubscriber);
   }
 
   return true;

package/src/client/api/markerSync.ts

@@ -2,11 +2,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
 
 import { getActiveClient } from './activeClient';
-import {
-  convertChannelMarkerResponse,
-  convertSubChannelMarkerResponse,
-  convertUserMarkerResponse,
-} from '~/utils/marker';
+import { convertChannelMarkerResponse, convertSubChannelMarkerResponse } from '~/utils/marker';
 
 /**
  * ```js
@@ -43,10 +39,9 @@ export const markerSync = async (
     userEntityMarkers: userEntityMarkersPayload,
     userFeedMarkers: userFeedMarkersPayload,
     feedMarkers,
-    userMarkers: userMarkersPayload,
+    userMarkers,
   } = payload;
 
-  const userMarkers = convertUserMarkerResponse(userMarkersPayload);
   const userEntityMarkers = convertChannelMarkerResponse(userEntityMarkersPayload);
   const userFeedMarkers = convertSubChannelMarkerResponse(userFeedMarkersPayload);
 

package/src/client/api/renewal.ts

@@ -35,14 +35,11 @@ export const renewal = (): Amity.AccessTokenRenewal => {
 
     const params = { userId, displayName, authToken, deviceId };
 
-    if (client.sessionState === Amity.SessionStates.TOKEN_EXPIRED) {
-      // sessionHandler will never be empty when renewal is instantiatied
-      await login(params, client.sessionHandler!);
+    if (client.sessionState === Amity.SessionStates.TOKEN_EXPIRED && client.sessionHandler) {
+      await login(params, client.sessionHandler);
     } else {
       // about to expire
 
-      // @ts-ignore: in that particular case, typing can be
-      // ignored since we enforce default values just before.
       await refreshToken(params);
     }
 

package/src/client/api/validateTexts.ts

@@ -0,0 +1,23 @@
+import { getActiveClient } from './activeClient';
+
+/**
+ * Validate a list of texts
+ * @param texts array of strings to validate (max 10 items)
+ *
+ * @category Client API
+ */
+export const validateTexts = async (texts: string[]): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('channel/markerSync');
+
+  if (texts.length === 0) return false;
+
+  const { data: payload } = await client.http.post<{ success: boolean }>(
+    '/api/v3/blocklists/verify',
+    {
+      data: texts,
+    },
+  );
+
+  return payload.success;
+};

package/src/client/api/validateUrls.ts

@@ -0,0 +1,23 @@
+import { getActiveClient } from './activeClient';
+
+/**
+ * Validate a list of urls
+ * @param urls  array of strings to validate (max 10 items)
+ *
+ * @category Client API
+ */
+export const validateUrls = async (urls: string[]): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('channel/markerSync');
+
+  if (urls.length === 0) return false;
+
+  const { data: payload } = await client.http.post<{ success: boolean }>(
+    '/api/v3/allowlists/verify',
+    {
+      data: urls,
+    },
+  );
+
+  return payload.success;
+};