@ecency/sdk 1.3.6 → 1.3.9

package/dist/node/index.mjs

@@ -1,5 +1,5 @@
-import { QueryClient, useQuery, useInfiniteQuery, useMutation, queryOptions, useQueryClient, infiniteQueryOptions } from '@tanstack/react-query';
-import { Client, PrivateKey, cryptoUtils, RCAPI } from '@hiveio/dhive';
+import { QueryClient, useQuery, useInfiniteQuery, useMutation, queryOptions, infiniteQueryOptions, useQueryClient } from '@tanstack/react-query';
+import { Client, utils, PrivateKey, cryptoUtils, RCAPI } from '@hiveio/dhive';
 import hs from 'hivesigner';
 import * as R4 from 'remeda';
 
@@ -55,7 +55,16 @@ var CONFIG = {
   heliusApiKey: process.env.VITE_HELIUS_API_KEY,
   queryClient: new QueryClient(),
   plausibleHost: "https://pl.ecency.com",
-  spkNode: "https://spk.good-karma.xyz"
+  spkNode: "https://spk.good-karma.xyz",
+  // DMCA filtering - can be configured by the app
+  dmcaAccounts: [],
+  dmcaTags: [],
+  dmcaPatterns: [],
+  // Pre-compiled regex patterns for performance and security
+  dmcaTagRegexes: [],
+  dmcaPatternRegexes: [],
+  // Track if DMCA has been initialized to avoid duplicate logs
+  _dmcaInitialized: false
 };
 var ConfigManager;
 ((ConfigManager2) => {
@@ -63,6 +72,115 @@ var ConfigManager;
     CONFIG.queryClient = client;
   }
   ConfigManager2.setQueryClient = setQueryClient;
+  function setPrivateApiHost(host) {
+    CONFIG.privateApiHost = host;
+  }
+  ConfigManager2.setPrivateApiHost = setPrivateApiHost;
+  function analyzeRedosRisk(pattern) {
+    if (/(\([^)]*[*+{][^)]*\))[*+{]/.test(pattern)) {
+      return { safe: false, reason: "nested quantifiers detected" };
+    }
+    if (/\([^|)]*\|[^)]*\)[*+{]/.test(pattern)) {
+      return { safe: false, reason: "alternation with quantifier (potential overlap)" };
+    }
+    if (/\([^)]*[*+][^)]*\)[*+]/.test(pattern)) {
+      return { safe: false, reason: "repeated quantifiers (catastrophic backtracking risk)" };
+    }
+    if (/\.\*\.\*/.test(pattern) || /\.\+\.\+/.test(pattern)) {
+      return { safe: false, reason: "multiple greedy quantifiers on wildcards" };
+    }
+    const unboundedRange = /\.?\{(\d+),(\d+)\}/g;
+    let match;
+    while ((match = unboundedRange.exec(pattern)) !== null) {
+      const [, min, max] = match;
+      const range = parseInt(max, 10) - parseInt(min, 10);
+      if (range > 1e3) {
+        return { safe: false, reason: `excessive range: {${min},${max}}` };
+      }
+    }
+    return { safe: true };
+  }
+  function testRegexPerformance(regex) {
+    const adversarialInputs = [
+      // Nested quantifier attack
+      "a".repeat(50) + "x",
+      // Alternation attack
+      "ab".repeat(50) + "x",
+      // Wildcard attack
+      "x".repeat(100),
+      // Mixed attack
+      "aaa".repeat(30) + "bbb".repeat(30) + "x"
+    ];
+    const maxExecutionTime = 5;
+    for (const input of adversarialInputs) {
+      const start = Date.now();
+      try {
+        regex.test(input);
+        const duration = Date.now() - start;
+        if (duration > maxExecutionTime) {
+          return {
+            safe: false,
+            reason: `runtime test exceeded ${maxExecutionTime}ms (took ${duration}ms on input length ${input.length})`
+          };
+        }
+      } catch (err) {
+        return { safe: false, reason: `runtime test threw error: ${err}` };
+      }
+    }
+    return { safe: true };
+  }
+  function safeCompileRegex(pattern, maxLength = 200) {
+    try {
+      if (!pattern) {
+        console.warn(`[SDK] DMCA pattern rejected: empty pattern`);
+        return null;
+      }
+      if (pattern.length > maxLength) {
+        console.warn(`[SDK] DMCA pattern rejected: length ${pattern.length} exceeds max ${maxLength} - pattern: ${pattern.substring(0, 50)}...`);
+        return null;
+      }
+      const staticAnalysis = analyzeRedosRisk(pattern);
+      if (!staticAnalysis.safe) {
+        console.warn(`[SDK] DMCA pattern rejected: static analysis failed (${staticAnalysis.reason}) - pattern: ${pattern.substring(0, 50)}...`);
+        return null;
+      }
+      let regex;
+      try {
+        regex = new RegExp(pattern);
+      } catch (compileErr) {
+        console.warn(`[SDK] DMCA pattern rejected: compilation failed - pattern: ${pattern.substring(0, 50)}...`, compileErr);
+        return null;
+      }
+      const runtimeTest = testRegexPerformance(regex);
+      if (!runtimeTest.safe) {
+        console.warn(`[SDK] DMCA pattern rejected: runtime test failed (${runtimeTest.reason}) - pattern: ${pattern.substring(0, 50)}...`);
+        return null;
+      }
+      return regex;
+    } catch (err) {
+      console.warn(`[SDK] DMCA pattern rejected: unexpected error - pattern: ${pattern.substring(0, 50)}...`, err);
+      return null;
+    }
+  }
+  function setDmcaLists(accounts = [], tags = [], patterns = []) {
+    CONFIG.dmcaAccounts = accounts;
+    CONFIG.dmcaTags = tags;
+    CONFIG.dmcaPatterns = patterns;
+    CONFIG.dmcaTagRegexes = tags.map((pattern) => safeCompileRegex(pattern)).filter((r) => r !== null);
+    CONFIG.dmcaPatternRegexes = [];
+    const rejectedTagCount = tags.length - CONFIG.dmcaTagRegexes.length;
+    if (!CONFIG._dmcaInitialized) {
+      console.log(`[SDK] DMCA configuration loaded:`);
+      console.log(`  - Accounts: ${accounts.length}`);
+      console.log(`  - Tag patterns: ${CONFIG.dmcaTagRegexes.length}/${tags.length} compiled (${rejectedTagCount} rejected)`);
+      console.log(`  - Post patterns: ${patterns.length} (using exact string matching)`);
+      if (rejectedTagCount > 0) {
+        console.warn(`[SDK] ${rejectedTagCount} DMCA tag patterns were rejected due to security validation. Check warnings above for details.`);
+      }
+      CONFIG._dmcaInitialized = true;
+    }
+  }
+  ConfigManager2.setDmcaLists = setDmcaLists;
 })(ConfigManager || (ConfigManager = {}));
 
 // src/modules/core/utils/decoder-encoder.ts
@@ -468,6 +586,176 @@ function getAccountFullQueryOptions(username) {
     staleTime: 6e4
   });
 }
+function sanitizeTokens(tokens) {
+  return tokens?.map(({ meta, ...rest }) => {
+    if (!meta || typeof meta !== "object") {
+      return { ...rest, meta };
+    }
+    const { privateKey, username, ...safeMeta } = meta;
+    return { ...rest, meta: safeMeta };
+  });
+}
+function parseProfileMetadata(postingJsonMetadata) {
+  if (!postingJsonMetadata) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(postingJsonMetadata);
+    if (parsed && typeof parsed === "object" && parsed.profile && typeof parsed.profile === "object") {
+      return parsed.profile;
+    }
+  } catch (err) {
+  }
+  return {};
+}
+function extractAccountProfile(data) {
+  return parseProfileMetadata(data?.posting_json_metadata);
+}
+function buildProfileMetadata({
+  existingProfile,
+  profile,
+  tokens
+}) {
+  const { tokens: profileTokens, version: _ignoredVersion, ...profileRest } = profile ?? {};
+  const metadata = R4.mergeDeep(
+    existingProfile ?? {},
+    profileRest
+  );
+  const nextTokens = tokens ?? profileTokens;
+  if (nextTokens && nextTokens.length > 0) {
+    metadata.tokens = nextTokens;
+  }
+  metadata.tokens = sanitizeTokens(metadata.tokens);
+  metadata.version = 2;
+  return metadata;
+}
+
+// src/modules/accounts/utils/parse-accounts.ts
+function parseAccounts(rawAccounts) {
+  return rawAccounts.map((x) => {
+    const account = {
+      name: x.name,
+      owner: x.owner,
+      active: x.active,
+      posting: x.posting,
+      memo_key: x.memo_key,
+      post_count: x.post_count,
+      created: x.created,
+      reputation: x.reputation,
+      posting_json_metadata: x.posting_json_metadata,
+      last_vote_time: x.last_vote_time,
+      last_post: x.last_post,
+      json_metadata: x.json_metadata,
+      reward_hive_balance: x.reward_hive_balance,
+      reward_hbd_balance: x.reward_hbd_balance,
+      reward_vesting_hive: x.reward_vesting_hive,
+      reward_vesting_balance: x.reward_vesting_balance,
+      balance: x.balance,
+      hbd_balance: x.hbd_balance,
+      savings_balance: x.savings_balance,
+      savings_hbd_balance: x.savings_hbd_balance,
+      savings_hbd_last_interest_payment: x.savings_hbd_last_interest_payment,
+      savings_hbd_seconds_last_update: x.savings_hbd_seconds_last_update,
+      savings_hbd_seconds: x.savings_hbd_seconds,
+      next_vesting_withdrawal: x.next_vesting_withdrawal,
+      pending_claimed_accounts: x.pending_claimed_accounts,
+      vesting_shares: x.vesting_shares,
+      delegated_vesting_shares: x.delegated_vesting_shares,
+      received_vesting_shares: x.received_vesting_shares,
+      vesting_withdraw_rate: x.vesting_withdraw_rate,
+      to_withdraw: x.to_withdraw,
+      withdrawn: x.withdrawn,
+      witness_votes: x.witness_votes,
+      proxy: x.proxy,
+      recovery_account: x.recovery_account,
+      proxied_vsf_votes: x.proxied_vsf_votes,
+      voting_manabar: x.voting_manabar,
+      voting_power: x.voting_power,
+      downvote_manabar: x.downvote_manabar
+    };
+    let profile = parseProfileMetadata(
+      x.posting_json_metadata
+    );
+    if (!profile || Object.keys(profile).length === 0) {
+      try {
+        const jsonMetadata = JSON.parse(x.json_metadata || "{}");
+        if (jsonMetadata.profile) {
+          profile = jsonMetadata.profile;
+        }
+      } catch (e) {
+      }
+    }
+    if (!profile || Object.keys(profile).length === 0) {
+      profile = {
+        about: "",
+        cover_image: "",
+        location: "",
+        name: "",
+        profile_image: "",
+        website: ""
+      };
+    }
+    return { ...account, profile };
+  });
+}
+
+// src/modules/accounts/queries/get-accounts-query-options.ts
+function getAccountsQueryOptions(usernames) {
+  return queryOptions({
+    queryKey: ["accounts", "get-accounts", usernames],
+    queryFn: async () => {
+      const response = await CONFIG.hiveClient.database.getAccounts(usernames);
+      return parseAccounts(response);
+    },
+    enabled: usernames.length > 0
+  });
+}
+function getFollowCountQueryOptions(username) {
+  return queryOptions({
+    queryKey: ["accounts", "follow-count", username],
+    queryFn: () => CONFIG.hiveClient.database.call("get_follow_count", [
+      username
+    ])
+  });
+}
+function getFollowingQueryOptions(follower, startFollowing, followType = "blog", limit = 100) {
+  return queryOptions({
+    queryKey: ["accounts", "following", follower, startFollowing, followType, limit],
+    queryFn: () => CONFIG.hiveClient.database.call("get_following", [
+      follower,
+      startFollowing,
+      followType,
+      limit
+    ]),
+    enabled: !!follower
+  });
+}
+function getMutedUsersQueryOptions(username, limit = 100) {
+  return queryOptions({
+    queryKey: ["accounts", "muted-users", username],
+    queryFn: async () => {
+      const response = await CONFIG.hiveClient.database.call("get_following", [
+        username,
+        "",
+        "ignore",
+        limit
+      ]);
+      return response.map((user) => user.following);
+    },
+    enabled: !!username
+  });
+}
+function lookupAccountsQueryOptions(query, limit = 50) {
+  return queryOptions({
+    queryKey: ["accounts", "lookup", query, limit],
+    queryFn: () => CONFIG.hiveClient.database.call("lookup_accounts", [
+      query,
+      limit
+    ]),
+    enabled: !!query,
+    staleTime: Infinity
+  });
+}
 function getSearchAccountsByUsernameQueryOptions(query, limit = 5, excludeList = []) {
   return queryOptions({
     queryKey: ["accounts", "search", query, excludeList],
@@ -687,314 +975,1320 @@ function getAccountPendingRecoveryQueryOptions(username) {
     )
   });
 }
-function sanitizeTokens(tokens) {
-  return tokens?.map(({ meta, ...rest }) => {
-    if (!meta || typeof meta !== "object") {
-      return { ...rest, meta };
-    }
-    const { privateKey, username, ...safeMeta } = meta;
-    return { ...rest, meta: safeMeta };
+var ops = utils.operationOrders;
+var ACCOUNT_OPERATION_GROUPS = {
+  transfers: [
+    ops.transfer,
+    ops.transfer_to_savings,
+    ops.transfer_from_savings,
+    ops.cancel_transfer_from_savings,
+    ops.recurrent_transfer,
+    ops.fill_recurrent_transfer,
+    ops.escrow_transfer,
+    ops.fill_recurrent_transfer
+  ],
+  "market-orders": [
+    ops.fill_convert_request,
+    ops.fill_order,
+    ops.fill_collateralized_convert_request,
+    ops.limit_order_create2,
+    ops.limit_order_create,
+    ops.limit_order_cancel
+  ],
+  interests: [ops.interest],
+  "stake-operations": [
+    ops.return_vesting_delegation,
+    ops.withdraw_vesting,
+    ops.transfer_to_vesting,
+    ops.set_withdraw_vesting_route,
+    ops.update_proposal_votes,
+    ops.fill_vesting_withdraw,
+    ops.account_witness_proxy,
+    ops.delegate_vesting_shares
+  ],
+  rewards: [
+    ops.author_reward,
+    ops.curation_reward,
+    ops.producer_reward,
+    ops.claim_reward_balance,
+    ops.comment_benefactor_reward,
+    ops.liquidity_reward,
+    ops.proposal_pay
+  ]
+};
+var ALL_ACCOUNT_OPERATIONS = [...Object.values(ACCOUNT_OPERATION_GROUPS)].reduce(
+  (acc, val) => acc.concat(val),
+  []
+);
+function getTransactionsInfiniteQueryOptions(username, limit = 20, group = "") {
+  return infiniteQueryOptions({
+    queryKey: ["accounts", "transactions", username ?? "", group, limit],
+    initialPageParam: -1,
+    queryFn: async ({ pageParam }) => {
+      if (!username) {
+        return [];
+      }
+      let filters;
+      switch (group) {
+        case "transfers":
+          filters = utils.makeBitMaskFilter(ACCOUNT_OPERATION_GROUPS["transfers"]);
+          break;
+        case "market-orders":
+          filters = utils.makeBitMaskFilter(ACCOUNT_OPERATION_GROUPS["market-orders"]);
+          break;
+        case "interests":
+          filters = utils.makeBitMaskFilter(ACCOUNT_OPERATION_GROUPS["interests"]);
+          break;
+        case "stake-operations":
+          filters = utils.makeBitMaskFilter(ACCOUNT_OPERATION_GROUPS["stake-operations"]);
+          break;
+        case "rewards":
+          filters = utils.makeBitMaskFilter(ACCOUNT_OPERATION_GROUPS["rewards"]);
+          break;
+        default:
+          filters = utils.makeBitMaskFilter(ALL_ACCOUNT_OPERATIONS);
+      }
+      const response = await (filters ? CONFIG.hiveClient.call("condenser_api", "get_account_history", [
+        username,
+        pageParam,
+        limit,
+        ...filters
+      ]) : CONFIG.hiveClient.call("condenser_api", "get_account_history", [
+        username,
+        pageParam,
+        limit
+      ]));
+      const mapped = response.map(([num, operation]) => {
+        const base = {
+          num,
+          type: operation.op[0],
+          timestamp: operation.timestamp,
+          trx_id: operation.trx_id
+        };
+        const payload = operation.op[1];
+        return { ...base, ...payload };
+      }).filter(Boolean).sort((a, b) => b.num - a.num);
+      return mapped;
+    },
+    getNextPageParam: (lastPage) => lastPage?.length ? (lastPage[lastPage.length - 1]?.num ?? 0) - 1 : -1
   });
 }
-function parseProfileMetadata(postingJsonMetadata) {
-  if (!postingJsonMetadata) {
-    return {};
-  }
-  try {
-    const parsed = JSON.parse(postingJsonMetadata);
-    if (parsed && typeof parsed === "object" && parsed.profile && typeof parsed.profile === "object") {
-      return parsed.profile;
-    }
-  } catch (err) {
-  }
-  return {};
-}
-function extractAccountProfile(data) {
-  return parseProfileMetadata(data?.posting_json_metadata);
-}
-function buildProfileMetadata({
-  existingProfile,
-  profile,
-  tokens
-}) {
-  const { tokens: profileTokens, version: _ignoredVersion, ...profileRest } = profile ?? {};
-  const metadata = R4.mergeDeep(
-    existingProfile ?? {},
-    profileRest
-  );
-  const nextTokens = tokens ?? profileTokens;
-  if (nextTokens && nextTokens.length > 0) {
-    metadata.tokens = nextTokens;
-  }
-  metadata.tokens = sanitizeTokens(metadata.tokens);
-  metadata.version = 2;
-  return metadata;
+function getBotsQueryOptions() {
+  return queryOptions({
+    queryKey: ["accounts", "bots"],
+    queryFn: async () => {
+      const response = await fetch(CONFIG.privateApiHost + "/private-api/public/bots", {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to fetch bots: ${response.status}`);
+      }
+      return response.json();
+    },
+    refetchOnMount: true,
+    staleTime: Infinity
+  });
 }
-
-// src/modules/accounts/mutations/use-account-update.ts
-function useAccountUpdate(username) {
-  const queryClient = useQueryClient();
-  const { data } = useQuery(getAccountFullQueryOptions(username));
-  return useBroadcastMutation(
-    ["accounts", "update"],
-    username,
-    (payload) => {
-      if (!data) {
-        throw new Error("[SDK][Accounts] \u2013 cannot update not existing account");
+function getReferralsInfiniteQueryOptions(username) {
+  return infiniteQueryOptions({
+    queryKey: ["accounts", "referrals", username],
+    initialPageParam: { maxId: void 0 },
+    queryFn: async ({ pageParam }) => {
+      const { maxId } = pageParam ?? {};
+      const url = new URL(CONFIG.privateApiHost + `/private-api/referrals/${username}`);
+      if (maxId !== void 0) {
+        url.searchParams.set("max_id", maxId.toString());
       }
-      const profile = buildProfileMetadata({
-        existingProfile: extractAccountProfile(data),
-        profile: payload.profile,
-        tokens: payload.tokens
+      const response = await fetch(url.toString(), {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json"
+        }
       });
-      return [
-        [
-          "account_update2",
-          {
-            account: username,
-            json_metadata: "",
-            extensions: [],
-            posting_json_metadata: JSON.stringify({
-              profile
-            })
-          }
-        ]
-      ];
+      if (!response.ok) {
+        throw new Error(`Failed to fetch referrals: ${response.status}`);
+      }
+      return response.json();
     },
-    (_, variables) => queryClient.setQueryData(
-      getAccountFullQueryOptions(username).queryKey,
-      (data2) => {
-        if (!data2) {
-          return data2;
+    getNextPageParam: (lastPage) => {
+      const nextMaxId = lastPage?.[lastPage.length - 1]?.id;
+      return typeof nextMaxId === "number" ? { maxId: nextMaxId } : void 0;
+    }
+  });
+}
+function getReferralsStatsQueryOptions(username) {
+  return queryOptions({
+    queryKey: ["accounts", "referrals-stats", username],
+    queryFn: async () => {
+      const response = await fetch(
+        CONFIG.privateApiHost + `/private-api/referrals/${username}/stats`,
+        {
+          method: "GET",
+          headers: {
+            "Content-Type": "application/json"
+          }
         }
-        const obj = R4.clone(data2);
-        obj.profile = buildProfileMetadata({
-          existingProfile: extractAccountProfile(data2),
-          profile: variables.profile,
-          tokens: variables.tokens
-        });
-        return obj;
+      );
+      if (!response.ok) {
+        throw new Error(`Failed to fetch referral stats: ${response.status}`);
       }
-    )
-  );
+      const data = await response.json();
+      if (!data) {
+        throw new Error("No Referrals for this user!");
+      }
+      return {
+        total: data.total ?? 0,
+        rewarded: data.rewarded ?? 0
+      };
+    }
+  });
 }
-function useAccountRelationsUpdate(reference, target, onSuccess, onError) {
-  return useMutation({
-    mutationKey: ["accounts", "relation", "update", reference, target],
-    mutationFn: async (kind) => {
-      const relationsQuery = getRelationshipBetweenAccountsQueryOptions(
-        reference,
-        target
+function getFriendsInfiniteQueryOptions(following, mode, options) {
+  const { followType = "blog", limit = 100, enabled = true } = options ?? {};
+  return infiniteQueryOptions({
+    queryKey: ["accounts", "friends", following, mode, followType, limit],
+    initialPageParam: { startFollowing: "" },
+    enabled,
+    refetchOnMount: true,
+    queryFn: async ({ pageParam }) => {
+      const { startFollowing } = pageParam;
+      const response = await CONFIG.hiveClient.database.call(
+        mode === "following" ? "get_following" : "get_followers",
+        [following, startFollowing === "" ? null : startFollowing, followType, limit]
       );
-      await getQueryClient().prefetchQuery(relationsQuery);
-      const actualRelation = getQueryClient().getQueryData(
-        relationsQuery.queryKey
+      const accountNames = response.map(
+        (e) => mode === "following" ? e.following : e.follower
       );
-      await broadcastJson(reference, "follow", [
-        "follow",
-        {
-          follower: reference,
-          following: target,
-          what: [
-            ...kind === "toggle-ignore" && !actualRelation?.ignores ? ["ignore"] : [],
-            ...kind === "toggle-follow" && !actualRelation?.follows ? ["blog"] : []
-          ]
-        }
-      ]);
-      return {
-        ...actualRelation,
-        ignores: kind === "toggle-ignore" ? !actualRelation?.ignores : actualRelation?.ignores,
-        follows: kind === "toggle-follow" ? !actualRelation?.follows : actualRelation?.follows
-      };
+      const accounts = await CONFIG.hiveClient.call("bridge", "get_profiles", {
+        accounts: accountNames,
+        observer: void 0
+      });
+      const rows = (accounts ?? []).map((a) => ({
+        name: a.name,
+        reputation: a.reputation,
+        active: a.active
+        // Return raw timestamp
+      }));
+      return rows;
     },
-    onError,
-    onSuccess(data) {
-      onSuccess(data);
-      getQueryClient().setQueryData(
-        ["accounts", "relations", reference, target],
-        data
+    getNextPageParam: (lastPage) => lastPage && lastPage.length === limit ? { startFollowing: lastPage[lastPage.length - 1].name } : void 0
+  });
+}
+var SEARCH_LIMIT = 30;
+function getSearchFriendsQueryOptions(username, mode, query) {
+  return queryOptions({
+    queryKey: ["accounts", "friends", "search", username, mode, query],
+    refetchOnMount: false,
+    enabled: false,
+    // Manual query via refetch
+    queryFn: async () => {
+      if (!query) return [];
+      const start = query.slice(0, -1);
+      const response = await CONFIG.hiveClient.database.call(
+        mode === "following" ? "get_following" : "get_followers",
+        [username, start, "blog", 1e3]
       );
+      const accountNames = response.map((e) => mode === "following" ? e.following : e.follower).filter((name) => name.toLowerCase().includes(query.toLowerCase())).slice(0, SEARCH_LIMIT);
+      const accounts = await CONFIG.hiveClient.call("bridge", "get_profiles", {
+        accounts: accountNames,
+        observer: void 0
+      });
+      return accounts?.map((a) => ({
+        name: a.name,
+        full_name: a.metadata.profile?.name || "",
+        reputation: a.reputation,
+        active: a.active
+        // Return raw timestamp
+      })) ?? [];
     }
   });
 }
-function useBookmarkAdd(username, onSuccess, onError) {
-  return useMutation({
-    mutationKey: ["accounts", "bookmarks", "add", username],
-    mutationFn: async ({ author, permlink }) => {
-      if (!username) {
-        throw new Error("[SDK][Account][Bookmarks] \u2013 no active user");
-      }
+function getTrendingTagsQueryOptions(limit = 20) {
+  return infiniteQueryOptions({
+    queryKey: ["posts", "trending-tags"],
+    queryFn: async ({ pageParam: { afterTag } }) => CONFIG.hiveClient.database.call("get_trending_tags", [afterTag, limit]).then(
+      (tags) => tags.filter((x) => x.name !== "").filter((x) => !x.name.startsWith("hive-")).map((x) => x.name)
+    ),
+    initialPageParam: { afterTag: "" },
+    getNextPageParam: (lastPage) => ({
+      afterTag: lastPage?.[lastPage?.length - 1]
+    }),
+    staleTime: Infinity,
+    refetchOnMount: true
+  });
+}
+function getFragmentsQueryOptions(username) {
+  return queryOptions({
+    queryKey: ["posts", "fragments", username],
+    queryFn: async () => {
       const fetchApi = getBoundFetch();
       const response = await fetchApi(
-        CONFIG.privateApiHost + "/private-api/bookmarks-add",
+        CONFIG.privateApiHost + "/private-api/fragments",
         {
           method: "POST",
-          headers: {
-            "Content-Type": "application/json"
-          },
           body: JSON.stringify({
-            author,
-            permlink,
             code: getAccessToken(username)
-          })
+          }),
+          headers: {
+            "Content-Type": "application/json"
+          }
         }
       );
       return response.json();
     },
-    onSuccess: () => {
-      onSuccess();
-      getQueryClient().invalidateQueries({
-        queryKey: ["accounts", "bookmarks", username]
-      });
-    },
-    onError
+    enabled: !!username
   });
 }
-function useBookmarkDelete(username, onSuccess, onError) {
-  return useMutation({
-    mutationKey: ["accounts", "bookmarks", "delete", username],
-    mutationFn: async (bookmarkId) => {
-      if (!username) {
-        throw new Error("[SDK][Account][Bookmarks] \u2013 no active user");
+function getPromotedPostsQuery(type = "feed") {
+  return queryOptions({
+    queryKey: ["posts", "promoted", type],
+    queryFn: async () => {
+      const url = new URL(
+        CONFIG.privateApiHost + "/private-api/promoted-entries"
+      );
+      if (type === "waves") {
+        url.searchParams.append("short_content", "1");
       }
       const fetchApi = getBoundFetch();
-      const response = await fetchApi(
-        CONFIG.privateApiHost + "/private-api/bookmarks-delete",
-        {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify({
-            id: bookmarkId,
-            code: getAccessToken(username)
-          })
+      const response = await fetchApi(url.toString(), {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json"
         }
-      );
-      return response.json();
+      });
+      const data = await response.json();
+      return data;
+    }
+  });
+}
+function getEntryActiveVotesQueryOptions(entry) {
+  return queryOptions({
+    queryKey: ["posts", "entry-active-votes", entry?.author, entry?.permlink],
+    queryFn: async () => {
+      return CONFIG.hiveClient.database.call("get_active_votes", [
+        entry?.author,
+        entry?.permlink
+      ]);
     },
-    onSuccess: () => {
-      onSuccess();
-      getQueryClient().invalidateQueries({
-        queryKey: ["accounts", "bookmarks", username]
+    enabled: !!entry
+  });
+}
+function getPostHeaderQueryOptions(author, permlink) {
+  return queryOptions({
+    queryKey: ["posts", "post-header", author, permlink],
+    queryFn: async () => {
+      return CONFIG.hiveClient.call("bridge", "get_post_header", {
+        author,
+        permlink
       });
     },
-    onError
+    initialData: null
   });
 }
-function useAccountFavouriteAdd(username, onSuccess, onError) {
-  return useMutation({
-    mutationKey: ["accounts", "favourites", "add", username],
-    mutationFn: async (account) => {
-      if (!username) {
-        throw new Error("[SDK][Account][Bookmarks] \u2013 no active user");
+
+// src/modules/posts/utils/filter-dmca-entries.ts
+function filterDmcaEntry(entryOrEntries) {
+  if (Array.isArray(entryOrEntries)) {
+    return entryOrEntries.map((entry) => applyFilter(entry));
+  }
+  return applyFilter(entryOrEntries);
+}
+function applyFilter(entry) {
+  if (!entry) return entry;
+  const entryPath = `@${entry.author}/${entry.permlink}`;
+  const isDmca = CONFIG.dmcaPatternRegexes.some((regex) => regex.test(entryPath));
+  if (isDmca) {
+    return {
+      ...entry,
+      body: "This post is not available due to a copyright/fraudulent claim.",
+      title: ""
+    };
+  }
+  return entry;
+}
+
+// src/modules/posts/queries/get-post-query-options.ts
+function makeEntryPath(category, author, permlink) {
+  return `${category}/@${author}/${permlink}`;
+}
+function getPostQueryOptions(author, permlink, observer = "", num) {
+  const cleanPermlink = permlink?.trim();
+  const entryPath = makeEntryPath("", author, cleanPermlink ?? "");
+  return queryOptions({
+    queryKey: ["posts", "entry", entryPath],
+    queryFn: async () => {
+      if (!cleanPermlink || cleanPermlink === "undefined") {
+        return null;
       }
-      const fetchApi = getBoundFetch();
-      const response = await fetchApi(
-        CONFIG.privateApiHost + "/private-api/favorites-add",
-        {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify({
-            account,
-            code: getAccessToken(username)
-          })
-        }
-      );
-      return response.json();
-    },
-    onSuccess: () => {
-      onSuccess();
-      getQueryClient().invalidateQueries({
-        queryKey: ["accounts", "favourites", username]
+      const response = await CONFIG.hiveClient.call("bridge", "get_post", {
+        author,
+        permlink: cleanPermlink,
+        observer
       });
+      if (!response) {
+        return null;
+      }
+      const entry = num !== void 0 ? { ...response, num } : response;
+      return filterDmcaEntry(entry);
     },
-    onError
+    enabled: !!author && !!permlink && permlink.trim() !== "" && permlink.trim() !== "undefined"
   });
 }
-function useAccountFavouriteDelete(username, onSuccess, onError) {
-  return useMutation({
-    mutationKey: ["accounts", "favourites", "add", username],
-    mutationFn: async (account) => {
-      if (!username) {
-        throw new Error("[SDK][Account][Bookmarks] \u2013 no active user");
+var SortOrder = /* @__PURE__ */ ((SortOrder2) => {
+  SortOrder2["trending"] = "trending";
+  SortOrder2["author_reputation"] = "author_reputation";
+  SortOrder2["votes"] = "votes";
+  SortOrder2["created"] = "created";
+  return SortOrder2;
+})(SortOrder || {});
+function parseAsset2(value) {
+  const match = value.match(/^(\d+\.?\d*)\s*([A-Z]+)$/);
+  if (!match) return { amount: 0, symbol: "" };
+  return {
+    amount: parseFloat(match[1]),
+    symbol: match[2]
+  };
+}
+function sortDiscussions(entry, discussion, order) {
+  const allPayout = (c) => parseAsset2(c.pending_payout_value).amount + parseAsset2(c.author_payout_value).amount + parseAsset2(c.curator_payout_value).amount;
+  const absNegative = (a) => a.net_rshares < 0;
+  const isPinned = (a) => entry.json_metadata?.pinned_reply === `${a.author}/${a.permlink}`;
+  const sortOrders = {
+    trending: (a, b) => {
+      if (absNegative(a)) {
+        return 1;
       }
-      const fetchApi = getBoundFetch();
-      const response = await fetchApi(
-        CONFIG.privateApiHost + "/private-api/favorites-delete",
-        {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify({
-            account,
-            code: getAccessToken(username)
-          })
-        }
-      );
-      return response.json();
+      if (absNegative(b)) {
+        return -1;
+      }
+      const _a = allPayout(a);
+      const _b = allPayout(b);
+      if (_a !== _b) {
+        return _b - _a;
+      }
+      return 0;
     },
-    onSuccess: () => {
-      onSuccess();
-      getQueryClient().invalidateQueries({
-        queryKey: ["accounts", "favourites", username]
-      });
+    author_reputation: (a, b) => {
+      const keyA = a.author_reputation;
+      const keyB = b.author_reputation;
+      if (keyA > keyB) return -1;
+      if (keyA < keyB) return 1;
+      return 0;
     },
-    onError
-  });
+    votes: (a, b) => {
+      const keyA = a.children;
+      const keyB = b.children;
+      if (keyA > keyB) return -1;
+      if (keyA < keyB) return 1;
+      return 0;
+    },
+    created: (a, b) => {
+      if (absNegative(a)) {
+        return 1;
+      }
+      if (absNegative(b)) {
+        return -1;
+      }
+      const keyA = Date.parse(a.created);
+      const keyB = Date.parse(b.created);
+      if (keyA > keyB) return -1;
+      if (keyA < keyB) return 1;
+      return 0;
+    }
+  };
+  const sorted = discussion.sort(sortOrders[order]);
+  const pinnedIndex = sorted.findIndex((i) => isPinned(i));
+  const pinned = sorted[pinnedIndex];
+  if (pinnedIndex >= 0) {
+    sorted.splice(pinnedIndex, 1);
+    sorted.unshift(pinned);
+  }
+  return sorted;
 }
-function dedupeAndSortKeyAuths(existing, additions) {
-  const merged = /* @__PURE__ */ new Map();
-  existing.forEach(([key, weight]) => {
-    merged.set(key.toString(), weight);
-  });
-  additions.forEach(([key, weight]) => {
-    merged.set(key.toString(), weight);
+function getDiscussionsQueryOptions(entry, order = "created" /* created */, enabled = true, observer) {
+  return queryOptions({
+    queryKey: [
+      "posts",
+      "discussions",
+      entry?.author,
+      entry?.permlink,
+      order,
+      observer || entry?.author
+    ],
+    queryFn: async () => {
+      if (!entry) {
+        return [];
+      }
+      const response = await CONFIG.hiveClient.call("bridge", "get_discussion", {
+        author: entry.author,
+        permlink: entry.permlink,
+        observer: observer || entry.author
+      });
+      const results = response ? Array.from(Object.values(response)) : [];
+      return filterDmcaEntry(results);
+    },
+    enabled: enabled && !!entry,
+    select: (data) => sortDiscussions(entry, data, order)
   });
-  return Array.from(merged.entries()).sort(([keyA], [keyB]) => keyA.localeCompare(keyB)).map(([key, weight]) => [key, weight]);
 }
-function useAccountUpdateKeyAuths(username, options) {
-  const { data: accountData } = useQuery(getAccountFullQueryOptions(username));
-  return useMutation({
-    mutationKey: ["accounts", "keys-update", username],
-    mutationFn: async ({ keys, keepCurrent = false, currentKey }) => {
-      if (!accountData) {
-        throw new Error(
-          "[SDK][Update password] \u2013 cannot update keys for anon user"
+function getAccountPostsInfiniteQueryOptions(username, filter = "posts", limit = 20, observer = "", enabled = true) {
+  return infiniteQueryOptions({
+    queryKey: ["posts", "account-posts", username ?? "", filter, limit, observer],
+    enabled: !!username && enabled,
+    initialPageParam: {
+      author: void 0,
+      permlink: void 0,
+      hasNextPage: true
+    },
+    queryFn: async ({ pageParam }) => {
+      if (!pageParam?.hasNextPage || !username) return [];
+      const rpcParams = {
+        sort: filter,
+        account: username,
+        limit,
+        ...observer && observer.length > 0 ? { observer } : {},
+        ...pageParam.author ? { start_author: pageParam.author } : {},
+        ...pageParam.permlink ? { start_permlink: pageParam.permlink } : {}
+      };
+      try {
+        if (CONFIG.dmcaAccounts.includes(username)) return [];
+        const resp = await CONFIG.hiveClient.call(
+          "bridge",
+          "get_account_posts",
+          rpcParams
         );
+        if (resp && Array.isArray(resp)) {
+          return filterDmcaEntry(resp);
+        }
+        return [];
+      } catch (err) {
+        console.error("[SDK] get_account_posts error:", err);
+        return [];
       }
-      const prepareAuth = (keyName) => {
-        const auth = R4.clone(accountData[keyName]);
-        auth.key_auths = dedupeAndSortKeyAuths(
-          keepCurrent ? auth.key_auths : [],
-          keys.map(
-            (values, i) => [values[keyName].createPublic().toString(), i + 1]
-          )
-        );
-        return auth;
-      };
-      return CONFIG.hiveClient.broadcast.updateAccount(
-        {
-          account: username,
-          json_metadata: accountData.json_metadata,
-          owner: prepareAuth("owner"),
-          active: prepareAuth("active"),
-          posting: prepareAuth("posting"),
-          memo_key: keepCurrent ? accountData.memo_key : keys[0].memo_key.createPublic().toString()
-        },
-        currentKey
-      );
     },
-    ...options
+    getNextPageParam: (lastPage) => {
+      const last = lastPage?.[lastPage.length - 1];
+      const hasNextPage = (lastPage?.length ?? 0) === limit;
+      if (!hasNextPage) {
+        return void 0;
+      }
+      return {
+        author: last?.author,
+        permlink: last?.permlink,
+        hasNextPage
+      };
+    }
   });
 }
-function useAccountUpdatePassword(username, options) {
-  const { data: accountData } = useQuery(getAccountFullQueryOptions(username));
-  const { mutateAsync: updateKeys } = useAccountUpdateKeyAuths(username);
-  return useMutation({
+function getPostsRankedInfiniteQueryOptions(sort, tag, limit = 20, observer = "", enabled = true, _options = {}) {
+  return infiniteQueryOptions({
+    queryKey: ["posts", "posts-ranked", sort, tag, limit, observer],
+    queryFn: async ({ pageParam }) => {
+      if (!pageParam.hasNextPage) {
+        return [];
+      }
+      let sanitizedTag = tag;
+      if (CONFIG.dmcaTagRegexes.some((regex) => regex.test(tag))) {
+        sanitizedTag = "";
+      }
+      const response = await CONFIG.hiveClient.call("bridge", "get_ranked_posts", {
+        sort,
+        start_author: pageParam.author,
+        start_permlink: pageParam.permlink,
+        limit,
+        tag: sanitizedTag,
+        observer
+      });
+      if (response && Array.isArray(response)) {
+        const data = response;
+        const sorted = sort === "hot" ? data : data.sort(
+          (a, b) => new Date(b.created).getTime() - new Date(a.created).getTime()
+        );
+        const pinnedEntry = sorted.find((s) => s.stats?.is_pinned);
+        const nonPinnedEntries = sorted.filter((s) => !s.stats?.is_pinned);
+        const combined = [pinnedEntry, ...nonPinnedEntries].filter((s) => !!s);
+        return filterDmcaEntry(combined);
+      }
+      return [];
+    },
+    enabled,
+    initialPageParam: {
+      author: void 0,
+      permlink: void 0,
+      hasNextPage: true
+    },
+    getNextPageParam: (lastPage) => {
+      const last = lastPage?.[lastPage.length - 1];
+      return {
+        author: last?.author,
+        permlink: last?.permlink,
+        hasNextPage: (lastPage?.length ?? 0) > 0
+      };
+    }
+  });
+}
+function getReblogsQueryOptions(username, activeUsername, limit = 200) {
+  return queryOptions({
+    queryKey: ["posts", "reblogs", username ?? "", limit],
+    queryFn: async () => {
+      const response = await CONFIG.hiveClient.call("condenser_api", "get_blog_entries", [
+        username ?? activeUsername,
+        0,
+        limit
+      ]);
+      return response.filter(
+        (i) => i.author !== activeUsername && !i.reblogged_on.startsWith("1970-")
+      ).map((i) => ({ author: i.author, permlink: i.permlink }));
+    },
+    enabled: !!username
+  });
+}
+function getSchedulesQueryOptions(activeUsername) {
+  return queryOptions({
+    queryKey: ["posts", "schedules", activeUsername],
+    queryFn: async () => {
+      if (!activeUsername) {
+        return [];
+      }
+      const response = await fetch(CONFIG.privateApiHost + "/private-api/schedules", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          code: getAccessToken(activeUsername)
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to fetch schedules: ${response.status}`);
+      }
+      return response.json();
+    },
+    enabled: !!activeUsername
+  });
+}
+function getDraftsQueryOptions(activeUsername) {
+  return queryOptions({
+    queryKey: ["posts", "drafts", activeUsername],
+    queryFn: async () => {
+      if (!activeUsername) {
+        return [];
+      }
+      const response = await fetch(CONFIG.privateApiHost + "/private-api/drafts", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          code: getAccessToken(activeUsername)
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to fetch drafts: ${response.status}`);
+      }
+      return response.json();
+    },
+    enabled: !!activeUsername
+  });
+}
+async function fetchUserImages(username) {
+  const response = await fetch(CONFIG.privateApiHost + "/private-api/images", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      code: getAccessToken(username)
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch images: ${response.status}`);
+  }
+  return response.json();
+}
+function getImagesQueryOptions(username) {
+  return queryOptions({
+    queryKey: ["posts", "images", username],
+    queryFn: async () => {
+      if (!username) {
+        return [];
+      }
+      return fetchUserImages(username);
+    },
+    enabled: !!username
+  });
+}
+function getGalleryImagesQueryOptions(activeUsername) {
+  return queryOptions({
+    queryKey: ["posts", "gallery-images", activeUsername],
+    queryFn: async () => {
+      if (!activeUsername) {
+        return [];
+      }
+      return fetchUserImages(activeUsername);
+    },
+    enabled: !!activeUsername
+  });
+}
+function getCommentHistoryQueryOptions(author, permlink, onlyMeta = false) {
+  return queryOptions({
+    queryKey: ["posts", "comment-history", author, permlink, onlyMeta],
+    queryFn: async ({ signal }) => {
+      const response = await fetch(CONFIG.privateApiHost + "/private-api/comment-history", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          author,
+          permlink,
+          onlyMeta: onlyMeta ? "1" : ""
+        }),
+        signal
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to fetch comment history: ${response.status}`);
+      }
+      return response.json();
+    },
+    enabled: !!author && !!permlink
+  });
+}
+function makeEntryPath2(author, permlink) {
+  const cleanAuthor = author?.trim();
+  const cleanPermlink = permlink?.trim();
+  if (!cleanAuthor || !cleanPermlink) {
+    throw new Error("Invalid entry path: author and permlink are required");
+  }
+  const normalizedAuthor = cleanAuthor.replace(/^@+/, "");
+  const normalizedPermlink = cleanPermlink.replace(/^\/+/, "");
+  if (!normalizedAuthor || !normalizedPermlink) {
+    throw new Error("Invalid entry path: author and permlink cannot be empty after normalization");
+  }
+  return `@${normalizedAuthor}/${normalizedPermlink}`;
+}
+function getDeletedEntryQueryOptions(author, permlink) {
+  const cleanPermlink = permlink?.trim();
+  const cleanAuthor = author?.trim();
+  const isValid = !!cleanAuthor && !!cleanPermlink && cleanPermlink !== "undefined";
+  const entryPath = isValid ? makeEntryPath2(cleanAuthor, cleanPermlink) : "";
+  return queryOptions({
+    queryKey: ["posts", "deleted-entry", entryPath],
+    queryFn: async ({ signal }) => {
+      const response = await fetch(CONFIG.privateApiHost + "/private-api/comment-history", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          author,
+          permlink: cleanPermlink || ""
+        }),
+        signal
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to fetch comment history: ${response.status}`);
+      }
+      return response.json();
+    },
+    select: (history) => {
+      if (!history?.list?.[0]) {
+        return null;
+      }
+      const { body, title, tags } = history.list[0];
+      return {
+        body,
+        title,
+        tags
+      };
+    },
+    enabled: isValid
+  });
+}
+function getPostTipsQueryOptions(author, permlink, isEnabled = true) {
+  return queryOptions({
+    queryKey: ["posts", "tips", author, permlink],
+    queryFn: async () => {
+      const response = await fetch(CONFIG.privateApiHost + "/private-api/post-tips", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          author,
+          permlink
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to fetch post tips: ${response.status}`);
+      }
+      return response.json();
+    },
+    enabled: !!author && !!permlink && isEnabled
+  });
+}
+
+// src/modules/posts/utils/waves-helpers.ts
+function normalizeContainer(entry, host) {
+  return {
+    ...entry,
+    id: entry.id ?? entry.post_id,
+    host
+  };
+}
+function normalizeParent(entry) {
+  return {
+    ...entry,
+    id: entry.id ?? entry.post_id
+  };
+}
+function normalizeWaveEntryFromApi(entry, host) {
+  if (!entry) {
+    return null;
+  }
+  const containerSource = entry.container ?? entry;
+  const container = normalizeContainer(containerSource, host);
+  const parent = entry.parent ? normalizeParent(entry.parent) : void 0;
+  return {
+    ...entry,
+    id: entry.id ?? entry.post_id,
+    host,
+    container,
+    parent
+  };
+}
+function toEntryArray(x) {
+  return Array.isArray(x) ? x : [];
+}
+async function getVisibleFirstLevelThreadItems(container) {
+  const queryOptions76 = getDiscussionsQueryOptions(container, "created" /* created */, true);
+  const discussionItemsRaw = await CONFIG.queryClient.fetchQuery(queryOptions76);
+  const discussionItems = toEntryArray(discussionItemsRaw);
+  if (discussionItems.length <= 1) {
+    return [];
+  }
+  const firstLevelItems = discussionItems.filter(
+    ({ parent_author, parent_permlink }) => parent_author === container.author && parent_permlink === container.permlink
+  );
+  if (firstLevelItems.length === 0) {
+    return [];
+  }
+  const visibleItems = firstLevelItems.filter((item) => !item.stats?.gray);
+  return visibleItems;
+}
+function mapThreadItemsToWaveEntries(items, container, host) {
+  if (items.length === 0) {
+    return [];
+  }
+  return items.map((item) => {
+    const parent = items.find(
+      (i) => i.author === item.parent_author && i.permlink === item.parent_permlink && i.author !== host
+    );
+    return {
+      ...item,
+      id: item.post_id,
+      host,
+      container,
+      parent
+    };
+  }).filter((entry) => entry.container.post_id !== entry.post_id).sort(
+    (a, b) => new Date(b.created).getTime() - new Date(a.created).getTime()
+  );
+}
+
+// src/modules/posts/queries/get-waves-by-host-query-options.ts
+var THREAD_CONTAINER_BATCH_SIZE = 5;
+var MAX_CONTAINERS_TO_SCAN = 50;
+async function getThreads(host, pageParam) {
+  let startAuthor = pageParam?.author;
+  let startPermlink = pageParam?.permlink;
+  let scannedContainers = 0;
+  let skipContainerId = pageParam?.post_id;
+  while (scannedContainers < MAX_CONTAINERS_TO_SCAN) {
+    const rpcParams = {
+      sort: "posts",
+      // ProfileFilter.posts
+      account: host,
+      limit: THREAD_CONTAINER_BATCH_SIZE,
+      ...startAuthor ? { start_author: startAuthor } : {},
+      ...startPermlink ? { start_permlink: startPermlink } : {}
+    };
+    const containers = await CONFIG.hiveClient.call(
+      "bridge",
+      "get_account_posts",
+      rpcParams
+    );
+    if (!containers || containers.length === 0) {
+      return null;
+    }
+    const normalizedContainers = containers.map((container) => {
+      container.id = container.post_id;
+      container.host = host;
+      return container;
+    });
+    for (const container of normalizedContainers) {
+      if (skipContainerId && container.post_id === skipContainerId) {
+        skipContainerId = void 0;
+        continue;
+      }
+      scannedContainers += 1;
+      if (container.stats?.gray) {
+        startAuthor = container.author;
+        startPermlink = container.permlink;
+        continue;
+      }
+      const visibleItems = await getVisibleFirstLevelThreadItems(container);
+      if (visibleItems.length === 0) {
+        startAuthor = container.author;
+        startPermlink = container.permlink;
+        continue;
+      }
+      return {
+        entries: mapThreadItemsToWaveEntries(visibleItems, container, host)
+      };
+    }
+    const lastContainer = normalizedContainers[normalizedContainers.length - 1];
+    if (!lastContainer) {
+      return null;
+    }
+    startAuthor = lastContainer.author;
+    startPermlink = lastContainer.permlink;
+  }
+  return null;
+}
+function getWavesByHostQueryOptions(host) {
+  return infiniteQueryOptions({
+    queryKey: ["posts", "waves", "by-host", host],
+    initialPageParam: void 0,
+    queryFn: async ({ pageParam }) => {
+      const result = await getThreads(host, pageParam);
+      if (!result) return [];
+      return result.entries;
+    },
+    getNextPageParam: (lastPage) => lastPage?.[0]?.container
+  });
+}
+var DEFAULT_TAG_FEED_LIMIT = 40;
+function getWavesByTagQueryOptions(host, tag, limit = DEFAULT_TAG_FEED_LIMIT) {
+  return infiniteQueryOptions({
+    queryKey: ["posts", "waves", "by-tag", host, tag],
+    initialPageParam: void 0,
+    queryFn: async ({ signal }) => {
+      try {
+        const url = new URL(CONFIG.privateApiHost + "/private-api/waves/tags");
+        url.searchParams.set("container", host);
+        url.searchParams.set("tag", tag);
+        const response = await fetch(url.toString(), {
+          method: "GET",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          signal
+        });
+        if (!response.ok) {
+          throw new Error(`Failed to fetch waves by tag: ${response.status}`);
+        }
+        const data = await response.json();
+        const result = data.slice(0, limit).map((entry) => normalizeWaveEntryFromApi(entry, host)).filter((entry) => Boolean(entry));
+        return result.sort(
+          (a, b) => new Date(b.created).getTime() - new Date(a.created).getTime()
+        );
+      } catch (error) {
+        console.error("[SDK] Failed to fetch waves by tag", error);
+        return [];
+      }
+    },
+    getNextPageParam: () => void 0
+  });
+}
+function getWavesFollowingQueryOptions(host, username) {
+  const normalizedUsername = username?.trim().toLowerCase();
+  return infiniteQueryOptions({
+    queryKey: ["posts", "waves", "following", host, normalizedUsername ?? ""],
+    enabled: Boolean(normalizedUsername),
+    initialPageParam: void 0,
+    queryFn: async ({ signal }) => {
+      if (!normalizedUsername) {
+        return [];
+      }
+      try {
+        const url = new URL(CONFIG.privateApiHost + "/private-api/waves/following");
+        url.searchParams.set("container", host);
+        url.searchParams.set("username", normalizedUsername);
+        const response = await fetch(url.toString(), {
+          method: "GET",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          signal
+        });
+        if (!response.ok) {
+          throw new Error(`Failed to fetch waves following feed: ${response.status}`);
+        }
+        const data = await response.json();
+        if (!Array.isArray(data) || data.length === 0) {
+          return [];
+        }
+        const flattened = data.map((entry) => normalizeWaveEntryFromApi(entry, host)).filter((entry) => Boolean(entry));
+        if (flattened.length === 0) {
+          return [];
+        }
+        return flattened.sort(
+          (a, b) => new Date(b.created).getTime() - new Date(a.created).getTime()
+        );
+      } catch (error) {
+        console.error("[SDK] Failed to fetch waves following feed", error);
+        return [];
+      }
+    },
+    getNextPageParam: () => void 0
+  });
+}
+function getWavesTrendingTagsQueryOptions(host, hours = 24) {
+  return queryOptions({
+    queryKey: ["posts", "waves", "trending-tags", host, hours],
+    queryFn: async ({ signal }) => {
+      try {
+        const url = new URL(CONFIG.privateApiHost + "/private-api/waves/trending/tags");
+        url.searchParams.set("container", host);
+        url.searchParams.set("hours", hours.toString());
+        const response = await fetch(url.toString(), {
+          method: "GET",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          signal
+        });
+        if (!response.ok) {
+          throw new Error(`Failed to fetch waves trending tags: ${response.status}`);
+        }
+        const data = await response.json();
+        return data.map(({ tag, posts }) => ({ tag, posts }));
+      } catch (error) {
+        console.error("[SDK] Failed to fetch waves trending tags", error);
+        return [];
+      }
+    }
+  });
+}
+
+// src/modules/accounts/queries/get-account-vote-history-infinite-query-options.ts
+function isEntry(x) {
+  return !!x && typeof x === "object" && "author" in x && "permlink" in x && "active_votes" in x;
+}
+function getDays(createdDate) {
+  const past = new Date(createdDate);
+  const now = /* @__PURE__ */ new Date();
+  const diffMs = now.getTime() - past.getTime();
+  return diffMs / (1e3 * 60 * 60 * 24);
+}
+function getAccountVoteHistoryInfiniteQueryOptions(username, options) {
+  const { limit = 20, filters = [], dayLimit = 7 } = options ?? {};
+  return infiniteQueryOptions({
+    queryKey: ["accounts", "vote-history", username, limit],
+    initialPageParam: { start: -1 },
+    queryFn: async ({ pageParam }) => {
+      const { start } = pageParam;
+      const response = await CONFIG.hiveClient.call(
+        "condenser_api",
+        "get_account_history",
+        [username, start, limit, ...filters]
+      );
+      const mappedResults = response.map(([num, historyObj]) => ({
+        ...historyObj.op[1],
+        num,
+        timestamp: historyObj.timestamp
+      }));
+      const result = mappedResults.filter(
+        (filtered) => filtered.voter === username && filtered.weight !== 0 && getDays(filtered.timestamp) <= dayLimit
+      );
+      const entries = [];
+      for (const obj of result) {
+        const post = await CONFIG.queryClient.fetchQuery(
+          getPostQueryOptions(obj.author, obj.permlink)
+        );
+        if (isEntry(post)) entries.push(post);
+      }
+      const [firstHistory] = response;
+      return {
+        lastDate: firstHistory ? getDays(firstHistory[1].timestamp) : 0,
+        lastItemFetched: firstHistory ? firstHistory[0] : start,
+        entries
+      };
+    },
+    getNextPageParam: (lastPage) => ({
+      start: lastPage.lastItemFetched
+    })
+  });
+}
+
+// src/modules/accounts/mutations/use-account-update.ts
+function useAccountUpdate(username) {
+  const queryClient = useQueryClient();
+  const { data } = useQuery(getAccountFullQueryOptions(username));
+  return useBroadcastMutation(
+    ["accounts", "update"],
+    username,
+    (payload) => {
+      if (!data) {
+        throw new Error("[SDK][Accounts] \u2013 cannot update not existing account");
+      }
+      const profile = buildProfileMetadata({
+        existingProfile: extractAccountProfile(data),
+        profile: payload.profile,
+        tokens: payload.tokens
+      });
+      return [
+        [
+          "account_update2",
+          {
+            account: username,
+            json_metadata: "",
+            extensions: [],
+            posting_json_metadata: JSON.stringify({
+              profile
+            })
+          }
+        ]
+      ];
+    },
+    (_, variables) => queryClient.setQueryData(
+      getAccountFullQueryOptions(username).queryKey,
+      (data2) => {
+        if (!data2) {
+          return data2;
+        }
+        const obj = R4.clone(data2);
+        obj.profile = buildProfileMetadata({
+          existingProfile: extractAccountProfile(data2),
+          profile: variables.profile,
+          tokens: variables.tokens
+        });
+        return obj;
+      }
+    )
+  );
+}
+function useAccountRelationsUpdate(reference, target, onSuccess, onError) {
+  return useMutation({
+    mutationKey: ["accounts", "relation", "update", reference, target],
+    mutationFn: async (kind) => {
+      const relationsQuery = getRelationshipBetweenAccountsQueryOptions(
+        reference,
+        target
+      );
+      await getQueryClient().prefetchQuery(relationsQuery);
+      const actualRelation = getQueryClient().getQueryData(
+        relationsQuery.queryKey
+      );
+      await broadcastJson(reference, "follow", [
+        "follow",
+        {
+          follower: reference,
+          following: target,
+          what: [
+            ...kind === "toggle-ignore" && !actualRelation?.ignores ? ["ignore"] : [],
+            ...kind === "toggle-follow" && !actualRelation?.follows ? ["blog"] : []
+          ]
+        }
+      ]);
+      return {
+        ...actualRelation,
+        ignores: kind === "toggle-ignore" ? !actualRelation?.ignores : actualRelation?.ignores,
+        follows: kind === "toggle-follow" ? !actualRelation?.follows : actualRelation?.follows
+      };
+    },
+    onError,
+    onSuccess(data) {
+      onSuccess(data);
+      getQueryClient().setQueryData(
+        ["accounts", "relations", reference, target],
+        data
+      );
+    }
+  });
+}
+function useBookmarkAdd(username, onSuccess, onError) {
+  return useMutation({
+    mutationKey: ["accounts", "bookmarks", "add", username],
+    mutationFn: async ({ author, permlink }) => {
+      if (!username) {
+        throw new Error("[SDK][Account][Bookmarks] \u2013 no active user");
+      }
+      const fetchApi = getBoundFetch();
+      const response = await fetchApi(
+        CONFIG.privateApiHost + "/private-api/bookmarks-add",
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            author,
+            permlink,
+            code: getAccessToken(username)
+          })
+        }
+      );
+      return response.json();
+    },
+    onSuccess: () => {
+      onSuccess();
+      getQueryClient().invalidateQueries({
+        queryKey: ["accounts", "bookmarks", username]
+      });
+    },
+    onError
+  });
+}
+function useBookmarkDelete(username, onSuccess, onError) {
+  return useMutation({
+    mutationKey: ["accounts", "bookmarks", "delete", username],
+    mutationFn: async (bookmarkId) => {
+      if (!username) {
+        throw new Error("[SDK][Account][Bookmarks] \u2013 no active user");
+      }
+      const fetchApi = getBoundFetch();
+      const response = await fetchApi(
+        CONFIG.privateApiHost + "/private-api/bookmarks-delete",
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            id: bookmarkId,
+            code: getAccessToken(username)
+          })
+        }
+      );
+      return response.json();
+    },
+    onSuccess: () => {
+      onSuccess();
+      getQueryClient().invalidateQueries({
+        queryKey: ["accounts", "bookmarks", username]
+      });
+    },
+    onError
+  });
+}
+function useAccountFavouriteAdd(username, onSuccess, onError) {
+  return useMutation({
+    mutationKey: ["accounts", "favourites", "add", username],
+    mutationFn: async (account) => {
+      if (!username) {
+        throw new Error("[SDK][Account][Bookmarks] \u2013 no active user");
+      }
+      const fetchApi = getBoundFetch();
+      const response = await fetchApi(
+        CONFIG.privateApiHost + "/private-api/favorites-add",
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            account,
+            code: getAccessToken(username)
+          })
+        }
+      );
+      return response.json();
+    },
+    onSuccess: () => {
+      onSuccess();
+      getQueryClient().invalidateQueries({
+        queryKey: ["accounts", "favourites", username]
+      });
+    },
+    onError
+  });
+}
+function useAccountFavouriteDelete(username, onSuccess, onError) {
+  return useMutation({
+    mutationKey: ["accounts", "favourites", "add", username],
+    mutationFn: async (account) => {
+      if (!username) {
+        throw new Error("[SDK][Account][Bookmarks] \u2013 no active user");
+      }
+      const fetchApi = getBoundFetch();
+      const response = await fetchApi(
+        CONFIG.privateApiHost + "/private-api/favorites-delete",
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            account,
+            code: getAccessToken(username)
+          })
+        }
+      );
+      return response.json();
+    },
+    onSuccess: () => {
+      onSuccess();
+      getQueryClient().invalidateQueries({
+        queryKey: ["accounts", "favourites", username]
+      });
+    },
+    onError
+  });
+}
+function dedupeAndSortKeyAuths(existing, additions) {
+  const merged = /* @__PURE__ */ new Map();
+  existing.forEach(([key, weight]) => {
+    merged.set(key.toString(), weight);
+  });
+  additions.forEach(([key, weight]) => {
+    merged.set(key.toString(), weight);
+  });
+  return Array.from(merged.entries()).sort(([keyA], [keyB]) => keyA.localeCompare(keyB)).map(([key, weight]) => [key, weight]);
+}
+function useAccountUpdateKeyAuths(username, options) {
+  const { data: accountData } = useQuery(getAccountFullQueryOptions(username));
+  return useMutation({
+    mutationKey: ["accounts", "keys-update", username],
+    mutationFn: async ({ keys, keepCurrent = false, currentKey }) => {
+      if (!accountData) {
+        throw new Error(
+          "[SDK][Update password] \u2013 cannot update keys for anon user"
+        );
+      }
+      const prepareAuth = (keyName) => {
+        const auth = R4.clone(accountData[keyName]);
+        auth.key_auths = dedupeAndSortKeyAuths(
+          keepCurrent ? auth.key_auths : [],
+          keys.map(
+            (values, i) => [values[keyName].createPublic().toString(), i + 1]
+          )
+        );
+        return auth;
+      };
+      return CONFIG.hiveClient.broadcast.updateAccount(
+        {
+          account: username,
+          json_metadata: accountData.json_metadata,
+          owner: prepareAuth("owner"),
+          active: prepareAuth("active"),
+          posting: prepareAuth("posting"),
+          memo_key: keepCurrent ? accountData.memo_key : keys[0].memo_key.createPublic().toString()
+        },
+        currentKey
+      );
+    },
+    ...options
+  });
+}
+function useAccountUpdatePassword(username, options) {
+  const { data: accountData } = useQuery(getAccountFullQueryOptions(username));
+  const { mutateAsync: updateKeys } = useAccountUpdateKeyAuths(username);
+  return useMutation({
     mutationKey: ["accounts", "password-update", username],
     mutationFn: async ({
       newPassword,
@@ -1003,745 +2297,1585 @@ function useAccountUpdatePassword(username, options) {
     }) => {
       if (!accountData) {
         throw new Error(
-          "[SDK][Update password] \u2013 cannot update password for anon user"
+          "[SDK][Update password] \u2013 cannot update password for anon user"
+        );
+      }
+      const currentKey = PrivateKey.fromLogin(
+        username,
+        currentPassword,
+        "owner"
+      );
+      return updateKeys({
+        currentKey,
+        keepCurrent,
+        keys: [
+          {
+            owner: PrivateKey.fromLogin(username, newPassword, "owner"),
+            active: PrivateKey.fromLogin(username, newPassword, "active"),
+            posting: PrivateKey.fromLogin(username, newPassword, "posting"),
+            memo_key: PrivateKey.fromLogin(username, newPassword, "memo")
+          }
+        ]
+      });
+    },
+    ...options
+  });
+}
+function useAccountRevokePosting(username, options) {
+  const queryClient = useQueryClient();
+  const { data } = useQuery(getAccountFullQueryOptions(username));
+  return useMutation({
+    mutationKey: ["accounts", "revoke-posting", data?.name],
+    mutationFn: async ({ accountName, type, key }) => {
+      if (!data) {
+        throw new Error(
+          "[SDK][Accounts] \u2013\xA0cannot revoke posting for anonymous user"
+        );
+      }
+      const posting = R4.pipe(
+        {},
+        R4.mergeDeep(data.posting)
+      );
+      posting.account_auths = posting.account_auths.filter(
+        ([account]) => account !== accountName
+      );
+      const operationBody = {
+        account: data.name,
+        posting,
+        memo_key: data.memo_key,
+        json_metadata: data.json_metadata
+      };
+      if (type === "key" && key) {
+        return CONFIG.hiveClient.broadcast.updateAccount(operationBody, key);
+      } else if (type === "keychain") {
+        return keychain_exports.broadcast(
+          data.name,
+          [["account_update", operationBody]],
+          "Active"
+        );
+      } else {
+        const params = {
+          callback: `https://ecency.com/@${data.name}/permissions`
+        };
+        return hs.sendOperation(
+          ["account_update", operationBody],
+          params,
+          () => {
+          }
+        );
+      }
+    },
+    onError: options.onError,
+    onSuccess: (resp, payload, ctx) => {
+      options.onSuccess?.(resp, payload, ctx);
+      queryClient.setQueryData(
+        getAccountFullQueryOptions(username).queryKey,
+        (data2) => ({
+          ...data2,
+          posting: {
+            ...data2?.posting,
+            account_auths: data2?.posting?.account_auths?.filter(
+              ([account]) => account !== payload.accountName
+            ) ?? []
+          }
+        })
+      );
+    }
+  });
+}
+function useAccountUpdateRecovery(username, options) {
+  const { data } = useQuery(getAccountFullQueryOptions(username));
+  return useMutation({
+    mutationKey: ["accounts", "recovery", data?.name],
+    mutationFn: async ({ accountName, type, key, email }) => {
+      if (!data) {
+        throw new Error(
+          "[SDK][Accounts] \u2013\xA0cannot change recovery for anonymous user"
+        );
+      }
+      const operationBody = {
+        account_to_recover: data.name,
+        new_recovery_account: accountName,
+        extensions: []
+      };
+      if (type === "ecency") {
+        const fetchApi = getBoundFetch();
+        return fetchApi(CONFIG.privateApiHost + "/private-api/recoveries-add", {
+          method: "POST",
+          body: JSON.stringify({
+            code: getAccessToken(data.name),
+            email,
+            publicKeys: [
+              ...data.owner.key_auths,
+              ...data.active.key_auths,
+              ...data.posting.key_auths,
+              data.memo_key
+            ]
+          })
+        });
+      } else if (type === "key" && key) {
+        return CONFIG.hiveClient.broadcast.sendOperations(
+          [["change_recovery_account", operationBody]],
+          key
+        );
+      } else if (type === "keychain") {
+        return keychain_exports.broadcast(
+          data.name,
+          [["change_recovery_account", operationBody]],
+          "Active"
+        );
+      } else {
+        const params = {
+          callback: `https://ecency.com/@${data.name}/permissions`
+        };
+        return hs.sendOperation(
+          ["change_recovery_account", operationBody],
+          params,
+          () => {
+          }
+        );
+      }
+    },
+    onError: options.onError,
+    onSuccess: options.onSuccess
+  });
+}
+function useAccountRevokeKey(username, options) {
+  const { data: accountData } = useQuery(getAccountFullQueryOptions(username));
+  return useMutation({
+    mutationKey: ["accounts", "revoke-key", accountData?.name],
+    mutationFn: async ({ currentKey, revokingKey }) => {
+      if (!accountData) {
+        throw new Error(
+          "[SDK][Update password] \u2013 cannot update keys for anon user"
+        );
+      }
+      const prepareAuth = (keyName) => {
+        const auth = R4.clone(accountData[keyName]);
+        auth.key_auths = auth.key_auths.filter(
+          ([key]) => key !== revokingKey.toString()
+        );
+        return auth;
+      };
+      return CONFIG.hiveClient.broadcast.updateAccount(
+        {
+          account: accountData.name,
+          json_metadata: accountData.json_metadata,
+          owner: prepareAuth("owner"),
+          active: prepareAuth("active"),
+          posting: prepareAuth("posting"),
+          memo_key: accountData.memo_key
+        },
+        currentKey
+      );
+    },
+    ...options
+  });
+}
+function useSignOperationByKey(username) {
+  return useMutation({
+    mutationKey: ["operations", "sign", username],
+    mutationFn: ({
+      operation,
+      keyOrSeed
+    }) => {
+      if (!username) {
+        throw new Error("[Operations][Sign] \u2013 cannot sign op with anon user");
+      }
+      let privateKey;
+      if (keyOrSeed.split(" ").length === 12) {
+        privateKey = PrivateKey.fromLogin(username, keyOrSeed, "active");
+      } else if (cryptoUtils.isWif(keyOrSeed)) {
+        privateKey = PrivateKey.fromString(keyOrSeed);
+      } else {
+        privateKey = PrivateKey.from(keyOrSeed);
+      }
+      return CONFIG.hiveClient.broadcast.sendOperations(
+        [operation],
+        privateKey
+      );
+    }
+  });
+}
+function useSignOperationByKeychain(username, keyType = "Active") {
+  return useMutation({
+    mutationKey: ["operations", "sign-keychain", username],
+    mutationFn: ({ operation }) => {
+      if (!username) {
+        throw new Error(
+          "[SDK][Keychain] \u2013\xA0cannot sign operation with anon user"
         );
       }
-      const currentKey = PrivateKey.fromLogin(
-        username,
-        currentPassword,
-        "owner"
+      return keychain_exports.broadcast(username, [operation], keyType);
+    }
+  });
+}
+function useSignOperationByHivesigner(callbackUri = "/") {
+  return useMutation({
+    mutationKey: ["operations", "sign-hivesigner", callbackUri],
+    mutationFn: async ({ operation }) => {
+      return hs.sendOperation(operation, { callback: callbackUri }, () => {
+      });
+    }
+  });
+}
+function getChainPropertiesQueryOptions() {
+  return queryOptions({
+    queryKey: ["operations", "chain-properties"],
+    queryFn: async () => {
+      return await CONFIG.hiveClient.database.getChainProperties();
+    }
+  });
+}
+function useAddFragment(username) {
+  return useMutation({
+    mutationKey: ["posts", "add-fragment", username],
+    mutationFn: async ({ title, body }) => {
+      const fetchApi = getBoundFetch();
+      const response = await fetchApi(
+        CONFIG.privateApiHost + "/private-api/fragments-add",
+        {
+          method: "POST",
+          body: JSON.stringify({
+            code: getAccessToken(username),
+            title,
+            body
+          }),
+          headers: {
+            "Content-Type": "application/json"
+          }
+        }
       );
-      return updateKeys({
-        currentKey,
-        keepCurrent,
-        keys: [
-          {
-            owner: PrivateKey.fromLogin(username, newPassword, "owner"),
-            active: PrivateKey.fromLogin(username, newPassword, "active"),
-            posting: PrivateKey.fromLogin(username, newPassword, "posting"),
-            memo_key: PrivateKey.fromLogin(username, newPassword, "memo")
+      return response.json();
+    },
+    onSuccess(response) {
+      getQueryClient().setQueryData(
+        getFragmentsQueryOptions(username).queryKey,
+        (data) => [response, ...data ?? []]
+      );
+    }
+  });
+}
+function useEditFragment(username, fragmentId) {
+  return useMutation({
+    mutationKey: ["posts", "edit-fragment", username, fragmentId],
+    mutationFn: async ({ title, body }) => {
+      const fetchApi = getBoundFetch();
+      const response = await fetchApi(
+        CONFIG.privateApiHost + "/private-api/fragments-update",
+        {
+          method: "POST",
+          body: JSON.stringify({
+            code: getAccessToken(username),
+            id: fragmentId,
+            title,
+            body
+          }),
+          headers: {
+            "Content-Type": "application/json"
           }
-        ]
+        }
+      );
+      return response.json();
+    },
+    onSuccess(response) {
+      getQueryClient().setQueryData(
+        getFragmentsQueryOptions(username).queryKey,
+        (data) => {
+          if (!data) {
+            return [];
+          }
+          const index = data.findIndex(({ id }) => id === fragmentId);
+          if (index >= 0) {
+            data[index] = response;
+          }
+          return [...data];
+        }
+      );
+    }
+  });
+}
+function useRemoveFragment(username, fragmentId) {
+  return useMutation({
+    mutationKey: ["posts", "remove-fragment", username],
+    mutationFn: async () => {
+      const fetchApi = getBoundFetch();
+      return fetchApi(CONFIG.privateApiHost + "/private-api/fragments-delete", {
+        method: "POST",
+        body: JSON.stringify({
+          code: getAccessToken(username),
+          id: fragmentId
+        }),
+        headers: {
+          "Content-Type": "application/json"
+        }
       });
     },
-    ...options
+    onSuccess() {
+      getQueryClient().setQueryData(
+        getFragmentsQueryOptions(username).queryKey,
+        (data) => [...data ?? []].filter(({ id }) => id !== fragmentId)
+      );
+    }
+  });
+}
+
+// src/modules/analytics/mutations/index.ts
+var mutations_exports = {};
+__export(mutations_exports, {
+  useRecordActivity: () => useRecordActivity
+});
+function useRecordActivity(username, activityType) {
+  return useMutation({
+    mutationKey: ["analytics", activityType],
+    mutationFn: async () => {
+      if (!activityType) {
+        throw new Error("[SDK][Analytics] \u2013 no activity type provided");
+      }
+      const fetchApi = getBoundFetch();
+      await fetchApi(CONFIG.plausibleHost + "/api/event", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          name: activityType,
+          url: window.location.href,
+          domain: window.location.host,
+          props: {
+            username
+          }
+        })
+      });
+    }
+  });
+}
+function getDiscoverLeaderboardQueryOptions(duration) {
+  return 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 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 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) {
+  return queryOptions({
+    queryKey: ["integrations", "hivesigner", "decode-memo", username],
+    queryFn: async () => {
+      const accessToken = getAccessToken(username);
+      if (accessToken) {
+        const hsClient = new hs.Client({
+          accessToken
+        });
+        return hsClient.decode(memo);
+      }
+    }
+  });
+}
+
+// src/modules/integrations/hivesigner/index.ts
+var HiveSignerIntegration = {
+  queries: queries_exports
+};
+
+// src/modules/integrations/3speak/queries/get-account-token-query-options.ts
+function getAccountTokenQueryOptions(username) {
+  return queryOptions({
+    queryKey: ["integrations", "3speak", "authenticate", username],
+    enabled: !!username,
+    queryFn: async () => {
+      if (!username) {
+        throw new Error("[SDK][Integrations][3Speak] \u2013\xA0anon user");
+      }
+      const fetchApi = getBoundFetch();
+      const response = await fetchApi(
+        `https://studio.3speak.tv/mobile/login?username=${username}&hivesigner=true`,
+        {
+          headers: {
+            "Content-Type": "application/json"
+          }
+        }
+      );
+      const memoQueryOptions = HiveSignerIntegration.queries.getDecodeMemoQueryOptions(
+        username,
+        (await response.json()).memo
+      );
+      await getQueryClient().prefetchQuery(memoQueryOptions);
+      const { memoDecoded } = getQueryClient().getQueryData(
+        memoQueryOptions.queryKey
+      );
+      return memoDecoded.replace("#", "");
+    }
   });
 }
-function useAccountRevokePosting(username, options) {
-  const queryClient = useQueryClient();
-  const { data } = useQuery(getAccountFullQueryOptions(username));
-  return useMutation({
-    mutationKey: ["accounts", "revoke-posting", data?.name],
-    mutationFn: async ({ accountName, type, key }) => {
-      if (!data) {
-        throw new Error(
-          "[SDK][Accounts] \u2013\xA0cannot revoke posting for anonymous user"
-        );
-      }
-      const posting = R4.pipe(
-        {},
-        R4.mergeDeep(data.posting)
+function getAccountVideosQueryOptions(username) {
+  return queryOptions({
+    queryKey: ["integrations", "3speak", "videos", username],
+    enabled: !!username,
+    queryFn: async () => {
+      await getQueryClient().prefetchQuery(
+        getAccountTokenQueryOptions(username)
       );
-      posting.account_auths = posting.account_auths.filter(
-        ([account]) => account !== accountName
+      const token = getQueryClient().getQueryData(
+        getAccountTokenQueryOptions(username).queryKey
       );
-      const operationBody = {
-        account: data.name,
-        posting,
-        memo_key: data.memo_key,
-        json_metadata: data.json_metadata
-      };
-      if (type === "key" && key) {
-        return CONFIG.hiveClient.broadcast.updateAccount(operationBody, key);
-      } else if (type === "keychain") {
-        return keychain_exports.broadcast(
-          data.name,
-          [["account_update", operationBody]],
-          "Active"
-        );
-      } else {
-        const params = {
-          callback: `https://ecency.com/@${data.name}/permissions`
-        };
-        return hs.sendOperation(
-          ["account_update", operationBody],
-          params,
-          () => {
-          }
-        );
-      }
-    },
-    onError: options.onError,
-    onSuccess: (resp, payload, ctx) => {
-      options.onSuccess?.(resp, payload, ctx);
-      queryClient.setQueryData(
-        getAccountFullQueryOptions(username).queryKey,
-        (data2) => ({
-          ...data2,
-          posting: {
-            ...data2?.posting,
-            account_auths: data2?.posting?.account_auths?.filter(
-              ([account]) => account !== payload.accountName
-            ) ?? []
+      const fetchApi = getBoundFetch();
+      const response = await fetchApi(
+        `https://studio.3speak.tv/mobile/api/my-videos`,
+        {
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`
           }
-        })
+        }
       );
+      return await response.json();
     }
   });
 }
-function useAccountUpdateRecovery(username, options) {
-  const { data } = useQuery(getAccountFullQueryOptions(username));
-  return useMutation({
-    mutationKey: ["accounts", "recovery", data?.name],
-    mutationFn: async ({ accountName, type, key, email }) => {
-      if (!data) {
-        throw new Error(
-          "[SDK][Accounts] \u2013\xA0cannot change recovery for anonymous user"
-        );
-      }
-      const operationBody = {
-        account_to_recover: data.name,
-        new_recovery_account: accountName,
-        extensions: []
-      };
-      if (type === "ecency") {
+
+// src/modules/integrations/3speak/index.ts
+var ThreeSpeakIntegration = {
+  queries: queries_exports2
+};
+function getHivePoshLinksQueryOptions(username) {
+  return queryOptions({
+    queryKey: ["integrations", "hiveposh", "links", username],
+    retry: false,
+    // Don't retry on user not found errors
+    queryFn: async () => {
+      try {
         const fetchApi = getBoundFetch();
-        return fetchApi(CONFIG.privateApiHost + "/private-api/recoveries-add", {
-          method: "POST",
-          body: JSON.stringify({
-            code: getAccessToken(data.name),
-            email,
-            publicKeys: [
-              ...data.owner.key_auths,
-              ...data.active.key_auths,
-              ...data.posting.key_auths,
-              data.memo_key
-            ]
-          })
-        });
-      } else if (type === "key" && key) {
-        return CONFIG.hiveClient.broadcast.sendOperations(
-          [["change_recovery_account", operationBody]],
-          key
-        );
-      } else if (type === "keychain") {
-        return keychain_exports.broadcast(
-          data.name,
-          [["change_recovery_account", operationBody]],
-          "Active"
-        );
-      } else {
-        const params = {
-          callback: `https://ecency.com/@${data.name}/permissions`
-        };
-        return hs.sendOperation(
-          ["change_recovery_account", operationBody],
-          params,
-          () => {
+        const response = await fetchApi(
+          `https://hiveposh.com/api/v0/linked-accounts/${username}`,
+          {
+            headers: {
+              "Content-Type": "application/json"
+            }
           }
         );
+        if (response.status === 400) {
+          const errorData = await response.json().catch(() => ({}));
+          if (errorData?.message === "User Not Connected") {
+            return null;
+          }
+        }
+        if (!response.ok) {
+          return null;
+        }
+        const data = await response.json();
+        return {
+          twitter: {
+            username: data.twitter_username,
+            profile: data.twitter_profile
+          },
+          reddit: {
+            username: data.reddit_username,
+            profile: data.reddit_profile
+          }
+        };
+      } catch (err) {
+        return null;
       }
+    }
+  });
+}
+function getStatsQueryOptions({
+  url,
+  dimensions = [],
+  metrics = ["visitors", "pageviews", "visit_duration"],
+  enabled = true
+}) {
+  return queryOptions({
+    queryKey: ["integrations", "plausible", url, dimensions, metrics],
+    queryFn: async () => {
+      const fetchApi = getBoundFetch();
+      const response = await fetchApi(`https://ecency.com/api/stats`, {
+        method: "POST",
+        body: JSON.stringify({
+          metrics,
+          url: encodeURIComponent(url),
+          dimensions
+        }),
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+      return await response.json();
     },
-    onError: options.onError,
-    onSuccess: options.onSuccess
+    enabled: !!url && enabled
   });
 }
-function useAccountRevokeKey(username, options) {
-  const { data: accountData } = useQuery(getAccountFullQueryOptions(username));
-  return useMutation({
-    mutationKey: ["accounts", "revoke-key", accountData?.name],
-    mutationFn: async ({ currentKey, revokingKey }) => {
-      if (!accountData) {
-        throw new Error(
-          "[SDK][Update password] \u2013 cannot update keys for anon user"
-        );
-      }
-      const prepareAuth = (keyName) => {
-        const auth = R4.clone(accountData[keyName]);
-        auth.key_auths = auth.key_auths.filter(
-          ([key]) => key !== revokingKey.toString()
-        );
-        return auth;
-      };
-      return CONFIG.hiveClient.broadcast.updateAccount(
-        {
-          account: accountData.name,
-          json_metadata: accountData.json_metadata,
-          owner: prepareAuth("owner"),
-          active: prepareAuth("active"),
-          posting: prepareAuth("posting"),
-          memo_key: accountData.memo_key
-        },
-        currentKey
+function getRcStatsQueryOptions() {
+  return queryOptions({
+    queryKey: ["resource-credits", "stats"],
+    queryFn: async () => {
+      const response = await CONFIG.hiveClient.call(
+        "rc_api",
+        "get_rc_stats",
+        {}
       );
+      return response.rc_stats;
+    }
+  });
+}
+function getAccountRcQueryOptions(username) {
+  return queryOptions({
+    queryKey: ["resource-credits", "account", username],
+    queryFn: async () => {
+      const rcClient = new RCAPI(CONFIG.hiveClient);
+      return rcClient.findRCAccounts([username]);
     },
-    ...options
+    enabled: !!username
   });
 }
-function useSignOperationByKey(username) {
-  return useMutation({
-    mutationKey: ["operations", "sign", username],
-    mutationFn: ({
-      operation,
-      keyOrSeed
-    }) => {
+function getGameStatusCheckQueryOptions(username, gameType) {
+  return queryOptions({
+    queryKey: ["games", "status-check", gameType, username],
+    enabled: !!username,
+    queryFn: async () => {
       if (!username) {
-        throw new Error("[Operations][Sign] \u2013 cannot sign op with anon user");
-      }
-      let privateKey;
-      if (keyOrSeed.split(" ").length === 12) {
-        privateKey = PrivateKey.fromLogin(username, keyOrSeed, "active");
-      } else if (cryptoUtils.isWif(keyOrSeed)) {
-        privateKey = PrivateKey.fromString(keyOrSeed);
-      } else {
-        privateKey = PrivateKey.from(keyOrSeed);
+        throw new Error("[SDK][Games] \u2013 anon user in status check");
       }
-      return CONFIG.hiveClient.broadcast.sendOperations(
-        [operation],
-        privateKey
+      const fetchApi = getBoundFetch();
+      const response = await fetchApi(
+        CONFIG.privateApiHost + "/private-api/get-game",
+        {
+          method: "POST",
+          body: JSON.stringify({
+            game_type: gameType,
+            code: getAccessToken(username)
+          }),
+          headers: {
+            "Content-Type": "application/json"
+          }
+        }
       );
+      return await response.json();
     }
   });
 }
-function useSignOperationByKeychain(username, keyType = "Active") {
+function useGameClaim(username, gameType, key) {
+  const { mutateAsync: recordActivity } = useRecordActivity(
+    username,
+    "spin-rolled"
+  );
   return useMutation({
-    mutationKey: ["operations", "sign-keychain", username],
-    mutationFn: ({ operation }) => {
+    mutationKey: ["games", "post", gameType, username],
+    mutationFn: async () => {
       if (!username) {
-        throw new Error(
-          "[SDK][Keychain] \u2013\xA0cannot sign operation with anon user"
-        );
+        throw new Error("[SDK][Games] \u2013 anon user in game post");
       }
-      return keychain_exports.broadcast(username, [operation], keyType);
+      const fetchApi = getBoundFetch();
+      const response = await fetchApi(
+        CONFIG.privateApiHost + "/private-api/post-game",
+        {
+          method: "POST",
+          body: JSON.stringify({
+            game_type: gameType,
+            code: getAccessToken(username),
+            key
+          }),
+          headers: {
+            "Content-Type": "application/json"
+          }
+        }
+      );
+      return await response.json();
+    },
+    onSuccess() {
+      recordActivity();
     }
   });
 }
-function useSignOperationByHivesigner(callbackUri = "/") {
-  return useMutation({
-    mutationKey: ["operations", "sign-hivesigner", callbackUri],
-    mutationFn: async ({ operation }) => {
-      return hs.sendOperation(operation, { callback: callbackUri }, () => {
-      });
+function getCommunitiesQueryOptions(sort, query, limit = 100, observer = void 0, enabled = true) {
+  return queryOptions({
+    queryKey: ["communities", "list", sort, query, limit],
+    enabled,
+    queryFn: async () => {
+      const response = await CONFIG.hiveClient.call(
+        "bridge",
+        "list_communities",
+        {
+          last: "",
+          limit,
+          sort: sort === "hot" ? "rank" : sort,
+          query: query ? query : null,
+          observer
+        }
+      );
+      return response ? sort === "hot" ? response.sort(() => Math.random() - 0.5) : response : [];
     }
   });
 }
-function getChainPropertiesQueryOptions() {
+function getCommunityContextQueryOptions(username, communityName) {
   return queryOptions({
-    queryKey: ["operations", "chain-properties"],
+    queryKey: ["community", "context", username, communityName],
+    enabled: !!username && !!communityName,
     queryFn: async () => {
-      return await CONFIG.hiveClient.database.getChainProperties();
+      const response = await CONFIG.hiveClient.call(
+        "bridge",
+        "get_community_context",
+        {
+          account: username,
+          name: communityName
+        }
+      );
+      return {
+        role: response?.role ?? "guest",
+        subscribed: response?.subscribed ?? false
+      };
     }
   });
 }
-function getTrendingTagsQueryOptions(limit = 20) {
+function getCommunitySubscribersQueryOptions(communityName) {
+  return queryOptions({
+    queryKey: ["communities", "subscribers", communityName],
+    queryFn: async () => {
+      const response = await CONFIG.hiveClient.call("bridge", "list_subscribers", {
+        community: communityName
+      });
+      return response ?? [];
+    },
+    staleTime: 6e4
+  });
+}
+function getAccountNotificationsInfiniteQueryOptions(account, limit) {
   return infiniteQueryOptions({
-    queryKey: ["posts", "trending-tags"],
-    queryFn: async ({ pageParam: { afterTag } }) => CONFIG.hiveClient.database.call("get_trending_tags", [afterTag, limit]).then(
-      (tags) => tags.filter((x) => x.name !== "").filter((x) => !x.name.startsWith("hive-")).map((x) => x.name)
-    ),
-    initialPageParam: { afterTag: "" },
-    getNextPageParam: (lastPage) => ({
-      afterTag: lastPage?.[lastPage?.length - 1]
-    }),
-    staleTime: Infinity,
-    refetchOnMount: true
+    queryKey: ["communities", "account-notifications", account, limit],
+    initialPageParam: null,
+    queryFn: async ({ pageParam }) => {
+      try {
+        const response = await CONFIG.hiveClient.call("bridge", "account_notifications", {
+          account,
+          limit,
+          last_id: pageParam ?? void 0
+        });
+        return response ?? [];
+      } catch {
+        return [];
+      }
+    },
+    getNextPageParam: (lastPage) => lastPage?.length > 0 ? lastPage[lastPage.length - 1].id : null
   });
 }
-function getFragmentsQueryOptions(username) {
+function getRewardedCommunitiesQueryOptions() {
   return queryOptions({
-    queryKey: ["posts", "fragments", username],
+    queryKey: ["communities", "rewarded"],
     queryFn: async () => {
-      const fetchApi = getBoundFetch();
-      const response = await fetchApi(
-        CONFIG.privateApiHost + "/private-api/fragments",
+      const response = await fetch(
+        CONFIG.privateApiHost + "/private-api/rewarded-communities",
         {
-          method: "POST",
-          body: JSON.stringify({
-            code: getAccessToken(username)
-          }),
+          method: "GET",
           headers: {
             "Content-Type": "application/json"
           }
         }
       );
+      if (!response.ok) {
+        throw new Error(`Failed to fetch rewarded communities: ${response.status}`);
+      }
       return response.json();
-    },
-    enabled: !!username
+    }
   });
 }
-function getPromotedPostsQuery(type = "feed") {
-  return queryOptions({
-    queryKey: ["posts", "promoted", type],
-    queryFn: async () => {
-      const url = new URL(
-        CONFIG.privateApiHost + "/private-api/promoted-entries"
-      );
-      if (type === "waves") {
-        url.searchParams.append("short_content", "1");
-      }
-      const fetchApi = getBoundFetch();
-      const response = await fetchApi(url.toString(), {
-        method: "GET",
-        headers: {
-          "Content-Type": "application/json"
-        }
-      });
-      const data = await response.json();
-      return data;
+
+// src/modules/communities/types/community.ts
+var ROLES = /* @__PURE__ */ ((ROLES2) => {
+  ROLES2["OWNER"] = "owner";
+  ROLES2["ADMIN"] = "admin";
+  ROLES2["MOD"] = "mod";
+  ROLES2["MEMBER"] = "member";
+  ROLES2["GUEST"] = "guest";
+  ROLES2["MUTED"] = "muted";
+  return ROLES2;
+})(ROLES || {});
+var roleMap = {
+  ["owner" /* OWNER */]: [
+    "admin" /* ADMIN */,
+    "mod" /* MOD */,
+    "member" /* MEMBER */,
+    "guest" /* GUEST */,
+    "muted" /* MUTED */
+  ],
+  ["admin" /* ADMIN */]: ["mod" /* MOD */, "member" /* MEMBER */, "guest" /* GUEST */, "muted" /* MUTED */],
+  ["mod" /* MOD */]: ["member" /* MEMBER */, "guest" /* GUEST */, "muted" /* MUTED */]
+};
+
+// src/modules/communities/utils/index.ts
+function getCommunityType(name, type_id) {
+  if (name.startsWith("hive-3") || type_id === 3) return "Council";
+  if (name.startsWith("hive-2") || type_id === 2) return "Journal";
+  return "Topic";
+}
+function getCommunityPermissions({
+  communityType,
+  userRole,
+  subscribed
+}) {
+  const canPost = (() => {
+    if (userRole === "muted" /* MUTED */) return false;
+    if (communityType === "Topic") return true;
+    return ["owner" /* OWNER */, "admin" /* ADMIN */, "mod" /* MOD */, "member" /* MEMBER */].includes(
+      userRole
+    );
+  })();
+  const canComment = (() => {
+    if (userRole === "muted" /* MUTED */) return false;
+    switch (communityType) {
+      case "Topic":
+        return true;
+      case "Journal":
+        return userRole !== "guest" /* GUEST */ || subscribed;
+      case "Council":
+        return canPost;
     }
-  });
+  })();
+  const isModerator = ["owner" /* OWNER */, "admin" /* ADMIN */, "mod" /* MOD */].includes(userRole);
+  return {
+    canPost,
+    canComment,
+    isModerator
+  };
 }
-function useAddFragment(username) {
-  return useMutation({
-    mutationKey: ["posts", "add-fragment", username],
-    mutationFn: async ({ title, body }) => {
-      const fetchApi = getBoundFetch();
-      const response = await fetchApi(
-        CONFIG.privateApiHost + "/private-api/fragments-add",
+function getNotificationsUnreadCountQueryOptions(activeUsername) {
+  return queryOptions({
+    queryKey: ["notifications", "unread", activeUsername],
+    queryFn: async () => {
+      const response = await fetch(
+        `${CONFIG.privateApiHost}/private-api/notifications/unread`,
         {
           method: "POST",
-          body: JSON.stringify({
-            code: getAccessToken(username),
-            title,
-            body
-          }),
+          body: JSON.stringify({ code: getAccessToken(activeUsername) }),
           headers: {
             "Content-Type": "application/json"
           }
         }
       );
-      return response.json();
+      const data = await response.json();
+      return data.count;
     },
-    onSuccess(response) {
-      getQueryClient().setQueryData(
-        getFragmentsQueryOptions(username).queryKey,
-        (data) => [response, ...data ?? []]
-      );
-    }
+    enabled: !!activeUsername,
+    initialData: 0,
+    refetchInterval: 6e4
   });
 }
-function useEditFragment(username, fragmentId) {
-  return useMutation({
-    mutationKey: ["posts", "edit-fragment", username, fragmentId],
-    mutationFn: async ({ title, body }) => {
-      const fetchApi = getBoundFetch();
-      const response = await fetchApi(
-        CONFIG.privateApiHost + "/private-api/fragments-update",
+function getNotificationsInfiniteQueryOptions(activeUsername, filter = void 0) {
+  return infiniteQueryOptions({
+    queryKey: ["notifications", activeUsername, filter],
+    queryFn: async ({ pageParam }) => {
+      const data = {
+        code: getAccessToken(activeUsername),
+        filter,
+        since: pageParam,
+        user: void 0
+      };
+      const response = await fetch(
+        CONFIG.privateApiHost + "/private-api/notifications",
         {
           method: "POST",
-          body: JSON.stringify({
-            code: getAccessToken(username),
-            id: fragmentId,
-            title,
-            body
-          }),
           headers: {
             "Content-Type": "application/json"
-          }
+          },
+          body: JSON.stringify(data)
         }
       );
       return response.json();
     },
-    onSuccess(response) {
-      getQueryClient().setQueryData(
-        getFragmentsQueryOptions(username).queryKey,
-        (data) => {
-          if (!data) {
-            return [];
-          }
-          const index = data.findIndex(({ id }) => id === fragmentId);
-          if (index >= 0) {
-            data[index] = response;
+    enabled: !!activeUsername,
+    initialData: { pages: [], pageParams: [] },
+    initialPageParam: "",
+    getNextPageParam: (lastPage) => lastPage?.[lastPage.length - 1]?.id ?? "",
+    refetchOnMount: true
+  });
+}
+
+// src/modules/notifications/enums/notification-filter.ts
+var NotificationFilter = /* @__PURE__ */ ((NotificationFilter2) => {
+  NotificationFilter2["VOTES"] = "rvotes";
+  NotificationFilter2["MENTIONS"] = "mentions";
+  NotificationFilter2["FAVORITES"] = "nfavorites";
+  NotificationFilter2["BOOKMARKS"] = "nbookmarks";
+  NotificationFilter2["FOLLOWS"] = "follows";
+  NotificationFilter2["REPLIES"] = "replies";
+  NotificationFilter2["REBLOGS"] = "reblogs";
+  NotificationFilter2["TRANSFERS"] = "transfers";
+  NotificationFilter2["DELEGATIONS"] = "delegations";
+  return NotificationFilter2;
+})(NotificationFilter || {});
+
+// src/modules/notifications/enums/notify-types.ts
+var NotifyTypes = /* @__PURE__ */ ((NotifyTypes2) => {
+  NotifyTypes2[NotifyTypes2["VOTE"] = 1] = "VOTE";
+  NotifyTypes2[NotifyTypes2["MENTION"] = 2] = "MENTION";
+  NotifyTypes2[NotifyTypes2["FOLLOW"] = 3] = "FOLLOW";
+  NotifyTypes2[NotifyTypes2["COMMENT"] = 4] = "COMMENT";
+  NotifyTypes2[NotifyTypes2["RE_BLOG"] = 5] = "RE_BLOG";
+  NotifyTypes2[NotifyTypes2["TRANSFERS"] = 6] = "TRANSFERS";
+  NotifyTypes2[NotifyTypes2["FAVORITES"] = 13] = "FAVORITES";
+  NotifyTypes2[NotifyTypes2["BOOKMARKS"] = 15] = "BOOKMARKS";
+  NotifyTypes2["ALLOW_NOTIFY"] = "ALLOW_NOTIFY";
+  return NotifyTypes2;
+})(NotifyTypes || {});
+var ALL_NOTIFY_TYPES = [
+  1 /* VOTE */,
+  2 /* MENTION */,
+  3 /* FOLLOW */,
+  4 /* COMMENT */,
+  5 /* RE_BLOG */,
+  6 /* TRANSFERS */,
+  13 /* FAVORITES */,
+  15 /* BOOKMARKS */
+];
+var NotificationViewType = /* @__PURE__ */ ((NotificationViewType2) => {
+  NotificationViewType2["ALL"] = "All";
+  NotificationViewType2["UNREAD"] = "Unread";
+  NotificationViewType2["READ"] = "Read";
+  return NotificationViewType2;
+})(NotificationViewType || {});
+
+// src/modules/notifications/queries/get-notifications-settings-query-options.ts
+function getNotificationsSettingsQueryOptions(activeUsername) {
+  return queryOptions({
+    queryKey: ["notifications", "settings", activeUsername],
+    queryFn: async () => {
+      let token = activeUsername + "-web";
+      const response = await fetch(
+        CONFIG.privateApiHost + "/private-api/detail-device",
+        {
+          body: JSON.stringify({
+            code: getAccessToken(activeUsername),
+            username: activeUsername,
+            token
+          }),
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
           }
-          return [...data];
         }
       );
+      if (!response.ok) {
+        throw new Error(`Failed to fetch notification settings: ${response.status}`);
+      }
+      return response.json();
+    },
+    enabled: !!activeUsername,
+    refetchOnMount: false,
+    initialData: () => {
+      const wasMutedPreviously = typeof window !== "undefined" ? localStorage.getItem("notifications") !== "true" : false;
+      return {
+        status: 0,
+        system: "web",
+        allows_notify: 0,
+        notify_types: wasMutedPreviously ? [] : [
+          4 /* COMMENT */,
+          3 /* FOLLOW */,
+          2 /* MENTION */,
+          13 /* FAVORITES */,
+          15 /* BOOKMARKS */,
+          1 /* VOTE */,
+          5 /* RE_BLOG */,
+          6 /* TRANSFERS */
+        ]
+      };
     }
   });
 }
-function useRemoveFragment(username, fragmentId) {
-  return useMutation({
-    mutationKey: ["posts", "remove-fragment", username],
-    mutationFn: async () => {
-      const fetchApi = getBoundFetch();
-      return fetchApi(CONFIG.privateApiHost + "/private-api/fragments-delete", {
-        method: "POST",
-        body: JSON.stringify({
-          code: getAccessToken(username),
-          id: fragmentId
-        }),
+function getAnnouncementsQueryOptions() {
+  return queryOptions({
+    queryKey: ["notifications", "announcements"],
+    queryFn: async () => {
+      const response = await fetch(CONFIG.privateApiHost + "/private-api/announcements", {
+        method: "GET",
         headers: {
           "Content-Type": "application/json"
         }
       });
+      if (!response.ok) {
+        throw new Error(`Failed to fetch announcements: ${response.status}`);
+      }
+      const data = await response.json();
+      return data || [];
     },
-    onSuccess() {
-      getQueryClient().setQueryData(
-        getFragmentsQueryOptions(username).queryKey,
-        (data) => [...data ?? []].filter(({ id }) => id !== fragmentId)
-      );
-    }
+    staleTime: 36e5
   });
 }
-
-// src/modules/analytics/mutations/index.ts
-var mutations_exports = {};
-__export(mutations_exports, {
-  useRecordActivity: () => useRecordActivity
-});
-function useRecordActivity(username, activityType) {
-  return useMutation({
-    mutationKey: ["analytics", activityType],
-    mutationFn: async () => {
-      if (!activityType) {
-        throw new Error("[SDK][Analytics] \u2013 no activity type provided");
+function getProposalQueryOptions(id) {
+  return queryOptions({
+    queryKey: ["proposals", "proposal", id],
+    queryFn: async () => {
+      const r = await CONFIG.hiveClient.call("condenser_api", "find_proposals", [[id]]);
+      const proposal = r[0];
+      if (new Date(proposal.start_date) < /* @__PURE__ */ new Date() && new Date(proposal.end_date) >= /* @__PURE__ */ new Date()) {
+        proposal.status = "active";
+      } else if (new Date(proposal.end_date) < /* @__PURE__ */ new Date()) {
+        proposal.status = "expired";
+      } else {
+        proposal.status = "inactive";
       }
-      const fetchApi = getBoundFetch();
-      await fetchApi(CONFIG.plausibleHost + "/api/event", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          name: activityType,
-          url: window.location.href,
-          domain: window.location.host,
-          props: {
-            username
-          }
-        })
+      return proposal;
+    }
+  });
+}
+function getProposalsQueryOptions() {
+  return queryOptions({
+    queryKey: ["proposals", "list"],
+    queryFn: async () => {
+      const response = await CONFIG.hiveClient.call("database_api", "list_proposals", {
+        start: [-1],
+        limit: 500,
+        order: "by_total_votes",
+        order_direction: "descending",
+        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];
     }
   });
 }
-
-// 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) {
+function getProposalVotesInfiniteQueryOptions(proposalId, voter, limit) {
+  return 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 queryOptions({
-    queryKey: ["integrations", "hivesigner", "decode-memo", username],
+    queryKey: ["proposals", "votes", "by-user", voter],
+    enabled: !!voter && voter !== "",
+    staleTime: 60 * 1e3,
+    // Cache for 1 minute
     queryFn: async () => {
-      const accessToken = getAccessToken(username);
-      if (accessToken) {
-        const hsClient = new hs.Client({
-          accessToken
-        });
-        return hsClient.decode(memo);
+      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;
     }
   });
 }
-
-// src/modules/integrations/hivesigner/index.ts
-var HiveSignerIntegration = {
-  queries: queries_exports
-};
-
-// src/modules/integrations/3speak/queries/get-account-token-query-options.ts
-function getAccountTokenQueryOptions(username) {
+function getVestingDelegationsQueryOptions(username, from, limit = 50) {
   return queryOptions({
-    queryKey: ["integrations", "3speak", "authenticate", username],
-    enabled: !!username,
-    queryFn: async () => {
-      if (!username) {
-        throw new Error("[SDK][Integrations][3Speak] \u2013\xA0anon user");
+    queryKey: ["wallet", "vesting-delegations", username, from, limit],
+    queryFn: () => CONFIG.hiveClient.database.call("get_vesting_delegations", [
+      username,
+      from,
+      limit
+    ]),
+    enabled: !!username
+  });
+}
+function getConversionRequestsQueryOptions(account) {
+  return 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 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 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 queryOptions({
+    queryKey: ["wallet", "withdraw-routes", account],
+    queryFn: () => CONFIG.hiveClient.database.call("get_withdraw_routes", [
+      account,
+      "outgoing"
+    ])
+  });
+}
+function getOpenOrdersQueryOptions(user) {
+  return 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 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);
       }
-      const fetchApi = getBoundFetch();
-      const response = await fetchApi(
-        `https://studio.3speak.tv/mobile/login?username=${username}&hivesigner=true`,
-        {
-          headers: {
-            "Content-Type": "application/json"
-          }
-        }
-      );
-      const memoQueryOptions = HiveSignerIntegration.queries.getDecodeMemoQueryOptions(
-        username,
-        (await response.json()).memo
-      );
-      await getQueryClient().prefetchQuery(memoQueryOptions);
-      const { memoDecoded } = getQueryClient().getQueryData(
-        memoQueryOptions.queryKey
+      return delegations;
+    },
+    getNextPageParam: (lastPage) => lastPage.length === limit ? lastPage[lastPage.length - 1].to : null
+  });
+}
+function getReceivedVestingSharesQueryOptions(username) {
+  return queryOptions({
+    queryKey: ["wallet", "received-vesting-shares", username],
+    queryFn: async () => {
+      const response = await fetch(
+        CONFIG.privateApiHost + `/private-api/received-vesting/${username}`
       );
-      return memoDecoded.replace("#", "");
+      if (!response.ok) {
+        throw new Error(`Failed to fetch received vesting shares: ${response.status}`);
+      }
+      const data = await response.json();
+      return data.list;
     }
   });
 }
-function getAccountVideosQueryOptions(username) {
+function getWitnessesInfiniteQueryOptions(limit) {
+  return 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 queryOptions({
-    queryKey: ["integrations", "3speak", "videos", username],
-    enabled: !!username,
+    queryKey: ["market", "order-book", limit],
+    queryFn: () => CONFIG.hiveClient.call("condenser_api", "get_order_book", [
+      limit
+    ])
+  });
+}
+function getMarketStatisticsQueryOptions() {
+  return queryOptions({
+    queryKey: ["market", "statistics"],
+    queryFn: () => CONFIG.hiveClient.call("condenser_api", "get_ticker", [])
+  });
+}
+function getMarketHistoryQueryOptions(seconds, startDate, endDate) {
+  const formatDate = (date) => {
+    return date.toISOString().replace(/\.\d{3}Z$/, "");
+  };
+  return queryOptions({
+    queryKey: ["market", "history", seconds, startDate.getTime(), endDate.getTime()],
+    queryFn: () => CONFIG.hiveClient.call("condenser_api", "get_market_history", [
+      seconds,
+      formatDate(startDate),
+      formatDate(endDate)
+    ])
+  });
+}
+function getHiveHbdStatsQueryOptions() {
+  return queryOptions({
+    queryKey: ["market", "hive-hbd-stats"],
     queryFn: async () => {
-      await getQueryClient().prefetchQuery(
-        getAccountTokenQueryOptions(username)
+      const stats = await CONFIG.hiveClient.call(
+        "condenser_api",
+        "get_ticker",
+        []
       );
-      const token = getQueryClient().getQueryData(
-        getAccountTokenQueryOptions(username).queryKey
+      const now = /* @__PURE__ */ new Date();
+      const oneDayAgo = new Date(now.getTime() - 864e5);
+      const formatDate = (date) => {
+        return date.toISOString().replace(/\.\d{3}Z$/, "");
+      };
+      const dayChange = await CONFIG.hiveClient.call(
+        "condenser_api",
+        "get_market_history",
+        [86400, formatDate(oneDayAgo), formatDate(now)]
       );
-      const fetchApi = getBoundFetch();
-      const response = await fetchApi(
-        `https://studio.3speak.tv/mobile/api/my-videos`,
+      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 getMarketDataQueryOptions(coin, vsCurrency, fromTs, toTs) {
+  return queryOptions({
+    queryKey: ["market", "data", coin, vsCurrency, fromTs, toTs],
+    queryFn: async ({ signal }) => {
+      const url = `https://api.coingecko.com/api/v3/coins/${coin}/market_chart/range?vs_currency=${vsCurrency}&from=${fromTs}&to=${toTs}`;
+      const response = await fetch(url, { signal });
+      if (!response.ok) {
+        throw new Error(`Failed to fetch market data: ${response.status}`);
+      }
+      return response.json();
+    }
+  });
+}
+function getPointsQueryOptions(username, filter = 0) {
+  return 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",
-            Authorization: `Bearer ${token}`
-          }
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({ username: name, type: filter })
         }
       );
-      return await response.json();
+      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
+  });
+}
+function searchQueryOptions(q, sort, hideLow, since, scroll_id, votes) {
+  return 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();
     }
   });
 }
-
-// src/modules/integrations/3speak/index.ts
-var ThreeSpeakIntegration = {
-  queries: queries_exports2
-};
-function getHivePoshLinksQueryOptions(username) {
+function getControversialRisingInfiniteQueryOptions(what, tag, enabled = true) {
+  return 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 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}`);
+      }
+      return response.json();
+    },
+    getNextPageParam: (resp) => {
+      return {
+        sid: resp?.scroll_id,
+        hasNextPage: resp.results.length > 0
+      };
+    },
+    enabled
+  });
+}
+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 !== "").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 queryOptions({
-    queryKey: ["integrations", "hiveposh", "links", username],
+    queryKey: ["search", "similar-entries", entry.author, entry.permlink, query],
     queryFn: async () => {
-      const fetchApi = getBoundFetch();
-      const response = await fetchApi(
-        `https://hiveposh.com/api/v0/linked-accounts/${username}`,
-        {
-          headers: {
-            "Content-Type": "application/json"
-          }
-        }
-      );
-      const data = await response.json();
-      return {
-        twitter: {
-          username: data.twitter_username,
-          profile: data.twitter_profile
+      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"
         },
-        reddit: {
-          username: data.reddit_username,
-          profile: data.reddit_profile
+        body: JSON.stringify(data)
+      });
+      if (!response.ok) {
+        throw new Error(`Search failed: ${response.status}`);
+      }
+      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 getStatsQueryOptions({
-  url,
-  dimensions = [],
-  metrics = ["visitors", "pageviews", "visit_duration"],
-  enabled = true
-}) {
+function getSearchAccountQueryOptions(q, limit = 5, random = false) {
   return queryOptions({
-    queryKey: ["integrations", "plausible", url, dimensions, metrics],
+    queryKey: ["search", "account", q, limit],
     queryFn: async () => {
-      const fetchApi = getBoundFetch();
-      const response = await fetchApi(`https://ecency.com/api/stats`, {
+      const data = { q, limit, random: +random };
+      const response = await fetch(CONFIG.privateApiHost + "/search-api/search-account", {
         method: "POST",
-        body: JSON.stringify({
-          metrics,
-          url: encodeURIComponent(url),
-          dimensions
-        }),
         headers: {
           "Content-Type": "application/json"
-        }
+        },
+        body: JSON.stringify(data)
       });
-      return await response.json();
+      if (!response.ok) {
+        throw new Error(`Failed to search accounts: ${response.status}`);
+      }
+      return response.json();
     },
-    enabled: !!url && enabled
+    enabled: !!q
   });
 }
-function getRcStatsQueryOptions() {
+function getSearchTopicsQueryOptions(q, limit = 20, random = false) {
   return queryOptions({
-    queryKey: ["resource-credits", "stats"],
+    queryKey: ["search", "topics", q],
     queryFn: async () => {
-      const response = await CONFIG.hiveClient.call(
-        "rc_api",
-        "get_rc_stats",
-        {}
-      );
-      return response.rc_stats;
-    }
+      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
   });
 }
-function getAccountRcQueryOptions(username) {
-  return queryOptions({
-    queryKey: ["resource-credits", "account", username],
-    queryFn: async () => {
-      const rcClient = new RCAPI(CONFIG.hiveClient);
-      return rcClient.findRCAccounts([username]);
+function getSearchApiInfiniteQueryOptions(q, sort, hideLow, since, votes) {
+  return 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();
     },
-    enabled: !!username
+    initialPageParam: void 0,
+    getNextPageParam: (lastPage) => lastPage?.scroll_id,
+    enabled: !!q
   });
 }
-function getGameStatusCheckQueryOptions(username, gameType) {
+function getSearchPathQueryOptions(q) {
   return queryOptions({
-    queryKey: ["games", "status-check", gameType, username],
-    enabled: !!username,
+    queryKey: ["search", "path", q],
     queryFn: async () => {
-      if (!username) {
-        throw new Error("[SDK][Games] \u2013 anon user in status check");
+      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 fetchApi = getBoundFetch();
-      const response = await fetchApi(
-        CONFIG.privateApiHost + "/private-api/get-game",
-        {
-          method: "POST",
-          body: JSON.stringify({
-            game_type: gameType,
-            code: getAccessToken(username)
-          }),
-          headers: {
-            "Content-Type": "application/json"
-          }
-        }
-      );
-      return await response.json();
+      const data = await response.json();
+      if (data?.length > 0) {
+        return data;
+      }
+      return [q];
     }
   });
 }
-function useGameClaim(username, gameType, key) {
-  const { mutateAsync: recordActivity } = useRecordActivity(
-    username,
-    "spin-rolled"
-  );
-  return useMutation({
-    mutationKey: ["games", "post", gameType, username],
-    mutationFn: async () => {
-      if (!username) {
-        throw new Error("[SDK][Games] \u2013 anon user in game post");
+function getBoostPlusPricesQueryOptions(accessToken) {
+  return 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}`);
       }
-      const fetchApi = getBoundFetch();
-      const response = await fetchApi(
-        CONFIG.privateApiHost + "/private-api/post-game",
-        {
-          method: "POST",
-          body: JSON.stringify({
-            game_type: gameType,
-            code: getAccessToken(username),
-            key
-          }),
-          headers: {
-            "Content-Type": "application/json"
-          }
-        }
-      );
       return await response.json();
     },
-    onSuccess() {
-      recordActivity();
-    }
+    staleTime: Infinity,
+    refetchOnMount: true,
+    enabled: !!accessToken
   });
 }
-function getCommunitiesQueryOptions(sort, query, limit = 100, observer = void 0, enabled = true) {
+function getPromotePriceQueryOptions(accessToken) {
   return queryOptions({
-    queryKey: ["communities", "list", sort, query, limit],
-    enabled,
+    queryKey: ["promotions", "promote-price"],
     queryFn: async () => {
-      const response = await CONFIG.hiveClient.call(
-        "bridge",
-        "list_communities",
-        {
-          last: "",
-          limit,
-          sort: sort === "hot" ? "rank" : sort,
-          query: query ? query : null,
-          observer
-        }
-      );
-      return response ? sort === "hot" ? response.sort(() => Math.random() - 0.5) : response : [];
-    }
+      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();
+    },
+    enabled: !!accessToken
   });
 }
-function getCommunityContextQueryOptions(username, communityName) {
+function getBoostPlusAccountPricesQueryOptions(account, accessToken) {
   return queryOptions({
-    queryKey: ["community", "context", username, communityName],
-    enabled: !!username && !!communityName,
+    queryKey: ["promotions", "boost-plus-accounts", account],
     queryFn: async () => {
-      const response = await CONFIG.hiveClient.call(
-        "bridge",
-        "get_community_context",
-        {
-          account: username,
-          name: communityName
-        }
-      );
-      return {
-        role: response?.role ?? "guest",
-        subscribed: response?.subscribed ?? false
-      };
-    }
+      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;
+    },
+    enabled: !!account && !!accessToken
   });
 }
 
-// src/modules/communities/types/community.ts
-var ROLES = /* @__PURE__ */ ((ROLES2) => {
-  ROLES2["OWNER"] = "owner";
-  ROLES2["ADMIN"] = "admin";
-  ROLES2["MOD"] = "mod";
-  ROLES2["MEMBER"] = "member";
-  ROLES2["GUEST"] = "guest";
-  ROLES2["MUTED"] = "muted";
-  return ROLES2;
-})(ROLES || {});
-var roleMap = {
-  ["owner" /* OWNER */]: [
-    "admin" /* ADMIN */,
-    "mod" /* MOD */,
-    "member" /* MEMBER */,
-    "guest" /* GUEST */,
-    "muted" /* MUTED */
-  ],
-  ["admin" /* ADMIN */]: ["mod" /* MOD */, "member" /* MEMBER */, "guest" /* GUEST */, "muted" /* MUTED */],
-  ["mod" /* MOD */]: ["member" /* MEMBER */, "guest" /* GUEST */, "muted" /* MUTED */]
-};
-
-// src/modules/communities/utils/index.ts
-function getCommunityType(name, type_id) {
-  if (name.startsWith("hive-3") || type_id === 3) return "Council";
-  if (name.startsWith("hive-2") || type_id === 2) return "Journal";
-  return "Topic";
-}
-function getCommunityPermissions({
-  communityType,
-  userRole,
-  subscribed
-}) {
-  const canPost = (() => {
-    if (userRole === "muted" /* MUTED */) return false;
-    if (communityType === "Topic") return true;
-    return ["owner" /* OWNER */, "admin" /* ADMIN */, "mod" /* MOD */, "member" /* MEMBER */].includes(
-      userRole
-    );
-  })();
-  const canComment = (() => {
-    if (userRole === "muted" /* MUTED */) return false;
-    switch (communityType) {
-      case "Topic":
-        return true;
-      case "Journal":
-        return userRole !== "guest" /* GUEST */ || subscribed;
-      case "Council":
-        return canPost;
-    }
-  })();
-  const isModerator = ["owner" /* OWNER */, "admin" /* ADMIN */, "mod" /* MOD */].includes(userRole);
-  return {
-    canPost,
-    canComment,
-    isModerator
-  };
-}
-
-export { CONFIG, ConfigManager, mutations_exports as EcencyAnalytics, EcencyQueriesManager, HiveSignerIntegration, keychain_exports as Keychain, NaiMap, ROLES, Symbol2 as Symbol, ThreeSpeakIntegration, broadcastJson, buildProfileMetadata, checkUsernameWalletsPendingQueryOptions, decodeObj, dedupeAndSortKeyAuths, encodeObj, extractAccountProfile, getAccessToken, getAccountFullQueryOptions, getAccountPendingRecoveryQueryOptions, getAccountRcQueryOptions, getAccountRecoveriesQueryOptions, getAccountSubscriptionsQueryOptions, getActiveAccountBookmarksQueryOptions, getActiveAccountFavouritesQueryOptions, getBoundFetch, getChainPropertiesQueryOptions, getCommunitiesQueryOptions, getCommunityContextQueryOptions, getCommunityPermissions, getCommunityType, getDynamicPropsQueryOptions, getFragmentsQueryOptions, getGameStatusCheckQueryOptions, getHivePoshLinksQueryOptions, getLoginType, getPostingKey, getPromotedPostsQuery, getQueryClient, getRcStatsQueryOptions, getRefreshToken, getRelationshipBetweenAccountsQueryOptions, getSearchAccountsByUsernameQueryOptions, getStatsQueryOptions, getTrendingTagsQueryOptions, getUser, makeQueryClient, parseAsset, parseProfileMetadata, roleMap, useAccountFavouriteAdd, useAccountFavouriteDelete, useAccountRelationsUpdate, useAccountRevokeKey, useAccountRevokePosting, useAccountUpdate, useAccountUpdateKeyAuths, useAccountUpdatePassword, useAccountUpdateRecovery, useAddFragment, useBookmarkAdd, useBookmarkDelete, useBroadcastMutation, useEditFragment, useGameClaim, useRemoveFragment, useSignOperationByHivesigner, useSignOperationByKey, useSignOperationByKeychain };
+export { ACCOUNT_OPERATION_GROUPS, ALL_ACCOUNT_OPERATIONS, ALL_NOTIFY_TYPES, CONFIG, ConfigManager, mutations_exports as EcencyAnalytics, EcencyQueriesManager, HiveSignerIntegration, keychain_exports as Keychain, NaiMap, NotificationFilter, NotificationViewType, NotifyTypes, ROLES, SortOrder, Symbol2 as Symbol, ThreeSpeakIntegration, broadcastJson, buildProfileMetadata, checkUsernameWalletsPendingQueryOptions, decodeObj, dedupeAndSortKeyAuths, encodeObj, extractAccountProfile, getAccessToken, getAccountFullQueryOptions, getAccountNotificationsInfiniteQueryOptions, getAccountPendingRecoveryQueryOptions, getAccountPostsInfiniteQueryOptions, getAccountRcQueryOptions, getAccountRecoveriesQueryOptions, getAccountSubscriptionsQueryOptions, getAccountVoteHistoryInfiniteQueryOptions, getAccountsQueryOptions, getActiveAccountBookmarksQueryOptions, getActiveAccountFavouritesQueryOptions, getAnnouncementsQueryOptions, getBoostPlusAccountPricesQueryOptions, getBoostPlusPricesQueryOptions, getBotsQueryOptions, getBoundFetch, getChainPropertiesQueryOptions, getCollateralizedConversionRequestsQueryOptions, getCommentHistoryQueryOptions, getCommunitiesQueryOptions, getCommunityContextQueryOptions, getCommunityPermissions, getCommunitySubscribersQueryOptions, getCommunityType, getControversialRisingInfiniteQueryOptions, getConversionRequestsQueryOptions, getDeletedEntryQueryOptions, getDiscoverCurationQueryOptions, getDiscoverLeaderboardQueryOptions, getDiscussionsQueryOptions, getDraftsQueryOptions, getDynamicPropsQueryOptions, getEntryActiveVotesQueryOptions, getFollowCountQueryOptions, getFollowingQueryOptions, getFragmentsQueryOptions, getFriendsInfiniteQueryOptions, getGalleryImagesQueryOptions, getGameStatusCheckQueryOptions, getHiveHbdStatsQueryOptions, getHivePoshLinksQueryOptions, getImagesQueryOptions, getLoginType, getMarketDataQueryOptions, getMarketHistoryQueryOptions, getMarketStatisticsQueryOptions, getMutedUsersQueryOptions, getNotificationsInfiniteQueryOptions, getNotificationsSettingsQueryOptions, getNotificationsUnreadCountQueryOptions, getOpenOrdersQueryOptions, getOrderBookQueryOptions, getOutgoingRcDelegationsInfiniteQueryOptions, getPageStatsQueryOptions, getPointsQueryOptions, getPostHeaderQueryOptions, getPostQueryOptions, getPostTipsQueryOptions, getPostingKey, getPostsRankedInfiniteQueryOptions, getPromotePriceQueryOptions, getPromotedPostsQuery, getProposalQueryOptions, getProposalVotesInfiniteQueryOptions, getProposalsQueryOptions, getQueryClient, getRcStatsQueryOptions, getReblogsQueryOptions, getReceivedVestingSharesQueryOptions, getReferralsInfiniteQueryOptions, getReferralsStatsQueryOptions, getRefreshToken, getRelationshipBetweenAccountsQueryOptions, getRewardedCommunitiesQueryOptions, getSavingsWithdrawFromQueryOptions, getSchedulesQueryOptions, getSearchAccountQueryOptions, getSearchAccountsByUsernameQueryOptions, getSearchApiInfiniteQueryOptions, getSearchFriendsQueryOptions, getSearchPathQueryOptions, getSearchTopicsQueryOptions, getSimilarEntriesQueryOptions, getStatsQueryOptions, getTransactionsInfiniteQueryOptions, getTrendingTagsQueryOptions, getUser, getUserProposalVotesQueryOptions, getVestingDelegationsQueryOptions, getVisibleFirstLevelThreadItems, getWavesByHostQueryOptions, getWavesByTagQueryOptions, getWavesFollowingQueryOptions, getWavesTrendingTagsQueryOptions, getWithdrawRoutesQueryOptions, getWitnessesInfiniteQueryOptions, lookupAccountsQueryOptions, makeQueryClient, mapThreadItemsToWaveEntries, normalizeWaveEntryFromApi, parseAccounts, parseAsset, parseProfileMetadata, roleMap, searchQueryOptions, sortDiscussions, toEntryArray, useAccountFavouriteAdd, useAccountFavouriteDelete, useAccountRelationsUpdate, useAccountRevokeKey, useAccountRevokePosting, useAccountUpdate, useAccountUpdateKeyAuths, useAccountUpdatePassword, useAccountUpdateRecovery, useAddFragment, useBookmarkAdd, useBookmarkDelete, useBroadcastMutation, useEditFragment, useGameClaim, useRecordActivity, useRemoveFragment, useSignOperationByHivesigner, useSignOperationByKey, useSignOperationByKeychain };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map