@ecency/sdk 1.3.6 → 1.3.9

package/dist/node/index.cjs

@@ -80,7 +80,16 @@ var CONFIG = {
   heliusApiKey: process.env.VITE_HELIUS_API_KEY,
   queryClient: new reactQuery.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
 };
 exports.ConfigManager = void 0;
 ((ConfigManager2) => {
@@ -88,6 +97,115 @@ exports.ConfigManager = void 0;
     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;
 })(exports.ConfigManager || (exports.ConfigManager = {}));
 
 // src/modules/core/utils/decoder-encoder.ts
@@ -493,6 +611,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__namespace.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 reactQuery.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 reactQuery.queryOptions({
+    queryKey: ["accounts", "follow-count", username],
+    queryFn: () => CONFIG.hiveClient.database.call("get_follow_count", [
+      username
+    ])
+  });
+}
+function getFollowingQueryOptions(follower, startFollowing, followType = "blog", limit = 100) {
+  return reactQuery.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 reactQuery.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 reactQuery.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 reactQuery.queryOptions({
     queryKey: ["accounts", "search", query, excludeList],
@@ -712,314 +1000,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 = dhive.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 reactQuery.infiniteQueryOptions({
+    queryKey: ["accounts", "transactions", username ?? "", group, limit],
+    initialPageParam: -1,
+    queryFn: async ({ pageParam }) => {
+      if (!username) {
+        return [];
+      }
+      let filters;
+      switch (group) {
+        case "transfers":
+          filters = dhive.utils.makeBitMaskFilter(ACCOUNT_OPERATION_GROUPS["transfers"]);
+          break;
+        case "market-orders":
+          filters = dhive.utils.makeBitMaskFilter(ACCOUNT_OPERATION_GROUPS["market-orders"]);
+          break;
+        case "interests":
+          filters = dhive.utils.makeBitMaskFilter(ACCOUNT_OPERATION_GROUPS["interests"]);
+          break;
+        case "stake-operations":
+          filters = dhive.utils.makeBitMaskFilter(ACCOUNT_OPERATION_GROUPS["stake-operations"]);
+          break;
+        case "rewards":
+          filters = dhive.utils.makeBitMaskFilter(ACCOUNT_OPERATION_GROUPS["rewards"]);
+          break;
+        default:
+          filters = dhive.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__namespace.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 reactQuery.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 = reactQuery.useQueryClient();
-  const { data } = reactQuery.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 reactQuery.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 reactQuery.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__namespace.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 reactQuery.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 reactQuery.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 reactQuery.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 reactQuery.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 reactQuery.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 reactQuery.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 reactQuery.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 reactQuery.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 reactQuery.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 reactQuery.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 reactQuery.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 reactQuery.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 reactQuery.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 reactQuery.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 } = reactQuery.useQuery(getAccountFullQueryOptions(username));
-  return reactQuery.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 reactQuery.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__namespace.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 } = reactQuery.useQuery(getAccountFullQueryOptions(username));
-  const { mutateAsync: updateKeys } = useAccountUpdateKeyAuths(username);
-  return reactQuery.useMutation({
+function getPostsRankedInfiniteQueryOptions(sort, tag, limit = 20, observer = "", enabled = true, _options = {}) {
+  return reactQuery.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 reactQuery.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 reactQuery.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 reactQuery.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 reactQuery.queryOptions({
+    queryKey: ["posts", "images", username],
+    queryFn: async () => {
+      if (!username) {
+        return [];
+      }
+      return fetchUserImages(username);
+    },
+    enabled: !!username
+  });
+}
+function getGalleryImagesQueryOptions(activeUsername) {
+  return reactQuery.queryOptions({
+    queryKey: ["posts", "gallery-images", activeUsername],
+    queryFn: async () => {
+      if (!activeUsername) {
+        return [];
+      }
+      return fetchUserImages(activeUsername);
+    },
+    enabled: !!activeUsername
+  });
+}
+function getCommentHistoryQueryOptions(author, permlink, onlyMeta = false) {
+  return reactQuery.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 reactQuery.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 reactQuery.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 reactQuery.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 reactQuery.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 reactQuery.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 reactQuery.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 reactQuery.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 = reactQuery.useQueryClient();
+  const { data } = reactQuery.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__namespace.clone(data2);
+        obj.profile = buildProfileMetadata({
+          existingProfile: extractAccountProfile(data2),
+          profile: variables.profile,
+          tokens: variables.tokens
+        });
+        return obj;
+      }
+    )
+  );
+}
+function useAccountRelationsUpdate(reference, target, onSuccess, onError) {
+  return reactQuery.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 reactQuery.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 reactQuery.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 reactQuery.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 reactQuery.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 } = reactQuery.useQuery(getAccountFullQueryOptions(username));
+  return reactQuery.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__namespace.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 } = reactQuery.useQuery(getAccountFullQueryOptions(username));
+  const { mutateAsync: updateKeys } = useAccountUpdateKeyAuths(username);
+  return reactQuery.useMutation({
     mutationKey: ["accounts", "password-update", username],
     mutationFn: async ({
       newPassword,
@@ -1028,751 +2322,1598 @@ 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 = dhive.PrivateKey.fromLogin(
+        username,
+        currentPassword,
+        "owner"
+      );
+      return updateKeys({
+        currentKey,
+        keepCurrent,
+        keys: [
+          {
+            owner: dhive.PrivateKey.fromLogin(username, newPassword, "owner"),
+            active: dhive.PrivateKey.fromLogin(username, newPassword, "active"),
+            posting: dhive.PrivateKey.fromLogin(username, newPassword, "posting"),
+            memo_key: dhive.PrivateKey.fromLogin(username, newPassword, "memo")
+          }
+        ]
+      });
+    },
+    ...options
+  });
+}
+function useAccountRevokePosting(username, options) {
+  const queryClient = reactQuery.useQueryClient();
+  const { data } = reactQuery.useQuery(getAccountFullQueryOptions(username));
+  return reactQuery.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__namespace.pipe(
+        {},
+        R4__namespace.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__default.default.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 } = reactQuery.useQuery(getAccountFullQueryOptions(username));
+  return reactQuery.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__default.default.sendOperation(
+          ["change_recovery_account", operationBody],
+          params,
+          () => {
+          }
+        );
+      }
+    },
+    onError: options.onError,
+    onSuccess: options.onSuccess
+  });
+}
+function useAccountRevokeKey(username, options) {
+  const { data: accountData } = reactQuery.useQuery(getAccountFullQueryOptions(username));
+  return reactQuery.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__namespace.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 reactQuery.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 = dhive.PrivateKey.fromLogin(username, keyOrSeed, "active");
+      } else if (dhive.cryptoUtils.isWif(keyOrSeed)) {
+        privateKey = dhive.PrivateKey.fromString(keyOrSeed);
+      } else {
+        privateKey = dhive.PrivateKey.from(keyOrSeed);
+      }
+      return CONFIG.hiveClient.broadcast.sendOperations(
+        [operation],
+        privateKey
+      );
+    }
+  });
+}
+function useSignOperationByKeychain(username, keyType = "Active") {
+  return reactQuery.useMutation({
+    mutationKey: ["operations", "sign-keychain", username],
+    mutationFn: ({ operation }) => {
+      if (!username) {
+        throw new Error(
+          "[SDK][Keychain] \u2013\xA0cannot sign operation with anon user"
         );
       }
-      const currentKey = dhive.PrivateKey.fromLogin(
-        username,
-        currentPassword,
-        "owner"
+      return keychain_exports.broadcast(username, [operation], keyType);
+    }
+  });
+}
+function useSignOperationByHivesigner(callbackUri = "/") {
+  return reactQuery.useMutation({
+    mutationKey: ["operations", "sign-hivesigner", callbackUri],
+    mutationFn: async ({ operation }) => {
+      return hs__default.default.sendOperation(operation, { callback: callbackUri }, () => {
+      });
+    }
+  });
+}
+function getChainPropertiesQueryOptions() {
+  return reactQuery.queryOptions({
+    queryKey: ["operations", "chain-properties"],
+    queryFn: async () => {
+      return await CONFIG.hiveClient.database.getChainProperties();
+    }
+  });
+}
+function useAddFragment(username) {
+  return reactQuery.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: dhive.PrivateKey.fromLogin(username, newPassword, "owner"),
-            active: dhive.PrivateKey.fromLogin(username, newPassword, "active"),
-            posting: dhive.PrivateKey.fromLogin(username, newPassword, "posting"),
-            memo_key: dhive.PrivateKey.fromLogin(username, newPassword, "memo")
+      return response.json();
+    },
+    onSuccess(response) {
+      getQueryClient().setQueryData(
+        getFragmentsQueryOptions(username).queryKey,
+        (data) => [response, ...data ?? []]
+      );
+    }
+  });
+}
+function useEditFragment(username, fragmentId) {
+  return reactQuery.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 reactQuery.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 reactQuery.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 reactQuery.queryOptions({
+    queryKey: ["analytics", "discover-leaderboard", duration],
+    queryFn: async ({ signal }) => {
+      const response = await fetch(
+        CONFIG.privateApiHost + `/private-api/leaderboard/${duration}`,
+        { signal }
+      );
+      if (!response.ok) {
+        throw new Error(`Failed to fetch leaderboard: ${response.status}`);
+      }
+      return response.json();
+    }
+  });
+}
+function getDiscoverCurationQueryOptions(duration) {
+  return reactQuery.queryOptions({
+    queryKey: ["analytics", "discover-curation", duration],
+    queryFn: async ({ signal }) => {
+      const response = await fetch(
+        CONFIG.privateApiHost + `/private-api/curation/${duration}`,
+        { signal }
+      );
+      if (!response.ok) {
+        throw new Error(`Failed to fetch curation data: ${response.status}`);
+      }
+      const data = await response.json();
+      const accounts = data.map((item) => item.account);
+      const accountsResponse = await CONFIG.hiveClient.database.getAccounts(accounts);
+      for (let index = 0; index < accountsResponse.length; index++) {
+        const element = accountsResponse[index];
+        const curator = data[index];
+        const vestingShares = typeof element.vesting_shares === "string" ? element.vesting_shares : element.vesting_shares.toString();
+        const receivedVestingShares = typeof element.received_vesting_shares === "string" ? element.received_vesting_shares : element.received_vesting_shares.toString();
+        const delegatedVestingShares = typeof element.delegated_vesting_shares === "string" ? element.delegated_vesting_shares : element.delegated_vesting_shares.toString();
+        const vestingWithdrawRate = typeof element.vesting_withdraw_rate === "string" ? element.vesting_withdraw_rate : element.vesting_withdraw_rate.toString();
+        const effectiveVest = parseFloat(vestingShares) + parseFloat(receivedVestingShares) - parseFloat(delegatedVestingShares) - parseFloat(vestingWithdrawRate);
+        curator.efficiency = curator.vests / effectiveVest;
+      }
+      data.sort((a, b) => b.efficiency - a.efficiency);
+      return data;
+    }
+  });
+}
+function getPageStatsQueryOptions(url, dimensions = [], metrics = ["visitors", "pageviews", "visit_duration"], dateRange) {
+  return reactQuery.queryOptions({
+    queryKey: ["analytics", "page-stats", url, dimensions, metrics, dateRange],
+    queryFn: async ({ signal }) => {
+      const response = await fetch(CONFIG.privateApiHost + "/api/stats", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          metrics,
+          url: encodeURIComponent(url),
+          dimensions,
+          date_range: dateRange
+        }),
+        signal
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to fetch page stats: ${response.status}`);
+      }
+      return response.json();
+    },
+    enabled: !!url
+  });
+}
+
+// src/modules/integrations/3speak/queries/index.ts
+var queries_exports2 = {};
+__export(queries_exports2, {
+  getAccountTokenQueryOptions: () => getAccountTokenQueryOptions,
+  getAccountVideosQueryOptions: () => getAccountVideosQueryOptions
+});
+
+// src/modules/integrations/hivesigner/queries/index.ts
+var queries_exports = {};
+__export(queries_exports, {
+  getDecodeMemoQueryOptions: () => getDecodeMemoQueryOptions
+});
+function getDecodeMemoQueryOptions(username, memo) {
+  return reactQuery.queryOptions({
+    queryKey: ["integrations", "hivesigner", "decode-memo", username],
+    queryFn: async () => {
+      const accessToken = getAccessToken(username);
+      if (accessToken) {
+        const hsClient = new hs__default.default.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 reactQuery.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 = reactQuery.useQueryClient();
-  const { data } = reactQuery.useQuery(getAccountFullQueryOptions(username));
-  return reactQuery.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__namespace.pipe(
-        {},
-        R4__namespace.mergeDeep(data.posting)
+function getAccountVideosQueryOptions(username) {
+  return reactQuery.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__default.default.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 } = reactQuery.useQuery(getAccountFullQueryOptions(username));
-  return reactQuery.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 reactQuery.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__default.default.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 reactQuery.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 } = reactQuery.useQuery(getAccountFullQueryOptions(username));
-  return reactQuery.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__namespace.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 reactQuery.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 reactQuery.queryOptions({
+    queryKey: ["resource-credits", "account", username],
+    queryFn: async () => {
+      const rcClient = new dhive.RCAPI(CONFIG.hiveClient);
+      return rcClient.findRCAccounts([username]);
     },
-    ...options
+    enabled: !!username
   });
 }
-function useSignOperationByKey(username) {
-  return reactQuery.useMutation({
-    mutationKey: ["operations", "sign", username],
-    mutationFn: ({
-      operation,
-      keyOrSeed
-    }) => {
+function getGameStatusCheckQueryOptions(username, gameType) {
+  return reactQuery.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 = dhive.PrivateKey.fromLogin(username, keyOrSeed, "active");
-      } else if (dhive.cryptoUtils.isWif(keyOrSeed)) {
-        privateKey = dhive.PrivateKey.fromString(keyOrSeed);
-      } else {
-        privateKey = dhive.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 reactQuery.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 reactQuery.useMutation({
-    mutationKey: ["operations", "sign-hivesigner", callbackUri],
-    mutationFn: async ({ operation }) => {
-      return hs__default.default.sendOperation(operation, { callback: callbackUri }, () => {
-      });
+function getCommunitiesQueryOptions(sort, query, limit = 100, observer = void 0, enabled = true) {
+  return reactQuery.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 reactQuery.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 reactQuery.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 reactQuery.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 reactQuery.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 reactQuery.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 reactQuery.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 reactQuery.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 reactQuery.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 reactQuery.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 reactQuery.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 reactQuery.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 reactQuery.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 reactQuery.useMutation({
-    mutationKey: ["analytics", activityType],
-    mutationFn: async () => {
-      if (!activityType) {
-        throw new Error("[SDK][Analytics] \u2013 no activity type provided");
+function getProposalQueryOptions(id) {
+  return reactQuery.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 reactQuery.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 reactQuery.infiniteQueryOptions({
+    queryKey: ["proposals", "votes", proposalId, voter, limit],
+    initialPageParam: voter,
+    refetchOnMount: true,
+    staleTime: 0,
+    // Always refetch on mount
+    queryFn: async ({ pageParam }) => {
+      const startParam = pageParam ?? voter;
+      const response = await CONFIG.hiveClient.call("condenser_api", "list_proposal_votes", [
+        [proposalId, startParam],
+        limit,
+        "by_proposal_voter"
+      ]);
+      const list = response.filter((x) => x.proposal?.proposal_id === proposalId).map((x) => ({ id: x.id, voter: x.voter }));
+      const rawAccounts = await CONFIG.hiveClient.database.getAccounts(list.map((l) => l.voter));
+      const accounts = parseAccounts(rawAccounts);
+      const page = list.map((i) => ({
+        ...i,
+        voterAccount: accounts.find((a) => i.voter === a.name)
+      }));
+      return page;
+    },
+    getNextPageParam: (lastPage) => {
+      const last = lastPage?.[lastPage.length - 1];
+      return last?.voter ?? void 0;
+    }
+  });
+}
+function getUserProposalVotesQueryOptions(voter) {
   return reactQuery.queryOptions({
-    queryKey: ["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__default.default.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 reactQuery.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 reactQuery.queryOptions({
+    queryKey: ["wallet", "conversion-requests", account],
+    queryFn: () => CONFIG.hiveClient.database.call("get_conversion_requests", [
+      account
+    ]),
+    select: (data) => data.sort((a, b) => a.requestid - b.requestid)
+  });
+}
+function getCollateralizedConversionRequestsQueryOptions(account) {
+  return reactQuery.queryOptions({
+    queryKey: ["wallet", "collateralized-conversion-requests", account],
+    queryFn: () => CONFIG.hiveClient.database.call("get_collateralized_conversion_requests", [
+      account
+    ]),
+    select: (data) => data.sort((a, b) => a.requestid - b.requestid)
+  });
+}
+function getSavingsWithdrawFromQueryOptions(account) {
+  return reactQuery.queryOptions({
+    queryKey: ["wallet", "savings-withdraw", account],
+    queryFn: () => CONFIG.hiveClient.database.call("get_savings_withdraw_from", [
+      account
+    ]),
+    select: (data) => data.sort((a, b) => a.request_id - b.request_id)
+  });
+}
+function getWithdrawRoutesQueryOptions(account) {
+  return reactQuery.queryOptions({
+    queryKey: ["wallet", "withdraw-routes", account],
+    queryFn: () => CONFIG.hiveClient.database.call("get_withdraw_routes", [
+      account,
+      "outgoing"
+    ])
+  });
+}
+function getOpenOrdersQueryOptions(user) {
+  return reactQuery.queryOptions({
+    queryKey: ["wallet", "open-orders", user],
+    queryFn: () => CONFIG.hiveClient.call("condenser_api", "get_open_orders", [
+      user
+    ]),
+    select: (data) => data.sort((a, b) => a.orderid - b.orderid),
+    enabled: !!user
+  });
+}
+function getOutgoingRcDelegationsInfiniteQueryOptions(username, limit = 100) {
+  return reactQuery.infiniteQueryOptions({
+    queryKey: ["wallet", "outgoing-rc-delegations", username, limit],
+    initialPageParam: null,
+    queryFn: async ({ pageParam }) => {
+      const response = await CONFIG.hiveClient.call("rc_api", "list_rc_direct_delegations", {
+        start: [username, pageParam ?? ""],
+        limit
+      }).then((r) => r);
+      let delegations = response.rc_direct_delegations || [];
+      if (pageParam) {
+        delegations = delegations.filter((delegation) => delegation.to !== pageParam);
       }
-      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 reactQuery.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 reactQuery.infiniteQueryOptions({
+    queryKey: ["witnesses", "list", limit],
+    initialPageParam: "",
+    queryFn: async ({ pageParam }) => CONFIG.hiveClient.call("condenser_api", "get_witnesses_by_vote", [
+      pageParam,
+      limit
+    ]),
+    getNextPageParam: (lastPage) => {
+      const last = lastPage?.[lastPage.length - 1];
+      return last ? last.owner : void 0;
+    }
+  });
+}
+function getOrderBookQueryOptions(limit = 500) {
   return reactQuery.queryOptions({
-    queryKey: ["integrations", "3speak", "videos", username],
-    enabled: !!username,
+    queryKey: ["market", "order-book", limit],
+    queryFn: () => CONFIG.hiveClient.call("condenser_api", "get_order_book", [
+      limit
+    ])
+  });
+}
+function getMarketStatisticsQueryOptions() {
+  return reactQuery.queryOptions({
+    queryKey: ["market", "statistics"],
+    queryFn: () => CONFIG.hiveClient.call("condenser_api", "get_ticker", [])
+  });
+}
+function getMarketHistoryQueryOptions(seconds, startDate, endDate) {
+  const formatDate = (date) => {
+    return date.toISOString().replace(/\.\d{3}Z$/, "");
+  };
+  return reactQuery.queryOptions({
+    queryKey: ["market", "history", seconds, startDate.getTime(), endDate.getTime()],
+    queryFn: () => CONFIG.hiveClient.call("condenser_api", "get_market_history", [
+      seconds,
+      formatDate(startDate),
+      formatDate(endDate)
+    ])
+  });
+}
+function getHiveHbdStatsQueryOptions() {
+  return reactQuery.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 reactQuery.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 reactQuery.queryOptions({
+    queryKey: ["points", username, filter],
+    queryFn: async () => {
+      if (!username) {
+        throw new Error("Get points query \u2013 username wasn't provided");
+      }
+      const name = username.replace("@", "");
+      const pointsResponse = await fetch(CONFIG.privateApiHost + "/private-api/points", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ username: name })
+      });
+      if (!pointsResponse.ok) {
+        throw new Error(`Failed to fetch points: ${pointsResponse.status}`);
+      }
+      const points = await pointsResponse.json();
+      const transactionsResponse = await fetch(
+        CONFIG.privateApiHost + "/private-api/point-list",
         {
+          method: "POST",
           headers: {
-            "Content-Type": "application/json",
-            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 reactQuery.queryOptions({
+    queryKey: ["search", q, sort, hideLow, since, scroll_id, votes],
+    queryFn: async () => {
+      const data = { q, sort, hide_low: hideLow };
+      if (since) data.since = since;
+      if (scroll_id) data.scroll_id = scroll_id;
+      if (votes) data.votes = votes;
+      const response = await fetch(CONFIG.privateApiHost + "/search-api/search", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(data)
+      });
+      if (!response.ok) {
+        throw new Error(`Search failed: ${response.status}`);
+      }
+      return response.json();
     }
   });
 }
-
-// src/modules/integrations/3speak/index.ts
-var ThreeSpeakIntegration = {
-  queries: queries_exports2
-};
-function getHivePoshLinksQueryOptions(username) {
+function getControversialRisingInfiniteQueryOptions(what, tag, enabled = true) {
+  return reactQuery.infiniteQueryOptions({
+    queryKey: ["search", "controversial-rising", what, tag],
+    initialPageParam: { sid: void 0, hasNextPage: true },
+    queryFn: async ({ pageParam }) => {
+      if (!pageParam.hasNextPage) {
+        return {
+          hits: 0,
+          took: 0,
+          results: []
+        };
+      }
+      let sinceDate;
+      const now = /* @__PURE__ */ new Date();
+      switch (tag) {
+        case "today":
+          sinceDate = new Date(now.getTime() - 24 * 60 * 60 * 1e3);
+          break;
+        case "week":
+          sinceDate = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1e3);
+          break;
+        case "month":
+          sinceDate = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1e3);
+          break;
+        case "year":
+          sinceDate = new Date(now.getTime() - 365 * 24 * 60 * 60 * 1e3);
+          break;
+        default:
+          sinceDate = void 0;
+      }
+      const 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 reactQuery.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 reactQuery.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 reactQuery.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 reactQuery.queryOptions({
-    queryKey: ["resource-credits", "account", username],
-    queryFn: async () => {
-      const rcClient = new dhive.RCAPI(CONFIG.hiveClient);
-      return rcClient.findRCAccounts([username]);
+function getSearchApiInfiniteQueryOptions(q, sort, hideLow, since, votes) {
+  return reactQuery.infiniteQueryOptions({
+    queryKey: ["search", "api", q, sort, hideLow, since, votes],
+    queryFn: async ({ pageParam }) => {
+      const payload = { q, sort, hide_low: hideLow };
+      if (since) {
+        payload.since = since;
+      }
+      if (pageParam) {
+        payload.scroll_id = pageParam;
+      }
+      if (votes !== void 0) {
+        payload.votes = votes;
+      }
+      const response = await fetch(CONFIG.privateApiHost + "/search-api/search", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(payload)
+      });
+      if (!response.ok) {
+        throw new Error(`Search failed: ${response.status}`);
+      }
+      return response.json();
     },
-    enabled: !!username
+    initialPageParam: void 0,
+    getNextPageParam: (lastPage) => lastPage?.scroll_id,
+    enabled: !!q
   });
 }
-function getGameStatusCheckQueryOptions(username, gameType) {
+function getSearchPathQueryOptions(q) {
   return reactQuery.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 reactQuery.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 reactQuery.queryOptions({
+    queryKey: ["promotions", "boost-plus-prices"],
+    queryFn: async () => {
+      if (!accessToken) {
+        return [];
+      }
+      const response = await fetch(CONFIG.privateApiHost + "/private-api/boost-plus-price", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ code: accessToken })
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to fetch boost plus prices: ${response.status}`);
       }
-      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 reactQuery.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 reactQuery.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
-  };
-}
-
+exports.ACCOUNT_OPERATION_GROUPS = ACCOUNT_OPERATION_GROUPS;
+exports.ALL_ACCOUNT_OPERATIONS = ALL_ACCOUNT_OPERATIONS;
+exports.ALL_NOTIFY_TYPES = ALL_NOTIFY_TYPES;
 exports.CONFIG = CONFIG;
 exports.EcencyAnalytics = mutations_exports;
 exports.HiveSignerIntegration = HiveSignerIntegration;
 exports.Keychain = keychain_exports;
 exports.NaiMap = NaiMap;
+exports.NotificationFilter = NotificationFilter;
+exports.NotificationViewType = NotificationViewType;
+exports.NotifyTypes = NotifyTypes;
 exports.ROLES = ROLES;
+exports.SortOrder = SortOrder;
 exports.Symbol = Symbol2;
 exports.ThreeSpeakIntegration = ThreeSpeakIntegration;
 exports.broadcastJson = broadcastJson;
@@ -1784,37 +3925,112 @@ exports.encodeObj = encodeObj;
 exports.extractAccountProfile = extractAccountProfile;
 exports.getAccessToken = getAccessToken;
 exports.getAccountFullQueryOptions = getAccountFullQueryOptions;
+exports.getAccountNotificationsInfiniteQueryOptions = getAccountNotificationsInfiniteQueryOptions;
 exports.getAccountPendingRecoveryQueryOptions = getAccountPendingRecoveryQueryOptions;
+exports.getAccountPostsInfiniteQueryOptions = getAccountPostsInfiniteQueryOptions;
 exports.getAccountRcQueryOptions = getAccountRcQueryOptions;
 exports.getAccountRecoveriesQueryOptions = getAccountRecoveriesQueryOptions;
 exports.getAccountSubscriptionsQueryOptions = getAccountSubscriptionsQueryOptions;
+exports.getAccountVoteHistoryInfiniteQueryOptions = getAccountVoteHistoryInfiniteQueryOptions;
+exports.getAccountsQueryOptions = getAccountsQueryOptions;
 exports.getActiveAccountBookmarksQueryOptions = getActiveAccountBookmarksQueryOptions;
 exports.getActiveAccountFavouritesQueryOptions = getActiveAccountFavouritesQueryOptions;
+exports.getAnnouncementsQueryOptions = getAnnouncementsQueryOptions;
+exports.getBoostPlusAccountPricesQueryOptions = getBoostPlusAccountPricesQueryOptions;
+exports.getBoostPlusPricesQueryOptions = getBoostPlusPricesQueryOptions;
+exports.getBotsQueryOptions = getBotsQueryOptions;
 exports.getBoundFetch = getBoundFetch;
 exports.getChainPropertiesQueryOptions = getChainPropertiesQueryOptions;
+exports.getCollateralizedConversionRequestsQueryOptions = getCollateralizedConversionRequestsQueryOptions;
+exports.getCommentHistoryQueryOptions = getCommentHistoryQueryOptions;
 exports.getCommunitiesQueryOptions = getCommunitiesQueryOptions;
 exports.getCommunityContextQueryOptions = getCommunityContextQueryOptions;
 exports.getCommunityPermissions = getCommunityPermissions;
+exports.getCommunitySubscribersQueryOptions = getCommunitySubscribersQueryOptions;
 exports.getCommunityType = getCommunityType;
+exports.getControversialRisingInfiniteQueryOptions = getControversialRisingInfiniteQueryOptions;
+exports.getConversionRequestsQueryOptions = getConversionRequestsQueryOptions;
+exports.getDeletedEntryQueryOptions = getDeletedEntryQueryOptions;
+exports.getDiscoverCurationQueryOptions = getDiscoverCurationQueryOptions;
+exports.getDiscoverLeaderboardQueryOptions = getDiscoverLeaderboardQueryOptions;
+exports.getDiscussionsQueryOptions = getDiscussionsQueryOptions;
+exports.getDraftsQueryOptions = getDraftsQueryOptions;
 exports.getDynamicPropsQueryOptions = getDynamicPropsQueryOptions;
+exports.getEntryActiveVotesQueryOptions = getEntryActiveVotesQueryOptions;
+exports.getFollowCountQueryOptions = getFollowCountQueryOptions;
+exports.getFollowingQueryOptions = getFollowingQueryOptions;
 exports.getFragmentsQueryOptions = getFragmentsQueryOptions;
+exports.getFriendsInfiniteQueryOptions = getFriendsInfiniteQueryOptions;
+exports.getGalleryImagesQueryOptions = getGalleryImagesQueryOptions;
 exports.getGameStatusCheckQueryOptions = getGameStatusCheckQueryOptions;
+exports.getHiveHbdStatsQueryOptions = getHiveHbdStatsQueryOptions;
 exports.getHivePoshLinksQueryOptions = getHivePoshLinksQueryOptions;
+exports.getImagesQueryOptions = getImagesQueryOptions;
 exports.getLoginType = getLoginType;
+exports.getMarketDataQueryOptions = getMarketDataQueryOptions;
+exports.getMarketHistoryQueryOptions = getMarketHistoryQueryOptions;
+exports.getMarketStatisticsQueryOptions = getMarketStatisticsQueryOptions;
+exports.getMutedUsersQueryOptions = getMutedUsersQueryOptions;
+exports.getNotificationsInfiniteQueryOptions = getNotificationsInfiniteQueryOptions;
+exports.getNotificationsSettingsQueryOptions = getNotificationsSettingsQueryOptions;
+exports.getNotificationsUnreadCountQueryOptions = getNotificationsUnreadCountQueryOptions;
+exports.getOpenOrdersQueryOptions = getOpenOrdersQueryOptions;
+exports.getOrderBookQueryOptions = getOrderBookQueryOptions;
+exports.getOutgoingRcDelegationsInfiniteQueryOptions = getOutgoingRcDelegationsInfiniteQueryOptions;
+exports.getPageStatsQueryOptions = getPageStatsQueryOptions;
+exports.getPointsQueryOptions = getPointsQueryOptions;
+exports.getPostHeaderQueryOptions = getPostHeaderQueryOptions;
+exports.getPostQueryOptions = getPostQueryOptions;
+exports.getPostTipsQueryOptions = getPostTipsQueryOptions;
 exports.getPostingKey = getPostingKey;
+exports.getPostsRankedInfiniteQueryOptions = getPostsRankedInfiniteQueryOptions;
+exports.getPromotePriceQueryOptions = getPromotePriceQueryOptions;
 exports.getPromotedPostsQuery = getPromotedPostsQuery;
+exports.getProposalQueryOptions = getProposalQueryOptions;
+exports.getProposalVotesInfiniteQueryOptions = getProposalVotesInfiniteQueryOptions;
+exports.getProposalsQueryOptions = getProposalsQueryOptions;
 exports.getQueryClient = getQueryClient;
 exports.getRcStatsQueryOptions = getRcStatsQueryOptions;
+exports.getReblogsQueryOptions = getReblogsQueryOptions;
+exports.getReceivedVestingSharesQueryOptions = getReceivedVestingSharesQueryOptions;
+exports.getReferralsInfiniteQueryOptions = getReferralsInfiniteQueryOptions;
+exports.getReferralsStatsQueryOptions = getReferralsStatsQueryOptions;
 exports.getRefreshToken = getRefreshToken;
 exports.getRelationshipBetweenAccountsQueryOptions = getRelationshipBetweenAccountsQueryOptions;
+exports.getRewardedCommunitiesQueryOptions = getRewardedCommunitiesQueryOptions;
+exports.getSavingsWithdrawFromQueryOptions = getSavingsWithdrawFromQueryOptions;
+exports.getSchedulesQueryOptions = getSchedulesQueryOptions;
+exports.getSearchAccountQueryOptions = getSearchAccountQueryOptions;
 exports.getSearchAccountsByUsernameQueryOptions = getSearchAccountsByUsernameQueryOptions;
+exports.getSearchApiInfiniteQueryOptions = getSearchApiInfiniteQueryOptions;
+exports.getSearchFriendsQueryOptions = getSearchFriendsQueryOptions;
+exports.getSearchPathQueryOptions = getSearchPathQueryOptions;
+exports.getSearchTopicsQueryOptions = getSearchTopicsQueryOptions;
+exports.getSimilarEntriesQueryOptions = getSimilarEntriesQueryOptions;
 exports.getStatsQueryOptions = getStatsQueryOptions;
+exports.getTransactionsInfiniteQueryOptions = getTransactionsInfiniteQueryOptions;
 exports.getTrendingTagsQueryOptions = getTrendingTagsQueryOptions;
 exports.getUser = getUser;
+exports.getUserProposalVotesQueryOptions = getUserProposalVotesQueryOptions;
+exports.getVestingDelegationsQueryOptions = getVestingDelegationsQueryOptions;
+exports.getVisibleFirstLevelThreadItems = getVisibleFirstLevelThreadItems;
+exports.getWavesByHostQueryOptions = getWavesByHostQueryOptions;
+exports.getWavesByTagQueryOptions = getWavesByTagQueryOptions;
+exports.getWavesFollowingQueryOptions = getWavesFollowingQueryOptions;
+exports.getWavesTrendingTagsQueryOptions = getWavesTrendingTagsQueryOptions;
+exports.getWithdrawRoutesQueryOptions = getWithdrawRoutesQueryOptions;
+exports.getWitnessesInfiniteQueryOptions = getWitnessesInfiniteQueryOptions;
+exports.lookupAccountsQueryOptions = lookupAccountsQueryOptions;
 exports.makeQueryClient = makeQueryClient;
+exports.mapThreadItemsToWaveEntries = mapThreadItemsToWaveEntries;
+exports.normalizeWaveEntryFromApi = normalizeWaveEntryFromApi;
+exports.parseAccounts = parseAccounts;
 exports.parseAsset = parseAsset;
 exports.parseProfileMetadata = parseProfileMetadata;
 exports.roleMap = roleMap;
+exports.searchQueryOptions = searchQueryOptions;
+exports.sortDiscussions = sortDiscussions;
+exports.toEntryArray = toEntryArray;
 exports.useAccountFavouriteAdd = useAccountFavouriteAdd;
 exports.useAccountFavouriteDelete = useAccountFavouriteDelete;
 exports.useAccountRelationsUpdate = useAccountRelationsUpdate;
@@ -1830,6 +4046,7 @@ exports.useBookmarkDelete = useBookmarkDelete;
 exports.useBroadcastMutation = useBroadcastMutation;
 exports.useEditFragment = useEditFragment;
 exports.useGameClaim = useGameClaim;
+exports.useRecordActivity = useRecordActivity;
 exports.useRemoveFragment = useRemoveFragment;
 exports.useSignOperationByHivesigner = useSignOperationByHivesigner;
 exports.useSignOperationByKey = useSignOperationByKey;