@ecency/sdk 1.5.27 → 2.0.0

package/dist/index.cjs

@@ -1,1747 +0,0 @@
-'use strict';
-
-var reactQuery = require('@tanstack/react-query');
-var dhive = require('@hiveio/dhive');
-var hs = require('hivesigner');
-var R = require('remeda');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var hs__default = /*#__PURE__*/_interopDefault(hs);
-var R__namespace = /*#__PURE__*/_interopNamespace(R);
-
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/modules/core/mock-storage.ts
-var MockStorage = class {
-  length = 0;
-  clear() {
-    throw new Error("Method not implemented.");
-  }
-  getItem(key) {
-    return this[key];
-  }
-  key(index) {
-    return Object.keys(this)[index];
-  }
-  removeItem(key) {
-    delete this[key];
-  }
-  setItem(key, value) {
-    this[key] = value;
-  }
-};
-var CONFIG = {
-  privateApiHost: "https://ecency.com",
-  storage: typeof window === "undefined" ? new MockStorage() : window.localStorage,
-  storagePrefix: "ecency",
-  hiveClient: new dhive.Client(
-    [
-      "https://api.hive.blog",
-      "https://api.deathwing.me",
-      "https://rpc.mahdiyari.info",
-      "https://api.openhive.network",
-      "https://techcoderx.com",
-      "https://hive-api.arcange.eu",
-      "https://api.syncad.com",
-      "https://anyx.io",
-      "https://api.c0ff33a.uk",
-      "https://hiveapi.actifit.io",
-      "https://hive-api.3speak.tv"
-    ],
-    {
-      timeout: 2e3,
-      failoverThreshold: 2,
-      consoleOnFailover: true
-    }
-  ),
-  heliusApiKey: process.env.VITE_HELIUS_API_KEY,
-  queryClient: new reactQuery.QueryClient(),
-  plausibleHost: "https://pl.ecency.com",
-  spkNode: "https://spk.good-karma.xyz"
-};
-exports.ConfigManager = void 0;
-((ConfigManager2) => {
-  function setQueryClient(client) {
-    CONFIG.queryClient = client;
-  }
-  ConfigManager2.setQueryClient = setQueryClient;
-})(exports.ConfigManager || (exports.ConfigManager = {}));
-
-// src/modules/core/utils/decoder-encoder.ts
-function encodeObj(o) {
-  return btoa(JSON.stringify(o));
-}
-function decodeObj(o) {
-  let dataToParse = atob(o);
-  if (dataToParse[0] !== "{") {
-    return void 0;
-  }
-  return JSON.parse(dataToParse);
-}
-
-// src/modules/core/utils/parse-asset.ts
-var Symbol2 = /* @__PURE__ */ ((Symbol3) => {
-  Symbol3["HIVE"] = "HIVE";
-  Symbol3["HBD"] = "HBD";
-  Symbol3["VESTS"] = "VESTS";
-  Symbol3["SPK"] = "SPK";
-  return Symbol3;
-})(Symbol2 || {});
-var NaiMap = /* @__PURE__ */ ((NaiMap2) => {
-  NaiMap2["@@000000021"] = "HIVE";
-  NaiMap2["@@000000013"] = "HBD";
-  NaiMap2["@@000000037"] = "VESTS";
-  return NaiMap2;
-})(NaiMap || {});
-function parseAsset(sval) {
-  if (typeof sval === "string") {
-    const sp = sval.split(" ");
-    return {
-      amount: parseFloat(sp[0]),
-      // @ts-ignore
-      symbol: Symbol2[sp[1]]
-    };
-  } else {
-    return {
-      amount: parseFloat(sval.amount.toString()) / Math.pow(10, sval.precision),
-      // @ts-ignore
-      symbol: NaiMap[sval.nai]
-    };
-  }
-}
-
-// src/modules/core/utils/get-bound-fetch.ts
-var cachedFetch;
-function getBoundFetch() {
-  if (!cachedFetch) {
-    if (typeof globalThis.fetch !== "function") {
-      throw new Error("[Ecency][SDK] - global fetch is not available");
-    }
-    cachedFetch = globalThis.fetch.bind(globalThis);
-  }
-  return cachedFetch;
-}
-
-// src/modules/core/storage.ts
-var getUser = (username) => {
-  try {
-    const raw = CONFIG.storage.getItem(
-      CONFIG.storagePrefix + "_user_" + username
-    );
-    return decodeObj(JSON.parse(raw));
-  } catch (e) {
-    console.error(e);
-    return void 0;
-  }
-};
-var getAccessToken = (username) => getUser(username) && getUser(username).accessToken;
-var getPostingKey = (username) => getUser(username) && getUser(username).postingKey;
-var getLoginType = (username) => getUser(username) && getUser(username).loginType;
-var getRefreshToken = (username) => getUser(username) && getUser(username).refreshToken;
-
-// src/modules/keychain/keychain.ts
-var keychain_exports = {};
-__export(keychain_exports, {
-  broadcast: () => broadcast,
-  customJson: () => customJson,
-  handshake: () => handshake
-});
-function handshake() {
-  return new Promise((resolve) => {
-    window.hive_keychain?.requestHandshake(() => {
-      resolve();
-    });
-  });
-}
-var broadcast = (account, operations, key, rpc = null) => new Promise((resolve, reject) => {
-  window.hive_keychain?.requestBroadcast(
-    account,
-    operations,
-    key,
-    (resp) => {
-      if (!resp.success) {
-        reject({ message: "Operation cancelled" });
-      }
-      resolve(resp);
-    },
-    rpc
-  );
-});
-var customJson = (account, id, key, json, display_msg, rpc = null) => new Promise((resolve, reject) => {
-  window.hive_keychain?.requestCustomJson(
-    account,
-    id,
-    key,
-    json,
-    display_msg,
-    (resp) => {
-      if (!resp.success) {
-        reject({ message: "Operation cancelled" });
-      }
-      resolve(resp);
-    },
-    rpc
-  );
-});
-
-// src/modules/core/mutations/use-broadcast-mutation.ts
-var getBoundFetch2 = () => {
-  if (typeof window !== "undefined" && typeof window.fetch === "function") {
-    return window.fetch.bind(window);
-  }
-  return globalThis.fetch;
-};
-function useBroadcastMutation(mutationKey = [], username, accessToken, operations, onSuccess = () => {
-}, auth) {
-  return reactQuery.useMutation({
-    onSuccess,
-    mutationKey: [...mutationKey, username],
-    mutationFn: async (payload) => {
-      if (!username) {
-        throw new Error(
-          "[Core][Broadcast] Attempted to call broadcast API with anon user"
-        );
-      }
-      const postingKey = auth?.postingKey;
-      if (postingKey) {
-        const privateKey = dhive.PrivateKey.fromString(postingKey);
-        return CONFIG.hiveClient.broadcast.sendOperations(
-          operations(payload),
-          privateKey
-        );
-      }
-      const loginType = auth?.loginType;
-      if (loginType && loginType == "keychain") {
-        return keychain_exports.broadcast(
-          username,
-          operations(payload),
-          "Posting"
-        ).then((r) => r.result);
-      }
-      if (accessToken) {
-        const f = getBoundFetch2();
-        const res = await f("https://hivesigner.com/api/broadcast", {
-          method: "POST",
-          headers: {
-            Authorization: accessToken,
-            "Content-Type": "application/json",
-            Accept: "application/json"
-          },
-          body: JSON.stringify({ operations: operations(payload) })
-        });
-        if (!res.ok) {
-          const txt = await res.text().catch(() => "");
-          throw new Error(`[Hivesigner] ${res.status} ${res.statusText} ${txt}`);
-        }
-        const json = await res.json();
-        if (json?.errors) {
-          throw new Error(`[Hivesigner] ${JSON.stringify(json.errors)}`);
-        }
-        return json.result;
-      }
-      throw new Error(
-        "[SDK][Broadcast] \u2013 cannot broadcast w/o posting key or token"
-      );
-    }
-  });
-}
-async function broadcastJson(username, id, payload, accessToken, auth) {
-  if (!username) {
-    throw new Error(
-      "[Core][Broadcast] Attempted to call broadcast API with anon user"
-    );
-  }
-  const jjson = {
-    id,
-    required_auths: [],
-    required_posting_auths: [username],
-    json: JSON.stringify(payload)
-  };
-  const postingKey = auth?.postingKey;
-  if (postingKey) {
-    const privateKey = dhive.PrivateKey.fromString(postingKey);
-    return CONFIG.hiveClient.broadcast.json(
-      jjson,
-      privateKey
-    );
-  }
-  const loginType = auth?.loginType;
-  if (loginType && loginType == "keychain") {
-    return keychain_exports.broadcast(username, [["custom_json", jjson]], "Posting").then((r) => r.result);
-  }
-  if (accessToken) {
-    const response = await new hs__default.default.Client({
-      accessToken
-    }).customJson([], [username], id, JSON.stringify(payload));
-    return response.result;
-  }
-  throw new Error(
-    "[SDK][Broadcast] \u2013 cannot broadcast w/o posting key or token"
-  );
-}
-function makeQueryClient() {
-  return new reactQuery.QueryClient({
-    defaultOptions: {
-      queries: {
-        // With SSR, we usually want to set some default staleTime
-        // above 0 to avoid refetching immediately on the client
-        // staleTime: 60 * 1000,
-        refetchOnWindowFocus: false,
-        refetchOnMount: false
-      }
-    }
-  });
-}
-var getQueryClient = () => CONFIG.queryClient;
-exports.EcencyQueriesManager = void 0;
-((EcencyQueriesManager2) => {
-  function getQueryData(queryKey) {
-    const queryClient = getQueryClient();
-    return queryClient.getQueryData(queryKey);
-  }
-  EcencyQueriesManager2.getQueryData = getQueryData;
-  function getInfiniteQueryData(queryKey) {
-    const queryClient = getQueryClient();
-    return queryClient.getQueryData(queryKey);
-  }
-  EcencyQueriesManager2.getInfiniteQueryData = getInfiniteQueryData;
-  async function prefetchQuery(options) {
-    const queryClient = getQueryClient();
-    await queryClient.prefetchQuery(options);
-    return getQueryData(options.queryKey);
-  }
-  EcencyQueriesManager2.prefetchQuery = prefetchQuery;
-  async function prefetchInfiniteQuery(options) {
-    const queryClient = getQueryClient();
-    await queryClient.prefetchInfiniteQuery(options);
-    return getInfiniteQueryData(options.queryKey);
-  }
-  EcencyQueriesManager2.prefetchInfiniteQuery = prefetchInfiniteQuery;
-  function generateClientServerQuery(options) {
-    return {
-      prefetch: () => prefetchQuery(options),
-      getData: () => getQueryData(options.queryKey),
-      useClientQuery: () => reactQuery.useQuery(options),
-      fetchAndGet: () => getQueryClient().fetchQuery(options)
-    };
-  }
-  EcencyQueriesManager2.generateClientServerQuery = generateClientServerQuery;
-  function generateClientServerInfiniteQuery(options) {
-    return {
-      prefetch: () => prefetchInfiniteQuery(options),
-      getData: () => getInfiniteQueryData(options.queryKey),
-      useClientQuery: () => reactQuery.useInfiniteQuery(options),
-      fetchAndGet: () => getQueryClient().fetchInfiniteQuery(options)
-    };
-  }
-  EcencyQueriesManager2.generateClientServerInfiniteQuery = generateClientServerInfiniteQuery;
-})(exports.EcencyQueriesManager || (exports.EcencyQueriesManager = {}));
-function getDynamicPropsQueryOptions() {
-  return reactQuery.queryOptions({
-    queryKey: ["core", "dynamic-props"],
-    refetchInterval: 6e4,
-    staleTime: 6e4,
-    refetchOnMount: true,
-    queryFn: async () => {
-      const globalDynamic = await CONFIG.hiveClient.database.getDynamicGlobalProperties().then((r) => ({
-        total_vesting_fund_hive: r.total_vesting_fund_hive || r.total_vesting_fund_steem,
-        total_vesting_shares: r.total_vesting_shares,
-        hbd_print_rate: r.hbd_print_rate || r.sbd_print_rate,
-        hbd_interest_rate: r.hbd_interest_rate,
-        head_block_number: r.head_block_number,
-        vesting_reward_percent: r.vesting_reward_percent,
-        virtual_supply: r.virtual_supply
-      }));
-      const feedHistory = await CONFIG.hiveClient.database.call("get_feed_history");
-      const chainProps = await CONFIG.hiveClient.database.call(
-        "get_chain_properties"
-      );
-      const rewardFund = await CONFIG.hiveClient.database.call(
-        "get_reward_fund",
-        ["post"]
-      );
-      const hivePerMVests = parseAsset(globalDynamic.total_vesting_fund_hive).amount / parseAsset(globalDynamic.total_vesting_shares).amount * 1e6;
-      const base = parseAsset(feedHistory.current_median_history.base).amount;
-      const quote = parseAsset(feedHistory.current_median_history.quote).amount;
-      const fundRecentClaims = parseFloat(rewardFund.recent_claims);
-      const fundRewardBalance = parseAsset(rewardFund.reward_balance).amount;
-      const hbdPrintRate = globalDynamic.hbd_print_rate;
-      const hbdInterestRate = globalDynamic.hbd_interest_rate;
-      const headBlock = globalDynamic.head_block_number;
-      const totalVestingFund = parseAsset(
-        globalDynamic.total_vesting_fund_hive
-      ).amount;
-      const totalVestingShares = parseAsset(
-        globalDynamic.total_vesting_shares
-      ).amount;
-      const virtualSupply = parseAsset(globalDynamic.virtual_supply).amount;
-      const vestingRewardPercent = globalDynamic.vesting_reward_percent;
-      const accountCreationFee = chainProps.account_creation_fee;
-      return {
-        hivePerMVests,
-        base,
-        quote,
-        fundRecentClaims,
-        fundRewardBalance,
-        hbdPrintRate,
-        hbdInterestRate,
-        headBlock,
-        totalVestingFund,
-        totalVestingShares,
-        virtualSupply,
-        vestingRewardPercent,
-        accountCreationFee
-      };
-    }
-  });
-}
-function getAccountFullQueryOptions(username) {
-  return reactQuery.queryOptions({
-    queryKey: ["get-account-full", username],
-    queryFn: async () => {
-      if (!username) {
-        throw new Error("[SDK] Username is empty");
-      }
-      const response = await CONFIG.hiveClient.database.getAccounts([
-        username
-      ]);
-      if (!response[0]) {
-        throw new Error("[SDK] No account with given username");
-      }
-      const profile = JSON.parse(response[0].posting_json_metadata).profile;
-      let follow_stats;
-      try {
-        follow_stats = await CONFIG.hiveClient.database.call(
-          "get_follow_count",
-          [username]
-        );
-      } catch (e) {
-      }
-      const reputation = await CONFIG.hiveClient.call(
-        "condenser_api",
-        "get_account_reputations",
-        [username, 1]
-      );
-      return {
-        name: response[0].name,
-        owner: response[0].owner,
-        active: response[0].active,
-        posting: response[0].posting,
-        memo_key: response[0].memo_key,
-        post_count: response[0].post_count,
-        created: response[0].created,
-        posting_json_metadata: response[0].posting_json_metadata,
-        last_vote_time: response[0].last_vote_time,
-        last_post: response[0].last_post,
-        json_metadata: response[0].json_metadata,
-        reward_hive_balance: response[0].reward_hive_balance,
-        reward_hbd_balance: response[0].reward_hbd_balance,
-        reward_vesting_hive: response[0].reward_vesting_hive,
-        reward_vesting_balance: response[0].reward_vesting_balance,
-        balance: response[0].balance,
-        hbd_balance: response[0].hbd_balance,
-        savings_balance: response[0].savings_balance,
-        savings_hbd_balance: response[0].savings_hbd_balance,
-        savings_hbd_last_interest_payment: response[0].savings_hbd_last_interest_payment,
-        savings_hbd_seconds_last_update: response[0].savings_hbd_seconds_last_update,
-        savings_hbd_seconds: response[0].savings_hbd_seconds,
-        next_vesting_withdrawal: response[0].next_vesting_withdrawal,
-        pending_claimed_accounts: response[0].pending_claimed_accounts,
-        vesting_shares: response[0].vesting_shares,
-        delegated_vesting_shares: response[0].delegated_vesting_shares,
-        received_vesting_shares: response[0].received_vesting_shares,
-        vesting_withdraw_rate: response[0].vesting_withdraw_rate,
-        to_withdraw: response[0].to_withdraw,
-        withdrawn: response[0].withdrawn,
-        witness_votes: response[0].witness_votes,
-        proxy: response[0].proxy,
-        recovery_account: response[0].recovery_account,
-        proxied_vsf_votes: response[0].proxied_vsf_votes,
-        voting_manabar: response[0].voting_manabar,
-        voting_power: response[0].voting_power,
-        downvote_manabar: response[0].downvote_manabar,
-        follow_stats,
-        reputation: reputation[0].reputation,
-        profile: {
-          ...profile,
-          reputation: reputation[0].reputation
-        }
-      };
-    },
-    enabled: !!username,
-    staleTime: 6e4
-  });
-}
-function getSearchAccountsByUsernameQueryOptions(query, limit = 5, excludeList = []) {
-  return reactQuery.queryOptions({
-    queryKey: ["accounts", "search", query, excludeList],
-    enabled: !!query,
-    queryFn: async () => {
-      const response = await CONFIG.hiveClient.database.call(
-        "lookup_accounts",
-        [query, limit]
-      );
-      return response.filter(
-        (item) => excludeList.length > 0 ? !excludeList.includes(item) : true
-      );
-    }
-  });
-}
-function checkUsernameWalletsPendingQueryOptions(username) {
-  return reactQuery.queryOptions({
-    queryKey: ["accounts", "check-wallet-pending", username],
-    queryFn: async () => {
-      const fetchApi = getBoundFetch();
-      const response = await fetchApi(
-        CONFIG.privateApiHost + "/private-api/wallets-chkuser",
-        {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify({
-            username
-          })
-        }
-      );
-      return await response.json();
-    },
-    enabled: !!username,
-    refetchOnMount: true
-  });
-}
-function getRelationshipBetweenAccountsQueryOptions(reference, target) {
-  return reactQuery.queryOptions({
-    queryKey: ["accounts", "relations", reference, target],
-    enabled: !!reference && !!target,
-    refetchOnMount: false,
-    refetchInterval: 36e5,
-    queryFn: async () => {
-      return await CONFIG.hiveClient.call(
-        "bridge",
-        "get_relationship_between_accounts",
-        [reference, target]
-      );
-    }
-  });
-}
-function getAccountSubscriptionsQueryOptions(username) {
-  return reactQuery.queryOptions({
-    queryKey: ["accounts", "subscriptions", username],
-    enabled: !!username,
-    queryFn: async () => {
-      const response = await CONFIG.hiveClient.call(
-        "bridge",
-        "list_all_subscriptions",
-        {
-          account: username
-        }
-      );
-      return response ?? [];
-    }
-  });
-}
-function getActiveAccountBookmarksQueryOptions(activeUsername) {
-  return reactQuery.queryOptions({
-    queryKey: ["accounts", "bookmarks", activeUsername],
-    enabled: !!activeUsername,
-    queryFn: async () => {
-      if (!activeUsername) {
-        throw new Error("[SDK][Accounts][Bookmarks] \u2013 no active user");
-      }
-      const fetchApi = getBoundFetch();
-      const response = await fetchApi(
-        CONFIG.privateApiHost + "/private-api/bookmarks",
-        {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify({ code: getAccessToken(activeUsername) })
-        }
-      );
-      return await response.json();
-    }
-  });
-}
-function getActiveAccountFavouritesQueryOptions(activeUsername) {
-  return reactQuery.queryOptions({
-    queryKey: ["accounts", "favourites", activeUsername],
-    enabled: !!activeUsername,
-    queryFn: async () => {
-      if (!activeUsername) {
-        throw new Error("[SDK][Accounts][Favourites] \u2013 no active user");
-      }
-      const fetchApi = getBoundFetch();
-      const response = await fetchApi(
-        CONFIG.privateApiHost + "/private-api/favorites",
-        {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify({ code: getAccessToken(activeUsername) })
-        }
-      );
-      return await response.json();
-    }
-  });
-}
-function getAccountRecoveriesQueryOptions(username, code) {
-  return reactQuery.queryOptions({
-    enabled: !!username && !!code,
-    queryKey: ["accounts", "recoveries", username],
-    queryFn: async () => {
-      if (!username || !code) {
-        throw new Error("[SDK][Accounts] Missing username or access token");
-      }
-      const fetchApi = getBoundFetch();
-      const response = await fetchApi(
-        CONFIG.privateApiHost + "/private-api/recoveries",
-        {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify({ code })
-        }
-      );
-      return response.json();
-    }
-  });
-}
-function getAccountPendingRecoveryQueryOptions(username) {
-  return reactQuery.queryOptions({
-    enabled: !!username,
-    queryKey: ["accounts", "recoveries", username, "pending-request"],
-    queryFn: () => CONFIG.hiveClient.call(
-      "database_api",
-      "find_change_recovery_account_requests",
-      { accounts: [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 };
-  });
-}
-function getBuiltProfile({
-  profile,
-  tokens,
-  data
-}) {
-  const metadata = R__namespace.pipe(
-    JSON.parse(data?.posting_json_metadata || "{}").profile,
-    R__namespace.mergeDeep(profile ?? {})
-  );
-  if (tokens && tokens.length > 0) {
-    metadata.tokens = tokens;
-  }
-  metadata.tokens = sanitizeTokens(metadata.tokens);
-  return metadata;
-}
-function useAccountUpdate(username, accessToken, auth) {
-  const queryClient = reactQuery.useQueryClient();
-  const { data } = reactQuery.useQuery(getAccountFullQueryOptions(username));
-  return useBroadcastMutation(
-    ["accounts", "update"],
-    username,
-    accessToken,
-    (payload) => {
-      if (!data) {
-        throw new Error("[SDK][Accounts] \u2013 cannot update not existing account");
-      }
-      return [
-        [
-          "account_update2",
-          {
-            account: username,
-            json_metadata: "",
-            extensions: [],
-            posting_json_metadata: JSON.stringify({
-              profile: getBuiltProfile({ ...payload, data })
-            })
-          }
-        ]
-      ];
-    },
-    (_, variables) => queryClient.setQueryData(
-      getAccountFullQueryOptions(username).queryKey,
-      (data2) => {
-        if (!data2) {
-          return data2;
-        }
-        const obj = R__namespace.clone(data2);
-        obj.profile = getBuiltProfile({ ...variables, data: data2 });
-        return obj;
-      }
-    ),
-    auth
-  );
-}
-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 = R__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,
-      currentPassword,
-      keepCurrent
-    }) => {
-      if (!accountData) {
-        throw new Error(
-          "[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 = R__namespace.pipe(
-        {},
-        R__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 = R__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"
-        );
-      }
-      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 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/fragments",
-        {
-          method: "POST",
-          body: JSON.stringify({
-            code: getAccessToken(username)
-          }),
-          headers: {
-            "Content-Type": "application/json"
-          }
-        }
-      );
-      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;
-    }
-  });
-}
-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 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"
-        }
-      });
-    },
-    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
-          }
-        })
-      });
-    }
-  });
-}
-
-// src/modules/integrations/3speak/queries/index.ts
-var queries_exports2 = {};
-__export(queries_exports2, {
-  getAccountTokenQueryOptions: () => getAccountTokenQueryOptions,
-  getAccountVideosQueryOptions: () => getAccountVideosQueryOptions
-});
-
-// src/modules/integrations/hivesigner/queries/index.ts
-var queries_exports = {};
-__export(queries_exports, {
-  getDecodeMemoQueryOptions: () => getDecodeMemoQueryOptions
-});
-function getDecodeMemoQueryOptions(username, memo, accessToken) {
-  return reactQuery.queryOptions({
-    queryKey: ["integrations", "hivesigner", "decode-memo", username],
-    queryFn: async () => {
-      if (accessToken) {
-        const hsClient = new hs__default.default.Client({
-          accessToken
-        });
-        return hsClient.decode(memo);
-      }
-    }
-  });
-}
-
-// 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, accessToken) {
-  return reactQuery.queryOptions({
-    queryKey: ["integrations", "3speak", "authenticate", username],
-    enabled: !!username && !!accessToken,
-    queryFn: async () => {
-      if (!username || !accessToken) {
-        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,
-        accessToken
-      );
-      await getQueryClient().prefetchQuery(memoQueryOptions);
-      const { memoDecoded } = getQueryClient().getQueryData(
-        memoQueryOptions.queryKey
-      );
-      return memoDecoded.replace("#", "");
-    }
-  });
-}
-function getAccountVideosQueryOptions(username, accessToken) {
-  return reactQuery.queryOptions({
-    queryKey: ["integrations", "3speak", "videos", username],
-    enabled: !!username && !!accessToken,
-    queryFn: async () => {
-      if (!username || !accessToken) {
-        throw new Error("[SDK][Integrations][3Speak] \u2013\xA0anon user");
-      }
-      const tokenQueryOptions = getAccountTokenQueryOptions(
-        username,
-        accessToken
-      );
-      await getQueryClient().prefetchQuery(tokenQueryOptions);
-      const token = getQueryClient().getQueryData(
-        tokenQueryOptions.queryKey
-      );
-      if (!token) {
-        throw new Error("[SDK][Integrations][3Speak] \u2013 missing account token");
-      }
-      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();
-    }
-  });
-}
-
-// src/modules/integrations/3speak/index.ts
-var ThreeSpeakIntegration = {
-  queries: queries_exports2
-};
-function getHivePoshLinksQueryOptions(username) {
-  return reactQuery.queryOptions({
-    queryKey: ["integrations", "hiveposh", "links", username],
-    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
-        },
-        reddit: {
-          username: data.reddit_username,
-          profile: data.reddit_profile
-        }
-      };
-    }
-  });
-}
-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();
-    },
-    enabled: !!url && enabled
-  });
-}
-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]);
-    },
-    enabled: !!username
-  });
-}
-function getGameStatusCheckQueryOptions(username, gameType) {
-  return reactQuery.queryOptions({
-    queryKey: ["games", "status-check", gameType, username],
-    enabled: !!username,
-    queryFn: async () => {
-      if (!username) {
-        throw new Error("[SDK][Games] \u2013 anon user in status check");
-      }
-      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 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");
-      }
-      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 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 getCommunityContextQueryOptions(username, communityName) {
-  return reactQuery.queryOptions({
-    queryKey: ["community", "context", username, communityName],
-    enabled: !!username && !!communityName,
-    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
-      };
-    }
-  });
-}
-
-// 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.CONFIG = CONFIG;
-exports.EcencyAnalytics = mutations_exports;
-exports.HiveSignerIntegration = HiveSignerIntegration;
-exports.Keychain = keychain_exports;
-exports.NaiMap = NaiMap;
-exports.ROLES = ROLES;
-exports.Symbol = Symbol2;
-exports.ThreeSpeakIntegration = ThreeSpeakIntegration;
-exports.broadcastJson = broadcastJson;
-exports.checkUsernameWalletsPendingQueryOptions = checkUsernameWalletsPendingQueryOptions;
-exports.decodeObj = decodeObj;
-exports.dedupeAndSortKeyAuths = dedupeAndSortKeyAuths;
-exports.encodeObj = encodeObj;
-exports.getAccessToken = getAccessToken;
-exports.getAccountFullQueryOptions = getAccountFullQueryOptions;
-exports.getAccountPendingRecoveryQueryOptions = getAccountPendingRecoveryQueryOptions;
-exports.getAccountRcQueryOptions = getAccountRcQueryOptions;
-exports.getAccountRecoveriesQueryOptions = getAccountRecoveriesQueryOptions;
-exports.getAccountSubscriptionsQueryOptions = getAccountSubscriptionsQueryOptions;
-exports.getActiveAccountBookmarksQueryOptions = getActiveAccountBookmarksQueryOptions;
-exports.getActiveAccountFavouritesQueryOptions = getActiveAccountFavouritesQueryOptions;
-exports.getBoundFetch = getBoundFetch;
-exports.getChainPropertiesQueryOptions = getChainPropertiesQueryOptions;
-exports.getCommunitiesQueryOptions = getCommunitiesQueryOptions;
-exports.getCommunityContextQueryOptions = getCommunityContextQueryOptions;
-exports.getCommunityPermissions = getCommunityPermissions;
-exports.getCommunityType = getCommunityType;
-exports.getDynamicPropsQueryOptions = getDynamicPropsQueryOptions;
-exports.getFragmentsQueryOptions = getFragmentsQueryOptions;
-exports.getGameStatusCheckQueryOptions = getGameStatusCheckQueryOptions;
-exports.getHivePoshLinksQueryOptions = getHivePoshLinksQueryOptions;
-exports.getLoginType = getLoginType;
-exports.getPostingKey = getPostingKey;
-exports.getPromotedPostsQuery = getPromotedPostsQuery;
-exports.getQueryClient = getQueryClient;
-exports.getRcStatsQueryOptions = getRcStatsQueryOptions;
-exports.getRefreshToken = getRefreshToken;
-exports.getRelationshipBetweenAccountsQueryOptions = getRelationshipBetweenAccountsQueryOptions;
-exports.getSearchAccountsByUsernameQueryOptions = getSearchAccountsByUsernameQueryOptions;
-exports.getStatsQueryOptions = getStatsQueryOptions;
-exports.getTrendingTagsQueryOptions = getTrendingTagsQueryOptions;
-exports.getUser = getUser;
-exports.makeQueryClient = makeQueryClient;
-exports.parseAsset = parseAsset;
-exports.roleMap = roleMap;
-exports.useAccountFavouriteAdd = useAccountFavouriteAdd;
-exports.useAccountFavouriteDelete = useAccountFavouriteDelete;
-exports.useAccountRelationsUpdate = useAccountRelationsUpdate;
-exports.useAccountRevokeKey = useAccountRevokeKey;
-exports.useAccountRevokePosting = useAccountRevokePosting;
-exports.useAccountUpdate = useAccountUpdate;
-exports.useAccountUpdateKeyAuths = useAccountUpdateKeyAuths;
-exports.useAccountUpdatePassword = useAccountUpdatePassword;
-exports.useAccountUpdateRecovery = useAccountUpdateRecovery;
-exports.useAddFragment = useAddFragment;
-exports.useBookmarkAdd = useBookmarkAdd;
-exports.useBookmarkDelete = useBookmarkDelete;
-exports.useBroadcastMutation = useBroadcastMutation;
-exports.useEditFragment = useEditFragment;
-exports.useGameClaim = useGameClaim;
-exports.useRemoveFragment = useRemoveFragment;
-exports.useSignOperationByHivesigner = useSignOperationByHivesigner;
-exports.useSignOperationByKey = useSignOperationByKey;
-exports.useSignOperationByKeychain = useSignOperationByKeychain;
-//# sourceMappingURL=index.cjs.map
-//# sourceMappingURL=index.cjs.map