@ecency/sdk 1.5.27 → 2.0.0

package/dist/node/index.cjs

@@ -33,8 +33,458 @@ 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 broadcastWithMethod(method, username, ops2, auth, authority = "posting", fetchedKey, fetchedToken) {
+  const adapter = auth?.adapter;
+  switch (method) {
+    case "key": {
+      if (!adapter) {
+        throw new Error("No adapter provided for key-based auth");
+      }
+      let key = fetchedKey;
+      if (key === void 0) {
+        switch (authority) {
+          case "owner":
+            if (adapter.getOwnerKey) {
+              key = await adapter.getOwnerKey(username);
+            } else {
+              throw new Error(
+                `Owner key not supported by adapter. Owner operations (like account recovery) require master password login or manual key entry.`
+              );
+            }
+            break;
+          case "active":
+            if (adapter.getActiveKey) {
+              key = await adapter.getActiveKey(username);
+            }
+            break;
+          case "memo":
+            if (adapter.getMemoKey) {
+              key = await adapter.getMemoKey(username);
+            } else {
+              throw new Error(
+                `Memo key not supported by adapter. Use memo encryption methods instead.`
+              );
+            }
+            break;
+          case "posting":
+          default:
+            key = await adapter.getPostingKey(username);
+            break;
+        }
+      }
+      if (!key) {
+        throw new Error(`No ${authority} key available for ${username}`);
+      }
+      const privateKey = dhive.PrivateKey.fromString(key);
+      return await CONFIG.hiveClient.broadcast.sendOperations(ops2, privateKey);
+    }
+    case "hiveauth": {
+      if (!adapter?.broadcastWithHiveAuth) {
+        throw new Error("HiveAuth not supported by adapter");
+      }
+      return await adapter.broadcastWithHiveAuth(username, ops2, authority);
+    }
+    case "hivesigner": {
+      if (!adapter) {
+        throw new Error("No adapter provided for HiveSigner auth");
+      }
+      const token = fetchedToken !== void 0 ? fetchedToken : await adapter.getAccessToken(username);
+      if (!token) {
+        throw new Error(`No access token available for ${username}`);
+      }
+      const client = new hs__default.default.Client({ accessToken: token });
+      const response = await client.broadcast(ops2);
+      return response.result;
+    }
+    case "keychain": {
+      if (!adapter?.broadcastWithKeychain) {
+        throw new Error("Keychain not supported by adapter");
+      }
+      return await adapter.broadcastWithKeychain(username, ops2, authority);
+    }
+    case "custom": {
+      if (!auth?.broadcast) {
+        throw new Error("No custom broadcast function provided");
+      }
+      return await auth.broadcast(ops2, authority);
+    }
+    default:
+      throw new Error(`Unknown auth method: ${method}`);
+  }
+}
+async function broadcastWithFallback(username, ops2, auth, authority = "posting") {
+  const adapter = auth?.adapter;
+  if (adapter?.getLoginType) {
+    const loginType = await adapter.getLoginType(username);
+    if (loginType) {
+      const hasPostingAuth = adapter.hasPostingAuthorization ? await adapter.hasPostingAuthorization(username) : false;
+      if (authority === "posting" && hasPostingAuth && loginType === "key") {
+        try {
+          return await broadcastWithMethod("hivesigner", username, ops2, auth, authority);
+        } catch (error) {
+          if (!shouldTriggerAuthFallback(error)) {
+            throw error;
+          }
+          console.warn("[SDK] HiveSigner token auth failed, falling back to key:", error);
+        }
+      }
+      if (authority === "posting" && hasPostingAuth && loginType === "hiveauth") {
+        try {
+          return await broadcastWithMethod("hivesigner", username, ops2, auth, authority);
+        } catch (error) {
+          if (!shouldTriggerAuthFallback(error)) {
+            throw error;
+          }
+          console.warn("[SDK] HiveSigner token auth failed, falling back to HiveAuth:", error);
+        }
+      }
+      try {
+        return await broadcastWithMethod(loginType, username, ops2, auth, authority);
+      } catch (error) {
+        if (shouldTriggerAuthFallback(error)) {
+          if (adapter.showAuthUpgradeUI && (authority === "posting" || authority === "active")) {
+            const operationName = ops2.length > 0 ? ops2[0][0] : "unknown";
+            const selectedMethod = await adapter.showAuthUpgradeUI(authority, operationName);
+            if (!selectedMethod) {
+              throw new Error(`Operation requires ${authority} authority. User declined alternate auth.`);
+            }
+            return await broadcastWithMethod(selectedMethod, username, ops2, auth, authority);
+          }
+        }
+        throw error;
+      }
+    }
+  }
+  const chain = auth?.fallbackChain ?? ["key", "hiveauth", "hivesigner", "keychain", "custom"];
+  const errors = /* @__PURE__ */ new Map();
+  for (const method of chain) {
+    try {
+      let shouldSkip = false;
+      let skipReason = "";
+      let prefetchedKey;
+      let prefetchedToken;
+      switch (method) {
+        case "key":
+          if (!adapter) {
+            shouldSkip = true;
+            skipReason = "No adapter provided";
+          } else {
+            let key;
+            switch (authority) {
+              case "owner":
+                if (adapter.getOwnerKey) {
+                  key = await adapter.getOwnerKey(username);
+                }
+                break;
+              case "active":
+                if (adapter.getActiveKey) {
+                  key = await adapter.getActiveKey(username);
+                }
+                break;
+              case "memo":
+                if (adapter.getMemoKey) {
+                  key = await adapter.getMemoKey(username);
+                }
+                break;
+              case "posting":
+              default:
+                key = await adapter.getPostingKey(username);
+                break;
+            }
+            if (!key) {
+              shouldSkip = true;
+              skipReason = `No ${authority} key available`;
+            } else {
+              prefetchedKey = key;
+            }
+          }
+          break;
+        case "hiveauth":
+          if (!adapter?.broadcastWithHiveAuth) {
+            shouldSkip = true;
+            skipReason = "HiveAuth not supported by adapter";
+          }
+          break;
+        case "hivesigner":
+          if (!adapter) {
+            shouldSkip = true;
+            skipReason = "No adapter provided";
+          } else {
+            const token = await adapter.getAccessToken(username);
+            if (!token) {
+              shouldSkip = true;
+              skipReason = "No access token available";
+            } else {
+              prefetchedToken = token;
+            }
+          }
+          break;
+        case "keychain":
+          if (!adapter?.broadcastWithKeychain) {
+            shouldSkip = true;
+            skipReason = "Keychain not supported by adapter";
+          }
+          break;
+        case "custom":
+          if (!auth?.broadcast) {
+            shouldSkip = true;
+            skipReason = "No custom broadcast function provided";
+          }
+          break;
+      }
+      if (shouldSkip) {
+        errors.set(method, new Error(`Skipped: ${skipReason}`));
+        continue;
+      }
+      return await broadcastWithMethod(method, username, ops2, auth, authority, prefetchedKey, prefetchedToken);
+    } 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 +494,28 @@ 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) {
+        if (authority !== "posting") {
+          throw new Error(
+            `[SDK][Broadcast] Legacy auth only supports posting authority, but '${authority}' was requested. Use AuthContextV2 with an adapter for ${authority} operations.`
+          );
+        }
         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;
@@ -2820,100 +3278,1151 @@ function useAccountRelationsUpdate(reference, target, auth, onSuccess, onError)
     }
   });
 }
-function useBookmarkAdd(username, code, onSuccess, onError) {
-  return reactQuery.useMutation({
-    mutationKey: ["accounts", "bookmarks", "add", username],
-    mutationFn: async ({ author, permlink }) => {
-      if (!username || !code) {
-        throw new Error("[SDK][Account][Bookmarks] \u2013 missing auth");
-      }
-      const fetchApi = getBoundFetch();
-      const response = await fetchApi(
-        CONFIG.privateApiHost + "/private-api/bookmarks-add",
-        {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify({
-            author,
-            permlink,
-            code
-          })
-        }
-      );
-      return response.json();
-    },
-    onSuccess: () => {
-      onSuccess();
-      getQueryClient().invalidateQueries({
-        queryKey: ["accounts", "bookmarks", username]
-      });
-    },
-    onError
-  });
+
+// 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 useBookmarkDelete(username, code, onSuccess, onError) {
-  return reactQuery.useMutation({
-    mutationKey: ["accounts", "bookmarks", "delete", username],
-    mutationFn: async (bookmarkId) => {
-      if (!username || !code) {
-        throw new Error("[SDK][Account][Bookmarks] \u2013 missing auth");
-      }
-      const fetchApi = getBoundFetch();
-      const response = await fetchApi(
-        CONFIG.privateApiHost + "/private-api/bookmarks-delete",
-        {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify({
-            id: bookmarkId,
-            code
-          })
-        }
-      );
-      return response.json();
-    },
-    onSuccess: () => {
-      onSuccess();
-      getQueryClient().invalidateQueries({
-        queryKey: ["accounts", "bookmarks", username]
-      });
-    },
-    onError
-  });
+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 useAccountFavouriteAdd(username, code, onSuccess, onError) {
-  return reactQuery.useMutation({
-    mutationKey: ["accounts", "favourites", "add", username],
-    mutationFn: async (account) => {
-      if (!username || !code) {
-        throw new Error("[SDK][Account][Bookmarks] \u2013 missing auth");
-      }
-      const fetchApi = getBoundFetch();
-      const response = await fetchApi(
-        CONFIG.privateApiHost + "/private-api/favorites-add",
-        {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify({
-            account,
-            code
-          })
-        }
-      );
-      return response.json();
-    },
-    onSuccess: () => {
-      onSuccess();
-      getQueryClient().invalidateQueries({
-        queryKey: ["accounts", "favourites", username]
-      });
-    },
+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 buildDeleteCommentOp(author, permlink) {
+  if (!author || !permlink) {
+    throw new Error("[SDK][buildDeleteCommentOp] Missing required parameters");
+  }
+  return [
+    "delete_comment",
+    {
+      author,
+      permlink
+    }
+  ];
+}
+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]
+    }
+  ];
+}
+
+// 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]
+    }
+  ];
+}
+
+// src/modules/accounts/mutations/use-follow.ts
+function useFollow(username, auth) {
+  return useBroadcastMutation(
+    ["accounts", "follow"],
+    username,
+    ({ following }) => [
+      buildFollowOp(username, following)
+    ],
+    async (_result, variables) => {
+      if (auth?.adapter?.invalidateQueries) {
+        await auth.adapter.invalidateQueries([
+          ["accounts", "relations", username, variables.following],
+          ["accounts", "full", variables.following]
+        ]);
+      }
+    },
+    auth
+  );
+}
+
+// src/modules/accounts/mutations/use-unfollow.ts
+function useUnfollow(username, auth) {
+  return useBroadcastMutation(
+    ["accounts", "unfollow"],
+    username,
+    ({ following }) => [
+      buildUnfollowOp(username, following)
+    ],
+    async (_result, variables) => {
+      if (auth?.adapter?.invalidateQueries) {
+        await auth.adapter.invalidateQueries([
+          ["accounts", "relations", username, variables.following],
+          ["accounts", "full", variables.following]
+        ]);
+      }
+    },
+    auth
+  );
+}
+function useBookmarkAdd(username, code, onSuccess, onError) {
+  return reactQuery.useMutation({
+    mutationKey: ["accounts", "bookmarks", "add", username],
+    mutationFn: async ({ author, permlink }) => {
+      if (!username || !code) {
+        throw new Error("[SDK][Account][Bookmarks] \u2013 missing auth");
+      }
+      const fetchApi = getBoundFetch();
+      const response = await fetchApi(
+        CONFIG.privateApiHost + "/private-api/bookmarks-add",
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            author,
+            permlink,
+            code
+          })
+        }
+      );
+      return response.json();
+    },
+    onSuccess: () => {
+      onSuccess();
+      getQueryClient().invalidateQueries({
+        queryKey: ["accounts", "bookmarks", username]
+      });
+    },
+    onError
+  });
+}
+function useBookmarkDelete(username, code, onSuccess, onError) {
+  return reactQuery.useMutation({
+    mutationKey: ["accounts", "bookmarks", "delete", username],
+    mutationFn: async (bookmarkId) => {
+      if (!username || !code) {
+        throw new Error("[SDK][Account][Bookmarks] \u2013 missing auth");
+      }
+      const fetchApi = getBoundFetch();
+      const response = await fetchApi(
+        CONFIG.privateApiHost + "/private-api/bookmarks-delete",
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            id: bookmarkId,
+            code
+          })
+        }
+      );
+      return response.json();
+    },
+    onSuccess: () => {
+      onSuccess();
+      getQueryClient().invalidateQueries({
+        queryKey: ["accounts", "bookmarks", username]
+      });
+    },
+    onError
+  });
+}
+function useAccountFavouriteAdd(username, code, onSuccess, onError) {
+  return reactQuery.useMutation({
+    mutationKey: ["accounts", "favourites", "add", username],
+    mutationFn: async (account) => {
+      if (!username || !code) {
+        throw new Error("[SDK][Account][Bookmarks] \u2013 missing auth");
+      }
+      const fetchApi = getBoundFetch();
+      const response = await fetchApi(
+        CONFIG.privateApiHost + "/private-api/favorites-add",
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            account,
+            code
+          })
+        }
+      );
+      return response.json();
+    },
+    onSuccess: () => {
+      onSuccess();
+      getQueryClient().invalidateQueries({
+        queryKey: ["accounts", "favourites", username]
+      });
+    },
     onError
   });
 }
@@ -3346,6 +4855,94 @@ function votingValue(account, dynamicProps, votingPowerValue, weight = 1e4) {
   }
   return rShares / fundRecentClaims * fundRewardBalance * (base / quote);
 }
+
+// src/modules/operations/authority-map.ts
+var OPERATION_AUTHORITY_MAP = {
+  // Posting authority operations
+  vote: "posting",
+  comment: "posting",
+  delete_comment: "posting",
+  comment_options: "posting",
+  claim_reward_balance: "posting",
+  // Active authority operations - Financial
+  cancel_transfer_from_savings: "active",
+  collateralized_convert: "active",
+  convert: "active",
+  delegate_vesting_shares: "active",
+  recurrent_transfer: "active",
+  set_withdraw_vesting_route: "active",
+  transfer: "active",
+  transfer_from_savings: "active",
+  transfer_to_savings: "active",
+  transfer_to_vesting: "active",
+  withdraw_vesting: "active",
+  // Active authority operations - Market
+  limit_order_create: "active",
+  limit_order_cancel: "active",
+  // Active authority operations - Account Management
+  account_update: "active",
+  account_update2: "active",
+  create_claimed_account: "active",
+  // Active authority operations - Governance
+  account_witness_proxy: "active",
+  account_witness_vote: "active",
+  remove_proposal: "active",
+  update_proposal_votes: "active",
+  // Owner authority operations - Security & Account Recovery
+  change_recovery_account: "owner",
+  request_account_recovery: "owner",
+  recover_account: "owner",
+  reset_account: "owner",
+  set_reset_account: "owner"
+  // Note: Some operations are handled separately via content inspection:
+  // - custom_json: via getCustomJsonAuthority() - posting or active based on required_auths
+  // - create_proposal/update_proposal: via getProposalAuthority() - typically active
+};
+function getCustomJsonAuthority(customJsonOp) {
+  const opType = customJsonOp[0];
+  const payload = customJsonOp[1];
+  if (opType !== "custom_json") {
+    throw new Error("Operation is not a custom_json operation");
+  }
+  const customJson = payload;
+  if (customJson.required_auths && customJson.required_auths.length > 0) {
+    return "active";
+  }
+  if (customJson.required_posting_auths && customJson.required_posting_auths.length > 0) {
+    return "posting";
+  }
+  return "posting";
+}
+function getProposalAuthority(proposalOp) {
+  const opType = proposalOp[0];
+  if (opType !== "create_proposal" && opType !== "update_proposal") {
+    throw new Error("Operation is not a proposal operation");
+  }
+  return "active";
+}
+function getOperationAuthority(op) {
+  const opType = op[0];
+  if (opType === "custom_json") {
+    return getCustomJsonAuthority(op);
+  }
+  if (opType === "create_proposal" || opType === "update_proposal") {
+    return getProposalAuthority(op);
+  }
+  return OPERATION_AUTHORITY_MAP[opType] ?? "posting";
+}
+function getRequiredAuthority(ops2) {
+  let highestAuthority = "posting";
+  for (const op of ops2) {
+    const authority = getOperationAuthority(op);
+    if (authority === "owner") {
+      return "owner";
+    }
+    if (authority === "active" && highestAuthority === "posting") {
+      highestAuthority = "active";
+    }
+  }
+  return highestAuthority;
+}
 function useSignOperationByKey(username) {
   return reactQuery.useMutation({
     mutationKey: ["operations", "sign", username],
@@ -4023,6 +5620,138 @@ 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],
+          ["account", username, "rc"]
+          // RC decreases after posting/commenting
+        ];
+        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));
@@ -4884,6 +6613,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],
@@ -5174,6 +6932,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],
@@ -6078,13 +7940,17 @@ 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.OPERATION_AUTHORITY_MAP = OPERATION_AUTHORITY_MAP;
+exports.OrderIdPrefix = OrderIdPrefix;
 exports.ROLES = ROLES;
 exports.SortOrder = SortOrder;
 exports.Symbol = Symbol2;
@@ -6094,7 +7960,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;
@@ -6105,6 +8032,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;
@@ -6143,6 +8071,7 @@ exports.getCurrencyRate = getCurrencyRate;
 exports.getCurrencyRates = getCurrencyRates;
 exports.getCurrencyTokenRate = getCurrencyTokenRate;
 exports.getCurrentMedianHistoryPriceQueryOptions = getCurrentMedianHistoryPriceQueryOptions;
+exports.getCustomJsonAuthority = getCustomJsonAuthority;
 exports.getDeletedEntryQueryOptions = getDeletedEntryQueryOptions;
 exports.getDiscoverCurationQueryOptions = getDiscoverCurationQueryOptions;
 exports.getDiscoverLeaderboardQueryOptions = getDiscoverLeaderboardQueryOptions;
@@ -6192,6 +8121,7 @@ exports.getNotificationsInfiniteQueryOptions = getNotificationsInfiniteQueryOpti
 exports.getNotificationsSettingsQueryOptions = getNotificationsSettingsQueryOptions;
 exports.getNotificationsUnreadCountQueryOptions = getNotificationsUnreadCountQueryOptions;
 exports.getOpenOrdersQueryOptions = getOpenOrdersQueryOptions;
+exports.getOperationAuthority = getOperationAuthority;
 exports.getOrderBookQueryOptions = getOrderBookQueryOptions;
 exports.getOutgoingRcDelegationsInfiniteQueryOptions = getOutgoingRcDelegationsInfiniteQueryOptions;
 exports.getPageStatsQueryOptions = getPageStatsQueryOptions;
@@ -6210,6 +8140,7 @@ exports.getProfilesQueryOptions = getProfilesQueryOptions;
 exports.getPromotePriceQueryOptions = getPromotePriceQueryOptions;
 exports.getPromotedPost = getPromotedPost;
 exports.getPromotedPostsQuery = getPromotedPostsQuery;
+exports.getProposalAuthority = getProposalAuthority;
 exports.getProposalQueryOptions = getProposalQueryOptions;
 exports.getProposalVotesInfiniteQueryOptions = getProposalVotesInfiniteQueryOptions;
 exports.getProposalsQueryOptions = getProposalsQueryOptions;
@@ -6223,6 +8154,7 @@ exports.getReferralsInfiniteQueryOptions = getReferralsInfiniteQueryOptions;
 exports.getReferralsStatsQueryOptions = getReferralsStatsQueryOptions;
 exports.getRelationshipBetweenAccounts = getRelationshipBetweenAccounts;
 exports.getRelationshipBetweenAccountsQueryOptions = getRelationshipBetweenAccountsQueryOptions;
+exports.getRequiredAuthority = getRequiredAuthority;
 exports.getRewardFundQueryOptions = getRewardFundQueryOptions;
 exports.getRewardedCommunitiesQueryOptions = getRewardedCommunitiesQueryOptions;
 exports.getSavingsWithdrawFromQueryOptions = getSavingsWithdrawFromQueryOptions;
@@ -6256,6 +8188,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;
@@ -6268,6 +8203,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;
@@ -6279,6 +8215,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;
@@ -6301,20 +8238,27 @@ exports.useAddSchedule = useAddSchedule;
 exports.useBookmarkAdd = useBookmarkAdd;
 exports.useBookmarkDelete = useBookmarkDelete;
 exports.useBroadcastMutation = useBroadcastMutation;
+exports.useComment = useComment;
 exports.useDeleteDraft = useDeleteDraft;
 exports.useDeleteImage = useDeleteImage;
 exports.useDeleteSchedule = useDeleteSchedule;
 exports.useEditFragment = useEditFragment;
+exports.useFollow = useFollow;
 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.useUnfollow = useUnfollow;
 exports.useUpdateDraft = useUpdateDraft;
 exports.useUploadImage = useUploadImage;
+exports.useVote = useVote;
 exports.usrActivity = usrActivity;
 exports.validatePostCreating = validatePostCreating;
 exports.votingPower = votingPower;