@ecency/sdk 1.5.26 → 1.5.28

package/dist/browser/index.js

@@ -8,8 +8,315 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+
+// src/modules/core/errors/chain-errors.ts
+var ErrorType = /* @__PURE__ */ ((ErrorType2) => {
+  ErrorType2["COMMON"] = "common";
+  ErrorType2["INFO"] = "info";
+  ErrorType2["INSUFFICIENT_RESOURCE_CREDITS"] = "insufficient_resource_credits";
+  ErrorType2["MISSING_AUTHORITY"] = "missing_authority";
+  ErrorType2["TOKEN_EXPIRED"] = "token_expired";
+  ErrorType2["NETWORK"] = "network";
+  ErrorType2["TIMEOUT"] = "timeout";
+  ErrorType2["VALIDATION"] = "validation";
+  return ErrorType2;
+})(ErrorType || {});
+function parseChainError(error) {
+  const errorDescription = error?.error_description ? String(error.error_description) : "";
+  const errorMessage = error?.message ? String(error.message) : "";
+  const errorString = errorDescription || errorMessage || String(error || "");
+  const testPattern = (pattern) => {
+    if (errorDescription && pattern.test(errorDescription)) return true;
+    if (errorMessage && pattern.test(errorMessage)) return true;
+    if (errorString && pattern.test(errorString)) return true;
+    return false;
+  };
+  if (testPattern(/please wait to transact/i) || testPattern(/insufficient rc/i) || testPattern(/rc mana|rc account|resource credits/i)) {
+    return {
+      message: "Insufficient Resource Credits. Please wait or power up.",
+      type: "insufficient_resource_credits" /* INSUFFICIENT_RESOURCE_CREDITS */,
+      originalError: error
+    };
+  }
+  if (testPattern(/you may only post once every/i)) {
+    return {
+      message: "Please wait before posting again (minimum 3 second interval between comments).",
+      type: "common" /* COMMON */,
+      originalError: error
+    };
+  }
+  if (testPattern(/your current vote on this comment is identical/i)) {
+    return {
+      message: "You have already voted with the same weight.",
+      type: "info" /* INFO */,
+      originalError: error
+    };
+  }
+  if (testPattern(/must claim something/i)) {
+    return {
+      message: "You must claim rewards before performing this action.",
+      type: "info" /* INFO */,
+      originalError: error
+    };
+  }
+  if (testPattern(/cannot claim that much vests/i)) {
+    return {
+      message: "Cannot claim that amount. Please check your pending rewards.",
+      type: "info" /* INFO */,
+      originalError: error
+    };
+  }
+  if (testPattern(/cannot delete a comment with net positive/i)) {
+    return {
+      message: "Cannot delete a comment with positive votes.",
+      type: "info" /* INFO */,
+      originalError: error
+    };
+  }
+  if (testPattern(/children == 0/i)) {
+    return {
+      message: "Cannot delete a comment with replies.",
+      type: "common" /* COMMON */,
+      originalError: error
+    };
+  }
+  if (testPattern(/comment_cashout/i)) {
+    return {
+      message: "Cannot modify a comment that has already been paid out.",
+      type: "common" /* COMMON */,
+      originalError: error
+    };
+  }
+  if (testPattern(/votes evaluating for comment that is paid out is forbidden/i)) {
+    return {
+      message: "Cannot vote on posts that have already been paid out.",
+      type: "common" /* COMMON */,
+      originalError: error
+    };
+  }
+  if (testPattern(/missing active authority/i)) {
+    return {
+      message: "Missing active authority. This operation requires your active key.",
+      type: "missing_authority" /* MISSING_AUTHORITY */,
+      originalError: error
+    };
+  }
+  if (testPattern(/missing owner authority/i)) {
+    return {
+      message: "Missing owner authority. This operation requires your owner key.",
+      type: "missing_authority" /* MISSING_AUTHORITY */,
+      originalError: error
+    };
+  }
+  if (testPattern(/missing (required )?posting authority/i)) {
+    return {
+      message: "Missing posting authority. Please check your login method.",
+      type: "missing_authority" /* MISSING_AUTHORITY */,
+      originalError: error
+    };
+  }
+  if (testPattern(/token expired/i) || testPattern(/invalid token/i)) {
+    return {
+      message: "Authentication token expired. Please log in again.",
+      type: "token_expired" /* TOKEN_EXPIRED */,
+      originalError: error
+    };
+  }
+  if (testPattern(/has already reblogged/i) || testPattern(/already reblogged this post/i)) {
+    return {
+      message: "You have already reblogged this post.",
+      type: "info" /* INFO */,
+      originalError: error
+    };
+  }
+  if (testPattern(/duplicate transaction/i)) {
+    return {
+      message: "This transaction has already been processed.",
+      type: "info" /* INFO */,
+      originalError: error
+    };
+  }
+  if (testPattern(/econnrefused/i) || testPattern(/connection refused/i) || testPattern(/failed to fetch/i) || testPattern(/\bnetwork[-\s]?(request|error|timeout|unreachable|down|failed)\b/i)) {
+    return {
+      message: "Network error. Please check your connection and try again.",
+      type: "network" /* NETWORK */,
+      originalError: error
+    };
+  }
+  if (testPattern(/timeout/i) || testPattern(/timed out/i)) {
+    return {
+      message: "Request timed out. Please try again.",
+      type: "timeout" /* TIMEOUT */,
+      originalError: error
+    };
+  }
+  if (testPattern(/account.*does not exist/i) || testPattern(/account not found/i)) {
+    return {
+      message: "Account not found. Please check the username.",
+      type: "validation" /* VALIDATION */,
+      originalError: error
+    };
+  }
+  if (testPattern(/invalid memo key/i)) {
+    return {
+      message: "Invalid memo key. Cannot encrypt message.",
+      type: "validation" /* VALIDATION */,
+      originalError: error
+    };
+  }
+  if (testPattern(/(?:insufficient.*(?:funds|balance)|(?:funds|balance).*insufficient)/i)) {
+    return {
+      message: "Insufficient funds for this transaction.",
+      type: "validation" /* VALIDATION */,
+      originalError: error
+    };
+  }
+  if (testPattern(/\b(invalid|validation)\b/i)) {
+    const message2 = (error?.message || errorString).substring(0, 150) || "Validation error occurred";
+    return {
+      message: message2,
+      type: "validation" /* VALIDATION */,
+      originalError: error
+    };
+  }
+  if (error?.error_description && typeof error.error_description === "string") {
+    return {
+      message: error.error_description.substring(0, 150),
+      type: "common" /* COMMON */,
+      originalError: error
+    };
+  }
+  if (error?.message && typeof error.message === "string") {
+    return {
+      message: error.message.substring(0, 150),
+      type: "common" /* COMMON */,
+      originalError: error
+    };
+  }
+  let message;
+  if (typeof error === "object" && error !== null) {
+    if (error.error_description) {
+      message = String(error.error_description);
+    } else if (error.code) {
+      message = `Error code: ${error.code}`;
+    } else if (errorString && errorString !== "[object Object]") {
+      message = errorString.substring(0, 150);
+    } else {
+      message = "Unknown error occurred";
+    }
+  } else {
+    message = errorString.substring(0, 150) || "Unknown error occurred";
+  }
+  return {
+    message,
+    type: "common" /* COMMON */,
+    originalError: error
+  };
+}
+function formatError(error) {
+  const parsed = parseChainError(error);
+  return [parsed.message, parsed.type];
+}
+function shouldTriggerAuthFallback(error) {
+  const { type } = parseChainError(error);
+  return type === "missing_authority" /* MISSING_AUTHORITY */ || type === "token_expired" /* TOKEN_EXPIRED */;
+}
+function isResourceCreditsError(error) {
+  const { type } = parseChainError(error);
+  return type === "insufficient_resource_credits" /* INSUFFICIENT_RESOURCE_CREDITS */;
+}
+function isInfoError(error) {
+  const { type } = parseChainError(error);
+  return type === "info" /* INFO */;
+}
+function isNetworkError(error) {
+  const { type } = parseChainError(error);
+  return type === "network" /* NETWORK */ || type === "timeout" /* TIMEOUT */;
+}
+async function broadcastWithFallback(username, ops2, auth, authority = "posting") {
+  const chain = auth?.fallbackChain ?? ["key", "hiveauth", "hivesigner", "keychain", "custom"];
+  const errors = /* @__PURE__ */ new Map();
+  const adapter = auth?.adapter;
+  for (const method of chain) {
+    try {
+      switch (method) {
+        case "key": {
+          if (!adapter) {
+            errors.set(method, new Error("Skipped: No adapter provided"));
+            break;
+          }
+          let key;
+          if (authority === "active" && adapter.getActiveKey) {
+            key = await adapter.getActiveKey(username);
+          } else if (authority === "posting") {
+            key = await adapter.getPostingKey(username);
+          }
+          if (!key) {
+            errors.set(method, new Error(`Skipped: No ${authority} key available`));
+            break;
+          }
+          const privateKey = PrivateKey.fromString(key);
+          return await CONFIG.hiveClient.broadcast.sendOperations(ops2, privateKey);
+        }
+        case "hiveauth": {
+          if (!adapter?.broadcastWithHiveAuth) {
+            errors.set(method, new Error("Skipped: HiveAuth not supported by adapter"));
+            break;
+          }
+          return await adapter.broadcastWithHiveAuth(username, ops2, authority);
+        }
+        case "hivesigner": {
+          if (!adapter) {
+            errors.set(method, new Error("Skipped: No adapter provided"));
+            break;
+          }
+          const token = await adapter.getAccessToken(username);
+          if (!token) {
+            errors.set(method, new Error("Skipped: No access token available"));
+            break;
+          }
+          const client = new hs.Client({ accessToken: token });
+          const response = await client.broadcast(ops2);
+          return response.result;
+        }
+        case "keychain": {
+          if (!adapter?.broadcastWithKeychain) {
+            errors.set(method, new Error("Skipped: Keychain not supported by adapter"));
+            break;
+          }
+          return await adapter.broadcastWithKeychain(username, ops2, authority);
+        }
+        case "custom": {
+          if (!auth?.broadcast) {
+            errors.set(method, new Error("Skipped: No custom broadcast function provided"));
+            break;
+          }
+          return await auth.broadcast(ops2, authority);
+        }
+      }
+    } catch (error) {
+      errors.set(method, error);
+      if (!shouldTriggerAuthFallback(error)) {
+        throw error;
+      }
+    }
+  }
+  const hasRealAttempts = Array.from(errors.values()).some(
+    (error) => !error.message.startsWith("Skipped:")
+  );
+  if (!hasRealAttempts) {
+    const skipReasons = Array.from(errors.entries()).map(([method, error]) => `${method}: ${error.message}`).join(", ");
+    throw new Error(
+      `[SDK][Broadcast] No auth methods attempted for ${username}. ${skipReasons}`
+    );
+  }
+  const errorMessages = Array.from(errors.entries()).map(([method, error]) => `${method}: ${error.message}`).join(", ");
+  throw new Error(
+    `[SDK][Broadcast] All auth methods failed for ${username}. Errors: ${errorMessages}`
+  );
+}
 function useBroadcastMutation(mutationKey = [], username, operations, onSuccess = () => {
-}, auth) {
+}, auth, authority = "posting") {
   return useMutation({
     onSuccess,
     mutationKey: [...mutationKey, username],
@@ -19,20 +326,23 @@ function useBroadcastMutation(mutationKey = [], username, operations, onSuccess
           "[Core][Broadcast] Attempted to call broadcast API with anon user"
         );
       }
+      const ops2 = operations(payload);
+      if (auth?.enableFallback !== false && auth?.adapter) {
+        return broadcastWithFallback(username, ops2, auth, authority);
+      }
       if (auth?.broadcast) {
-        return auth.broadcast(operations(payload), "posting");
+        return auth.broadcast(ops2, authority);
       }
       const postingKey = auth?.postingKey;
       if (postingKey) {
         const privateKey = PrivateKey.fromString(postingKey);
         return CONFIG.hiveClient.broadcast.sendOperations(
-          operations(payload),
+          ops2,
           privateKey
         );
       }
       const accessToken = auth?.accessToken;
       if (accessToken) {
-        const ops2 = operations(payload);
         const client = new hs.Client({ accessToken });
         const response = await client.broadcast(ops2);
         return response.result;
@@ -3321,123 +3631,1134 @@ function votingValue(account, dynamicProps, votingPowerValue, weight = 1e4) {
   }
   return rShares / fundRecentClaims * fundRewardBalance * (base / quote);
 }
-function useSignOperationByKey(username) {
-  return useMutation({
-    mutationKey: ["operations", "sign", username],
-    mutationFn: ({
-      operation,
-      keyOrSeed
-    }) => {
-      if (!username) {
-        throw new Error("[Operations][Sign] \u2013 cannot sign op with anon user");
-      }
-      let privateKey;
-      if (keyOrSeed.split(" ").length === 12) {
-        privateKey = PrivateKey.fromLogin(username, keyOrSeed, "active");
-      } else if (cryptoUtils.isWif(keyOrSeed)) {
-        privateKey = PrivateKey.fromString(keyOrSeed);
-      } else {
-        privateKey = PrivateKey.from(keyOrSeed);
-      }
-      return CONFIG.hiveClient.broadcast.sendOperations(
-        [operation],
-        privateKey
-      );
+
+// src/modules/operations/builders/content.ts
+function buildVoteOp(voter, author, permlink, weight) {
+  if (!voter || !author || !permlink) {
+    throw new Error("[SDK][buildVoteOp] Missing required parameters");
+  }
+  if (weight < -1e4 || weight > 1e4) {
+    throw new Error("[SDK][buildVoteOp] Weight must be between -10000 and 10000");
+  }
+  return [
+    "vote",
+    {
+      voter,
+      author,
+      permlink,
+      weight
     }
-  });
+  ];
 }
-function useSignOperationByKeychain(username, auth, keyType = "active") {
-  return useMutation({
-    mutationKey: ["operations", "sign-keychain", username],
-    mutationFn: ({ operation }) => {
-      if (!username) {
-        throw new Error(
-          "[SDK][Keychain] \u2013\xA0cannot sign operation with anon user"
-        );
-      }
-      if (!auth?.broadcast) {
-        throw new Error("[SDK][Keychain] \u2013 missing keychain broadcaster");
-      }
-      return auth.broadcast([operation], keyType);
+function buildCommentOp(author, permlink, parentAuthor, parentPermlink, title, body, jsonMetadata) {
+  if (!author || !permlink || parentPermlink === void 0 || !body) {
+    throw new Error("[SDK][buildCommentOp] Missing required parameters");
+  }
+  return [
+    "comment",
+    {
+      parent_author: parentAuthor,
+      parent_permlink: parentPermlink,
+      author,
+      permlink,
+      title,
+      body,
+      json_metadata: JSON.stringify(jsonMetadata)
     }
-  });
+  ];
 }
-function useSignOperationByHivesigner(callbackUri = "/") {
-  return useMutation({
-    mutationKey: ["operations", "sign-hivesigner", callbackUri],
-    mutationFn: async ({ operation }) => {
-      return hs.sendOperation(operation, { callback: callbackUri }, () => {
-      });
+function buildCommentOptionsOp(author, permlink, maxAcceptedPayout, percentHbd, allowVotes, allowCurationRewards, extensions) {
+  if (!author || !permlink) {
+    throw new Error("[SDK][buildCommentOptionsOp] Missing required parameters");
+  }
+  return [
+    "comment_options",
+    {
+      author,
+      permlink,
+      max_accepted_payout: maxAcceptedPayout,
+      percent_hbd: percentHbd,
+      allow_votes: allowVotes,
+      allow_curation_rewards: allowCurationRewards,
+      extensions
     }
-  });
+  ];
 }
-function getChainPropertiesQueryOptions() {
-  return queryOptions({
-    queryKey: ["operations", "chain-properties"],
-    queryFn: async () => {
-      return await CONFIG.hiveClient.database.getChainProperties();
+function buildDeleteCommentOp(author, permlink) {
+  if (!author || !permlink) {
+    throw new Error("[SDK][buildDeleteCommentOp] Missing required parameters");
+  }
+  return [
+    "delete_comment",
+    {
+      author,
+      permlink
     }
-  });
+  ];
 }
-function useAddFragment(username, code) {
-  return useMutation({
-    mutationKey: ["posts", "add-fragment", username],
-    mutationFn: async ({ title, body }) => {
-      if (!code) {
-        throw new Error("[SDK][Posts] Missing access token");
-      }
-      const fetchApi = getBoundFetch();
-      const response = await fetchApi(
-        CONFIG.privateApiHost + "/private-api/fragments-add",
-        {
-          method: "POST",
-          body: JSON.stringify({
-            code,
-            title,
-            body
-          }),
-          headers: {
-            "Content-Type": "application/json"
-          }
-        }
-      );
-      return response.json();
-    },
-    onSuccess(response) {
-      const queryClient = getQueryClient();
-      queryClient.setQueryData(
-        getFragmentsQueryOptions(username, code).queryKey,
-        (data) => [response, ...data ?? []]
-      );
-      queryClient.setQueriesData(
-        { queryKey: ["posts", "fragments", "infinite", username] },
-        (oldData) => {
-          if (!oldData) return oldData;
-          return {
-            ...oldData,
-            pages: oldData.pages.map(
-              (page, index) => index === 0 ? { ...page, data: [response, ...page.data] } : page
-            )
-          };
-        }
-      );
+function buildReblogOp(account, author, permlink, deleteReblog = false) {
+  if (!account || !author || !permlink) {
+    throw new Error("[SDK][buildReblogOp] Missing required parameters");
+  }
+  const json = {
+    account,
+    author,
+    permlink
+  };
+  if (deleteReblog) {
+    json.delete = "delete";
+  }
+  return [
+    "custom_json",
+    {
+      id: "follow",
+      json: JSON.stringify(["reblog", json]),
+      required_auths: [],
+      required_posting_auths: [account]
     }
-  });
+  ];
 }
-function useEditFragment(username, code) {
-  return useMutation({
-    mutationKey: ["posts", "edit-fragment", username],
-    mutationFn: async ({
-      fragmentId,
-      title,
-      body
-    }) => {
-      if (!code) {
-        throw new Error("[SDK][Posts] Missing access token");
-      }
-      const fetchApi = getBoundFetch();
-      const response = await fetchApi(
-        CONFIG.privateApiHost + "/private-api/fragments-update",
+
+// src/modules/operations/builders/wallet.ts
+function buildTransferOp(from, to, amount, memo) {
+  if (!from || !to || !amount) {
+    throw new Error("[SDK][buildTransferOp] Missing required parameters");
+  }
+  return [
+    "transfer",
+    {
+      from,
+      to,
+      amount,
+      memo: memo || ""
+    }
+  ];
+}
+function buildMultiTransferOps(from, destinations, amount, memo) {
+  if (!from || !destinations || !amount) {
+    throw new Error("[SDK][buildMultiTransferOps] Missing required parameters");
+  }
+  const destArray = destinations.trim().split(/[\s,]+/).filter(Boolean);
+  return destArray.map(
+    (dest) => buildTransferOp(from, dest.trim(), amount, memo)
+  );
+}
+function buildRecurrentTransferOp(from, to, amount, memo, recurrence, executions) {
+  if (!from || !to || !amount) {
+    throw new Error("[SDK][buildRecurrentTransferOp] Missing required parameters");
+  }
+  if (recurrence < 24) {
+    throw new Error("[SDK][buildRecurrentTransferOp] Recurrence must be at least 24 hours");
+  }
+  return [
+    "recurrent_transfer",
+    {
+      from,
+      to,
+      amount,
+      memo: memo || "",
+      recurrence,
+      executions,
+      extensions: []
+    }
+  ];
+}
+function buildTransferToSavingsOp(from, to, amount, memo) {
+  if (!from || !to || !amount) {
+    throw new Error("[SDK][buildTransferToSavingsOp] Missing required parameters");
+  }
+  return [
+    "transfer_to_savings",
+    {
+      from,
+      to,
+      amount,
+      memo: memo || ""
+    }
+  ];
+}
+function buildTransferFromSavingsOp(from, to, amount, memo, requestId) {
+  if (!from || !to || !amount || requestId === void 0) {
+    throw new Error("[SDK][buildTransferFromSavingsOp] Missing required parameters");
+  }
+  return [
+    "transfer_from_savings",
+    {
+      from,
+      to,
+      amount,
+      memo: memo || "",
+      request_id: requestId
+    }
+  ];
+}
+function buildCancelTransferFromSavingsOp(from, requestId) {
+  if (!from || requestId === void 0) {
+    throw new Error("[SDK][buildCancelTransferFromSavingsOp] Missing required parameters");
+  }
+  return [
+    "cancel_transfer_from_savings",
+    {
+      from,
+      request_id: requestId
+    }
+  ];
+}
+function buildClaimInterestOps(from, to, amount, memo, requestId) {
+  if (!from || !to || !amount || requestId === void 0) {
+    throw new Error("[SDK][buildClaimInterestOps] Missing required parameters");
+  }
+  return [
+    buildTransferFromSavingsOp(from, to, amount, memo, requestId),
+    buildCancelTransferFromSavingsOp(from, requestId)
+  ];
+}
+function buildTransferToVestingOp(from, to, amount) {
+  if (!from || !to || !amount) {
+    throw new Error("[SDK][buildTransferToVestingOp] Missing required parameters");
+  }
+  return [
+    "transfer_to_vesting",
+    {
+      from,
+      to,
+      amount
+    }
+  ];
+}
+function buildWithdrawVestingOp(account, vestingShares) {
+  if (!account || !vestingShares) {
+    throw new Error("[SDK][buildWithdrawVestingOp] Missing required parameters");
+  }
+  return [
+    "withdraw_vesting",
+    {
+      account,
+      vesting_shares: vestingShares
+    }
+  ];
+}
+function buildDelegateVestingSharesOp(delegator, delegatee, vestingShares) {
+  if (!delegator || !delegatee || !vestingShares) {
+    throw new Error("[SDK][buildDelegateVestingSharesOp] Missing required parameters");
+  }
+  return [
+    "delegate_vesting_shares",
+    {
+      delegator,
+      delegatee,
+      vesting_shares: vestingShares
+    }
+  ];
+}
+function buildSetWithdrawVestingRouteOp(fromAccount, toAccount, percent, autoVest) {
+  if (!fromAccount || !toAccount || percent === void 0) {
+    throw new Error("[SDK][buildSetWithdrawVestingRouteOp] Missing required parameters");
+  }
+  if (percent < 0 || percent > 1e4) {
+    throw new Error("[SDK][buildSetWithdrawVestingRouteOp] Percent must be between 0 and 10000");
+  }
+  return [
+    "set_withdraw_vesting_route",
+    {
+      from_account: fromAccount,
+      to_account: toAccount,
+      percent,
+      auto_vest: autoVest
+    }
+  ];
+}
+function buildConvertOp(owner, amount, requestId) {
+  if (!owner || !amount || requestId === void 0) {
+    throw new Error("[SDK][buildConvertOp] Missing required parameters");
+  }
+  return [
+    "convert",
+    {
+      owner,
+      amount,
+      requestid: requestId
+    }
+  ];
+}
+function buildCollateralizedConvertOp(owner, amount, requestId) {
+  if (!owner || !amount || requestId === void 0) {
+    throw new Error("[SDK][buildCollateralizedConvertOp] Missing required parameters");
+  }
+  return [
+    "collateralized_convert",
+    {
+      owner,
+      amount,
+      requestid: requestId
+    }
+  ];
+}
+function buildDelegateRcOp(from, delegatees, maxRc) {
+  if (!from || !delegatees || maxRc === void 0) {
+    throw new Error("[SDK][buildDelegateRcOp] Missing required parameters");
+  }
+  const delegateeArray = delegatees.includes(",") ? delegatees.split(",").map((d) => d.trim()) : [delegatees];
+  return [
+    "custom_json",
+    {
+      id: "rc",
+      json: JSON.stringify([
+        "delegate_rc",
+        {
+          from,
+          delegatees: delegateeArray,
+          max_rc: maxRc
+        }
+      ]),
+      required_auths: [],
+      required_posting_auths: [from]
+    }
+  ];
+}
+
+// src/modules/operations/builders/social.ts
+function buildFollowOp(follower, following) {
+  if (!follower || !following) {
+    throw new Error("[SDK][buildFollowOp] Missing required parameters");
+  }
+  return [
+    "custom_json",
+    {
+      id: "follow",
+      json: JSON.stringify([
+        "follow",
+        {
+          follower,
+          following,
+          what: ["blog"]
+        }
+      ]),
+      required_auths: [],
+      required_posting_auths: [follower]
+    }
+  ];
+}
+function buildUnfollowOp(follower, following) {
+  if (!follower || !following) {
+    throw new Error("[SDK][buildUnfollowOp] Missing required parameters");
+  }
+  return [
+    "custom_json",
+    {
+      id: "follow",
+      json: JSON.stringify([
+        "follow",
+        {
+          follower,
+          following,
+          what: []
+        }
+      ]),
+      required_auths: [],
+      required_posting_auths: [follower]
+    }
+  ];
+}
+function buildIgnoreOp(follower, following) {
+  if (!follower || !following) {
+    throw new Error("[SDK][buildIgnoreOp] Missing required parameters");
+  }
+  return [
+    "custom_json",
+    {
+      id: "follow",
+      json: JSON.stringify([
+        "follow",
+        {
+          follower,
+          following,
+          what: ["ignore"]
+        }
+      ]),
+      required_auths: [],
+      required_posting_auths: [follower]
+    }
+  ];
+}
+function buildUnignoreOp(follower, following) {
+  if (!follower || !following) {
+    throw new Error("[SDK][buildUnignoreOp] Missing required parameters");
+  }
+  return buildUnfollowOp(follower, following);
+}
+function buildSetLastReadOps(username, date) {
+  if (!username) {
+    throw new Error("[SDK][buildSetLastReadOps] Missing required parameters");
+  }
+  const lastReadDate = date || (/* @__PURE__ */ new Date()).toISOString().split(".")[0];
+  const notifyOp = [
+    "custom_json",
+    {
+      id: "notify",
+      json: JSON.stringify(["setLastRead", { date: lastReadDate }]),
+      required_auths: [],
+      required_posting_auths: [username]
+    }
+  ];
+  const ecencyNotifyOp = [
+    "custom_json",
+    {
+      id: "ecency_notify",
+      json: JSON.stringify(["setLastRead", { date: lastReadDate }]),
+      required_auths: [],
+      required_posting_auths: [username]
+    }
+  ];
+  return [notifyOp, ecencyNotifyOp];
+}
+
+// src/modules/operations/builders/governance.ts
+function buildWitnessVoteOp(account, witness, approve) {
+  if (!account || !witness || approve === void 0) {
+    throw new Error("[SDK][buildWitnessVoteOp] Missing required parameters");
+  }
+  return [
+    "account_witness_vote",
+    {
+      account,
+      witness,
+      approve
+    }
+  ];
+}
+function buildWitnessProxyOp(account, proxy) {
+  if (!account || proxy === void 0) {
+    throw new Error("[SDK][buildWitnessProxyOp] Missing required parameters");
+  }
+  return [
+    "account_witness_proxy",
+    {
+      account,
+      proxy
+    }
+  ];
+}
+function buildProposalCreateOp(creator, payload) {
+  if (!creator || !payload.receiver || !payload.subject || !payload.permlink || !payload.start || !payload.end || !payload.dailyPay) {
+    throw new Error("[SDK][buildProposalCreateOp] Missing required parameters");
+  }
+  const startDate = new Date(payload.start);
+  const endDate = new Date(payload.end);
+  if (startDate.toString() === "Invalid Date" || endDate.toString() === "Invalid Date") {
+    throw new Error(
+      "[SDK][buildProposalCreateOp] Invalid date format: start and end must be valid ISO date strings"
+    );
+  }
+  return [
+    "create_proposal",
+    {
+      creator,
+      receiver: payload.receiver,
+      start_date: payload.start,
+      end_date: payload.end,
+      daily_pay: payload.dailyPay,
+      subject: payload.subject,
+      permlink: payload.permlink,
+      extensions: []
+    }
+  ];
+}
+function buildProposalVoteOp(voter, proposalIds, approve) {
+  if (!voter || !proposalIds || proposalIds.length === 0 || approve === void 0) {
+    throw new Error("[SDK][buildProposalVoteOp] Missing required parameters");
+  }
+  return [
+    "update_proposal_votes",
+    {
+      voter,
+      proposal_ids: proposalIds,
+      approve,
+      extensions: []
+    }
+  ];
+}
+function buildRemoveProposalOp(proposalOwner, proposalIds) {
+  if (!proposalOwner || !proposalIds || proposalIds.length === 0) {
+    throw new Error("[SDK][buildRemoveProposalOp] Missing required parameters");
+  }
+  return [
+    "remove_proposal",
+    {
+      proposal_owner: proposalOwner,
+      proposal_ids: proposalIds,
+      extensions: []
+    }
+  ];
+}
+function buildUpdateProposalOp(proposalId, creator, dailyPay, subject, permlink) {
+  if (proposalId === void 0 || proposalId === null || typeof proposalId !== "number" || !creator || !dailyPay || !subject || !permlink) {
+    throw new Error("[SDK][buildUpdateProposalOp] Missing required parameters");
+  }
+  return [
+    "update_proposal",
+    {
+      proposal_id: proposalId,
+      creator,
+      daily_pay: dailyPay,
+      subject,
+      permlink,
+      extensions: []
+    }
+  ];
+}
+
+// src/modules/operations/builders/community.ts
+function buildSubscribeOp(username, community) {
+  if (!username || !community) {
+    throw new Error("[SDK][buildSubscribeOp] Missing required parameters");
+  }
+  return [
+    "custom_json",
+    {
+      id: "community",
+      json: JSON.stringify(["subscribe", { community }]),
+      required_auths: [],
+      required_posting_auths: [username]
+    }
+  ];
+}
+function buildUnsubscribeOp(username, community) {
+  if (!username || !community) {
+    throw new Error("[SDK][buildUnsubscribeOp] Missing required parameters");
+  }
+  return [
+    "custom_json",
+    {
+      id: "community",
+      json: JSON.stringify(["unsubscribe", { community }]),
+      required_auths: [],
+      required_posting_auths: [username]
+    }
+  ];
+}
+function buildSetRoleOp(username, community, account, role) {
+  if (!username || !community || !account || !role) {
+    throw new Error("[SDK][buildSetRoleOp] Missing required parameters");
+  }
+  return [
+    "custom_json",
+    {
+      id: "community",
+      json: JSON.stringify(["setRole", { community, account, role }]),
+      required_auths: [],
+      required_posting_auths: [username]
+    }
+  ];
+}
+function buildUpdateCommunityOp(username, community, props) {
+  if (!username || !community || !props) {
+    throw new Error("[SDK][buildUpdateCommunityOp] Missing required parameters");
+  }
+  return [
+    "custom_json",
+    {
+      id: "community",
+      json: JSON.stringify(["updateProps", { community, props }]),
+      required_auths: [],
+      required_posting_auths: [username]
+    }
+  ];
+}
+function buildPinPostOp(username, community, account, permlink, pin) {
+  if (!username || !community || !account || !permlink || pin === void 0) {
+    throw new Error("[SDK][buildPinPostOp] Missing required parameters");
+  }
+  const action = pin ? "pinPost" : "unpinPost";
+  return [
+    "custom_json",
+    {
+      id: "community",
+      json: JSON.stringify([action, { community, account, permlink }]),
+      required_auths: [],
+      required_posting_auths: [username]
+    }
+  ];
+}
+function buildMutePostOp(username, community, account, permlink, notes, mute) {
+  if (!username || !community || !account || !permlink || mute === void 0) {
+    throw new Error("[SDK][buildMutePostOp] Missing required parameters");
+  }
+  const action = mute ? "mutePost" : "unmutePost";
+  return [
+    "custom_json",
+    {
+      id: "community",
+      json: JSON.stringify([action, { community, account, permlink, notes }]),
+      required_auths: [],
+      required_posting_auths: [username]
+    }
+  ];
+}
+function buildMuteUserOp(username, community, account, notes, mute) {
+  if (!username || !community || !account || mute === void 0) {
+    throw new Error("[SDK][buildMuteUserOp] Missing required parameters");
+  }
+  const action = mute ? "muteUser" : "unmuteUser";
+  return [
+    "custom_json",
+    {
+      id: "community",
+      json: JSON.stringify([action, { community, account, notes }]),
+      required_auths: [],
+      required_posting_auths: [username]
+    }
+  ];
+}
+function buildFlagPostOp(username, community, account, permlink, notes) {
+  if (!username || !community || !account || !permlink) {
+    throw new Error("[SDK][buildFlagPostOp] Missing required parameters");
+  }
+  return [
+    "custom_json",
+    {
+      id: "community",
+      json: JSON.stringify(["flagPost", { community, account, permlink, notes }]),
+      required_auths: [],
+      required_posting_auths: [username]
+    }
+  ];
+}
+
+// src/modules/operations/builders/market.ts
+var BuySellTransactionType = /* @__PURE__ */ ((BuySellTransactionType2) => {
+  BuySellTransactionType2["Buy"] = "buy";
+  BuySellTransactionType2["Sell"] = "sell";
+  return BuySellTransactionType2;
+})(BuySellTransactionType || {});
+var OrderIdPrefix = /* @__PURE__ */ ((OrderIdPrefix2) => {
+  OrderIdPrefix2["EMPTY"] = "";
+  OrderIdPrefix2["SWAP"] = "9";
+  return OrderIdPrefix2;
+})(OrderIdPrefix || {});
+function buildLimitOrderCreateOp(owner, amountToSell, minToReceive, fillOrKill, expiration, orderId) {
+  if (!owner || !amountToSell || !minToReceive || !expiration || orderId === void 0) {
+    throw new Error("[SDK][buildLimitOrderCreateOp] Missing required parameters");
+  }
+  return [
+    "limit_order_create",
+    {
+      owner,
+      orderid: orderId,
+      amount_to_sell: amountToSell,
+      min_to_receive: minToReceive,
+      fill_or_kill: fillOrKill,
+      expiration
+    }
+  ];
+}
+function formatNumber(value, decimals = 3) {
+  return value.toFixed(decimals);
+}
+function buildLimitOrderCreateOpWithType(owner, amountToSell, minToReceive, orderType, idPrefix = "" /* EMPTY */) {
+  if (!owner || orderType === void 0 || !Number.isFinite(amountToSell) || amountToSell <= 0 || !Number.isFinite(minToReceive) || minToReceive <= 0) {
+    throw new Error("[SDK][buildLimitOrderCreateOpWithType] Missing or invalid parameters");
+  }
+  const expiration = new Date(Date.now());
+  expiration.setDate(expiration.getDate() + 27);
+  const expirationStr = expiration.toISOString().split(".")[0];
+  const orderId = Number(
+    `${idPrefix}${Math.floor(Date.now() / 1e3).toString().slice(2)}`
+  );
+  const formattedAmountToSell = orderType === "buy" /* Buy */ ? `${formatNumber(amountToSell, 3)} HBD` : `${formatNumber(amountToSell, 3)} HIVE`;
+  const formattedMinToReceive = orderType === "buy" /* Buy */ ? `${formatNumber(minToReceive, 3)} HIVE` : `${formatNumber(minToReceive, 3)} HBD`;
+  return buildLimitOrderCreateOp(
+    owner,
+    formattedAmountToSell,
+    formattedMinToReceive,
+    false,
+    expirationStr,
+    orderId
+  );
+}
+function buildLimitOrderCancelOp(owner, orderId) {
+  if (!owner || orderId === void 0) {
+    throw new Error("[SDK][buildLimitOrderCancelOp] Missing required parameters");
+  }
+  return [
+    "limit_order_cancel",
+    {
+      owner,
+      orderid: orderId
+    }
+  ];
+}
+function buildClaimRewardBalanceOp(account, rewardHive, rewardHbd, rewardVests) {
+  if (!account || !rewardHive || !rewardHbd || !rewardVests) {
+    throw new Error("[SDK][buildClaimRewardBalanceOp] Missing required parameters");
+  }
+  return [
+    "claim_reward_balance",
+    {
+      account,
+      reward_hive: rewardHive,
+      reward_hbd: rewardHbd,
+      reward_vests: rewardVests
+    }
+  ];
+}
+
+// src/modules/operations/builders/account.ts
+function buildAccountUpdateOp(account, owner, active, posting, memoKey, jsonMetadata) {
+  if (!account || !memoKey) {
+    throw new Error("[SDK][buildAccountUpdateOp] Missing required parameters");
+  }
+  return [
+    "account_update",
+    {
+      account,
+      owner,
+      active,
+      posting,
+      memo_key: memoKey,
+      json_metadata: jsonMetadata
+    }
+  ];
+}
+function buildAccountUpdate2Op(account, jsonMetadata, postingJsonMetadata, extensions) {
+  if (!account || postingJsonMetadata === void 0) {
+    throw new Error("[SDK][buildAccountUpdate2Op] Missing required parameters");
+  }
+  return [
+    "account_update2",
+    {
+      account,
+      json_metadata: jsonMetadata || "",
+      posting_json_metadata: postingJsonMetadata,
+      extensions: extensions || []
+    }
+  ];
+}
+function buildAccountCreateOp(creator, newAccountName, keys, fee) {
+  if (!creator || !newAccountName || !keys || !fee) {
+    throw new Error("[SDK][buildAccountCreateOp] Missing required parameters");
+  }
+  const owner = {
+    weight_threshold: 1,
+    account_auths: [],
+    key_auths: [[keys.ownerPublicKey, 1]]
+  };
+  const active = {
+    weight_threshold: 1,
+    account_auths: [],
+    key_auths: [[keys.activePublicKey, 1]]
+  };
+  const posting = {
+    weight_threshold: 1,
+    account_auths: [["ecency.app", 1]],
+    key_auths: [[keys.postingPublicKey, 1]]
+  };
+  return [
+    "account_create",
+    {
+      creator,
+      new_account_name: newAccountName,
+      owner,
+      active,
+      posting,
+      memo_key: keys.memoPublicKey,
+      json_metadata: "",
+      extensions: [],
+      fee
+    }
+  ];
+}
+function buildCreateClaimedAccountOp(creator, newAccountName, keys) {
+  if (!creator || !newAccountName || !keys) {
+    throw new Error("[SDK][buildCreateClaimedAccountOp] Missing required parameters");
+  }
+  const owner = {
+    weight_threshold: 1,
+    account_auths: [],
+    key_auths: [[keys.ownerPublicKey, 1]]
+  };
+  const active = {
+    weight_threshold: 1,
+    account_auths: [],
+    key_auths: [[keys.activePublicKey, 1]]
+  };
+  const posting = {
+    weight_threshold: 1,
+    account_auths: [["ecency.app", 1]],
+    key_auths: [[keys.postingPublicKey, 1]]
+  };
+  return [
+    "create_claimed_account",
+    {
+      creator,
+      new_account_name: newAccountName,
+      owner,
+      active,
+      posting,
+      memo_key: keys.memoPublicKey,
+      json_metadata: "",
+      extensions: []
+    }
+  ];
+}
+function buildClaimAccountOp(creator, fee) {
+  if (!creator || !fee) {
+    throw new Error("[SDK][buildClaimAccountOp] Missing required parameters");
+  }
+  return [
+    "claim_account",
+    {
+      creator,
+      fee,
+      extensions: []
+    }
+  ];
+}
+function buildGrantPostingPermissionOp(account, currentPosting, grantedAccount, weightThreshold, memoKey, jsonMetadata) {
+  if (!account || !currentPosting || !grantedAccount || !memoKey) {
+    throw new Error("[SDK][buildGrantPostingPermissionOp] Missing required parameters");
+  }
+  const existingIndex = currentPosting.account_auths.findIndex(
+    ([acc]) => acc === grantedAccount
+  );
+  const newAccountAuths = [...currentPosting.account_auths];
+  if (existingIndex >= 0) {
+    newAccountAuths[existingIndex] = [grantedAccount, weightThreshold];
+  } else {
+    newAccountAuths.push([grantedAccount, weightThreshold]);
+  }
+  const newPosting = {
+    ...currentPosting,
+    account_auths: newAccountAuths
+  };
+  newPosting.account_auths.sort((a, b) => a[0] > b[0] ? 1 : -1);
+  return [
+    "account_update",
+    {
+      account,
+      posting: newPosting,
+      memo_key: memoKey,
+      json_metadata: jsonMetadata
+    }
+  ];
+}
+function buildRevokePostingPermissionOp(account, currentPosting, revokedAccount, memoKey, jsonMetadata) {
+  if (!account || !currentPosting || !revokedAccount || !memoKey) {
+    throw new Error("[SDK][buildRevokePostingPermissionOp] Missing required parameters");
+  }
+  const newPosting = {
+    ...currentPosting,
+    account_auths: currentPosting.account_auths.filter(
+      ([acc]) => acc !== revokedAccount
+    )
+  };
+  return [
+    "account_update",
+    {
+      account,
+      posting: newPosting,
+      memo_key: memoKey,
+      json_metadata: jsonMetadata
+    }
+  ];
+}
+function buildChangeRecoveryAccountOp(accountToRecover, newRecoveryAccount, extensions = []) {
+  if (!accountToRecover || !newRecoveryAccount) {
+    throw new Error("[SDK][buildChangeRecoveryAccountOp] Missing required parameters");
+  }
+  return [
+    "change_recovery_account",
+    {
+      account_to_recover: accountToRecover,
+      new_recovery_account: newRecoveryAccount,
+      extensions
+    }
+  ];
+}
+function buildRequestAccountRecoveryOp(recoveryAccount, accountToRecover, newOwnerAuthority, extensions = []) {
+  if (!recoveryAccount || !accountToRecover || !newOwnerAuthority) {
+    throw new Error("[SDK][buildRequestAccountRecoveryOp] Missing required parameters");
+  }
+  return [
+    "request_account_recovery",
+    {
+      recovery_account: recoveryAccount,
+      account_to_recover: accountToRecover,
+      new_owner_authority: newOwnerAuthority,
+      extensions
+    }
+  ];
+}
+function buildRecoverAccountOp(accountToRecover, newOwnerAuthority, recentOwnerAuthority, extensions = []) {
+  if (!accountToRecover || !newOwnerAuthority || !recentOwnerAuthority) {
+    throw new Error("[SDK][buildRecoverAccountOp] Missing required parameters");
+  }
+  return [
+    "recover_account",
+    {
+      account_to_recover: accountToRecover,
+      new_owner_authority: newOwnerAuthority,
+      recent_owner_authority: recentOwnerAuthority,
+      extensions
+    }
+  ];
+}
+
+// src/modules/operations/builders/ecency.ts
+function buildBoostOp(user, author, permlink, amount) {
+  if (!user || !author || !permlink || !amount) {
+    throw new Error("[SDK][buildBoostOp] Missing required parameters");
+  }
+  return [
+    "custom_json",
+    {
+      id: "ecency_boost",
+      json: JSON.stringify({
+        user,
+        author,
+        permlink,
+        amount
+      }),
+      required_auths: [user],
+      required_posting_auths: []
+    }
+  ];
+}
+function buildBoostOpWithPoints(user, author, permlink, points) {
+  if (!user || !author || !permlink || !Number.isFinite(points)) {
+    throw new Error("[SDK][buildBoostOpWithPoints] Missing required parameters");
+  }
+  return buildBoostOp(user, author, permlink, `${points.toFixed(3)} POINT`);
+}
+function buildBoostPlusOp(user, account, duration) {
+  if (!user || !account || !Number.isFinite(duration)) {
+    throw new Error("[SDK][buildBoostPlusOp] Missing required parameters");
+  }
+  return [
+    "custom_json",
+    {
+      id: "ecency_boost_plus",
+      json: JSON.stringify({
+        user,
+        account,
+        duration
+      }),
+      required_auths: [user],
+      required_posting_auths: []
+    }
+  ];
+}
+function buildPromoteOp(user, author, permlink, duration) {
+  if (!user || !author || !permlink || !Number.isFinite(duration)) {
+    throw new Error("[SDK][buildPromoteOp] Missing required parameters");
+  }
+  return [
+    "custom_json",
+    {
+      id: "ecency_promote",
+      json: JSON.stringify({
+        user,
+        author,
+        permlink,
+        duration
+      }),
+      required_auths: [user],
+      required_posting_auths: []
+    }
+  ];
+}
+function buildPointTransferOp(sender, receiver, amount, memo) {
+  if (!sender || !receiver || !amount) {
+    throw new Error("[SDK][buildPointTransferOp] Missing required parameters");
+  }
+  return [
+    "custom_json",
+    {
+      id: "ecency_point_transfer",
+      json: JSON.stringify({
+        sender,
+        receiver,
+        amount,
+        memo: memo || ""
+      }),
+      required_auths: [sender],
+      required_posting_auths: []
+    }
+  ];
+}
+function buildMultiPointTransferOps(sender, destinations, amount, memo) {
+  if (!sender || !destinations || !amount) {
+    throw new Error("[SDK][buildMultiPointTransferOps] Missing required parameters");
+  }
+  const destArray = destinations.trim().split(/[\s,]+/).filter(Boolean);
+  if (destArray.length === 0) {
+    throw new Error("[SDK][buildMultiPointTransferOps] Missing valid destinations");
+  }
+  return destArray.map(
+    (dest) => buildPointTransferOp(sender, dest.trim(), amount, memo)
+  );
+}
+function buildCommunityRegistrationOp(name) {
+  if (!name) {
+    throw new Error("[SDK][buildCommunityRegistrationOp] Missing required parameters");
+  }
+  return [
+    "custom_json",
+    {
+      id: "ecency_registration",
+      json: JSON.stringify({
+        name
+      }),
+      required_auths: [name],
+      required_posting_auths: []
+    }
+  ];
+}
+function buildActiveCustomJsonOp(username, operationId, json) {
+  if (!username || !operationId || !json) {
+    throw new Error("[SDK][buildActiveCustomJsonOp] Missing required parameters");
+  }
+  return [
+    "custom_json",
+    {
+      id: operationId,
+      json: JSON.stringify(json),
+      required_auths: [username],
+      required_posting_auths: []
+    }
+  ];
+}
+function buildPostingCustomJsonOp(username, operationId, json) {
+  if (!username || !operationId || !json) {
+    throw new Error("[SDK][buildPostingCustomJsonOp] Missing required parameters");
+  }
+  return [
+    "custom_json",
+    {
+      id: operationId,
+      json: JSON.stringify(json),
+      required_auths: [],
+      required_posting_auths: [username]
+    }
+  ];
+}
+function useSignOperationByKey(username) {
+  return useMutation({
+    mutationKey: ["operations", "sign", username],
+    mutationFn: ({
+      operation,
+      keyOrSeed
+    }) => {
+      if (!username) {
+        throw new Error("[Operations][Sign] \u2013 cannot sign op with anon user");
+      }
+      let privateKey;
+      if (keyOrSeed.split(" ").length === 12) {
+        privateKey = PrivateKey.fromLogin(username, keyOrSeed, "active");
+      } else if (cryptoUtils.isWif(keyOrSeed)) {
+        privateKey = PrivateKey.fromString(keyOrSeed);
+      } else {
+        privateKey = PrivateKey.from(keyOrSeed);
+      }
+      return CONFIG.hiveClient.broadcast.sendOperations(
+        [operation],
+        privateKey
+      );
+    }
+  });
+}
+function useSignOperationByKeychain(username, auth, keyType = "active") {
+  return useMutation({
+    mutationKey: ["operations", "sign-keychain", username],
+    mutationFn: ({ operation }) => {
+      if (!username) {
+        throw new Error(
+          "[SDK][Keychain] \u2013\xA0cannot sign operation with anon user"
+        );
+      }
+      if (!auth?.broadcast) {
+        throw new Error("[SDK][Keychain] \u2013 missing keychain broadcaster");
+      }
+      return auth.broadcast([operation], keyType);
+    }
+  });
+}
+function useSignOperationByHivesigner(callbackUri = "/") {
+  return useMutation({
+    mutationKey: ["operations", "sign-hivesigner", callbackUri],
+    mutationFn: async ({ operation }) => {
+      return hs.sendOperation(operation, { callback: callbackUri }, () => {
+      });
+    }
+  });
+}
+function getChainPropertiesQueryOptions() {
+  return queryOptions({
+    queryKey: ["operations", "chain-properties"],
+    queryFn: async () => {
+      return await CONFIG.hiveClient.database.getChainProperties();
+    }
+  });
+}
+function useAddFragment(username, code) {
+  return useMutation({
+    mutationKey: ["posts", "add-fragment", username],
+    mutationFn: async ({ title, body }) => {
+      if (!code) {
+        throw new Error("[SDK][Posts] Missing access token");
+      }
+      const fetchApi = getBoundFetch();
+      const response = await fetchApi(
+        CONFIG.privateApiHost + "/private-api/fragments-add",
+        {
+          method: "POST",
+          body: JSON.stringify({
+            code,
+            title,
+            body
+          }),
+          headers: {
+            "Content-Type": "application/json"
+          }
+        }
+      );
+      return response.json();
+    },
+    onSuccess(response) {
+      const queryClient = getQueryClient();
+      queryClient.setQueryData(
+        getFragmentsQueryOptions(username, code).queryKey,
+        (data) => [response, ...data ?? []]
+      );
+      queryClient.setQueriesData(
+        { queryKey: ["posts", "fragments", "infinite", username] },
+        (oldData) => {
+          if (!oldData) return oldData;
+          return {
+            ...oldData,
+            pages: oldData.pages.map(
+              (page, index) => index === 0 ? { ...page, data: [response, ...page.data] } : page
+            )
+          };
+        }
+      );
+    }
+  });
+}
+function useEditFragment(username, code) {
+  return useMutation({
+    mutationKey: ["posts", "edit-fragment", username],
+    mutationFn: async ({
+      fragmentId,
+      title,
+      body
+    }) => {
+      if (!code) {
+        throw new Error("[SDK][Posts] Missing access token");
+      }
+      const fetchApi = getBoundFetch();
+      const response = await fetchApi(
+        CONFIG.privateApiHost + "/private-api/fragments-update",
         {
           method: "POST",
           body: JSON.stringify({
@@ -3998,6 +5319,136 @@ function useUploadImage(onSuccess, onError) {
   });
 }
 
+// src/modules/posts/mutations/use-vote.ts
+function useVote(username, auth) {
+  return useBroadcastMutation(
+    ["posts", "vote"],
+    username,
+    ({ author, permlink, weight }) => [
+      buildVoteOp(username, author, permlink, weight)
+    ],
+    async (result, variables) => {
+      if (auth?.adapter?.recordActivity && result?.block_num && result?.id) {
+        await auth.adapter.recordActivity(120, result.block_num, result.id);
+      }
+      if (auth?.adapter?.invalidateQueries) {
+        await auth.adapter.invalidateQueries([
+          ["posts", "entry", `/@${variables.author}/${variables.permlink}`],
+          ["account", username, "votingPower"]
+        ]);
+      }
+    },
+    auth
+  );
+}
+
+// src/modules/posts/mutations/use-reblog.ts
+function useReblog(username, auth) {
+  return useBroadcastMutation(
+    ["posts", "reblog"],
+    username,
+    ({ author, permlink, deleteReblog }) => [
+      buildReblogOp(username, author, permlink, deleteReblog ?? false)
+    ],
+    async (result, variables) => {
+      if (auth?.adapter?.recordActivity && result?.block_num && result?.id) {
+        await auth.adapter.recordActivity(130, result.block_num, result.id);
+      }
+      if (auth?.adapter?.invalidateQueries) {
+        await auth.adapter.invalidateQueries([
+          ["posts", "blog", username],
+          ["posts", "entry", `/@${variables.author}/${variables.permlink}`]
+        ]);
+      }
+    },
+    auth
+  );
+}
+
+// src/modules/posts/mutations/use-comment.ts
+function useComment(username, auth) {
+  return useBroadcastMutation(
+    ["posts", "comment"],
+    username,
+    (payload) => {
+      const operations = [];
+      operations.push(
+        buildCommentOp(
+          payload.author,
+          payload.permlink,
+          payload.parentAuthor,
+          payload.parentPermlink,
+          payload.title,
+          payload.body,
+          payload.jsonMetadata
+        )
+      );
+      if (payload.options) {
+        const {
+          maxAcceptedPayout = "1000000.000 HBD",
+          percentHbd = 1e4,
+          allowVotes = true,
+          allowCurationRewards = true,
+          beneficiaries = []
+        } = payload.options;
+        const extensions = [];
+        if (beneficiaries.length > 0) {
+          const sortedBeneficiaries = [...beneficiaries].sort(
+            (a, b) => a.account.localeCompare(b.account)
+          );
+          extensions.push([
+            0,
+            {
+              beneficiaries: sortedBeneficiaries.map((b) => ({
+                account: b.account,
+                weight: b.weight
+              }))
+            }
+          ]);
+        }
+        operations.push(
+          buildCommentOptionsOp(
+            payload.author,
+            payload.permlink,
+            maxAcceptedPayout,
+            percentHbd,
+            allowVotes,
+            allowCurationRewards,
+            extensions
+          )
+        );
+      }
+      return operations;
+    },
+    async (result, variables) => {
+      const isPost = !variables.parentAuthor;
+      const activityType = isPost ? 100 : 110;
+      if (auth?.adapter?.recordActivity && result?.block_num && result?.id) {
+        try {
+          await auth.adapter.recordActivity(activityType, result.block_num, result.id);
+        } catch (err) {
+          console.warn("[useComment] Failed to record activity:", err);
+        }
+      }
+      if (auth?.adapter?.invalidateQueries) {
+        const queriesToInvalidate = [
+          ["posts", "feed", username],
+          ["posts", "blog", username]
+        ];
+        if (!isPost) {
+          queriesToInvalidate.push([
+            "posts",
+            "entry",
+            `/@${variables.parentAuthor}/${variables.parentPermlink}`
+          ]);
+        }
+        await auth.adapter.invalidateQueries(queriesToInvalidate);
+      }
+    },
+    auth
+  );
+}
+
 // src/modules/posts/utils/validate-post-creating.ts
 var DEFAULT_VALIDATE_POST_DELAYS = [3e3, 3e3, 3e3];
 var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
@@ -4112,8 +5563,10 @@ function getDiscoverCurationQueryOptions(duration) {
   });
 }
 function getPageStatsQueryOptions(url, dimensions = [], metrics = ["visitors", "pageviews", "visit_duration"], dateRange) {
+  const sortedDimensions = [...dimensions].sort();
+  const sortedMetrics = [...metrics].sort();
   return queryOptions({
-    queryKey: ["analytics", "page-stats", url, dimensions, metrics, dateRange],
+    queryKey: ["analytics", "page-stats", url, sortedDimensions, sortedMetrics, dateRange],
     queryFn: async ({ signal }) => {
       const response = await fetch(CONFIG.privateApiHost + "/api/stats", {
         method: "POST",
@@ -4133,7 +5586,9 @@ function getPageStatsQueryOptions(url, dimensions = [], metrics = ["visitors", "
       }
       return response.json();
     },
-    enabled: !!url
+    enabled: !!url,
+    // Analytics data should always be fresh - users expect current stats when changing range
+    staleTime: 0
   });
 }
 
@@ -4855,6 +6310,35 @@ function getUserProposalVotesQueryOptions(voter) {
     }
   });
 }
+
+// src/modules/proposals/mutations/use-proposal-vote.ts
+function useProposalVote(username, auth) {
+  return useBroadcastMutation(
+    ["proposals", "vote"],
+    username,
+    ({ proposalIds, approve }) => [
+      buildProposalVoteOp(username, proposalIds, approve)
+    ],
+    async (result) => {
+      try {
+        if (auth?.adapter?.recordActivity && result?.block_num && result?.id) {
+          await auth.adapter.recordActivity(150, result.block_num, result.id);
+        }
+        if (auth?.adapter?.invalidateQueries) {
+          await auth.adapter.invalidateQueries([
+            ["proposals", "list"],
+            ["proposals", "votes", username]
+          ]);
+        }
+      } catch (error) {
+        console.warn("[useProposalVote] Post-broadcast side-effect failed:", error);
+      }
+    },
+    auth,
+    "active"
+    // Use active authority for proposal votes (required by blockchain)
+  );
+}
 function getVestingDelegationsQueryOptions(username, limit = 50) {
   return infiniteQueryOptions({
     queryKey: ["wallet", "vesting-delegations", username, limit],
@@ -5145,6 +6629,110 @@ function getPortfolioQueryOptions(username, currency = "usd", onlyEnabled = true
     }
   });
 }
+async function broadcastTransferWithFallback(username, ops2, auth) {
+  const chain = auth?.fallbackChain ?? ["key", "hiveauth", "hivesigner", "keychain"];
+  const errors = /* @__PURE__ */ new Map();
+  const adapter = auth?.adapter;
+  for (const method of chain) {
+    try {
+      switch (method) {
+        case "key": {
+          if (!adapter) break;
+          const key = await adapter.getActiveKey?.(username);
+          if (key) {
+            const privateKey = PrivateKey.fromString(key);
+            return await CONFIG.hiveClient.broadcast.sendOperations(ops2, privateKey);
+          }
+          break;
+        }
+        case "hiveauth": {
+          if (adapter?.broadcastWithHiveAuth) {
+            return await adapter.broadcastWithHiveAuth(username, ops2, "active");
+          }
+          break;
+        }
+        case "hivesigner": {
+          if (!adapter) break;
+          const token = await adapter.getAccessToken(username);
+          if (token) {
+            const client = new hs.Client({ accessToken: token });
+            const response = await client.broadcast(ops2);
+            return response.result;
+          }
+          break;
+        }
+        case "keychain": {
+          if (adapter?.broadcastWithKeychain) {
+            return await adapter.broadcastWithKeychain(username, ops2, "active");
+          }
+          break;
+        }
+        case "custom": {
+          if (auth?.broadcast) {
+            return await auth.broadcast(ops2, "active");
+          }
+          break;
+        }
+      }
+    } catch (error) {
+      errors.set(method, error);
+      if (!shouldTriggerAuthFallback(error)) {
+        throw error;
+      }
+    }
+  }
+  const errorMessages = Array.from(errors.entries()).map(([method, error]) => `${method}: ${error.message}`).join(", ");
+  throw new Error(
+    `[SDK][Transfer] All auth methods failed for ${username}. Errors: ${errorMessages}`
+  );
+}
+function useTransfer(username, auth) {
+  return useMutation({
+    mutationKey: ["wallet", "transfer", username],
+    mutationFn: async (payload) => {
+      if (!username) {
+        throw new Error(
+          "[SDK][Transfer] Attempted to call transfer API with anon user"
+        );
+      }
+      const ops2 = [buildTransferOp(username, payload.to, payload.amount, payload.memo)];
+      if (auth?.enableFallback !== false && auth?.adapter) {
+        return broadcastTransferWithFallback(username, ops2, auth);
+      }
+      if (auth?.broadcast) {
+        return auth.broadcast(ops2, "active");
+      }
+      if (auth?.adapter?.getActiveKey) {
+        const activeKey = await auth.adapter.getActiveKey(username);
+        if (activeKey) {
+          const privateKey = PrivateKey.fromString(activeKey);
+          return CONFIG.hiveClient.broadcast.sendOperations(ops2, privateKey);
+        }
+      }
+      const accessToken = auth?.accessToken;
+      if (accessToken) {
+        const client = new hs.Client({ accessToken });
+        const response = await client.broadcast(ops2);
+        return response.result;
+      }
+      throw new Error(
+        "[SDK][Transfer] \u2013 cannot broadcast transfer w/o active key or token"
+      );
+    },
+    onSuccess: async (result, variables) => {
+      if (auth?.adapter?.recordActivity && result?.block_num && result?.id) {
+        await auth.adapter.recordActivity(140, result.block_num, result.id);
+      }
+      if (auth?.adapter?.invalidateQueries) {
+        await auth.adapter.invalidateQueries([
+          ["wallet", "balances", username],
+          ["wallet", "balances", variables.to],
+          ["wallet", "transactions", username]
+        ]);
+      }
+    }
+  });
+}
 function getWitnessesInfiniteQueryOptions(limit) {
   return infiniteQueryOptions({
     queryKey: ["witnesses", "list", limit],
@@ -6046,6 +7634,6 @@ async function getSpkMarkets() {
   return await response.json();
 }
 
-export { ACCOUNT_OPERATION_GROUPS, ALL_ACCOUNT_OPERATIONS, ALL_NOTIFY_TYPES, CONFIG, ConfigManager, mutations_exports as EcencyAnalytics, EcencyQueriesManager, HiveSignerIntegration, NaiMap, NotificationFilter, NotificationViewType, NotifyTypes, ROLES, SortOrder, Symbol2 as Symbol, ThreeSpeakIntegration, addDraft, addImage, addSchedule, bridgeApiCall, broadcastJson, buildProfileMetadata, checkFavouriteQueryOptions, checkUsernameWalletsPendingQueryOptions, decodeObj, dedupeAndSortKeyAuths, deleteDraft, deleteImage, deleteSchedule, downVotingPower, encodeObj, extractAccountProfile, getAccountFullQueryOptions, getAccountNotificationsInfiniteQueryOptions, getAccountPendingRecoveryQueryOptions, getAccountPosts, getAccountPostsInfiniteQueryOptions, getAccountPostsQueryOptions, getAccountRcQueryOptions, getAccountRecoveriesQueryOptions, getAccountReputationsQueryOptions, getAccountSubscriptionsQueryOptions, getAccountVoteHistoryInfiniteQueryOptions, getAccountsQueryOptions, getAnnouncementsQueryOptions, getBookmarksInfiniteQueryOptions, getBookmarksQueryOptions, getBoostPlusAccountPricesQueryOptions, getBoostPlusPricesQueryOptions, getBotsQueryOptions, getBoundFetch, getChainPropertiesQueryOptions, getCollateralizedConversionRequestsQueryOptions, getCommentHistoryQueryOptions, getCommunities, getCommunitiesQueryOptions, getCommunity, getCommunityContextQueryOptions, getCommunityPermissions, getCommunityQueryOptions, getCommunitySubscribersQueryOptions, getCommunityType, getContentQueryOptions, getContentRepliesQueryOptions, getControversialRisingInfiniteQueryOptions, getConversionRequestsQueryOptions, getCurrencyRate, getCurrencyRates, getCurrencyTokenRate, getCurrentMedianHistoryPriceQueryOptions, getDeletedEntryQueryOptions, getDiscoverCurationQueryOptions, getDiscoverLeaderboardQueryOptions, getDiscussion, getDiscussionQueryOptions, getDiscussionsQueryOptions, getDraftsInfiniteQueryOptions, getDraftsQueryOptions, getDynamicPropsQueryOptions, getEntryActiveVotesQueryOptions, getFavouritesInfiniteQueryOptions, getFavouritesQueryOptions, getFeedHistoryQueryOptions, getFollowCountQueryOptions, getFollowersQueryOptions, getFollowingQueryOptions, getFragmentsInfiniteQueryOptions, getFragmentsQueryOptions, getFriendsInfiniteQueryOptions, getGalleryImagesQueryOptions, getGameStatusCheckQueryOptions, getHiveEngineMetrics, getHiveEngineOpenOrders, getHiveEngineOrderBook, getHiveEngineTokenMetrics, getHiveEngineTokenTransactions, getHiveEngineTokensBalances, getHiveEngineTokensMarket, getHiveEngineTokensMetadata, getHiveEngineTradeHistory, getHiveEngineUnclaimedRewards, getHiveHbdStatsQueryOptions, getHivePoshLinksQueryOptions, getHivePrice, getImagesInfiniteQueryOptions, getImagesQueryOptions, getIncomingRcQueryOptions, getMarketData, getMarketDataQueryOptions, getMarketHistoryQueryOptions, getMarketStatisticsQueryOptions, getMutedUsersQueryOptions, getNormalizePostQueryOptions, getNotificationSetting, getNotifications, getNotificationsInfiniteQueryOptions, getNotificationsSettingsQueryOptions, getNotificationsUnreadCountQueryOptions, getOpenOrdersQueryOptions, getOrderBookQueryOptions, getOutgoingRcDelegationsInfiniteQueryOptions, getPageStatsQueryOptions, getPointsQueryOptions, getPortfolioQueryOptions, getPost, getPostHeader, getPostHeaderQueryOptions, getPostQueryOptions, getPostTipsQueryOptions, getPostsRanked, getPostsRankedInfiniteQueryOptions, getPostsRankedQueryOptions, getProfiles, getProfilesQueryOptions, getPromotePriceQueryOptions, getPromotedPost, getPromotedPostsQuery, getProposalQueryOptions, getProposalVotesInfiniteQueryOptions, getProposalsQueryOptions, getQueryClient, getRcStatsQueryOptions, getRebloggedByQueryOptions, getReblogsQueryOptions, getReceivedVestingSharesQueryOptions, getRecurrentTransfersQueryOptions, getReferralsInfiniteQueryOptions, getReferralsStatsQueryOptions, getRelationshipBetweenAccounts, getRelationshipBetweenAccountsQueryOptions, getRewardFundQueryOptions, getRewardedCommunitiesQueryOptions, getSavingsWithdrawFromQueryOptions, getSchedulesInfiniteQueryOptions, getSchedulesQueryOptions, getSearchAccountQueryOptions, getSearchAccountsByUsernameQueryOptions, getSearchApiInfiniteQueryOptions, getSearchFriendsQueryOptions, getSearchPathQueryOptions, getSearchTopicsQueryOptions, getSimilarEntriesQueryOptions, getSpkMarkets, getSpkWallet, getStatsQueryOptions, getSubscribers, getSubscriptions, getTradeHistoryQueryOptions, getTransactionsInfiniteQueryOptions, getTrendingTagsQueryOptions, getTrendingTagsWithStatsQueryOptions, getUserPostVoteQueryOptions, getUserProposalVotesQueryOptions, getVestingDelegationsQueryOptions, getVisibleFirstLevelThreadItems, getWavesByHostQueryOptions, getWavesByTagQueryOptions, getWavesFollowingQueryOptions, getWavesTrendingTagsQueryOptions, getWithdrawRoutesQueryOptions, getWitnessesInfiniteQueryOptions, hsTokenRenew, isCommunity, isWrappedResponse, lookupAccountsQueryOptions, makeQueryClient, mapThreadItemsToWaveEntries, markNotifications, moveSchedule, normalizePost, normalizeToWrappedResponse, normalizeWaveEntryFromApi, onboardEmail, parseAccounts, parseAsset, parseProfileMetadata, powerRechargeTime, rcPower, resolvePost, roleMap, saveNotificationSetting, search, searchAccount, searchPath, searchQueryOptions, searchTag, signUp, sortDiscussions, subscribeEmail, toEntryArray, updateDraft, uploadImage, useAccountFavouriteAdd, useAccountFavouriteDelete, useAccountRelationsUpdate, useAccountRevokeKey, useAccountRevokePosting, useAccountUpdate, useAccountUpdateKeyAuths, useAccountUpdatePassword, useAccountUpdateRecovery, useAddDraft, useAddFragment, useAddImage, useAddSchedule, useBookmarkAdd, useBookmarkDelete, useBroadcastMutation, useDeleteDraft, useDeleteImage, useDeleteSchedule, useEditFragment, useGameClaim, useMarkNotificationsRead, useMoveSchedule, useRecordActivity, useRemoveFragment, useSignOperationByHivesigner, useSignOperationByKey, useSignOperationByKeychain, useUpdateDraft, useUploadImage, usrActivity, validatePostCreating, votingPower, votingValue };
+export { ACCOUNT_OPERATION_GROUPS, ALL_ACCOUNT_OPERATIONS, ALL_NOTIFY_TYPES, BuySellTransactionType, CONFIG, ConfigManager, mutations_exports as EcencyAnalytics, EcencyQueriesManager, ErrorType, HiveSignerIntegration, NaiMap, NotificationFilter, NotificationViewType, NotifyTypes, OrderIdPrefix, ROLES, SortOrder, Symbol2 as Symbol, ThreeSpeakIntegration, addDraft, addImage, addSchedule, bridgeApiCall, broadcastJson, buildAccountCreateOp, buildAccountUpdate2Op, buildAccountUpdateOp, buildActiveCustomJsonOp, buildBoostOp, buildBoostOpWithPoints, buildBoostPlusOp, buildCancelTransferFromSavingsOp, buildChangeRecoveryAccountOp, buildClaimAccountOp, buildClaimInterestOps, buildClaimRewardBalanceOp, buildCollateralizedConvertOp, buildCommentOp, buildCommentOptionsOp, buildCommunityRegistrationOp, buildConvertOp, buildCreateClaimedAccountOp, buildDelegateRcOp, buildDelegateVestingSharesOp, buildDeleteCommentOp, buildFlagPostOp, buildFollowOp, buildGrantPostingPermissionOp, buildIgnoreOp, buildLimitOrderCancelOp, buildLimitOrderCreateOp, buildLimitOrderCreateOpWithType, buildMultiPointTransferOps, buildMultiTransferOps, buildMutePostOp, buildMuteUserOp, buildPinPostOp, buildPointTransferOp, buildPostingCustomJsonOp, buildProfileMetadata, buildPromoteOp, buildProposalCreateOp, buildProposalVoteOp, buildReblogOp, buildRecoverAccountOp, buildRecurrentTransferOp, buildRemoveProposalOp, buildRequestAccountRecoveryOp, buildRevokePostingPermissionOp, buildSetLastReadOps, buildSetRoleOp, buildSetWithdrawVestingRouteOp, buildSubscribeOp, buildTransferFromSavingsOp, buildTransferOp, buildTransferToSavingsOp, buildTransferToVestingOp, buildUnfollowOp, buildUnignoreOp, buildUnsubscribeOp, buildUpdateCommunityOp, buildUpdateProposalOp, buildVoteOp, buildWithdrawVestingOp, buildWitnessProxyOp, buildWitnessVoteOp, checkFavouriteQueryOptions, checkUsernameWalletsPendingQueryOptions, decodeObj, dedupeAndSortKeyAuths, deleteDraft, deleteImage, deleteSchedule, downVotingPower, encodeObj, extractAccountProfile, formatError, getAccountFullQueryOptions, getAccountNotificationsInfiniteQueryOptions, getAccountPendingRecoveryQueryOptions, getAccountPosts, getAccountPostsInfiniteQueryOptions, getAccountPostsQueryOptions, getAccountRcQueryOptions, getAccountRecoveriesQueryOptions, getAccountReputationsQueryOptions, getAccountSubscriptionsQueryOptions, getAccountVoteHistoryInfiniteQueryOptions, getAccountsQueryOptions, getAnnouncementsQueryOptions, getBookmarksInfiniteQueryOptions, getBookmarksQueryOptions, getBoostPlusAccountPricesQueryOptions, getBoostPlusPricesQueryOptions, getBotsQueryOptions, getBoundFetch, getChainPropertiesQueryOptions, getCollateralizedConversionRequestsQueryOptions, getCommentHistoryQueryOptions, getCommunities, getCommunitiesQueryOptions, getCommunity, getCommunityContextQueryOptions, getCommunityPermissions, getCommunityQueryOptions, getCommunitySubscribersQueryOptions, getCommunityType, getContentQueryOptions, getContentRepliesQueryOptions, getControversialRisingInfiniteQueryOptions, getConversionRequestsQueryOptions, getCurrencyRate, getCurrencyRates, getCurrencyTokenRate, getCurrentMedianHistoryPriceQueryOptions, getDeletedEntryQueryOptions, getDiscoverCurationQueryOptions, getDiscoverLeaderboardQueryOptions, getDiscussion, getDiscussionQueryOptions, getDiscussionsQueryOptions, getDraftsInfiniteQueryOptions, getDraftsQueryOptions, getDynamicPropsQueryOptions, getEntryActiveVotesQueryOptions, getFavouritesInfiniteQueryOptions, getFavouritesQueryOptions, getFeedHistoryQueryOptions, getFollowCountQueryOptions, getFollowersQueryOptions, getFollowingQueryOptions, getFragmentsInfiniteQueryOptions, getFragmentsQueryOptions, getFriendsInfiniteQueryOptions, getGalleryImagesQueryOptions, getGameStatusCheckQueryOptions, getHiveEngineMetrics, getHiveEngineOpenOrders, getHiveEngineOrderBook, getHiveEngineTokenMetrics, getHiveEngineTokenTransactions, getHiveEngineTokensBalances, getHiveEngineTokensMarket, getHiveEngineTokensMetadata, getHiveEngineTradeHistory, getHiveEngineUnclaimedRewards, getHiveHbdStatsQueryOptions, getHivePoshLinksQueryOptions, getHivePrice, getImagesInfiniteQueryOptions, getImagesQueryOptions, getIncomingRcQueryOptions, getMarketData, getMarketDataQueryOptions, getMarketHistoryQueryOptions, getMarketStatisticsQueryOptions, getMutedUsersQueryOptions, getNormalizePostQueryOptions, getNotificationSetting, getNotifications, getNotificationsInfiniteQueryOptions, getNotificationsSettingsQueryOptions, getNotificationsUnreadCountQueryOptions, getOpenOrdersQueryOptions, getOrderBookQueryOptions, getOutgoingRcDelegationsInfiniteQueryOptions, getPageStatsQueryOptions, getPointsQueryOptions, getPortfolioQueryOptions, getPost, getPostHeader, getPostHeaderQueryOptions, getPostQueryOptions, getPostTipsQueryOptions, getPostsRanked, getPostsRankedInfiniteQueryOptions, getPostsRankedQueryOptions, getProfiles, getProfilesQueryOptions, getPromotePriceQueryOptions, getPromotedPost, getPromotedPostsQuery, getProposalQueryOptions, getProposalVotesInfiniteQueryOptions, getProposalsQueryOptions, getQueryClient, getRcStatsQueryOptions, getRebloggedByQueryOptions, getReblogsQueryOptions, getReceivedVestingSharesQueryOptions, getRecurrentTransfersQueryOptions, getReferralsInfiniteQueryOptions, getReferralsStatsQueryOptions, getRelationshipBetweenAccounts, getRelationshipBetweenAccountsQueryOptions, getRewardFundQueryOptions, getRewardedCommunitiesQueryOptions, getSavingsWithdrawFromQueryOptions, getSchedulesInfiniteQueryOptions, getSchedulesQueryOptions, getSearchAccountQueryOptions, getSearchAccountsByUsernameQueryOptions, getSearchApiInfiniteQueryOptions, getSearchFriendsQueryOptions, getSearchPathQueryOptions, getSearchTopicsQueryOptions, getSimilarEntriesQueryOptions, getSpkMarkets, getSpkWallet, getStatsQueryOptions, getSubscribers, getSubscriptions, getTradeHistoryQueryOptions, getTransactionsInfiniteQueryOptions, getTrendingTagsQueryOptions, getTrendingTagsWithStatsQueryOptions, getUserPostVoteQueryOptions, getUserProposalVotesQueryOptions, getVestingDelegationsQueryOptions, getVisibleFirstLevelThreadItems, getWavesByHostQueryOptions, getWavesByTagQueryOptions, getWavesFollowingQueryOptions, getWavesTrendingTagsQueryOptions, getWithdrawRoutesQueryOptions, getWitnessesInfiniteQueryOptions, hsTokenRenew, isCommunity, isInfoError, isNetworkError, isResourceCreditsError, isWrappedResponse, lookupAccountsQueryOptions, makeQueryClient, mapThreadItemsToWaveEntries, markNotifications, moveSchedule, normalizePost, normalizeToWrappedResponse, normalizeWaveEntryFromApi, onboardEmail, parseAccounts, parseAsset, parseChainError, parseProfileMetadata, powerRechargeTime, rcPower, resolvePost, roleMap, saveNotificationSetting, search, searchAccount, searchPath, searchQueryOptions, searchTag, shouldTriggerAuthFallback, signUp, sortDiscussions, subscribeEmail, toEntryArray, updateDraft, uploadImage, useAccountFavouriteAdd, useAccountFavouriteDelete, useAccountRelationsUpdate, useAccountRevokeKey, useAccountRevokePosting, useAccountUpdate, useAccountUpdateKeyAuths, useAccountUpdatePassword, useAccountUpdateRecovery, useAddDraft, useAddFragment, useAddImage, useAddSchedule, useBookmarkAdd, useBookmarkDelete, useBroadcastMutation, useComment, useDeleteDraft, useDeleteImage, useDeleteSchedule, useEditFragment, useGameClaim, useMarkNotificationsRead, useMoveSchedule, useProposalVote, useReblog, useRecordActivity, useRemoveFragment, useSignOperationByHivesigner, useSignOperationByKey, useSignOperationByKeychain, useTransfer, useUpdateDraft, useUploadImage, useVote, usrActivity, validatePostCreating, votingPower, votingValue };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map