@ecency/sdk 1.5.26 → 1.5.28

package/dist/node/index.cjs

@@ -33,8 +33,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 = dhive.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__default.default.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 reactQuery.useMutation({
     onSuccess,
     mutationKey: [...mutationKey, username],
@@ -44,20 +351,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 = dhive.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__default.default.Client({ accessToken });
         const response = await client.broadcast(ops2);
         return response.result;
@@ -3346,123 +3656,1134 @@ function votingValue(account, dynamicProps, votingPowerValue, weight = 1e4) {
   }
   return rShares / fundRecentClaims * fundRewardBalance * (base / quote);
 }
-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
-      );
+
+// 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 reactQuery.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 reactQuery.useMutation({
-    mutationKey: ["operations", "sign-hivesigner", callbackUri],
-    mutationFn: async ({ operation }) => {
-      return hs__default.default.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 reactQuery.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 reactQuery.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 reactQuery.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 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, auth, 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"
+        );
+      }
+      if (!auth?.broadcast) {
+        throw new Error("[SDK][Keychain] \u2013 missing keychain broadcaster");
+      }
+      return auth.broadcast([operation], keyType);
+    }
+  });
+}
+function useSignOperationByHivesigner(callbackUri = "/") {
+  return reactQuery.useMutation({
+    mutationKey: ["operations", "sign-hivesigner", callbackUri],
+    mutationFn: async ({ operation }) => {
+      return hs__default.default.sendOperation(operation, { callback: callbackUri }, () => {
+      });
+    }
+  });
+}
+function getChainPropertiesQueryOptions() {
+  return reactQuery.queryOptions({
+    queryKey: ["operations", "chain-properties"],
+    queryFn: async () => {
+      return await CONFIG.hiveClient.database.getChainProperties();
+    }
+  });
+}
+function useAddFragment(username, code) {
+  return reactQuery.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 reactQuery.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({
@@ -4023,6 +5344,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));
@@ -4137,8 +5588,10 @@ function getDiscoverCurationQueryOptions(duration) {
   });
 }
 function getPageStatsQueryOptions(url, dimensions = [], metrics = ["visitors", "pageviews", "visit_duration"], dateRange) {
+  const sortedDimensions = [...dimensions].sort();
+  const sortedMetrics = [...metrics].sort();
   return reactQuery.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",
@@ -4158,7 +5611,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
   });
 }
 
@@ -4880,6 +6335,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 reactQuery.infiniteQueryOptions({
     queryKey: ["wallet", "vesting-delegations", username, limit],
@@ -5170,6 +6654,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 = dhive.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__default.default.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 reactQuery.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 = dhive.PrivateKey.fromString(activeKey);
+          return CONFIG.hiveClient.broadcast.sendOperations(ops2, privateKey);
+        }
+      }
+      const accessToken = auth?.accessToken;
+      if (accessToken) {
+        const client = new hs__default.default.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 reactQuery.infiniteQueryOptions({
     queryKey: ["witnesses", "list", limit],
@@ -6074,13 +7662,16 @@ async function getSpkMarkets() {
 exports.ACCOUNT_OPERATION_GROUPS = ACCOUNT_OPERATION_GROUPS;
 exports.ALL_ACCOUNT_OPERATIONS = ALL_ACCOUNT_OPERATIONS;
 exports.ALL_NOTIFY_TYPES = ALL_NOTIFY_TYPES;
+exports.BuySellTransactionType = BuySellTransactionType;
 exports.CONFIG = CONFIG;
 exports.EcencyAnalytics = mutations_exports;
+exports.ErrorType = ErrorType;
 exports.HiveSignerIntegration = HiveSignerIntegration;
 exports.NaiMap = NaiMap;
 exports.NotificationFilter = NotificationFilter;
 exports.NotificationViewType = NotificationViewType;
 exports.NotifyTypes = NotifyTypes;
+exports.OrderIdPrefix = OrderIdPrefix;
 exports.ROLES = ROLES;
 exports.SortOrder = SortOrder;
 exports.Symbol = Symbol2;
@@ -6090,7 +7681,68 @@ exports.addImage = addImage;
 exports.addSchedule = addSchedule;
 exports.bridgeApiCall = bridgeApiCall;
 exports.broadcastJson = broadcastJson;
+exports.buildAccountCreateOp = buildAccountCreateOp;
+exports.buildAccountUpdate2Op = buildAccountUpdate2Op;
+exports.buildAccountUpdateOp = buildAccountUpdateOp;
+exports.buildActiveCustomJsonOp = buildActiveCustomJsonOp;
+exports.buildBoostOp = buildBoostOp;
+exports.buildBoostOpWithPoints = buildBoostOpWithPoints;
+exports.buildBoostPlusOp = buildBoostPlusOp;
+exports.buildCancelTransferFromSavingsOp = buildCancelTransferFromSavingsOp;
+exports.buildChangeRecoveryAccountOp = buildChangeRecoveryAccountOp;
+exports.buildClaimAccountOp = buildClaimAccountOp;
+exports.buildClaimInterestOps = buildClaimInterestOps;
+exports.buildClaimRewardBalanceOp = buildClaimRewardBalanceOp;
+exports.buildCollateralizedConvertOp = buildCollateralizedConvertOp;
+exports.buildCommentOp = buildCommentOp;
+exports.buildCommentOptionsOp = buildCommentOptionsOp;
+exports.buildCommunityRegistrationOp = buildCommunityRegistrationOp;
+exports.buildConvertOp = buildConvertOp;
+exports.buildCreateClaimedAccountOp = buildCreateClaimedAccountOp;
+exports.buildDelegateRcOp = buildDelegateRcOp;
+exports.buildDelegateVestingSharesOp = buildDelegateVestingSharesOp;
+exports.buildDeleteCommentOp = buildDeleteCommentOp;
+exports.buildFlagPostOp = buildFlagPostOp;
+exports.buildFollowOp = buildFollowOp;
+exports.buildGrantPostingPermissionOp = buildGrantPostingPermissionOp;
+exports.buildIgnoreOp = buildIgnoreOp;
+exports.buildLimitOrderCancelOp = buildLimitOrderCancelOp;
+exports.buildLimitOrderCreateOp = buildLimitOrderCreateOp;
+exports.buildLimitOrderCreateOpWithType = buildLimitOrderCreateOpWithType;
+exports.buildMultiPointTransferOps = buildMultiPointTransferOps;
+exports.buildMultiTransferOps = buildMultiTransferOps;
+exports.buildMutePostOp = buildMutePostOp;
+exports.buildMuteUserOp = buildMuteUserOp;
+exports.buildPinPostOp = buildPinPostOp;
+exports.buildPointTransferOp = buildPointTransferOp;
+exports.buildPostingCustomJsonOp = buildPostingCustomJsonOp;
 exports.buildProfileMetadata = buildProfileMetadata;
+exports.buildPromoteOp = buildPromoteOp;
+exports.buildProposalCreateOp = buildProposalCreateOp;
+exports.buildProposalVoteOp = buildProposalVoteOp;
+exports.buildReblogOp = buildReblogOp;
+exports.buildRecoverAccountOp = buildRecoverAccountOp;
+exports.buildRecurrentTransferOp = buildRecurrentTransferOp;
+exports.buildRemoveProposalOp = buildRemoveProposalOp;
+exports.buildRequestAccountRecoveryOp = buildRequestAccountRecoveryOp;
+exports.buildRevokePostingPermissionOp = buildRevokePostingPermissionOp;
+exports.buildSetLastReadOps = buildSetLastReadOps;
+exports.buildSetRoleOp = buildSetRoleOp;
+exports.buildSetWithdrawVestingRouteOp = buildSetWithdrawVestingRouteOp;
+exports.buildSubscribeOp = buildSubscribeOp;
+exports.buildTransferFromSavingsOp = buildTransferFromSavingsOp;
+exports.buildTransferOp = buildTransferOp;
+exports.buildTransferToSavingsOp = buildTransferToSavingsOp;
+exports.buildTransferToVestingOp = buildTransferToVestingOp;
+exports.buildUnfollowOp = buildUnfollowOp;
+exports.buildUnignoreOp = buildUnignoreOp;
+exports.buildUnsubscribeOp = buildUnsubscribeOp;
+exports.buildUpdateCommunityOp = buildUpdateCommunityOp;
+exports.buildUpdateProposalOp = buildUpdateProposalOp;
+exports.buildVoteOp = buildVoteOp;
+exports.buildWithdrawVestingOp = buildWithdrawVestingOp;
+exports.buildWitnessProxyOp = buildWitnessProxyOp;
+exports.buildWitnessVoteOp = buildWitnessVoteOp;
 exports.checkFavouriteQueryOptions = checkFavouriteQueryOptions;
 exports.checkUsernameWalletsPendingQueryOptions = checkUsernameWalletsPendingQueryOptions;
 exports.decodeObj = decodeObj;
@@ -6101,6 +7753,7 @@ exports.deleteSchedule = deleteSchedule;
 exports.downVotingPower = downVotingPower;
 exports.encodeObj = encodeObj;
 exports.extractAccountProfile = extractAccountProfile;
+exports.formatError = formatError;
 exports.getAccountFullQueryOptions = getAccountFullQueryOptions;
 exports.getAccountNotificationsInfiniteQueryOptions = getAccountNotificationsInfiniteQueryOptions;
 exports.getAccountPendingRecoveryQueryOptions = getAccountPendingRecoveryQueryOptions;
@@ -6252,6 +7905,9 @@ exports.getWithdrawRoutesQueryOptions = getWithdrawRoutesQueryOptions;
 exports.getWitnessesInfiniteQueryOptions = getWitnessesInfiniteQueryOptions;
 exports.hsTokenRenew = hsTokenRenew;
 exports.isCommunity = isCommunity;
+exports.isInfoError = isInfoError;
+exports.isNetworkError = isNetworkError;
+exports.isResourceCreditsError = isResourceCreditsError;
 exports.isWrappedResponse = isWrappedResponse;
 exports.lookupAccountsQueryOptions = lookupAccountsQueryOptions;
 exports.makeQueryClient = makeQueryClient;
@@ -6264,6 +7920,7 @@ exports.normalizeWaveEntryFromApi = normalizeWaveEntryFromApi;
 exports.onboardEmail = onboardEmail;
 exports.parseAccounts = parseAccounts;
 exports.parseAsset = parseAsset;
+exports.parseChainError = parseChainError;
 exports.parseProfileMetadata = parseProfileMetadata;
 exports.powerRechargeTime = powerRechargeTime;
 exports.rcPower = rcPower;
@@ -6275,6 +7932,7 @@ exports.searchAccount = searchAccount;
 exports.searchPath = searchPath;
 exports.searchQueryOptions = searchQueryOptions;
 exports.searchTag = searchTag;
+exports.shouldTriggerAuthFallback = shouldTriggerAuthFallback;
 exports.signUp = signUp;
 exports.sortDiscussions = sortDiscussions;
 exports.subscribeEmail = subscribeEmail;
@@ -6297,6 +7955,7 @@ exports.useAddSchedule = useAddSchedule;
 exports.useBookmarkAdd = useBookmarkAdd;
 exports.useBookmarkDelete = useBookmarkDelete;
 exports.useBroadcastMutation = useBroadcastMutation;
+exports.useComment = useComment;
 exports.useDeleteDraft = useDeleteDraft;
 exports.useDeleteImage = useDeleteImage;
 exports.useDeleteSchedule = useDeleteSchedule;
@@ -6304,13 +7963,17 @@ exports.useEditFragment = useEditFragment;
 exports.useGameClaim = useGameClaim;
 exports.useMarkNotificationsRead = useMarkNotificationsRead;
 exports.useMoveSchedule = useMoveSchedule;
+exports.useProposalVote = useProposalVote;
+exports.useReblog = useReblog;
 exports.useRecordActivity = useRecordActivity;
 exports.useRemoveFragment = useRemoveFragment;
 exports.useSignOperationByHivesigner = useSignOperationByHivesigner;
 exports.useSignOperationByKey = useSignOperationByKey;
 exports.useSignOperationByKeychain = useSignOperationByKeychain;
+exports.useTransfer = useTransfer;
 exports.useUpdateDraft = useUpdateDraft;
 exports.useUploadImage = useUploadImage;
+exports.useVote = useVote;
 exports.usrActivity = usrActivity;
 exports.validatePostCreating = validatePostCreating;
 exports.votingPower = votingPower;