@ecency/sdk 1.5.13 → 1.5.15

package/dist/node/index.cjs

@@ -705,6 +705,18 @@ function getFollowCountQueryOptions(username) {
     ])
   });
 }
+function getFollowersQueryOptions(following, startFollower, followType = "blog", limit = 100) {
+  return reactQuery.queryOptions({
+    queryKey: ["accounts", "followers", following, startFollower, followType, limit],
+    queryFn: () => CONFIG.hiveClient.database.call("get_followers", [
+      following,
+      startFollower,
+      followType,
+      limit
+    ]),
+    enabled: !!following
+  });
+}
 function getFollowingQueryOptions(follower, startFollowing, followType = "blog", limit = 100) {
   return reactQuery.queryOptions({
     queryKey: ["accounts", "following", follower, startFollowing, followType, limit],
@@ -1425,6 +1437,20 @@ function getEntryActiveVotesQueryOptions(entry) {
     enabled: !!entry
   });
 }
+function getUserPostVoteQueryOptions(username, author, permlink) {
+  return reactQuery.queryOptions({
+    queryKey: ["posts", "user-vote", username, author, permlink],
+    queryFn: async () => {
+      const result = await CONFIG.hiveClient.call("database_api", "list_votes", {
+        start: [username, author, permlink],
+        limit: 1,
+        order: "by_voter_comment"
+      });
+      return result?.votes?.[0] || null;
+    },
+    enabled: !!username && !!author && !!permlink
+  });
+}
 function getContentQueryOptions(author, permlink) {
   return reactQuery.queryOptions({
     queryKey: ["posts", "content", author, permlink],
@@ -2340,8 +2366,8 @@ function toEntryArray(x) {
   return Array.isArray(x) ? x : [];
 }
 async function getVisibleFirstLevelThreadItems(container) {
-  const queryOptions87 = getDiscussionsQueryOptions(container, "created" /* created */, true);
-  const discussionItemsRaw = await CONFIG.queryClient.fetchQuery(queryOptions87);
+  const queryOptions88 = getDiscussionsQueryOptions(container, "created" /* created */, true);
+  const discussionItemsRaw = await CONFIG.queryClient.fetchQuery(queryOptions88);
   const discussionItems = toEntryArray(discussionItemsRaw);
   if (discussionItems.length <= 1) {
     return [];
@@ -3313,10 +3339,14 @@ function useAddFragment(username, code) {
     }
   });
 }
-function useEditFragment(username, fragmentId, code) {
+function useEditFragment(username, code) {
   return reactQuery.useMutation({
-    mutationKey: ["posts", "edit-fragment", username, fragmentId],
-    mutationFn: async ({ title, body }) => {
+    mutationKey: ["posts", "edit-fragment", username],
+    mutationFn: async ({
+      fragmentId,
+      title,
+      body
+    }) => {
       if (!code) {
         throw new Error("[SDK][Posts] Missing access token");
       }
@@ -3338,14 +3368,14 @@ function useEditFragment(username, fragmentId, code) {
       );
       return response.json();
     },
-    onSuccess(response) {
+    onSuccess(response, variables) {
       getQueryClient().setQueryData(
         getFragmentsQueryOptions(username, code).queryKey,
         (data) => {
           if (!data) {
             return [];
           }
-          const index = data.findIndex(({ id }) => id === fragmentId);
+          const index = data.findIndex(({ id }) => id === variables.fragmentId);
           if (index >= 0) {
             data[index] = response;
           }
@@ -3355,10 +3385,10 @@ function useEditFragment(username, fragmentId, code) {
     }
   });
 }
-function useRemoveFragment(username, fragmentId, code) {
+function useRemoveFragment(username, code) {
   return reactQuery.useMutation({
     mutationKey: ["posts", "remove-fragment", username],
-    mutationFn: async () => {
+    mutationFn: async ({ fragmentId }) => {
       if (!code) {
         throw new Error("[SDK][Posts] Missing access token");
       }
@@ -3374,173 +3404,643 @@ function useRemoveFragment(username, fragmentId, code) {
         }
       });
     },
-    onSuccess() {
+    onSuccess(_data, variables) {
       getQueryClient().setQueryData(
         getFragmentsQueryOptions(username, code).queryKey,
-        (data) => [...data ?? []].filter(({ id }) => id !== fragmentId)
+        (data) => [...data ?? []].filter(({ id }) => id !== variables.fragmentId)
       );
     }
   });
 }
 
-// src/modules/posts/utils/validate-post-creating.ts
-var DEFAULT_VALIDATE_POST_DELAYS = [3e3, 3e3, 3e3];
-var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-async function getContent(author, permlink) {
-  return CONFIG.hiveClient.call("condenser_api", "get_content", [
-    author,
-    permlink
-  ]);
-}
-async function validatePostCreating(author, permlink, attempts = 0, options) {
-  const delays = options?.delays ?? DEFAULT_VALIDATE_POST_DELAYS;
-  let response;
-  try {
-    response = await getContent(author, permlink);
-  } catch (e) {
-    response = void 0;
+// src/modules/private-api/requests.ts
+async function parseJsonResponse(response) {
+  if (!response.ok) {
+    let errorData = void 0;
+    try {
+      errorData = await response.json();
+    } catch {
+      errorData = void 0;
+    }
+    const error = new Error(`Request failed with status ${response.status}`);
+    error.status = response.status;
+    error.data = errorData;
+    throw error;
   }
-  if (response || attempts >= delays.length) {
-    return;
+  const text = await response.text();
+  if (!text || text.trim() === "") {
+    return "";
   }
-  const waitMs = delays[attempts];
-  if (waitMs > 0) {
-    await delay(waitMs);
+  try {
+    return JSON.parse(text);
+  } catch (e) {
+    console.warn("[SDK] Failed to parse JSON response:", e, "Response:", text);
+    return "";
   }
-  return validatePostCreating(author, permlink, attempts + 1, options);
 }
-
-// src/modules/analytics/mutations/index.ts
-var mutations_exports = {};
-__export(mutations_exports, {
-  useRecordActivity: () => useRecordActivity
-});
-function getLocationInfo() {
-  if (typeof window !== "undefined" && window.location) {
-    return {
-      url: window.location.href,
-      domain: window.location.host
-    };
-  }
-  return { url: "", domain: "" };
+async function signUp(username, email, referral) {
+  const fetchApi = getBoundFetch();
+  const response = await fetchApi(CONFIG.privateApiHost + "/private-api/account-create", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ username, email, referral })
+  });
+  const data = await parseJsonResponse(response);
+  return { status: response.status, data };
 }
-function useRecordActivity(username, activityType, options) {
-  return reactQuery.useMutation({
-    mutationKey: ["analytics", activityType],
-    mutationFn: async () => {
-      if (!activityType) {
-        throw new Error("[SDK][Analytics] \u2013 no activity type provided");
-      }
-      const fetchApi = getBoundFetch();
-      const locationInfo = getLocationInfo();
-      const url = options?.url ?? locationInfo.url;
-      const domain = options?.domain ?? locationInfo.domain;
-      await fetchApi(CONFIG.plausibleHost + "/api/event", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          name: activityType,
-          url,
-          domain,
-          props: {
-            username
-          }
-        })
-      });
-    }
+async function subscribeEmail(email) {
+  const fetchApi = getBoundFetch();
+  const response = await fetchApi(CONFIG.privateApiHost + "/private-api/subscribe", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ email })
   });
+  const data = await parseJsonResponse(response);
+  return { status: response.status, data };
 }
-function getDiscoverLeaderboardQueryOptions(duration) {
-  return reactQuery.queryOptions({
-    queryKey: ["analytics", "discover-leaderboard", duration],
-    queryFn: async ({ signal }) => {
-      const response = await fetch(
-        CONFIG.privateApiHost + `/private-api/leaderboard/${duration}`,
-        { signal }
-      );
-      if (!response.ok) {
-        throw new Error(`Failed to fetch leaderboard: ${response.status}`);
-      }
-      return response.json();
-    }
+async function usrActivity(code, ty, bl = "", tx = "") {
+  const params = { code, ty };
+  if (bl) {
+    params.bl = bl;
+  }
+  if (tx) {
+    params.tx = tx;
+  }
+  const fetchApi = getBoundFetch();
+  const response = await fetchApi(CONFIG.privateApiHost + "/private-api/usr-activity", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(params)
   });
+  await parseJsonResponse(response);
 }
-function getDiscoverCurationQueryOptions(duration) {
-  return reactQuery.queryOptions({
-    queryKey: ["analytics", "discover-curation", duration],
-    queryFn: async ({ signal }) => {
-      const response = await fetch(
-        CONFIG.privateApiHost + `/private-api/curation/${duration}`,
-        { signal }
-      );
-      if (!response.ok) {
-        throw new Error(`Failed to fetch curation data: ${response.status}`);
-      }
-      const data = await response.json();
-      const accounts = data.map((item) => item.account);
-      const accountsResponse = await CONFIG.hiveClient.database.getAccounts(accounts);
-      for (let index = 0; index < accountsResponse.length; index++) {
-        const element = accountsResponse[index];
-        const curator = data[index];
-        const vestingShares = typeof element.vesting_shares === "string" ? element.vesting_shares : element.vesting_shares.toString();
-        const receivedVestingShares = typeof element.received_vesting_shares === "string" ? element.received_vesting_shares : element.received_vesting_shares.toString();
-        const delegatedVestingShares = typeof element.delegated_vesting_shares === "string" ? element.delegated_vesting_shares : element.delegated_vesting_shares.toString();
-        const vestingWithdrawRate = typeof element.vesting_withdraw_rate === "string" ? element.vesting_withdraw_rate : element.vesting_withdraw_rate.toString();
-        const effectiveVest = parseFloat(vestingShares) + parseFloat(receivedVestingShares) - parseFloat(delegatedVestingShares) - parseFloat(vestingWithdrawRate);
-        curator.efficiency = curator.vests / effectiveVest;
-      }
-      data.sort((a, b) => b.efficiency - a.efficiency);
-      return data;
-    }
+async function getNotifications(code, filter, since = null, user = null) {
+  const data = {
+    code
+  };
+  if (filter) {
+    data.filter = filter;
+  }
+  if (since) {
+    data.since = since;
+  }
+  if (user) {
+    data.user = user;
+  }
+  const fetchApi = getBoundFetch();
+  const response = await fetchApi(CONFIG.privateApiHost + "/private-api/notifications", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(data)
   });
+  return parseJsonResponse(response);
 }
-function getPageStatsQueryOptions(url, dimensions = [], metrics = ["visitors", "pageviews", "visit_duration"], dateRange) {
-  return reactQuery.queryOptions({
-    queryKey: ["analytics", "page-stats", url, dimensions, metrics, dateRange],
-    queryFn: async ({ signal }) => {
-      const response = await fetch(CONFIG.privateApiHost + "/api/stats", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          metrics,
-          url: encodeURIComponent(url),
-          dimensions,
-          date_range: dateRange
-        }),
-        signal
-      });
-      if (!response.ok) {
-        throw new Error(`Failed to fetch page stats: ${response.status}`);
-      }
-      return response.json();
+async function saveNotificationSetting(code, username, system, allows_notify, notify_types, token) {
+  const data = {
+    code,
+    username,
+    token,
+    system,
+    allows_notify,
+    notify_types
+  };
+  const fetchApi = getBoundFetch();
+  const response = await fetchApi(CONFIG.privateApiHost + "/private-api/register-device", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
     },
-    enabled: !!url
+    body: JSON.stringify(data)
   });
+  return parseJsonResponse(response);
 }
-
-// src/modules/integrations/3speak/queries/index.ts
-var queries_exports2 = {};
-__export(queries_exports2, {
-  getAccountTokenQueryOptions: () => getAccountTokenQueryOptions,
-  getAccountVideosQueryOptions: () => getAccountVideosQueryOptions
-});
-
-// src/modules/integrations/hivesigner/queries/index.ts
-var queries_exports = {};
-__export(queries_exports, {
-  getDecodeMemoQueryOptions: () => getDecodeMemoQueryOptions
-});
-function getDecodeMemoQueryOptions(username, memo, accessToken) {
-  return reactQuery.queryOptions({
-    queryKey: ["integrations", "hivesigner", "decode-memo", username],
-    queryFn: async () => {
-      if (accessToken) {
-        const hsClient = new hs__default.default.Client({
-          accessToken
+async function getNotificationSetting(code, username, token) {
+  const data = { code, username, token };
+  const fetchApi = getBoundFetch();
+  const response = await fetchApi(CONFIG.privateApiHost + "/private-api/detail-device", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(data)
+  });
+  return parseJsonResponse(response);
+}
+async function markNotifications(code, id) {
+  const data = {
+    code
+  };
+  if (id) {
+    data.id = id;
+  }
+  const fetchApi = getBoundFetch();
+  const response = await fetchApi(CONFIG.privateApiHost + "/private-api/notifications/mark", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(data)
+  });
+  return parseJsonResponse(response);
+}
+async function addImage(code, url) {
+  const data = { code, url };
+  const fetchApi = getBoundFetch();
+  const response = await fetchApi(CONFIG.privateApiHost + "/private-api/images-add", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(data)
+  });
+  return parseJsonResponse(response);
+}
+async function uploadImage(file, token, signal) {
+  const fetchApi = getBoundFetch();
+  const formData = new FormData();
+  formData.append("file", file);
+  const response = await fetchApi(`${CONFIG.imageHost}/hs/${token}`, {
+    method: "POST",
+    body: formData,
+    signal
+  });
+  return parseJsonResponse(response);
+}
+async function deleteImage(code, imageId) {
+  const data = { code, id: imageId };
+  const fetchApi = getBoundFetch();
+  const response = await fetchApi(CONFIG.privateApiHost + "/private-api/images-delete", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(data)
+  });
+  return parseJsonResponse(response);
+}
+async function addDraft(code, title, body, tags, meta) {
+  const data = { code, title, body, tags, meta };
+  const fetchApi = getBoundFetch();
+  const response = await fetchApi(CONFIG.privateApiHost + "/private-api/drafts-add", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(data)
+  });
+  return parseJsonResponse(response);
+}
+async function updateDraft(code, draftId, title, body, tags, meta) {
+  const data = { code, id: draftId, title, body, tags, meta };
+  const fetchApi = getBoundFetch();
+  const response = await fetchApi(CONFIG.privateApiHost + "/private-api/drafts-update", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(data)
+  });
+  return parseJsonResponse(response);
+}
+async function deleteDraft(code, draftId) {
+  const data = { code, id: draftId };
+  const fetchApi = getBoundFetch();
+  const response = await fetchApi(CONFIG.privateApiHost + "/private-api/drafts-delete", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(data)
+  });
+  return parseJsonResponse(response);
+}
+async function addSchedule(code, permlink, title, body, meta, options, schedule, reblog) {
+  const data = {
+    code,
+    permlink,
+    title,
+    body,
+    meta,
+    schedule,
+    reblog
+  };
+  if (options) {
+    data.options = options;
+  }
+  const fetchApi = getBoundFetch();
+  const response = await fetchApi(CONFIG.privateApiHost + "/private-api/schedules-add", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(data)
+  });
+  return parseJsonResponse(response);
+}
+async function deleteSchedule(code, id) {
+  const data = { code, id };
+  const fetchApi = getBoundFetch();
+  const response = await fetchApi(CONFIG.privateApiHost + "/private-api/schedules-delete", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(data)
+  });
+  return parseJsonResponse(response);
+}
+async function moveSchedule(code, id) {
+  const data = { code, id };
+  const fetchApi = getBoundFetch();
+  const response = await fetchApi(CONFIG.privateApiHost + "/private-api/schedules-move", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(data)
+  });
+  return parseJsonResponse(response);
+}
+async function getPromotedPost(code, author, permlink) {
+  const data = { code, author, permlink };
+  const fetchApi = getBoundFetch();
+  const response = await fetchApi(CONFIG.privateApiHost + "/private-api/promoted-post", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(data)
+  });
+  return parseJsonResponse(response);
+}
+async function onboardEmail(username, email, friend) {
+  const dataBody = {
+    username,
+    email,
+    friend
+  };
+  const fetchApi = getBoundFetch();
+  const response = await fetchApi(
+    CONFIG.privateApiHost + "/private-api/account-create-friend",
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(dataBody)
+    }
+  );
+  return parseJsonResponse(response);
+}
+
+// src/modules/posts/mutations/use-add-draft.ts
+function useAddDraft(username, code, onSuccess, onError) {
+  return reactQuery.useMutation({
+    mutationKey: ["posts", "drafts", "add", username],
+    mutationFn: async ({
+      title,
+      body,
+      tags,
+      meta
+    }) => {
+      if (!username || !code) {
+        throw new Error("[SDK][Posts] \u2013 missing auth for addDraft");
+      }
+      return addDraft(code, title, body, tags, meta);
+    },
+    onSuccess: () => {
+      onSuccess?.();
+      getQueryClient().invalidateQueries({
+        queryKey: ["posts", "drafts", username]
+      });
+    },
+    onError
+  });
+}
+function useUpdateDraft(username, code, onSuccess, onError) {
+  return reactQuery.useMutation({
+    mutationKey: ["posts", "drafts", "update", username],
+    mutationFn: async ({
+      draftId,
+      title,
+      body,
+      tags,
+      meta
+    }) => {
+      if (!username || !code) {
+        throw new Error("[SDK][Posts] \u2013 missing auth for updateDraft");
+      }
+      return updateDraft(code, draftId, title, body, tags, meta);
+    },
+    onSuccess: () => {
+      onSuccess?.();
+      getQueryClient().invalidateQueries({
+        queryKey: ["posts", "drafts", username]
+      });
+    },
+    onError
+  });
+}
+function useDeleteDraft(username, code, onSuccess, onError) {
+  return reactQuery.useMutation({
+    mutationKey: ["posts", "drafts", "delete", username],
+    mutationFn: async ({ draftId }) => {
+      if (!username || !code) {
+        throw new Error("[SDK][Posts] \u2013 missing auth for deleteDraft");
+      }
+      return deleteDraft(code, draftId);
+    },
+    onSuccess: () => {
+      onSuccess?.();
+      getQueryClient().invalidateQueries({
+        queryKey: ["posts", "drafts", username]
+      });
+    },
+    onError
+  });
+}
+function useAddSchedule(username, code, onSuccess, onError) {
+  return reactQuery.useMutation({
+    mutationKey: ["posts", "schedules", "add", username],
+    mutationFn: async ({
+      permlink,
+      title,
+      body,
+      meta,
+      options,
+      schedule,
+      reblog
+    }) => {
+      if (!username || !code) {
+        throw new Error("[SDK][Posts] \u2013 missing auth for addSchedule");
+      }
+      return addSchedule(code, permlink, title, body, meta, options, schedule, reblog);
+    },
+    onSuccess: () => {
+      onSuccess?.();
+      getQueryClient().invalidateQueries({
+        queryKey: ["posts", "schedules", username]
+      });
+    },
+    onError
+  });
+}
+function useDeleteSchedule(username, code, onSuccess, onError) {
+  return reactQuery.useMutation({
+    mutationKey: ["posts", "schedules", "delete", username],
+    mutationFn: async ({ id }) => {
+      if (!username || !code) {
+        throw new Error("[SDK][Posts] \u2013 missing auth for deleteSchedule");
+      }
+      return deleteSchedule(code, id);
+    },
+    onSuccess: () => {
+      onSuccess?.();
+      getQueryClient().invalidateQueries({
+        queryKey: ["posts", "schedules", username]
+      });
+    },
+    onError
+  });
+}
+function useMoveSchedule(username, code, onSuccess, onError) {
+  return reactQuery.useMutation({
+    mutationKey: ["posts", "schedules", "move", username],
+    mutationFn: async ({ id }) => {
+      if (!username || !code) {
+        throw new Error("[SDK][Posts] \u2013 missing auth for moveSchedule");
+      }
+      return moveSchedule(code, id);
+    },
+    onSuccess: () => {
+      onSuccess?.();
+      getQueryClient().invalidateQueries({
+        queryKey: ["posts", "schedules", username]
+      });
+      getQueryClient().invalidateQueries({
+        queryKey: ["posts", "drafts", username]
+      });
+    },
+    onError
+  });
+}
+function useAddImage(username, code, onSuccess, onError) {
+  return reactQuery.useMutation({
+    mutationKey: ["posts", "images", "add", username],
+    mutationFn: async ({ url }) => {
+      if (!username || !code) {
+        throw new Error("[SDK][Posts] \u2013 missing auth for addImage");
+      }
+      return addImage(code, url);
+    },
+    onSuccess: () => {
+      onSuccess?.();
+      getQueryClient().invalidateQueries({
+        queryKey: ["posts", "images", username]
+      });
+    },
+    onError
+  });
+}
+function useDeleteImage(username, code, onSuccess, onError) {
+  return reactQuery.useMutation({
+    mutationKey: ["posts", "images", "delete", username],
+    mutationFn: async ({ imageId }) => {
+      if (!username || !code) {
+        throw new Error("[SDK][Posts] \u2013 missing auth for deleteImage");
+      }
+      return deleteImage(code, imageId);
+    },
+    onSuccess: () => {
+      onSuccess?.();
+      getQueryClient().invalidateQueries({
+        queryKey: ["posts", "images", username]
+      });
+    },
+    onError
+  });
+}
+function useUploadImage(onSuccess, onError) {
+  return reactQuery.useMutation({
+    mutationKey: ["posts", "images", "upload"],
+    mutationFn: async ({
+      file,
+      token,
+      signal
+    }) => {
+      return uploadImage(file, token, signal);
+    },
+    onSuccess,
+    onError
+  });
+}
+
+// src/modules/posts/utils/validate-post-creating.ts
+var DEFAULT_VALIDATE_POST_DELAYS = [3e3, 3e3, 3e3];
+var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function getContent(author, permlink) {
+  return CONFIG.hiveClient.call("condenser_api", "get_content", [
+    author,
+    permlink
+  ]);
+}
+async function validatePostCreating(author, permlink, attempts = 0, options) {
+  const delays = options?.delays ?? DEFAULT_VALIDATE_POST_DELAYS;
+  let response;
+  try {
+    response = await getContent(author, permlink);
+  } catch (e) {
+    response = void 0;
+  }
+  if (response || attempts >= delays.length) {
+    return;
+  }
+  const waitMs = delays[attempts];
+  if (waitMs > 0) {
+    await delay(waitMs);
+  }
+  return validatePostCreating(author, permlink, attempts + 1, options);
+}
+
+// src/modules/analytics/mutations/index.ts
+var mutations_exports = {};
+__export(mutations_exports, {
+  useRecordActivity: () => useRecordActivity
+});
+function getLocationInfo() {
+  if (typeof window !== "undefined" && window.location) {
+    return {
+      url: window.location.href,
+      domain: window.location.host
+    };
+  }
+  return { url: "", domain: "" };
+}
+function useRecordActivity(username, activityType, options) {
+  return reactQuery.useMutation({
+    mutationKey: ["analytics", activityType],
+    mutationFn: async () => {
+      if (!activityType) {
+        throw new Error("[SDK][Analytics] \u2013 no activity type provided");
+      }
+      const fetchApi = getBoundFetch();
+      const locationInfo = getLocationInfo();
+      const url = options?.url ?? locationInfo.url;
+      const domain = options?.domain ?? locationInfo.domain;
+      await fetchApi(CONFIG.plausibleHost + "/api/event", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          name: activityType,
+          url,
+          domain,
+          props: {
+            username
+          }
+        })
+      });
+    }
+  });
+}
+function getDiscoverLeaderboardQueryOptions(duration) {
+  return reactQuery.queryOptions({
+    queryKey: ["analytics", "discover-leaderboard", duration],
+    queryFn: async ({ signal }) => {
+      const response = await fetch(
+        CONFIG.privateApiHost + `/private-api/leaderboard/${duration}`,
+        { signal }
+      );
+      if (!response.ok) {
+        throw new Error(`Failed to fetch leaderboard: ${response.status}`);
+      }
+      return response.json();
+    }
+  });
+}
+function getDiscoverCurationQueryOptions(duration) {
+  return reactQuery.queryOptions({
+    queryKey: ["analytics", "discover-curation", duration],
+    queryFn: async ({ signal }) => {
+      const response = await fetch(
+        CONFIG.privateApiHost + `/private-api/curation/${duration}`,
+        { signal }
+      );
+      if (!response.ok) {
+        throw new Error(`Failed to fetch curation data: ${response.status}`);
+      }
+      const data = await response.json();
+      const accounts = data.map((item) => item.account);
+      const accountsResponse = await CONFIG.hiveClient.database.getAccounts(accounts);
+      for (let index = 0; index < accountsResponse.length; index++) {
+        const element = accountsResponse[index];
+        const curator = data[index];
+        const vestingShares = typeof element.vesting_shares === "string" ? element.vesting_shares : element.vesting_shares.toString();
+        const receivedVestingShares = typeof element.received_vesting_shares === "string" ? element.received_vesting_shares : element.received_vesting_shares.toString();
+        const delegatedVestingShares = typeof element.delegated_vesting_shares === "string" ? element.delegated_vesting_shares : element.delegated_vesting_shares.toString();
+        const vestingWithdrawRate = typeof element.vesting_withdraw_rate === "string" ? element.vesting_withdraw_rate : element.vesting_withdraw_rate.toString();
+        const effectiveVest = parseFloat(vestingShares) + parseFloat(receivedVestingShares) - parseFloat(delegatedVestingShares) - parseFloat(vestingWithdrawRate);
+        curator.efficiency = curator.vests / effectiveVest;
+      }
+      data.sort((a, b) => b.efficiency - a.efficiency);
+      return data;
+    }
+  });
+}
+function getPageStatsQueryOptions(url, dimensions = [], metrics = ["visitors", "pageviews", "visit_duration"], dateRange) {
+  return reactQuery.queryOptions({
+    queryKey: ["analytics", "page-stats", url, dimensions, metrics, dateRange],
+    queryFn: async ({ signal }) => {
+      const response = await fetch(CONFIG.privateApiHost + "/api/stats", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          metrics,
+          url: encodeURIComponent(url),
+          dimensions,
+          date_range: dateRange
+        }),
+        signal
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to fetch page stats: ${response.status}`);
+      }
+      return response.json();
+    },
+    enabled: !!url
+  });
+}
+
+// src/modules/integrations/3speak/queries/index.ts
+var queries_exports2 = {};
+__export(queries_exports2, {
+  getAccountTokenQueryOptions: () => getAccountTokenQueryOptions,
+  getAccountVideosQueryOptions: () => getAccountVideosQueryOptions
+});
+
+// src/modules/integrations/hivesigner/queries/index.ts
+var queries_exports = {};
+__export(queries_exports, {
+  getDecodeMemoQueryOptions: () => getDecodeMemoQueryOptions
+});
+function getDecodeMemoQueryOptions(username, memo, accessToken) {
+  return reactQuery.queryOptions({
+    queryKey: ["integrations", "hivesigner", "decode-memo", username],
+    queryFn: async () => {
+      if (accessToken) {
+        const hsClient = new hs__default.default.Client({
+          accessToken
         });
         return hsClient.decode(memo);
       }
@@ -4097,6 +4597,63 @@ function getAnnouncementsQueryOptions() {
     staleTime: 36e5
   });
 }
+function useMarkNotificationsRead(username, code, onSuccess, onError) {
+  const queryClient = getQueryClient();
+  return reactQuery.useMutation({
+    mutationKey: ["notifications", "mark-read", username],
+    mutationFn: async ({ id }) => {
+      if (!username || !code) {
+        throw new Error("[SDK][Notifications] \u2013 missing auth for markNotifications");
+      }
+      return markNotifications(code, id);
+    },
+    // Optimistic update: Immediately mark notifications as read in cache
+    onMutate: async ({ id }) => {
+      await queryClient.cancelQueries({ queryKey: ["notifications"] });
+      const previousNotifications = [];
+      const queriesData = queryClient.getQueriesData({
+        queryKey: ["notifications"]
+      });
+      queriesData.forEach(([queryKey, data]) => {
+        if (data) {
+          previousNotifications.push([queryKey, data]);
+          const updatedData = data.map((item) => ({
+            ...item,
+            // If specific ID provided: mark only that notification
+            // If no ID (mark all): mark ALL notifications
+            read: !id || id === item.id ? 1 : item.read
+          }));
+          queryClient.setQueryData(queryKey, updatedData);
+        }
+      });
+      return { previousNotifications };
+    },
+    onSuccess: (response, variables) => {
+      const unreadCount = typeof response === "object" && response !== null ? response.unread : void 0;
+      onSuccess?.(unreadCount);
+      if (!variables.id) {
+        queryClient.invalidateQueries({
+          queryKey: ["notifications"]
+        });
+      }
+    },
+    // Rollback optimistic update on error
+    onError: (error, _variables, context) => {
+      if (context?.previousNotifications) {
+        context.previousNotifications.forEach(([queryKey, data]) => {
+          queryClient.setQueryData(queryKey, data);
+        });
+      }
+      onError?.(error);
+    },
+    // Always refetch after mutation settles
+    onSettled: () => {
+      queryClient.invalidateQueries({
+        queryKey: ["notifications"]
+      });
+    }
+  });
+}
 function getProposalQueryOptions(id) {
   return reactQuery.queryOptions({
     queryKey: ["proposals", "proposal", id],
@@ -4126,930 +4683,654 @@ function getProposalsQueryOptions() {
         status: "all"
       });
       const proposals = response.proposals;
-      const expired = proposals.filter((x) => x.status === "expired");
-      const others = proposals.filter((x) => x.status !== "expired");
-      return [...others, ...expired];
-    }
-  });
-}
-function getProposalVotesInfiniteQueryOptions(proposalId, voter, limit) {
-  return reactQuery.infiniteQueryOptions({
-    queryKey: ["proposals", "votes", proposalId, voter, limit],
-    initialPageParam: voter,
-    refetchOnMount: true,
-    staleTime: 0,
-    // Always refetch on mount
-    queryFn: async ({ pageParam }) => {
-      const startParam = pageParam ?? voter;
-      const response = await CONFIG.hiveClient.call("condenser_api", "list_proposal_votes", [
-        [proposalId, startParam],
-        limit,
-        "by_proposal_voter"
-      ]);
-      const list = response.filter((x) => x.proposal?.proposal_id === proposalId).map((x) => ({ id: x.id, voter: x.voter }));
-      const rawAccounts = await CONFIG.hiveClient.database.getAccounts(list.map((l) => l.voter));
-      const accounts = parseAccounts(rawAccounts);
-      const page = list.map((i) => ({
-        ...i,
-        voterAccount: accounts.find((a) => i.voter === a.name)
-      }));
-      return page;
-    },
-    getNextPageParam: (lastPage) => {
-      const last = lastPage?.[lastPage.length - 1];
-      return last?.voter ?? void 0;
-    }
-  });
-}
-function getUserProposalVotesQueryOptions(voter) {
-  return reactQuery.queryOptions({
-    queryKey: ["proposals", "votes", "by-user", voter],
-    enabled: !!voter && voter !== "",
-    staleTime: 60 * 1e3,
-    // Cache for 1 minute
-    queryFn: async () => {
-      if (!voter || voter === "") {
-        return [];
-      }
-      const response = await CONFIG.hiveClient.call("database_api", "list_proposal_votes", {
-        start: [voter],
-        limit: 1e3,
-        order: "by_voter_proposal",
-        order_direction: "ascending",
-        status: "votable"
-      });
-      const userVotes = (response.proposal_votes || []).filter((vote) => vote.voter === voter);
-      return userVotes;
-    }
-  });
-}
-function getVestingDelegationsQueryOptions(username, from, limit = 50) {
-  return reactQuery.queryOptions({
-    queryKey: ["wallet", "vesting-delegations", username, from, limit],
-    queryFn: () => CONFIG.hiveClient.database.call("get_vesting_delegations", [
-      username,
-      from,
-      limit
-    ]),
-    enabled: !!username
-  });
-}
-function getConversionRequestsQueryOptions(account) {
-  return reactQuery.queryOptions({
-    queryKey: ["wallet", "conversion-requests", account],
-    queryFn: () => CONFIG.hiveClient.database.call("get_conversion_requests", [
-      account
-    ]),
-    select: (data) => data.sort((a, b) => a.requestid - b.requestid)
-  });
-}
-function getCollateralizedConversionRequestsQueryOptions(account) {
-  return reactQuery.queryOptions({
-    queryKey: ["wallet", "collateralized-conversion-requests", account],
-    queryFn: () => CONFIG.hiveClient.database.call("get_collateralized_conversion_requests", [
-      account
-    ]),
-    select: (data) => data.sort((a, b) => a.requestid - b.requestid)
-  });
-}
-function getSavingsWithdrawFromQueryOptions(account) {
-  return reactQuery.queryOptions({
-    queryKey: ["wallet", "savings-withdraw", account],
-    queryFn: () => CONFIG.hiveClient.database.call("get_savings_withdraw_from", [
-      account
-    ]),
-    select: (data) => data.sort((a, b) => a.request_id - b.request_id)
-  });
-}
-function getWithdrawRoutesQueryOptions(account) {
-  return reactQuery.queryOptions({
-    queryKey: ["wallet", "withdraw-routes", account],
-    queryFn: () => CONFIG.hiveClient.database.call("get_withdraw_routes", [
-      account,
-      "outgoing"
-    ])
-  });
-}
-function getOpenOrdersQueryOptions(user) {
-  return reactQuery.queryOptions({
-    queryKey: ["wallet", "open-orders", user],
-    queryFn: () => CONFIG.hiveClient.call("condenser_api", "get_open_orders", [
-      user
-    ]),
-    select: (data) => data.sort((a, b) => a.orderid - b.orderid),
-    enabled: !!user
-  });
-}
-function getOutgoingRcDelegationsInfiniteQueryOptions(username, limit = 100) {
-  return reactQuery.infiniteQueryOptions({
-    queryKey: ["wallet", "outgoing-rc-delegations", username, limit],
-    initialPageParam: null,
-    queryFn: async ({ pageParam }) => {
-      const response = await CONFIG.hiveClient.call("rc_api", "list_rc_direct_delegations", {
-        start: [username, pageParam ?? ""],
-        limit
-      }).then((r) => r);
-      let delegations = response.rc_direct_delegations || [];
-      if (pageParam) {
-        delegations = delegations.filter((delegation) => delegation.to !== pageParam);
-      }
-      return delegations;
-    },
-    getNextPageParam: (lastPage) => lastPage.length === limit ? lastPage[lastPage.length - 1].to : null
-  });
-}
-function getIncomingRcQueryOptions(username) {
-  return reactQuery.queryOptions({
-    queryKey: ["wallet", "incoming-rc", username],
-    enabled: !!username,
-    queryFn: async () => {
-      if (!username) {
-        throw new Error("[SDK][Wallet] - Missing username for incoming RC");
-      }
-      const fetchApi = getBoundFetch();
-      const response = await fetchApi(
-        `${CONFIG.privateApiHost}/private-api/received-rc/${username}`
-      );
-      if (!response.ok) {
-        throw new Error(`Failed to fetch incoming RC: ${response.status}`);
-      }
-      return response.json();
-    }
-  });
-}
-function getReceivedVestingSharesQueryOptions(username) {
-  return reactQuery.queryOptions({
-    queryKey: ["wallet", "received-vesting-shares", username],
-    queryFn: async () => {
-      const response = await fetch(
-        CONFIG.privateApiHost + `/private-api/received-vesting/${username}`
-      );
-      if (!response.ok) {
-        throw new Error(`Failed to fetch received vesting shares: ${response.status}`);
-      }
-      const data = await response.json();
-      return data.list;
+      const expired = proposals.filter((x) => x.status === "expired");
+      const others = proposals.filter((x) => x.status !== "expired");
+      return [...others, ...expired];
     }
   });
 }
-function getRecurrentTransfersQueryOptions(username) {
-  return reactQuery.queryOptions({
-    queryKey: ["wallet", "recurrent-transfers", username],
-    queryFn: () => CONFIG.hiveClient.call("condenser_api", "find_recurrent_transfers", [
-      username
-    ]),
-    enabled: !!username
-  });
-}
-function getWitnessesInfiniteQueryOptions(limit) {
+function getProposalVotesInfiniteQueryOptions(proposalId, voter, limit) {
   return reactQuery.infiniteQueryOptions({
-    queryKey: ["witnesses", "list", limit],
-    initialPageParam: "",
-    queryFn: async ({ pageParam }) => CONFIG.hiveClient.call("condenser_api", "get_witnesses_by_vote", [
-      pageParam,
-      limit
-    ]),
+    queryKey: ["proposals", "votes", proposalId, voter, limit],
+    initialPageParam: voter,
+    refetchOnMount: true,
+    staleTime: 0,
+    // Always refetch on mount
+    queryFn: async ({ pageParam }) => {
+      const startParam = pageParam ?? voter;
+      const response = await CONFIG.hiveClient.call("condenser_api", "list_proposal_votes", [
+        [proposalId, startParam],
+        limit,
+        "by_proposal_voter"
+      ]);
+      const list = response.filter((x) => x.proposal?.proposal_id === proposalId).map((x) => ({ id: x.id, voter: x.voter }));
+      const rawAccounts = await CONFIG.hiveClient.database.getAccounts(list.map((l) => l.voter));
+      const accounts = parseAccounts(rawAccounts);
+      const page = list.map((i) => ({
+        ...i,
+        voterAccount: accounts.find((a) => i.voter === a.name)
+      }));
+      return page;
+    },
     getNextPageParam: (lastPage) => {
       const last = lastPage?.[lastPage.length - 1];
-      return last ? last.owner : void 0;
+      return last?.voter ?? void 0;
     }
   });
 }
-function getOrderBookQueryOptions(limit = 500) {
-  return reactQuery.queryOptions({
-    queryKey: ["market", "order-book", limit],
-    queryFn: () => CONFIG.hiveClient.call("condenser_api", "get_order_book", [
-      limit
-    ])
-  });
-}
-function getMarketStatisticsQueryOptions() {
+function getUserProposalVotesQueryOptions(voter) {
   return reactQuery.queryOptions({
-    queryKey: ["market", "statistics"],
-    queryFn: () => CONFIG.hiveClient.call("condenser_api", "get_ticker", [])
+    queryKey: ["proposals", "votes", "by-user", voter],
+    enabled: !!voter && voter !== "",
+    staleTime: 60 * 1e3,
+    // Cache for 1 minute
+    queryFn: async () => {
+      if (!voter || voter === "") {
+        return [];
+      }
+      const response = await CONFIG.hiveClient.call("database_api", "list_proposal_votes", {
+        start: [voter],
+        limit: 1e3,
+        order: "by_voter_proposal",
+        order_direction: "ascending",
+        status: "votable"
+      });
+      const userVotes = (response.proposal_votes || []).filter((vote) => vote.voter === voter);
+      return userVotes;
+    }
   });
 }
-function getMarketHistoryQueryOptions(seconds, startDate, endDate) {
-  const formatDate2 = (date) => {
-    return date.toISOString().replace(/\.\d{3}Z$/, "");
-  };
-  return reactQuery.queryOptions({
-    queryKey: ["market", "history", seconds, startDate.getTime(), endDate.getTime()],
-    queryFn: () => CONFIG.hiveClient.call("condenser_api", "get_market_history", [
-      seconds,
-      formatDate2(startDate),
-      formatDate2(endDate)
-    ])
+function getVestingDelegationsQueryOptions(username, limit = 50) {
+  return reactQuery.infiniteQueryOptions({
+    queryKey: ["wallet", "vesting-delegations", username, limit],
+    initialPageParam: "",
+    queryFn: async ({ pageParam }) => {
+      const fetchLimit = pageParam ? limit + 1 : limit;
+      const result = await CONFIG.hiveClient.database.call("get_vesting_delegations", [
+        username,
+        pageParam || "",
+        fetchLimit
+      ]);
+      if (pageParam && result.length > 0 && result[0]?.delegatee === pageParam) {
+        return result.slice(1, limit + 1);
+      }
+      return result;
+    },
+    getNextPageParam: (lastPage) => {
+      if (!lastPage || lastPage.length < limit) {
+        return void 0;
+      }
+      const lastDelegation = lastPage[lastPage.length - 1];
+      return lastDelegation?.delegatee;
+    },
+    enabled: !!username
   });
 }
-function getHiveHbdStatsQueryOptions() {
+function getConversionRequestsQueryOptions(account) {
   return reactQuery.queryOptions({
-    queryKey: ["market", "hive-hbd-stats"],
-    queryFn: async () => {
-      const stats = await CONFIG.hiveClient.call(
-        "condenser_api",
-        "get_ticker",
-        []
-      );
-      const now = /* @__PURE__ */ new Date();
-      const oneDayAgo = new Date(now.getTime() - 864e5);
-      const formatDate2 = (date) => {
-        return date.toISOString().replace(/\.\d{3}Z$/, "");
-      };
-      const dayChange = await CONFIG.hiveClient.call(
-        "condenser_api",
-        "get_market_history",
-        [86400, formatDate2(oneDayAgo), formatDate2(now)]
-      );
-      const result = {
-        price: +stats.latest,
-        close: dayChange[0] ? dayChange[0].non_hive.open / dayChange[0].hive.open : 0,
-        high: dayChange[0] ? dayChange[0].non_hive.high / dayChange[0].hive.high : 0,
-        low: dayChange[0] ? dayChange[0].non_hive.low / dayChange[0].hive.low : 0,
-        percent: dayChange[0] ? 100 - dayChange[0].non_hive.open / dayChange[0].hive.open * 100 / +stats.latest : 0,
-        totalFromAsset: stats.hive_volume.split(" ")[0],
-        totalToAsset: stats.hbd_volume.split(" ")[0]
-      };
-      return result;
-    }
+    queryKey: ["wallet", "conversion-requests", account],
+    queryFn: () => CONFIG.hiveClient.database.call("get_conversion_requests", [
+      account
+    ]),
+    select: (data) => data.sort((a, b) => a.requestid - b.requestid)
   });
 }
-function getMarketDataQueryOptions(coin, vsCurrency, fromTs, toTs) {
+function getCollateralizedConversionRequestsQueryOptions(account) {
   return reactQuery.queryOptions({
-    queryKey: ["market", "data", coin, vsCurrency, fromTs, toTs],
-    queryFn: async ({ signal }) => {
-      const fetchApi = getBoundFetch();
-      const url = `https://api.coingecko.com/api/v3/coins/${coin}/market_chart/range?vs_currency=${vsCurrency}&from=${fromTs}&to=${toTs}`;
-      const response = await fetchApi(url, { signal });
-      if (!response.ok) {
-        throw new Error(`Failed to fetch market data: ${response.status}`);
-      }
-      return response.json();
-    }
+    queryKey: ["wallet", "collateralized-conversion-requests", account],
+    queryFn: () => CONFIG.hiveClient.database.call("get_collateralized_conversion_requests", [
+      account
+    ]),
+    select: (data) => data.sort((a, b) => a.requestid - b.requestid)
   });
 }
-function formatDate(date) {
-  return date.toISOString().replace(/\.\d{3}Z$/, "");
-}
-function getTradeHistoryQueryOptions(limit = 1e3, startDate, endDate) {
-  const end = endDate ?? /* @__PURE__ */ new Date();
-  const start = startDate ?? new Date(end.getTime() - 10 * 60 * 60 * 1e3);
+function getSavingsWithdrawFromQueryOptions(account) {
   return reactQuery.queryOptions({
-    queryKey: ["market", "trade-history", limit, start.getTime(), end.getTime()],
-    queryFn: () => CONFIG.hiveClient.call("condenser_api", "get_trade_history", [
-      formatDate(start),
-      formatDate(end),
-      limit
-    ])
+    queryKey: ["wallet", "savings-withdraw", account],
+    queryFn: () => CONFIG.hiveClient.database.call("get_savings_withdraw_from", [
+      account
+    ]),
+    select: (data) => data.sort((a, b) => a.request_id - b.request_id)
   });
 }
-
-// src/modules/market/requests.ts
-async function parseJsonResponse(response) {
-  const data = await response.json();
-  if (!response.ok) {
-    const error = new Error(`Request failed with status ${response.status}`);
-    error.status = response.status;
-    error.data = data;
-    throw error;
-  }
-  return data;
-}
-async function getMarketData(coin, vsCurrency, fromTs, toTs) {
-  const fetchApi = getBoundFetch();
-  const url = `https://api.coingecko.com/api/v3/coins/${coin}/market_chart/range?vs_currency=${vsCurrency}&from=${fromTs}&to=${toTs}`;
-  const response = await fetchApi(url);
-  return parseJsonResponse(response);
-}
-async function getCurrencyRate(cur) {
-  if (cur === "hbd") {
-    return 1;
-  }
-  const fetchApi = getBoundFetch();
-  const url = `https://api.coingecko.com/api/v3/simple/price?ids=hive_dollar&vs_currencies=${cur}`;
-  const response = await fetchApi(url);
-  const data = await parseJsonResponse(response);
-  return data.hive_dollar[cur];
-}
-async function getCurrencyTokenRate(currency, token) {
-  const fetchApi = getBoundFetch();
-  const response = await fetchApi(
-    CONFIG.privateApiHost + `/private-api/market-data/${currency === "hbd" ? "usd" : currency}/${token}`
-  );
-  return parseJsonResponse(response);
-}
-async function getCurrencyRates() {
-  const fetchApi = getBoundFetch();
-  const response = await fetchApi(CONFIG.privateApiHost + "/private-api/market-data/latest");
-  return parseJsonResponse(response);
-}
-async function getHivePrice() {
-  const fetchApi = getBoundFetch();
-  const response = await fetchApi(
-    "https://api.coingecko.com/api/v3/simple/price?ids=hive&vs_currencies=usd"
-  );
-  return parseJsonResponse(response);
-}
-function getPointsQueryOptions(username, filter = 0) {
+function getWithdrawRoutesQueryOptions(account) {
   return reactQuery.queryOptions({
-    queryKey: ["points", username, filter],
-    queryFn: async () => {
-      if (!username) {
-        throw new Error("Get points query \u2013 username wasn't provided");
-      }
-      const name = username.replace("@", "");
-      const pointsResponse = await fetch(CONFIG.privateApiHost + "/private-api/points", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({ username: name })
-      });
-      if (!pointsResponse.ok) {
-        throw new Error(`Failed to fetch points: ${pointsResponse.status}`);
-      }
-      const points = await pointsResponse.json();
-      const transactionsResponse = await fetch(
-        CONFIG.privateApiHost + "/private-api/point-list",
-        {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify({ username: name, type: filter })
-        }
-      );
-      if (!transactionsResponse.ok) {
-        throw new Error(`Failed to fetch point transactions: ${transactionsResponse.status}`);
-      }
-      const transactions = await transactionsResponse.json();
-      return {
-        points: points.points,
-        uPoints: points.unclaimed_points,
-        transactions
-      };
-    },
-    staleTime: 3e4,
-    refetchOnMount: true,
-    enabled: !!username
+    queryKey: ["wallet", "withdraw-routes", account],
+    queryFn: () => CONFIG.hiveClient.database.call("get_withdraw_routes", [
+      account,
+      "outgoing"
+    ])
   });
 }
-function searchQueryOptions(q, sort, hideLow, since, scroll_id, votes) {
+function getOpenOrdersQueryOptions(user) {
   return reactQuery.queryOptions({
-    queryKey: ["search", q, sort, hideLow, since, scroll_id, votes],
-    queryFn: async () => {
-      const data = { q, sort, hide_low: hideLow };
-      if (since) data.since = since;
-      if (scroll_id) data.scroll_id = scroll_id;
-      if (votes) data.votes = votes;
-      const response = await fetch(CONFIG.privateApiHost + "/search-api/search", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(data)
-      });
-      if (!response.ok) {
-        throw new Error(`Search failed: ${response.status}`);
-      }
-      return response.json();
-    }
+    queryKey: ["wallet", "open-orders", user],
+    queryFn: () => CONFIG.hiveClient.call("condenser_api", "get_open_orders", [
+      user
+    ]),
+    select: (data) => data.sort((a, b) => a.orderid - b.orderid),
+    enabled: !!user
   });
 }
-function getControversialRisingInfiniteQueryOptions(what, tag, enabled = true) {
+function getOutgoingRcDelegationsInfiniteQueryOptions(username, limit = 100) {
   return reactQuery.infiniteQueryOptions({
-    queryKey: ["search", "controversial-rising", what, tag],
-    initialPageParam: { sid: void 0, hasNextPage: true },
+    queryKey: ["wallet", "outgoing-rc-delegations", username, limit],
+    initialPageParam: null,
     queryFn: async ({ pageParam }) => {
-      if (!pageParam.hasNextPage) {
-        return {
-          hits: 0,
-          took: 0,
-          results: []
-        };
-      }
-      let sinceDate;
-      const now = /* @__PURE__ */ new Date();
-      switch (tag) {
-        case "today":
-          sinceDate = new Date(now.getTime() - 24 * 60 * 60 * 1e3);
-          break;
-        case "week":
-          sinceDate = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1e3);
-          break;
-        case "month":
-          sinceDate = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1e3);
-          break;
-        case "year":
-          sinceDate = new Date(now.getTime() - 365 * 24 * 60 * 60 * 1e3);
-          break;
-        default:
-          sinceDate = void 0;
-      }
-      const q = "* type:post";
-      const sort = what === "rising" ? "children" : what;
-      const since = sinceDate ? sinceDate.toISOString().split(".")[0] : void 0;
-      const hideLow = "0";
-      const votes = tag === "today" ? 50 : 200;
-      const data = { q, sort, hide_low: hideLow };
-      if (since) data.since = since;
-      if (pageParam.sid) data.scroll_id = pageParam.sid;
-      data.votes = votes;
-      const response = await fetch(CONFIG.privateApiHost + "/search-api/search", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(data)
-      });
-      if (!response.ok) {
-        throw new Error(`Search failed: ${response.status}`);
+      const response = await CONFIG.hiveClient.call("rc_api", "list_rc_direct_delegations", {
+        start: [username, pageParam ?? ""],
+        limit
+      }).then((r) => r);
+      let delegations = response.rc_direct_delegations || [];
+      if (pageParam) {
+        delegations = delegations.filter((delegation) => delegation.to !== pageParam);
       }
-      return response.json();
-    },
-    getNextPageParam: (resp) => {
-      return {
-        sid: resp?.scroll_id,
-        hasNextPage: resp.results.length > 0
-      };
+      return delegations;
     },
-    enabled
+    getNextPageParam: (lastPage) => lastPage.length === limit ? lastPage[lastPage.length - 1].to : null
   });
 }
-function buildQuery(entry, retry = 3) {
-  const { json_metadata, permlink } = entry;
-  let q = "*";
-  q += ` -dporn type:post`;
-  let tags;
-  if (json_metadata && json_metadata.tags && Array.isArray(json_metadata.tags)) {
-    tags = json_metadata.tags.filter((tag) => tag && tag !== "" && typeof tag === "string").filter((tag) => !tag.startsWith("hive-")).filter((_tag, ind) => ind < +retry).join(",");
-  }
-  if (tags && tags.length > 0) {
-    q += ` tag:${tags}`;
-  } else {
-    const fperm = permlink.split("-");
-    tags = fperm.filter((part) => part !== "").filter((part) => !/^-?\d+$/.test(part)).filter((part) => part.length > 2).join(",");
-    q += ` tag:${tags}`;
-  }
-  return q;
-}
-function getSimilarEntriesQueryOptions(entry) {
-  const query = buildQuery(entry);
+function getIncomingRcQueryOptions(username) {
   return reactQuery.queryOptions({
-    queryKey: ["search", "similar-entries", entry.author, entry.permlink, query],
+    queryKey: ["wallet", "incoming-rc", username],
+    enabled: !!username,
     queryFn: async () => {
-      const data = {
-        q: query,
-        sort: "newest",
-        hide_low: "0"
-      };
-      const response = await fetch(CONFIG.privateApiHost + "/search-api/search", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(data)
-      });
-      if (!response.ok) {
-        throw new Error(`Search failed: ${response.status}`);
+      if (!username) {
+        throw new Error("[SDK][Wallet] - Missing username for incoming RC");
       }
-      const searchResponse = await response.json();
-      const rawEntries = searchResponse.results.filter(
-        (r) => r.permlink !== entry.permlink && r.tags.indexOf("nsfw") === -1
+      const fetchApi = getBoundFetch();
+      const response = await fetchApi(
+        `${CONFIG.privateApiHost}/private-api/received-rc/${username}`
       );
-      const entries = [];
-      for (const result of rawEntries) {
-        if (entries.find((y) => y.author === result.author) === void 0) {
-          entries.push(result);
-        }
+      if (!response.ok) {
+        throw new Error(`Failed to fetch incoming RC: ${response.status}`);
       }
-      return entries.slice(0, 3);
+      return response.json();
     }
   });
 }
-function getSearchAccountQueryOptions(q, limit = 5, random = false) {
+function getReceivedVestingSharesQueryOptions(username) {
   return reactQuery.queryOptions({
-    queryKey: ["search", "account", q, limit],
+    queryKey: ["wallet", "received-vesting-shares", username],
     queryFn: async () => {
-      const data = { q, limit, random: +random };
-      const response = await fetch(CONFIG.privateApiHost + "/search-api/search-account", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(data)
-      });
+      const response = await fetch(
+        CONFIG.privateApiHost + `/private-api/received-vesting/${username}`
+      );
       if (!response.ok) {
-        throw new Error(`Failed to search accounts: ${response.status}`);
+        throw new Error(`Failed to fetch received vesting shares: ${response.status}`);
       }
-      return response.json();
-    },
-    enabled: !!q
+      const data = await response.json();
+      return data.list;
+    }
   });
 }
-function getSearchTopicsQueryOptions(q, limit = 20, random = false) {
+function getRecurrentTransfersQueryOptions(username) {
   return reactQuery.queryOptions({
-    queryKey: ["search", "topics", q],
+    queryKey: ["wallet", "recurrent-transfers", username],
+    queryFn: () => CONFIG.hiveClient.call("condenser_api", "find_recurrent_transfers", [
+      username
+    ]),
+    enabled: !!username
+  });
+}
+function getWitnessesInfiniteQueryOptions(limit) {
+  return reactQuery.infiniteQueryOptions({
+    queryKey: ["witnesses", "list", limit],
+    initialPageParam: "",
+    queryFn: async ({ pageParam }) => CONFIG.hiveClient.call("condenser_api", "get_witnesses_by_vote", [
+      pageParam,
+      limit
+    ]),
+    getNextPageParam: (lastPage) => {
+      const last = lastPage?.[lastPage.length - 1];
+      return last ? last.owner : void 0;
+    }
+  });
+}
+function getOrderBookQueryOptions(limit = 500) {
+  return reactQuery.queryOptions({
+    queryKey: ["market", "order-book", limit],
+    queryFn: () => CONFIG.hiveClient.call("condenser_api", "get_order_book", [
+      limit
+    ])
+  });
+}
+function getMarketStatisticsQueryOptions() {
+  return reactQuery.queryOptions({
+    queryKey: ["market", "statistics"],
+    queryFn: () => CONFIG.hiveClient.call("condenser_api", "get_ticker", [])
+  });
+}
+function getMarketHistoryQueryOptions(seconds, startDate, endDate) {
+  const formatDate2 = (date) => {
+    return date.toISOString().replace(/\.\d{3}Z$/, "");
+  };
+  return reactQuery.queryOptions({
+    queryKey: ["market", "history", seconds, startDate.getTime(), endDate.getTime()],
+    queryFn: () => CONFIG.hiveClient.call("condenser_api", "get_market_history", [
+      seconds,
+      formatDate2(startDate),
+      formatDate2(endDate)
+    ])
+  });
+}
+function getHiveHbdStatsQueryOptions() {
+  return reactQuery.queryOptions({
+    queryKey: ["market", "hive-hbd-stats"],
     queryFn: async () => {
-      const data = { q, limit, random: +random };
-      const response = await fetch(CONFIG.privateApiHost + "/search-api/search-tag", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(data)
-      });
-      if (!response.ok) {
-        throw new Error(`Failed to search topics: ${response.status}`);
-      }
-      return response.json();
-    },
-    enabled: !!q
+      const stats = await CONFIG.hiveClient.call(
+        "condenser_api",
+        "get_ticker",
+        []
+      );
+      const now = /* @__PURE__ */ new Date();
+      const oneDayAgo = new Date(now.getTime() - 864e5);
+      const formatDate2 = (date) => {
+        return date.toISOString().replace(/\.\d{3}Z$/, "");
+      };
+      const dayChange = await CONFIG.hiveClient.call(
+        "condenser_api",
+        "get_market_history",
+        [86400, formatDate2(oneDayAgo), formatDate2(now)]
+      );
+      const result = {
+        price: +stats.latest,
+        close: dayChange[0] ? dayChange[0].non_hive.open / dayChange[0].hive.open : 0,
+        high: dayChange[0] ? dayChange[0].non_hive.high / dayChange[0].hive.high : 0,
+        low: dayChange[0] ? dayChange[0].non_hive.low / dayChange[0].hive.low : 0,
+        percent: dayChange[0] ? 100 - dayChange[0].non_hive.open / dayChange[0].hive.open * 100 / +stats.latest : 0,
+        totalFromAsset: stats.hive_volume.split(" ")[0],
+        totalToAsset: stats.hbd_volume.split(" ")[0]
+      };
+      return result;
+    }
   });
 }
-function getSearchApiInfiniteQueryOptions(q, sort, hideLow, since, votes) {
-  return reactQuery.infiniteQueryOptions({
-    queryKey: ["search", "api", q, sort, hideLow, since, votes],
-    queryFn: async ({ pageParam }) => {
-      const payload = { q, sort, hide_low: hideLow };
-      if (since) {
-        payload.since = since;
-      }
-      if (pageParam) {
-        payload.scroll_id = pageParam;
-      }
-      if (votes !== void 0) {
-        payload.votes = votes;
-      }
-      const response = await fetch(CONFIG.privateApiHost + "/search-api/search", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(payload)
-      });
+function getMarketDataQueryOptions(coin, vsCurrency, fromTs, toTs) {
+  return reactQuery.queryOptions({
+    queryKey: ["market", "data", coin, vsCurrency, fromTs, toTs],
+    queryFn: async ({ signal }) => {
+      const fetchApi = getBoundFetch();
+      const url = `https://api.coingecko.com/api/v3/coins/${coin}/market_chart/range?vs_currency=${vsCurrency}&from=${fromTs}&to=${toTs}`;
+      const response = await fetchApi(url, { signal });
       if (!response.ok) {
-        throw new Error(`Search failed: ${response.status}`);
+        throw new Error(`Failed to fetch market data: ${response.status}`);
       }
       return response.json();
-    },
-    initialPageParam: void 0,
-    getNextPageParam: (lastPage) => lastPage?.scroll_id,
-    enabled: !!q
+    }
   });
 }
-function getSearchPathQueryOptions(q) {
+function formatDate(date) {
+  return date.toISOString().replace(/\.\d{3}Z$/, "");
+}
+function getTradeHistoryQueryOptions(limit = 1e3, startDate, endDate) {
+  const end = endDate ?? /* @__PURE__ */ new Date();
+  const start = startDate ?? new Date(end.getTime() - 10 * 60 * 60 * 1e3);
   return reactQuery.queryOptions({
-    queryKey: ["search", "path", q],
-    queryFn: async () => {
-      const response = await fetch(CONFIG.privateApiHost + "/search-api/search-path", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({ q })
-      });
-      if (!response.ok) {
-        throw new Error(`Search path failed: ${response.status}`);
-      }
-      const data = await response.json();
-      if (data?.length > 0) {
-        return data;
-      }
-      return [q];
-    }
+    queryKey: ["market", "trade-history", limit, start.getTime(), end.getTime()],
+    queryFn: () => CONFIG.hiveClient.call("condenser_api", "get_trade_history", [
+      formatDate(start),
+      formatDate(end),
+      limit
+    ])
   });
 }
 
-// src/modules/search/requests.ts
+// src/modules/market/requests.ts
 async function parseJsonResponse2(response) {
-  const parseBody = async () => {
-    try {
-      return await response.json();
-    } catch {
-      try {
-        return await response.text();
-      } catch {
-        return void 0;
-      }
-    }
-  };
-  const data = await parseBody();
+  const data = await response.json();
   if (!response.ok) {
     const error = new Error(`Request failed with status ${response.status}`);
     error.status = response.status;
     error.data = data;
     throw error;
   }
-  if (data === void 0) {
-    throw new Error("Response body was empty or invalid JSON");
-  }
   return data;
 }
-async function search(q, sort, hideLow, since, scroll_id, votes) {
-  const data = { q, sort, hide_low: hideLow };
-  if (since) {
-    data.since = since;
-  }
-  if (scroll_id) {
-    data.scroll_id = scroll_id;
-  }
-  if (votes) {
-    data.votes = votes;
-  }
+async function getMarketData(coin, vsCurrency, fromTs, toTs) {
   const fetchApi = getBoundFetch();
-  const response = await fetchApi(CONFIG.privateApiHost + "/search-api/search", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify(data)
-  });
+  const url = `https://api.coingecko.com/api/v3/coins/${coin}/market_chart/range?vs_currency=${vsCurrency}&from=${fromTs}&to=${toTs}`;
+  const response = await fetchApi(url);
   return parseJsonResponse2(response);
 }
-async function searchAccount(q = "", limit = 20, random = 1) {
-  const data = { q, limit, random };
+async function getCurrencyRate(cur) {
+  if (cur === "hbd") {
+    return 1;
+  }
   const fetchApi = getBoundFetch();
-  const response = await fetchApi(CONFIG.privateApiHost + "/search-api/search-account", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify(data)
-  });
+  const url = `https://api.coingecko.com/api/v3/simple/price?ids=hive_dollar&vs_currencies=${cur}`;
+  const response = await fetchApi(url);
+  const data = await parseJsonResponse2(response);
+  return data.hive_dollar[cur];
+}
+async function getCurrencyTokenRate(currency, token) {
+  const fetchApi = getBoundFetch();
+  const response = await fetchApi(
+    CONFIG.privateApiHost + `/private-api/market-data/${currency === "hbd" ? "usd" : currency}/${token}`
+  );
   return parseJsonResponse2(response);
 }
-async function searchTag(q = "", limit = 20, random = 0) {
-  const data = { q, limit, random };
+async function getCurrencyRates() {
   const fetchApi = getBoundFetch();
-  const response = await fetchApi(CONFIG.privateApiHost + "/search-api/search-tag", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify(data)
-  });
+  const response = await fetchApi(CONFIG.privateApiHost + "/private-api/market-data/latest");
   return parseJsonResponse2(response);
 }
-async function searchPath(q) {
+async function getHivePrice() {
   const fetchApi = getBoundFetch();
-  const response = await fetchApi(CONFIG.privateApiHost + "/search-api/search-path", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json"
+  const response = await fetchApi(
+    "https://api.coingecko.com/api/v3/simple/price?ids=hive&vs_currencies=usd"
+  );
+  return parseJsonResponse2(response);
+}
+function getPointsQueryOptions(username, filter = 0) {
+  return reactQuery.queryOptions({
+    queryKey: ["points", username, filter],
+    queryFn: async () => {
+      if (!username) {
+        throw new Error("Get points query \u2013 username wasn't provided");
+      }
+      const name = username.replace("@", "");
+      const pointsResponse = await fetch(CONFIG.privateApiHost + "/private-api/points", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ username: name })
+      });
+      if (!pointsResponse.ok) {
+        throw new Error(`Failed to fetch points: ${pointsResponse.status}`);
+      }
+      const points = await pointsResponse.json();
+      const transactionsResponse = await fetch(
+        CONFIG.privateApiHost + "/private-api/point-list",
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({ username: name, type: filter })
+        }
+      );
+      if (!transactionsResponse.ok) {
+        throw new Error(`Failed to fetch point transactions: ${transactionsResponse.status}`);
+      }
+      const transactions = await transactionsResponse.json();
+      return {
+        points: points.points,
+        uPoints: points.unclaimed_points,
+        transactions
+      };
     },
-    body: JSON.stringify({ q })
+    staleTime: 3e4,
+    refetchOnMount: true,
+    enabled: !!username
   });
-  const data = await parseJsonResponse2(response);
-  return data?.length > 0 ? data : [q];
 }
-function getBoostPlusPricesQueryOptions(accessToken) {
+function searchQueryOptions(q, sort, hideLow, since, scroll_id, votes) {
   return reactQuery.queryOptions({
-    queryKey: ["promotions", "boost-plus-prices"],
+    queryKey: ["search", q, sort, hideLow, since, scroll_id, votes],
     queryFn: async () => {
-      if (!accessToken) {
-        return [];
+      const data = { q, sort, hide_low: hideLow };
+      if (since) data.since = since;
+      if (scroll_id) data.scroll_id = scroll_id;
+      if (votes) data.votes = votes;
+      const response = await fetch(CONFIG.privateApiHost + "/search-api/search", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(data)
+      });
+      if (!response.ok) {
+        throw new Error(`Search failed: ${response.status}`);
+      }
+      return response.json();
+    }
+  });
+}
+function getControversialRisingInfiniteQueryOptions(what, tag, enabled = true) {
+  return reactQuery.infiniteQueryOptions({
+    queryKey: ["search", "controversial-rising", what, tag],
+    initialPageParam: { sid: void 0, hasNextPage: true },
+    queryFn: async ({ pageParam }) => {
+      if (!pageParam.hasNextPage) {
+        return {
+          hits: 0,
+          took: 0,
+          results: []
+        };
+      }
+      let sinceDate;
+      const now = /* @__PURE__ */ new Date();
+      switch (tag) {
+        case "today":
+          sinceDate = new Date(now.getTime() - 24 * 60 * 60 * 1e3);
+          break;
+        case "week":
+          sinceDate = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1e3);
+          break;
+        case "month":
+          sinceDate = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1e3);
+          break;
+        case "year":
+          sinceDate = new Date(now.getTime() - 365 * 24 * 60 * 60 * 1e3);
+          break;
+        default:
+          sinceDate = void 0;
       }
-      const response = await fetch(CONFIG.privateApiHost + "/private-api/boost-plus-price", {
+      const q = "* type:post";
+      const sort = what === "rising" ? "children" : what;
+      const since = sinceDate ? sinceDate.toISOString().split(".")[0] : void 0;
+      const hideLow = "0";
+      const votes = tag === "today" ? 50 : 200;
+      const data = { q, sort, hide_low: hideLow };
+      if (since) data.since = since;
+      if (pageParam.sid) data.scroll_id = pageParam.sid;
+      data.votes = votes;
+      const response = await fetch(CONFIG.privateApiHost + "/search-api/search", {
         method: "POST",
         headers: {
           "Content-Type": "application/json"
         },
-        body: JSON.stringify({ code: accessToken })
+        body: JSON.stringify(data)
       });
       if (!response.ok) {
-        throw new Error(`Failed to fetch boost plus prices: ${response.status}`);
+        throw new Error(`Search failed: ${response.status}`);
       }
-      return await response.json();
+      return response.json();
     },
-    staleTime: Infinity,
-    refetchOnMount: true,
-    enabled: !!accessToken
+    getNextPageParam: (resp) => {
+      return {
+        sid: resp?.scroll_id,
+        hasNextPage: resp.results.length > 0
+      };
+    },
+    enabled
   });
 }
-function getPromotePriceQueryOptions(accessToken) {
+function buildQuery(entry, retry = 3) {
+  const { json_metadata, permlink } = entry;
+  let q = "*";
+  q += ` -dporn type:post`;
+  let tags;
+  if (json_metadata && json_metadata.tags && Array.isArray(json_metadata.tags)) {
+    tags = json_metadata.tags.filter((tag) => tag && tag !== "" && typeof tag === "string").filter((tag) => !tag.startsWith("hive-")).filter((_tag, ind) => ind < +retry).join(",");
+  }
+  if (tags && tags.length > 0) {
+    q += ` tag:${tags}`;
+  } else {
+    const fperm = permlink.split("-");
+    tags = fperm.filter((part) => part !== "").filter((part) => !/^-?\d+$/.test(part)).filter((part) => part.length > 2).join(",");
+    q += ` tag:${tags}`;
+  }
+  return q;
+}
+function getSimilarEntriesQueryOptions(entry) {
+  const query = buildQuery(entry);
   return reactQuery.queryOptions({
-    queryKey: ["promotions", "promote-price"],
+    queryKey: ["search", "similar-entries", entry.author, entry.permlink, query],
     queryFn: async () => {
-      const response = await fetch(CONFIG.privateApiHost + "/private-api/promote-price", {
+      const data = {
+        q: query,
+        sort: "newest",
+        hide_low: "0"
+      };
+      const response = await fetch(CONFIG.privateApiHost + "/search-api/search", {
         method: "POST",
         headers: {
           "Content-Type": "application/json"
         },
-        body: JSON.stringify({ code: accessToken })
+        body: JSON.stringify(data)
       });
       if (!response.ok) {
-        throw new Error(`Failed to fetch promote prices: ${response.status}`);
+        throw new Error(`Search failed: ${response.status}`);
       }
-      return await response.json();
-    },
-    enabled: !!accessToken
+      const searchResponse = await response.json();
+      const rawEntries = searchResponse.results.filter(
+        (r) => r.permlink !== entry.permlink && r.tags.indexOf("nsfw") === -1
+      );
+      const entries = [];
+      for (const result of rawEntries) {
+        if (entries.find((y) => y.author === result.author) === void 0) {
+          entries.push(result);
+        }
+      }
+      return entries.slice(0, 3);
+    }
   });
 }
-function getBoostPlusAccountPricesQueryOptions(account, accessToken) {
+function getSearchAccountQueryOptions(q, limit = 5, random = false) {
   return reactQuery.queryOptions({
-    queryKey: ["promotions", "boost-plus-accounts", account],
+    queryKey: ["search", "account", q, limit],
     queryFn: async () => {
-      if (!accessToken || !account) {
-        return null;
-      }
-      const response = await fetch(CONFIG.privateApiHost + "/private-api/boosted-plus-account", {
+      const data = { q, limit, random: +random };
+      const response = await fetch(CONFIG.privateApiHost + "/search-api/search-account", {
         method: "POST",
         headers: {
           "Content-Type": "application/json"
         },
-        body: JSON.stringify({ code: accessToken, account })
+        body: JSON.stringify(data)
       });
       if (!response.ok) {
-        throw new Error(`Failed to fetch boost plus account prices: ${response.status}`);
+        throw new Error(`Failed to search accounts: ${response.status}`);
       }
-      const responseData = await response.json();
-      return responseData ? {
-        account: responseData.account,
-        expires: new Date(responseData.expires)
-      } : null;
-    },
-    enabled: !!account && !!accessToken
-  });
-}
-
-// src/modules/private-api/requests.ts
-async function parseJsonResponse3(response) {
-  if (!response.ok) {
-    let errorData = void 0;
-    try {
-      errorData = await response.json();
-    } catch {
-      errorData = void 0;
-    }
-    const error = new Error(`Request failed with status ${response.status}`);
-    error.status = response.status;
-    error.data = errorData;
-    throw error;
-  }
-  const text = await response.text();
-  if (!text || text.trim() === "") {
-    return "";
-  }
-  try {
-    return JSON.parse(text);
-  } catch (e) {
-    console.warn("[SDK] Failed to parse JSON response:", e, "Response:", text);
-    return "";
-  }
-}
-async function signUp(username, email, referral) {
-  const fetchApi = getBoundFetch();
-  const response = await fetchApi(CONFIG.privateApiHost + "/private-api/account-create", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({ username, email, referral })
-  });
-  const data = await parseJsonResponse3(response);
-  return { status: response.status, data };
-}
-async function subscribeEmail(email) {
-  const fetchApi = getBoundFetch();
-  const response = await fetchApi(CONFIG.privateApiHost + "/private-api/subscribe", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({ email })
-  });
-  const data = await parseJsonResponse3(response);
-  return { status: response.status, data };
-}
-async function usrActivity(code, ty, bl = "", tx = "") {
-  const params = { code, ty };
-  if (bl) {
-    params.bl = bl;
-  }
-  if (tx) {
-    params.tx = tx;
-  }
-  const fetchApi = getBoundFetch();
-  const response = await fetchApi(CONFIG.privateApiHost + "/private-api/usr-activity", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify(params)
-  });
-  await parseJsonResponse3(response);
-}
-async function getNotifications(code, filter, since = null, user = null) {
-  const data = {
-    code
-  };
-  if (filter) {
-    data.filter = filter;
-  }
-  if (since) {
-    data.since = since;
-  }
-  if (user) {
-    data.user = user;
-  }
-  const fetchApi = getBoundFetch();
-  const response = await fetchApi(CONFIG.privateApiHost + "/private-api/notifications", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify(data)
-  });
-  return parseJsonResponse3(response);
-}
-async function saveNotificationSetting(code, username, system, allows_notify, notify_types, token) {
-  const data = {
-    code,
-    username,
-    token,
-    system,
-    allows_notify,
-    notify_types
-  };
-  const fetchApi = getBoundFetch();
-  const response = await fetchApi(CONFIG.privateApiHost + "/private-api/register-device", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify(data)
-  });
-  return parseJsonResponse3(response);
-}
-async function getNotificationSetting(code, username, token) {
-  const data = { code, username, token };
-  const fetchApi = getBoundFetch();
-  const response = await fetchApi(CONFIG.privateApiHost + "/private-api/detail-device", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify(data)
-  });
-  return parseJsonResponse3(response);
-}
-async function markNotifications(code, id) {
-  const data = {
-    code
-  };
-  if (id) {
-    data.id = id;
-  }
-  const fetchApi = getBoundFetch();
-  const response = await fetchApi(CONFIG.privateApiHost + "/private-api/notifications/mark", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json"
+      return response.json();
     },
-    body: JSON.stringify(data)
+    enabled: !!q
   });
-  return parseJsonResponse3(response);
 }
-async function addImage(code, url) {
-  const data = { code, url };
-  const fetchApi = getBoundFetch();
-  const response = await fetchApi(CONFIG.privateApiHost + "/private-api/images-add", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json"
+function getSearchTopicsQueryOptions(q, limit = 20, random = false) {
+  return reactQuery.queryOptions({
+    queryKey: ["search", "topics", q],
+    queryFn: async () => {
+      const data = { q, limit, random: +random };
+      const response = await fetch(CONFIG.privateApiHost + "/search-api/search-tag", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(data)
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to search topics: ${response.status}`);
+      }
+      return response.json();
     },
-    body: JSON.stringify(data)
+    enabled: !!q
   });
-  return parseJsonResponse3(response);
 }
-async function uploadImage(file, token, signal) {
-  const fetchApi = getBoundFetch();
-  const formData = new FormData();
-  formData.append("file", file);
-  const response = await fetchApi(`${CONFIG.imageHost}/hs/${token}`, {
-    method: "POST",
-    body: formData,
-    signal
+function getSearchApiInfiniteQueryOptions(q, sort, hideLow, since, votes) {
+  return reactQuery.infiniteQueryOptions({
+    queryKey: ["search", "api", q, sort, hideLow, since, votes],
+    queryFn: async ({ pageParam }) => {
+      const payload = { q, sort, hide_low: hideLow };
+      if (since) {
+        payload.since = since;
+      }
+      if (pageParam) {
+        payload.scroll_id = pageParam;
+      }
+      if (votes !== void 0) {
+        payload.votes = votes;
+      }
+      const response = await fetch(CONFIG.privateApiHost + "/search-api/search", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(payload)
+      });
+      if (!response.ok) {
+        throw new Error(`Search failed: ${response.status}`);
+      }
+      return response.json();
+    },
+    initialPageParam: void 0,
+    getNextPageParam: (lastPage) => lastPage?.scroll_id,
+    enabled: !!q
   });
-  return parseJsonResponse3(response);
 }
-async function deleteImage(code, imageId) {
-  const data = { code, id: imageId };
-  const fetchApi = getBoundFetch();
-  const response = await fetchApi(CONFIG.privateApiHost + "/private-api/images-delete", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify(data)
+function getSearchPathQueryOptions(q) {
+  return reactQuery.queryOptions({
+    queryKey: ["search", "path", q],
+    queryFn: async () => {
+      const response = await fetch(CONFIG.privateApiHost + "/search-api/search-path", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ q })
+      });
+      if (!response.ok) {
+        throw new Error(`Search path failed: ${response.status}`);
+      }
+      const data = await response.json();
+      if (data?.length > 0) {
+        return data;
+      }
+      return [q];
+    }
   });
-  return parseJsonResponse3(response);
 }
-async function addDraft(code, title, body, tags, meta) {
-  const data = { code, title, body, tags, meta };
+
+// src/modules/search/requests.ts
+async function parseJsonResponse3(response) {
+  const parseBody = async () => {
+    try {
+      return await response.json();
+    } catch {
+      try {
+        return await response.text();
+      } catch {
+        return void 0;
+      }
+    }
+  };
+  const data = await parseBody();
+  if (!response.ok) {
+    const error = new Error(`Request failed with status ${response.status}`);
+    error.status = response.status;
+    error.data = data;
+    throw error;
+  }
+  if (data === void 0) {
+    throw new Error("Response body was empty or invalid JSON");
+  }
+  return data;
+}
+async function search(q, sort, hideLow, since, scroll_id, votes) {
+  const data = { q, sort, hide_low: hideLow };
+  if (since) {
+    data.since = since;
+  }
+  if (scroll_id) {
+    data.scroll_id = scroll_id;
+  }
+  if (votes) {
+    data.votes = votes;
+  }
   const fetchApi = getBoundFetch();
-  const response = await fetchApi(CONFIG.privateApiHost + "/private-api/drafts-add", {
+  const response = await fetchApi(CONFIG.privateApiHost + "/search-api/search", {
     method: "POST",
     headers: {
       "Content-Type": "application/json"
@@ -5058,10 +5339,10 @@ async function addDraft(code, title, body, tags, meta) {
   });
   return parseJsonResponse3(response);
 }
-async function updateDraft(code, draftId, title, body, tags, meta) {
-  const data = { code, id: draftId, title, body, tags, meta };
+async function searchAccount(q = "", limit = 20, random = 1) {
+  const data = { q, limit, random };
   const fetchApi = getBoundFetch();
-  const response = await fetchApi(CONFIG.privateApiHost + "/private-api/drafts-update", {
+  const response = await fetchApi(CONFIG.privateApiHost + "/search-api/search-account", {
     method: "POST",
     headers: {
       "Content-Type": "application/json"
@@ -5070,10 +5351,10 @@ async function updateDraft(code, draftId, title, body, tags, meta) {
   });
   return parseJsonResponse3(response);
 }
-async function deleteDraft(code, draftId) {
-  const data = { code, id: draftId };
+async function searchTag(q = "", limit = 20, random = 0) {
+  const data = { q, limit, random };
   const fetchApi = getBoundFetch();
-  const response = await fetchApi(CONFIG.privateApiHost + "/private-api/drafts-delete", {
+  const response = await fetchApi(CONFIG.privateApiHost + "/search-api/search-tag", {
     method: "POST",
     headers: {
       "Content-Type": "application/json"
@@ -5082,83 +5363,86 @@ async function deleteDraft(code, draftId) {
   });
   return parseJsonResponse3(response);
 }
-async function addSchedule(code, permlink, title, body, meta, options, schedule, reblog) {
-  const data = {
-    code,
-    permlink,
-    title,
-    body,
-    meta,
-    schedule,
-    reblog
-  };
-  if (options) {
-    data.options = options;
-  }
+async function searchPath(q) {
   const fetchApi = getBoundFetch();
-  const response = await fetchApi(CONFIG.privateApiHost + "/private-api/schedules-add", {
+  const response = await fetchApi(CONFIG.privateApiHost + "/search-api/search-path", {
     method: "POST",
     headers: {
       "Content-Type": "application/json"
     },
-    body: JSON.stringify(data)
+    body: JSON.stringify({ q })
   });
-  return parseJsonResponse3(response);
+  const data = await parseJsonResponse3(response);
+  return data?.length > 0 ? data : [q];
 }
-async function deleteSchedule(code, id) {
-  const data = { code, id };
-  const fetchApi = getBoundFetch();
-  const response = await fetchApi(CONFIG.privateApiHost + "/private-api/schedules-delete", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json"
+function getBoostPlusPricesQueryOptions(accessToken) {
+  return reactQuery.queryOptions({
+    queryKey: ["promotions", "boost-plus-prices"],
+    queryFn: async () => {
+      if (!accessToken) {
+        return [];
+      }
+      const response = await fetch(CONFIG.privateApiHost + "/private-api/boost-plus-price", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ code: accessToken })
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to fetch boost plus prices: ${response.status}`);
+      }
+      return await response.json();
     },
-    body: JSON.stringify(data)
+    staleTime: Infinity,
+    refetchOnMount: true,
+    enabled: !!accessToken
   });
-  return parseJsonResponse3(response);
 }
-async function moveSchedule(code, id) {
-  const data = { code, id };
-  const fetchApi = getBoundFetch();
-  const response = await fetchApi(CONFIG.privateApiHost + "/private-api/schedules-move", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json"
+function getPromotePriceQueryOptions(accessToken) {
+  return reactQuery.queryOptions({
+    queryKey: ["promotions", "promote-price"],
+    queryFn: async () => {
+      const response = await fetch(CONFIG.privateApiHost + "/private-api/promote-price", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ code: accessToken })
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to fetch promote prices: ${response.status}`);
+      }
+      return await response.json();
     },
-    body: JSON.stringify(data)
+    enabled: !!accessToken
   });
-  return parseJsonResponse3(response);
 }
-async function getPromotedPost(code, author, permlink) {
-  const data = { code, author, permlink };
-  const fetchApi = getBoundFetch();
-  const response = await fetchApi(CONFIG.privateApiHost + "/private-api/promoted-post", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json"
+function getBoostPlusAccountPricesQueryOptions(account, accessToken) {
+  return reactQuery.queryOptions({
+    queryKey: ["promotions", "boost-plus-accounts", account],
+    queryFn: async () => {
+      if (!accessToken || !account) {
+        return null;
+      }
+      const response = await fetch(CONFIG.privateApiHost + "/private-api/boosted-plus-account", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ code: accessToken, account })
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to fetch boost plus account prices: ${response.status}`);
+      }
+      const responseData = await response.json();
+      return responseData ? {
+        account: responseData.account,
+        expires: new Date(responseData.expires)
+      } : null;
     },
-    body: JSON.stringify(data)
+    enabled: !!account && !!accessToken
   });
-  return parseJsonResponse3(response);
-}
-async function onboardEmail(username, email, friend) {
-  const dataBody = {
-    username,
-    email,
-    friend
-  };
-  const fetchApi = getBoundFetch();
-  const response = await fetchApi(
-    CONFIG.privateApiHost + "/private-api/account-create-friend",
-    {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(dataBody)
-    }
-  );
-  return parseJsonResponse3(response);
 }
 
 // src/modules/auth/requests.ts
@@ -5541,6 +5825,7 @@ exports.getEntryActiveVotesQueryOptions = getEntryActiveVotesQueryOptions;
 exports.getFavouritesInfiniteQueryOptions = getFavouritesInfiniteQueryOptions;
 exports.getFavouritesQueryOptions = getFavouritesQueryOptions;
 exports.getFollowCountQueryOptions = getFollowCountQueryOptions;
+exports.getFollowersQueryOptions = getFollowersQueryOptions;
 exports.getFollowingQueryOptions = getFollowingQueryOptions;
 exports.getFragmentsInfiniteQueryOptions = getFragmentsInfiniteQueryOptions;
 exports.getFragmentsQueryOptions = getFragmentsQueryOptions;
@@ -5624,6 +5909,7 @@ exports.getTradeHistoryQueryOptions = getTradeHistoryQueryOptions;
 exports.getTransactionsInfiniteQueryOptions = getTransactionsInfiniteQueryOptions;
 exports.getTrendingTagsQueryOptions = getTrendingTagsQueryOptions;
 exports.getTrendingTagsWithStatsQueryOptions = getTrendingTagsWithStatsQueryOptions;
+exports.getUserPostVoteQueryOptions = getUserPostVoteQueryOptions;
 exports.getUserProposalVotesQueryOptions = getUserProposalVotesQueryOptions;
 exports.getVestingDelegationsQueryOptions = getVestingDelegationsQueryOptions;
 exports.getVisibleFirstLevelThreadItems = getVisibleFirstLevelThreadItems;
@@ -5673,17 +5959,27 @@ exports.useAccountUpdate = useAccountUpdate;
 exports.useAccountUpdateKeyAuths = useAccountUpdateKeyAuths;
 exports.useAccountUpdatePassword = useAccountUpdatePassword;
 exports.useAccountUpdateRecovery = useAccountUpdateRecovery;
+exports.useAddDraft = useAddDraft;
 exports.useAddFragment = useAddFragment;
+exports.useAddImage = useAddImage;
+exports.useAddSchedule = useAddSchedule;
 exports.useBookmarkAdd = useBookmarkAdd;
 exports.useBookmarkDelete = useBookmarkDelete;
 exports.useBroadcastMutation = useBroadcastMutation;
+exports.useDeleteDraft = useDeleteDraft;
+exports.useDeleteImage = useDeleteImage;
+exports.useDeleteSchedule = useDeleteSchedule;
 exports.useEditFragment = useEditFragment;
 exports.useGameClaim = useGameClaim;
+exports.useMarkNotificationsRead = useMarkNotificationsRead;
+exports.useMoveSchedule = useMoveSchedule;
 exports.useRecordActivity = useRecordActivity;
 exports.useRemoveFragment = useRemoveFragment;
 exports.useSignOperationByHivesigner = useSignOperationByHivesigner;
 exports.useSignOperationByKey = useSignOperationByKey;
 exports.useSignOperationByKeychain = useSignOperationByKeychain;
+exports.useUpdateDraft = useUpdateDraft;
+exports.useUploadImage = useUploadImage;
 exports.usrActivity = usrActivity;
 exports.validatePostCreating = validatePostCreating;
 exports.votingPower = votingPower;