@ecency/sdk 1.5.28 → 2.0.0

package/dist/node/index.cjs

@@ -258,67 +258,210 @@ 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();
-  const adapter = auth?.adapter;
   for (const method of chain) {
     try {
+      let shouldSkip = false;
+      let skipReason = "";
+      let prefetchedKey;
+      let prefetchedToken;
       switch (method) {
-        case "key": {
+        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;
+            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;
+            }
           }
-          const privateKey = dhive.PrivateKey.fromString(key);
-          return await CONFIG.hiveClient.broadcast.sendOperations(ops2, privateKey);
-        }
-        case "hiveauth": {
+          break;
+        case "hiveauth":
           if (!adapter?.broadcastWithHiveAuth) {
-            errors.set(method, new Error("Skipped: HiveAuth not supported by adapter"));
-            break;
+            shouldSkip = true;
+            skipReason = "HiveAuth not supported by adapter";
           }
-          return await adapter.broadcastWithHiveAuth(username, ops2, authority);
-        }
-        case "hivesigner": {
+          break;
+        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;
+            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;
+            }
           }
-          const client = new hs__default.default.Client({ accessToken: token });
-          const response = await client.broadcast(ops2);
-          return response.result;
-        }
-        case "keychain": {
+          break;
+        case "keychain":
           if (!adapter?.broadcastWithKeychain) {
-            errors.set(method, new Error("Skipped: Keychain not supported by adapter"));
-            break;
+            shouldSkip = true;
+            skipReason = "Keychain not supported by adapter";
           }
-          return await adapter.broadcastWithKeychain(username, ops2, authority);
-        }
-        case "custom": {
+          break;
+        case "custom":
           if (!auth?.broadcast) {
-            errors.set(method, new Error("Skipped: No custom broadcast function provided"));
-            break;
+            shouldSkip = true;
+            skipReason = "No custom broadcast function provided";
           }
-          return await auth.broadcast(ops2, authority);
-        }
+          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)) {
@@ -360,6 +503,11 @@ function useBroadcastMutation(mutationKey = [], username, operations, onSuccess
       }
       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(
           ops2,
@@ -3130,1542 +3278,1670 @@ 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
-  });
-}
-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
-  });
+
+// 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 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
-  });
+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 useAccountFavouriteDelete(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-delete",
-        {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify({
-            account,
-            code
-          })
-        }
-      );
-      return response.json();
-    },
-    onSuccess: () => {
-      onSuccess();
-      getQueryClient().invalidateQueries({
-        queryKey: ["accounts", "favourites", username]
-      });
-    },
-    onError
-  });
+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 dedupeAndSortKeyAuths(existing, additions) {
-  const merged = /* @__PURE__ */ new Map();
-  existing.forEach(([key, weight]) => {
-    merged.set(key.toString(), weight);
-  });
-  additions.forEach(([key, weight]) => {
-    merged.set(key.toString(), weight);
-  });
-  return Array.from(merged.entries()).sort(([keyA], [keyB]) => keyA.localeCompare(keyB)).map(([key, weight]) => [key, weight]);
-}
-function useAccountUpdateKeyAuths(username, options) {
-  const { data: accountData } = reactQuery.useQuery(getAccountFullQueryOptions(username));
-  return reactQuery.useMutation({
-    mutationKey: ["accounts", "keys-update", username],
-    mutationFn: async ({
-      keys,
-      keepCurrent = false,
-      currentKey,
-      keysToRevoke = [],
-      keysToRevokeByAuthority = {}
-    }) => {
-      if (keys.length === 0) {
-        throw new Error(
-          "[SDK][Update password] \u2013 no new keys provided"
-        );
-      }
-      if (!accountData) {
-        throw new Error(
-          "[SDK][Update password] \u2013 cannot update keys for anon user"
-        );
-      }
-      const prepareAuth = (keyName) => {
-        const auth = R4__namespace.clone(accountData[keyName]);
-        const keysToRevokeForAuthority = keysToRevokeByAuthority[keyName] || [];
-        const allKeysToRevoke = [
-          ...keysToRevokeForAuthority,
-          ...keysToRevokeByAuthority[keyName] === void 0 ? keysToRevoke : []
-        ];
-        const existingKeys = keepCurrent ? auth.key_auths.filter(([key]) => !allKeysToRevoke.includes(key.toString())) : [];
-        auth.key_auths = dedupeAndSortKeyAuths(
-          existingKeys,
-          keys.map(
-            (values, i) => [values[keyName].createPublic().toString(), i + 1]
-          )
-        );
-        return auth;
-      };
-      return CONFIG.hiveClient.broadcast.updateAccount(
-        {
-          account: username,
-          json_metadata: accountData.json_metadata,
-          owner: prepareAuth("owner"),
-          active: prepareAuth("active"),
-          posting: prepareAuth("posting"),
-          // Always use new memo key when adding new keys
-          memo_key: keys[0].memo_key.createPublic().toString()
-        },
-        currentKey
-      );
-    },
-    ...options
-  });
-}
-function useAccountUpdatePassword(username, options) {
-  const { data: accountData } = reactQuery.useQuery(getAccountFullQueryOptions(username));
-  const { mutateAsync: updateKeys } = useAccountUpdateKeyAuths(username);
-  return reactQuery.useMutation({
-    mutationKey: ["accounts", "password-update", username],
-    mutationFn: async ({
-      newPassword,
-      currentPassword,
-      keepCurrent
-    }) => {
-      if (!accountData) {
-        throw new Error(
-          "[SDK][Update password] \u2013 cannot update password for anon user"
-        );
-      }
-      const currentKey = dhive.PrivateKey.fromLogin(
-        username,
-        currentPassword,
-        "owner"
-      );
-      return updateKeys({
-        currentKey,
-        keepCurrent,
-        keys: [
-          {
-            owner: dhive.PrivateKey.fromLogin(username, newPassword, "owner"),
-            active: dhive.PrivateKey.fromLogin(username, newPassword, "active"),
-            posting: dhive.PrivateKey.fromLogin(username, newPassword, "posting"),
-            memo_key: dhive.PrivateKey.fromLogin(username, newPassword, "memo")
-          }
-        ]
-      });
-    },
-    ...options
-  });
-}
-function useAccountRevokePosting(username, options, auth) {
-  const queryClient = reactQuery.useQueryClient();
-  const { data } = reactQuery.useQuery(getAccountFullQueryOptions(username));
-  return reactQuery.useMutation({
-    mutationKey: ["accounts", "revoke-posting", data?.name],
-    mutationFn: async ({ accountName, type, key }) => {
-      if (!data) {
-        throw new Error(
-          "[SDK][Accounts] \u2013\xA0cannot revoke posting for anonymous user"
-        );
-      }
-      const posting = R4__namespace.pipe(
-        {},
-        R4__namespace.mergeDeep(data.posting)
-      );
-      posting.account_auths = posting.account_auths.filter(
-        ([account]) => account !== accountName
-      );
-      const operationBody = {
-        account: data.name,
-        posting,
-        memo_key: data.memo_key,
-        json_metadata: data.json_metadata
-      };
-      if (type === "key" && key) {
-        return CONFIG.hiveClient.broadcast.updateAccount(operationBody, key);
-      } else if (type === "keychain") {
-        if (!auth?.broadcast) {
-          throw new Error("[SDK][Accounts] \u2013 missing keychain broadcaster");
-        }
-        return auth.broadcast([["account_update", operationBody]], "active");
-      } else {
-        const params = {
-          callback: `https://ecency.com/@${data.name}/permissions`
-        };
-        return hs__default.default.sendOperation(
-          ["account_update", operationBody],
-          params,
-          () => {
-          }
-        );
-      }
-    },
-    onError: options.onError,
-    onSuccess: (resp, payload, ctx) => {
-      options.onSuccess?.(resp, payload, ctx);
-      queryClient.setQueryData(
-        getAccountFullQueryOptions(username).queryKey,
-        (data2) => ({
-          ...data2,
-          posting: {
-            ...data2?.posting,
-            account_auths: data2?.posting?.account_auths?.filter(
-              ([account]) => account !== payload.accountName
-            ) ?? []
-          }
-        })
-      );
-    }
-  });
-}
-function useAccountUpdateRecovery(username, code, options, auth) {
-  const { data } = reactQuery.useQuery(getAccountFullQueryOptions(username));
-  return reactQuery.useMutation({
-    mutationKey: ["accounts", "recovery", data?.name],
-    mutationFn: async ({ accountName, type, key, email }) => {
-      if (!data) {
-        throw new Error(
-          "[SDK][Accounts] \u2013\xA0cannot change recovery for anonymous user"
-        );
-      }
-      const operationBody = {
-        account_to_recover: data.name,
-        new_recovery_account: accountName,
-        extensions: []
-      };
-      if (type === "ecency") {
-        if (!code) {
-          throw new Error("[SDK][Accounts] \u2013 missing access token");
-        }
-        const fetchApi = getBoundFetch();
-        return fetchApi(CONFIG.privateApiHost + "/private-api/recoveries-add", {
-          method: "POST",
-          body: JSON.stringify({
-            code,
-            email,
-            publicKeys: [
-              ...data.owner.key_auths,
-              ...data.active.key_auths,
-              ...data.posting.key_auths,
-              data.memo_key
-            ]
-          })
-        });
-      } else if (type === "key" && key) {
-        return CONFIG.hiveClient.broadcast.sendOperations(
-          [["change_recovery_account", operationBody]],
-          key
-        );
-      } else if (type === "keychain") {
-        if (!auth?.broadcast) {
-          throw new Error("[SDK][Accounts] \u2013 missing keychain broadcaster");
-        }
-        return auth.broadcast([["change_recovery_account", operationBody]], "owner");
-      } else {
-        const params = {
-          callback: `https://ecency.com/@${data.name}/permissions`
-        };
-        return hs__default.default.sendOperation(
-          ["change_recovery_account", operationBody],
-          params,
-          () => {
-          }
-        );
-      }
-    },
-    onError: options.onError,
-    onSuccess: options.onSuccess
-  });
-}
-function useAccountRevokeKey(username, options) {
-  const { data: accountData } = reactQuery.useQuery(getAccountFullQueryOptions(username));
-  return reactQuery.useMutation({
-    mutationKey: ["accounts", "revoke-key", accountData?.name],
-    mutationFn: async ({ currentKey, revokingKey }) => {
-      if (!accountData) {
-        throw new Error(
-          "[SDK][Update password] \u2013 cannot update keys for anon user"
-        );
-      }
-      const prepareAuth = (keyName) => {
-        const auth = R4__namespace.clone(accountData[keyName]);
-        auth.key_auths = auth.key_auths.filter(
-          ([key]) => key !== revokingKey.toString()
-        );
-        return auth;
-      };
-      return CONFIG.hiveClient.broadcast.updateAccount(
-        {
-          account: accountData.name,
-          json_metadata: accountData.json_metadata,
-          owner: prepareAuth("owner"),
-          active: prepareAuth("active"),
-          posting: prepareAuth("posting"),
-          memo_key: accountData.memo_key
-        },
-        currentKey
-      );
-    },
-    ...options
-  });
-}
-
-// src/modules/accounts/utils/account-power.ts
-var HIVE_VOTING_MANA_REGENERATION_SECONDS = 5 * 60 * 60 * 24;
-function vestsToRshares(vests, votingPowerValue, votePerc) {
-  const vestingShares = vests * 1e6;
-  const power = votingPowerValue * votePerc / 1e4 / 50 + 1;
-  return power * vestingShares / 1e4;
-}
-function toDhiveAccountForVotingMana(account) {
-  return {
-    id: 0,
-    name: account.name,
-    owner: account.owner,
-    active: account.active,
-    posting: account.posting,
-    memo_key: account.memo_key,
-    json_metadata: account.json_metadata,
-    posting_json_metadata: account.posting_json_metadata,
-    proxy: account.proxy ?? "",
-    last_owner_update: "",
-    last_account_update: "",
-    created: account.created,
-    mined: false,
-    owner_challenged: false,
-    active_challenged: false,
-    last_owner_proved: "",
-    last_active_proved: "",
-    recovery_account: account.recovery_account ?? "",
-    reset_account: "",
-    last_account_recovery: "",
-    comment_count: 0,
-    lifetime_vote_count: 0,
-    post_count: account.post_count,
-    can_vote: true,
-    voting_power: account.voting_power,
-    last_vote_time: account.last_vote_time,
-    voting_manabar: account.voting_manabar,
-    balance: account.balance,
-    savings_balance: account.savings_balance,
-    hbd_balance: account.hbd_balance,
-    hbd_seconds: "0",
-    hbd_seconds_last_update: "",
-    hbd_last_interest_payment: "",
-    savings_hbd_balance: account.savings_hbd_balance,
-    savings_hbd_seconds: account.savings_hbd_seconds,
-    savings_hbd_seconds_last_update: account.savings_hbd_seconds_last_update,
-    savings_hbd_last_interest_payment: account.savings_hbd_last_interest_payment,
-    savings_withdraw_requests: 0,
-    reward_hbd_balance: account.reward_hbd_balance,
-    reward_hive_balance: account.reward_hive_balance,
-    reward_vesting_balance: account.reward_vesting_balance,
-    reward_vesting_hive: account.reward_vesting_hive,
-    curation_rewards: 0,
-    posting_rewards: 0,
-    vesting_shares: account.vesting_shares,
-    delegated_vesting_shares: account.delegated_vesting_shares,
-    received_vesting_shares: account.received_vesting_shares,
-    vesting_withdraw_rate: account.vesting_withdraw_rate,
-    next_vesting_withdrawal: account.next_vesting_withdrawal,
-    withdrawn: account.withdrawn,
-    to_withdraw: account.to_withdraw,
-    withdraw_routes: 0,
-    proxied_vsf_votes: account.proxied_vsf_votes ?? [],
-    witnesses_voted_for: 0,
-    average_bandwidth: 0,
-    lifetime_bandwidth: 0,
-    last_bandwidth_update: "",
-    average_market_bandwidth: 0,
-    lifetime_market_bandwidth: 0,
-    last_market_bandwidth_update: "",
-    last_post: account.last_post,
-    last_root_post: ""
+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]
+    }
+  ];
 }
-function votingPower(account) {
-  const calc = CONFIG.hiveClient.rc.calculateVPMana(
-    toDhiveAccountForVotingMana(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)
   );
-  return calc.percentage / 100;
 }
-function powerRechargeTime(power) {
-  if (!Number.isFinite(power)) {
-    throw new TypeError("Voting power must be a finite number");
+function buildRecurrentTransferOp(from, to, amount, memo, recurrence, executions) {
+  if (!from || !to || !amount) {
+    throw new Error("[SDK][buildRecurrentTransferOp] Missing required parameters");
   }
-  if (power < 0 || power > 100) {
-    throw new RangeError("Voting power must be between 0 and 100");
+  if (recurrence < 24) {
+    throw new Error("[SDK][buildRecurrentTransferOp] Recurrence must be at least 24 hours");
   }
-  const missingPower = 100 - power;
-  return missingPower * 100 * HIVE_VOTING_MANA_REGENERATION_SECONDS / 1e4;
+  return [
+    "recurrent_transfer",
+    {
+      from,
+      to,
+      amount,
+      memo: memo || "",
+      recurrence,
+      executions,
+      extensions: []
+    }
+  ];
 }
-function downVotingPower(account) {
-  const totalShares = parseFloat(account.vesting_shares) + parseFloat(account.received_vesting_shares) - parseFloat(account.delegated_vesting_shares);
-  const elapsed = Math.floor(Date.now() / 1e3) - account.downvote_manabar.last_update_time;
-  const maxMana = totalShares * 1e6 / 4;
-  if (maxMana <= 0) {
-    return 0;
-  }
-  let currentMana = parseFloat(account.downvote_manabar.current_mana.toString()) + elapsed * maxMana / HIVE_VOTING_MANA_REGENERATION_SECONDS;
-  if (currentMana > maxMana) {
-    currentMana = maxMana;
+function buildTransferToSavingsOp(from, to, amount, memo) {
+  if (!from || !to || !amount) {
+    throw new Error("[SDK][buildTransferToSavingsOp] Missing required parameters");
   }
-  const currentManaPerc = currentMana * 100 / maxMana;
-  if (isNaN(currentManaPerc)) {
-    return 0;
+  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");
   }
-  if (currentManaPerc > 100) {
-    return 100;
+  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 currentManaPerc;
+  return [
+    "cancel_transfer_from_savings",
+    {
+      from,
+      request_id: requestId
+    }
+  ];
 }
-function rcPower(account) {
-  const calc = CONFIG.hiveClient.rc.calculateRCMana(account);
-  return calc.percentage / 100;
+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 votingValue(account, dynamicProps, votingPowerValue, weight = 1e4) {
-  if (!Number.isFinite(votingPowerValue) || !Number.isFinite(weight)) {
-    return 0;
+function buildTransferToVestingOp(from, to, amount) {
+  if (!from || !to || !amount) {
+    throw new Error("[SDK][buildTransferToVestingOp] Missing required parameters");
   }
-  const { fundRecentClaims, fundRewardBalance, base, quote } = dynamicProps;
-  if (!Number.isFinite(fundRecentClaims) || !Number.isFinite(fundRewardBalance) || !Number.isFinite(base) || !Number.isFinite(quote)) {
-    return 0;
+  return [
+    "transfer_to_vesting",
+    {
+      from,
+      to,
+      amount
+    }
+  ];
+}
+function buildWithdrawVestingOp(account, vestingShares) {
+  if (!account || !vestingShares) {
+    throw new Error("[SDK][buildWithdrawVestingOp] Missing required parameters");
   }
-  if (fundRecentClaims === 0 || quote === 0) {
-    return 0;
+  return [
+    "withdraw_vesting",
+    {
+      account,
+      vesting_shares: vestingShares
+    }
+  ];
+}
+function buildDelegateVestingSharesOp(delegator, delegatee, vestingShares) {
+  if (!delegator || !delegatee || !vestingShares) {
+    throw new Error("[SDK][buildDelegateVestingSharesOp] Missing required parameters");
   }
-  let totalVests = 0;
-  try {
-    const vesting = parseAsset(account.vesting_shares).amount;
-    const received = parseAsset(account.received_vesting_shares).amount;
-    const delegated = parseAsset(account.delegated_vesting_shares).amount;
-    if (![vesting, received, delegated].every(Number.isFinite)) {
-      return 0;
+  return [
+    "delegate_vesting_shares",
+    {
+      delegator,
+      delegatee,
+      vesting_shares: vestingShares
     }
-    totalVests = vesting + received - delegated;
-  } catch {
-    return 0;
+  ];
+}
+function buildSetWithdrawVestingRouteOp(fromAccount, toAccount, percent, autoVest) {
+  if (!fromAccount || !toAccount || percent === void 0) {
+    throw new Error("[SDK][buildSetWithdrawVestingRouteOp] Missing required parameters");
   }
-  if (!Number.isFinite(totalVests)) {
-    return 0;
+  if (percent < 0 || percent > 1e4) {
+    throw new Error("[SDK][buildSetWithdrawVestingRouteOp] Percent must be between 0 and 10000");
   }
-  const rShares = vestsToRshares(totalVests, votingPowerValue, weight);
-  if (!Number.isFinite(rShares)) {
-    return 0;
+  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 rShares / fundRecentClaims * fundRewardBalance * (base / quote);
+  return [
+    "collateralized_convert",
+    {
+      owner,
+      amount,
+      requestid: requestId
+    }
+  ];
 }
-
-// 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");
+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 [
-    "vote",
+    "custom_json",
     {
-      voter,
-      author,
-      permlink,
-      weight
+      id: "rc",
+      json: JSON.stringify([
+        "delegate_rc",
+        {
+          from,
+          delegatees: delegateeArray,
+          max_rc: maxRc
+        }
+      ]),
+      required_auths: [],
+      required_posting_auths: [from]
     }
   ];
 }
-function buildCommentOp(author, permlink, parentAuthor, parentPermlink, title, body, jsonMetadata) {
-  if (!author || !permlink || parentPermlink === void 0 || !body) {
-    throw new Error("[SDK][buildCommentOp] Missing required parameters");
+
+// src/modules/operations/builders/social.ts
+function buildFollowOp(follower, following) {
+  if (!follower || !following) {
+    throw new Error("[SDK][buildFollowOp] Missing required parameters");
   }
   return [
-    "comment",
+    "custom_json",
     {
-      parent_author: parentAuthor,
-      parent_permlink: parentPermlink,
-      author,
-      permlink,
-      title,
-      body,
-      json_metadata: JSON.stringify(jsonMetadata)
+      id: "follow",
+      json: JSON.stringify([
+        "follow",
+        {
+          follower,
+          following,
+          what: ["blog"]
+        }
+      ]),
+      required_auths: [],
+      required_posting_auths: [follower]
     }
   ];
 }
-function buildCommentOptionsOp(author, permlink, maxAcceptedPayout, percentHbd, allowVotes, allowCurationRewards, extensions) {
-  if (!author || !permlink) {
-    throw new Error("[SDK][buildCommentOptionsOp] Missing required parameters");
+function buildUnfollowOp(follower, following) {
+  if (!follower || !following) {
+    throw new Error("[SDK][buildUnfollowOp] Missing required parameters");
   }
   return [
-    "comment_options",
+    "custom_json",
     {
-      author,
-      permlink,
-      max_accepted_payout: maxAcceptedPayout,
-      percent_hbd: percentHbd,
-      allow_votes: allowVotes,
-      allow_curation_rewards: allowCurationRewards,
-      extensions
+      id: "follow",
+      json: JSON.stringify([
+        "follow",
+        {
+          follower,
+          following,
+          what: []
+        }
+      ]),
+      required_auths: [],
+      required_posting_auths: [follower]
     }
   ];
 }
-function buildDeleteCommentOp(author, permlink) {
-  if (!author || !permlink) {
-    throw new Error("[SDK][buildDeleteCommentOp] Missing required parameters");
+function buildIgnoreOp(follower, following) {
+  if (!follower || !following) {
+    throw new Error("[SDK][buildIgnoreOp] Missing required parameters");
   }
   return [
-    "delete_comment",
+    "custom_json",
     {
-      author,
-      permlink
+      id: "follow",
+      json: JSON.stringify([
+        "follow",
+        {
+          follower,
+          following,
+          what: ["ignore"]
+        }
+      ]),
+      required_auths: [],
+      required_posting_auths: [follower]
     }
   ];
 }
-function buildReblogOp(account, author, permlink, deleteReblog = false) {
-  if (!account || !author || !permlink) {
-    throw new Error("[SDK][buildReblogOp] Missing required parameters");
+function buildUnignoreOp(follower, following) {
+  if (!follower || !following) {
+    throw new Error("[SDK][buildUnignoreOp] Missing required parameters");
   }
-  const json = {
-    account,
-    author,
-    permlink
-  };
-  if (deleteReblog) {
-    json.delete = "delete";
+  return buildUnfollowOp(follower, following);
+}
+function buildSetLastReadOps(username, date) {
+  if (!username) {
+    throw new Error("[SDK][buildSetLastReadOps] Missing required parameters");
   }
-  return [
+  const lastReadDate = date || (/* @__PURE__ */ new Date()).toISOString().split(".")[0];
+  const notifyOp = [
     "custom_json",
     {
-      id: "follow",
-      json: JSON.stringify(["reblog", json]),
+      id: "notify",
+      json: JSON.stringify(["setLastRead", { date: lastReadDate }]),
       required_auths: [],
-      required_posting_auths: [account]
+      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/wallet.ts
-function buildTransferOp(from, to, amount, memo) {
-  if (!from || !to || !amount) {
-    throw new Error("[SDK][buildTransferOp] Missing required parameters");
+// 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 [
-    "transfer",
+    "account_witness_vote",
     {
-      from,
-      to,
-      amount,
-      memo: memo || ""
+      account,
+      witness,
+      approve
     }
   ];
 }
-function buildMultiTransferOps(from, destinations, amount, memo) {
-  if (!from || !destinations || !amount) {
-    throw new Error("[SDK][buildMultiTransferOps] Missing required parameters");
+function buildWitnessProxyOp(account, proxy) {
+  if (!account || proxy === void 0) {
+    throw new Error("[SDK][buildWitnessProxyOp] Missing required parameters");
   }
-  const destArray = destinations.trim().split(/[\s,]+/).filter(Boolean);
-  return destArray.map(
-    (dest) => buildTransferOp(from, dest.trim(), amount, memo)
-  );
+  return [
+    "account_witness_proxy",
+    {
+      account,
+      proxy
+    }
+  ];
 }
-function buildRecurrentTransferOp(from, to, amount, memo, recurrence, executions) {
-  if (!from || !to || !amount) {
-    throw new Error("[SDK][buildRecurrentTransferOp] Missing required parameters");
+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");
   }
-  if (recurrence < 24) {
-    throw new Error("[SDK][buildRecurrentTransferOp] Recurrence must be at least 24 hours");
+  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 [
-    "recurrent_transfer",
+    "create_proposal",
     {
-      from,
-      to,
-      amount,
-      memo: memo || "",
-      recurrence,
-      executions,
+      creator,
+      receiver: payload.receiver,
+      start_date: payload.start,
+      end_date: payload.end,
+      daily_pay: payload.dailyPay,
+      subject: payload.subject,
+      permlink: payload.permlink,
       extensions: []
     }
   ];
 }
-function buildTransferToSavingsOp(from, to, amount, memo) {
-  if (!from || !to || !amount) {
-    throw new Error("[SDK][buildTransferToSavingsOp] Missing required parameters");
+function buildProposalVoteOp(voter, proposalIds, approve) {
+  if (!voter || !proposalIds || proposalIds.length === 0 || approve === void 0) {
+    throw new Error("[SDK][buildProposalVoteOp] Missing required parameters");
   }
   return [
-    "transfer_to_savings",
+    "update_proposal_votes",
     {
-      from,
-      to,
-      amount,
-      memo: memo || ""
+      voter,
+      proposal_ids: proposalIds,
+      approve,
+      extensions: []
     }
   ];
 }
-function buildTransferFromSavingsOp(from, to, amount, memo, requestId) {
-  if (!from || !to || !amount || requestId === void 0) {
-    throw new Error("[SDK][buildTransferFromSavingsOp] Missing required parameters");
+function buildRemoveProposalOp(proposalOwner, proposalIds) {
+  if (!proposalOwner || !proposalIds || proposalIds.length === 0) {
+    throw new Error("[SDK][buildRemoveProposalOp] Missing required parameters");
   }
   return [
-    "transfer_from_savings",
+    "remove_proposal",
     {
-      from,
-      to,
-      amount,
-      memo: memo || "",
-      request_id: requestId
+      proposal_owner: proposalOwner,
+      proposal_ids: proposalIds,
+      extensions: []
     }
   ];
 }
-function buildCancelTransferFromSavingsOp(from, requestId) {
-  if (!from || requestId === void 0) {
-    throw new Error("[SDK][buildCancelTransferFromSavingsOp] Missing required parameters");
+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 [
-    "cancel_transfer_from_savings",
-    {
-      from,
-      request_id: requestId
+    "update_proposal",
+    {
+      proposal_id: proposalId,
+      creator,
+      daily_pay: dailyPay,
+      subject,
+      permlink,
+      extensions: []
     }
   ];
 }
-function buildClaimInterestOps(from, to, amount, memo, requestId) {
-  if (!from || !to || !amount || requestId === void 0) {
-    throw new Error("[SDK][buildClaimInterestOps] Missing required parameters");
+
+// src/modules/operations/builders/community.ts
+function buildSubscribeOp(username, community) {
+  if (!username || !community) {
+    throw new Error("[SDK][buildSubscribeOp] Missing required parameters");
   }
   return [
-    buildTransferFromSavingsOp(from, to, amount, memo, requestId),
-    buildCancelTransferFromSavingsOp(from, requestId)
+    "custom_json",
+    {
+      id: "community",
+      json: JSON.stringify(["subscribe", { community }]),
+      required_auths: [],
+      required_posting_auths: [username]
+    }
   ];
 }
-function buildTransferToVestingOp(from, to, amount) {
-  if (!from || !to || !amount) {
-    throw new Error("[SDK][buildTransferToVestingOp] Missing required parameters");
+function buildUnsubscribeOp(username, community) {
+  if (!username || !community) {
+    throw new Error("[SDK][buildUnsubscribeOp] Missing required parameters");
   }
   return [
-    "transfer_to_vesting",
+    "custom_json",
     {
-      from,
-      to,
-      amount
+      id: "community",
+      json: JSON.stringify(["unsubscribe", { community }]),
+      required_auths: [],
+      required_posting_auths: [username]
     }
   ];
 }
-function buildWithdrawVestingOp(account, vestingShares) {
-  if (!account || !vestingShares) {
-    throw new Error("[SDK][buildWithdrawVestingOp] Missing required parameters");
+function buildSetRoleOp(username, community, account, role) {
+  if (!username || !community || !account || !role) {
+    throw new Error("[SDK][buildSetRoleOp] Missing required parameters");
   }
   return [
-    "withdraw_vesting",
+    "custom_json",
     {
-      account,
-      vesting_shares: vestingShares
+      id: "community",
+      json: JSON.stringify(["setRole", { community, account, role }]),
+      required_auths: [],
+      required_posting_auths: [username]
     }
   ];
 }
-function buildDelegateVestingSharesOp(delegator, delegatee, vestingShares) {
-  if (!delegator || !delegatee || !vestingShares) {
-    throw new Error("[SDK][buildDelegateVestingSharesOp] Missing required parameters");
+function buildUpdateCommunityOp(username, community, props) {
+  if (!username || !community || !props) {
+    throw new Error("[SDK][buildUpdateCommunityOp] Missing required parameters");
   }
   return [
-    "delegate_vesting_shares",
+    "custom_json",
     {
-      delegator,
-      delegatee,
-      vesting_shares: vestingShares
+      id: "community",
+      json: JSON.stringify(["updateProps", { community, props }]),
+      required_auths: [],
+      required_posting_auths: [username]
     }
   ];
 }
-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");
+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 [
-    "set_withdraw_vesting_route",
+    "custom_json",
     {
-      from_account: fromAccount,
-      to_account: toAccount,
-      percent,
-      auto_vest: autoVest
+      id: "community",
+      json: JSON.stringify([action, { community, account, permlink }]),
+      required_auths: [],
+      required_posting_auths: [username]
     }
   ];
 }
-function buildConvertOp(owner, amount, requestId) {
-  if (!owner || !amount || requestId === void 0) {
-    throw new Error("[SDK][buildConvertOp] Missing required parameters");
+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 [
-    "convert",
+    "custom_json",
     {
-      owner,
-      amount,
-      requestid: requestId
+      id: "community",
+      json: JSON.stringify([action, { community, account, permlink, notes }]),
+      required_auths: [],
+      required_posting_auths: [username]
     }
   ];
 }
-function buildCollateralizedConvertOp(owner, amount, requestId) {
-  if (!owner || !amount || requestId === void 0) {
-    throw new Error("[SDK][buildCollateralizedConvertOp] Missing required parameters");
+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 [
-    "collateralized_convert",
+    "custom_json",
     {
-      owner,
-      amount,
-      requestid: requestId
+      id: "community",
+      json: JSON.stringify([action, { community, account, notes }]),
+      required_auths: [],
+      required_posting_auths: [username]
     }
   ];
 }
-function buildDelegateRcOp(from, delegatees, maxRc) {
-  if (!from || !delegatees || maxRc === void 0) {
-    throw new Error("[SDK][buildDelegateRcOp] Missing required parameters");
+function buildFlagPostOp(username, community, account, permlink, notes) {
+  if (!username || !community || !account || !permlink) {
+    throw new Error("[SDK][buildFlagPostOp] 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
-        }
-      ]),
+      id: "community",
+      json: JSON.stringify(["flagPost", { community, account, permlink, notes }]),
       required_auths: [],
-      required_posting_auths: [from]
+      required_posting_auths: [username]
     }
   ];
 }
 
-// src/modules/operations/builders/social.ts
-function buildFollowOp(follower, following) {
-  if (!follower || !following) {
-    throw new Error("[SDK][buildFollowOp] Missing required parameters");
+// 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 [
-    "custom_json",
+    "limit_order_create",
     {
-      id: "follow",
-      json: JSON.stringify([
-        "follow",
-        {
-          follower,
-          following,
-          what: ["blog"]
-        }
-      ]),
-      required_auths: [],
-      required_posting_auths: [follower]
+      owner,
+      orderid: orderId,
+      amount_to_sell: amountToSell,
+      min_to_receive: minToReceive,
+      fill_or_kill: fillOrKill,
+      expiration
     }
   ];
 }
-function buildUnfollowOp(follower, following) {
-  if (!follower || !following) {
-    throw new Error("[SDK][buildUnfollowOp] Missing required parameters");
+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 [
-    "custom_json",
+    "limit_order_cancel",
     {
-      id: "follow",
-      json: JSON.stringify([
-        "follow",
-        {
-          follower,
-          following,
-          what: []
-        }
-      ]),
-      required_auths: [],
-      required_posting_auths: [follower]
+      owner,
+      orderid: orderId
     }
   ];
 }
-function buildIgnoreOp(follower, following) {
-  if (!follower || !following) {
-    throw new Error("[SDK][buildIgnoreOp] Missing required parameters");
+function buildClaimRewardBalanceOp(account, rewardHive, rewardHbd, rewardVests) {
+  if (!account || !rewardHive || !rewardHbd || !rewardVests) {
+    throw new Error("[SDK][buildClaimRewardBalanceOp] Missing required parameters");
   }
   return [
-    "custom_json",
+    "claim_reward_balance",
     {
-      id: "follow",
-      json: JSON.stringify([
-        "follow",
-        {
-          follower,
-          following,
-          what: ["ignore"]
-        }
-      ]),
-      required_auths: [],
-      required_posting_auths: [follower]
+      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 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");
+function buildAccountUpdate2Op(account, jsonMetadata, postingJsonMetadata, extensions) {
+  if (!account || postingJsonMetadata === void 0) {
+    throw new Error("[SDK][buildAccountUpdate2Op] Missing required parameters");
   }
-  const lastReadDate = date || (/* @__PURE__ */ new Date()).toISOString().split(".")[0];
-  const notifyOp = [
-    "custom_json",
+  return [
+    "account_update2",
     {
-      id: "notify",
-      json: JSON.stringify(["setLastRead", { date: lastReadDate }]),
-      required_auths: [],
-      required_posting_auths: [username]
+      account,
+      json_metadata: jsonMetadata || "",
+      posting_json_metadata: postingJsonMetadata,
+      extensions: extensions || []
     }
   ];
-  const ecencyNotifyOp = [
-    "custom_json",
+}
+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",
     {
-      id: "ecency_notify",
-      json: JSON.stringify(["setLastRead", { date: lastReadDate }]),
-      required_auths: [],
-      required_posting_auths: [username]
+      creator,
+      new_account_name: newAccountName,
+      owner,
+      active,
+      posting,
+      memo_key: keys.memoPublicKey,
+      json_metadata: "",
+      extensions: [],
+      fee
     }
   ];
-  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");
+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 [
-    "account_witness_vote",
+    "create_claimed_account",
     {
-      account,
-      witness,
-      approve
+      creator,
+      new_account_name: newAccountName,
+      owner,
+      active,
+      posting,
+      memo_key: keys.memoPublicKey,
+      json_metadata: "",
+      extensions: []
     }
   ];
 }
-function buildWitnessProxyOp(account, proxy) {
-  if (!account || proxy === void 0) {
-    throw new Error("[SDK][buildWitnessProxyOp] Missing required parameters");
+function buildClaimAccountOp(creator, fee) {
+  if (!creator || !fee) {
+    throw new Error("[SDK][buildClaimAccountOp] Missing required parameters");
   }
   return [
-    "account_witness_proxy",
+    "claim_account",
     {
-      account,
-      proxy
+      creator,
+      fee,
+      extensions: []
     }
   ];
 }
-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");
+function buildGrantPostingPermissionOp(account, currentPosting, grantedAccount, weightThreshold, memoKey, jsonMetadata) {
+  if (!account || !currentPosting || !grantedAccount || !memoKey) {
+    throw new Error("[SDK][buildGrantPostingPermissionOp] 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"
-    );
+  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 [
-    "create_proposal",
+    "account_update",
     {
-      creator,
-      receiver: payload.receiver,
-      start_date: payload.start,
-      end_date: payload.end,
-      daily_pay: payload.dailyPay,
-      subject: payload.subject,
-      permlink: payload.permlink,
-      extensions: []
+      account,
+      posting: newPosting,
+      memo_key: memoKey,
+      json_metadata: jsonMetadata
     }
   ];
 }
-function buildProposalVoteOp(voter, proposalIds, approve) {
-  if (!voter || !proposalIds || proposalIds.length === 0 || approve === void 0) {
-    throw new Error("[SDK][buildProposalVoteOp] Missing required parameters");
+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 [
-    "update_proposal_votes",
+    "account_update",
     {
-      voter,
-      proposal_ids: proposalIds,
-      approve,
-      extensions: []
+      account,
+      posting: newPosting,
+      memo_key: memoKey,
+      json_metadata: jsonMetadata
     }
   ];
 }
-function buildRemoveProposalOp(proposalOwner, proposalIds) {
-  if (!proposalOwner || !proposalIds || proposalIds.length === 0) {
-    throw new Error("[SDK][buildRemoveProposalOp] Missing required parameters");
+function buildChangeRecoveryAccountOp(accountToRecover, newRecoveryAccount, extensions = []) {
+  if (!accountToRecover || !newRecoveryAccount) {
+    throw new Error("[SDK][buildChangeRecoveryAccountOp] Missing required parameters");
   }
   return [
-    "remove_proposal",
+    "change_recovery_account",
     {
-      proposal_owner: proposalOwner,
-      proposal_ids: proposalIds,
-      extensions: []
+      account_to_recover: accountToRecover,
+      new_recovery_account: newRecoveryAccount,
+      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");
+function buildRequestAccountRecoveryOp(recoveryAccount, accountToRecover, newOwnerAuthority, extensions = []) {
+  if (!recoveryAccount || !accountToRecover || !newOwnerAuthority) {
+    throw new Error("[SDK][buildRequestAccountRecoveryOp] Missing required parameters");
   }
   return [
-    "update_proposal",
+    "request_account_recovery",
     {
-      proposal_id: proposalId,
-      creator,
-      daily_pay: dailyPay,
-      subject,
-      permlink,
-      extensions: []
+      recovery_account: recoveryAccount,
+      account_to_recover: accountToRecover,
+      new_owner_authority: newOwnerAuthority,
+      extensions
     }
   ];
 }
-
-// src/modules/operations/builders/community.ts
-function buildSubscribeOp(username, community) {
-  if (!username || !community) {
-    throw new Error("[SDK][buildSubscribeOp] Missing required parameters");
+function buildRecoverAccountOp(accountToRecover, newOwnerAuthority, recentOwnerAuthority, extensions = []) {
+  if (!accountToRecover || !newOwnerAuthority || !recentOwnerAuthority) {
+    throw new Error("[SDK][buildRecoverAccountOp] Missing required parameters");
   }
   return [
-    "custom_json",
+    "recover_account",
     {
-      id: "community",
-      json: JSON.stringify(["subscribe", { community }]),
-      required_auths: [],
-      required_posting_auths: [username]
+      account_to_recover: accountToRecover,
+      new_owner_authority: newOwnerAuthority,
+      recent_owner_authority: recentOwnerAuthority,
+      extensions
     }
   ];
 }
-function buildUnsubscribeOp(username, community) {
-  if (!username || !community) {
-    throw new Error("[SDK][buildUnsubscribeOp] Missing required parameters");
+
+// 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: "community",
-      json: JSON.stringify(["unsubscribe", { community }]),
-      required_auths: [],
-      required_posting_auths: [username]
+      id: "ecency_boost",
+      json: JSON.stringify({
+        user,
+        author,
+        permlink,
+        amount
+      }),
+      required_auths: [user],
+      required_posting_auths: []
     }
   ];
 }
-function buildSetRoleOp(username, community, account, role) {
-  if (!username || !community || !account || !role) {
-    throw new Error("[SDK][buildSetRoleOp] Missing required parameters");
+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: "community",
-      json: JSON.stringify(["setRole", { community, account, role }]),
-      required_auths: [],
-      required_posting_auths: [username]
+      id: "ecency_boost_plus",
+      json: JSON.stringify({
+        user,
+        account,
+        duration
+      }),
+      required_auths: [user],
+      required_posting_auths: []
     }
   ];
 }
-function buildUpdateCommunityOp(username, community, props) {
-  if (!username || !community || !props) {
-    throw new Error("[SDK][buildUpdateCommunityOp] Missing required parameters");
+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: "community",
-      json: JSON.stringify(["updateProps", { community, props }]),
-      required_auths: [],
-      required_posting_auths: [username]
+      id: "ecency_promote",
+      json: JSON.stringify({
+        user,
+        author,
+        permlink,
+        duration
+      }),
+      required_auths: [user],
+      required_posting_auths: []
     }
   ];
 }
-function buildPinPostOp(username, community, account, permlink, pin) {
-  if (!username || !community || !account || !permlink || pin === void 0) {
-    throw new Error("[SDK][buildPinPostOp] Missing required parameters");
+function buildPointTransferOp(sender, receiver, amount, memo) {
+  if (!sender || !receiver || !amount) {
+    throw new Error("[SDK][buildPointTransferOp] 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]
+      id: "ecency_point_transfer",
+      json: JSON.stringify({
+        sender,
+        receiver,
+        amount,
+        memo: memo || ""
+      }),
+      required_auths: [sender],
+      required_posting_auths: []
     }
   ];
 }
-function buildMutePostOp(username, community, account, permlink, notes, mute) {
-  if (!username || !community || !account || !permlink || mute === void 0) {
-    throw new Error("[SDK][buildMutePostOp] Missing required parameters");
+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");
   }
-  const action = mute ? "mutePost" : "unmutePost";
   return [
     "custom_json",
     {
-      id: "community",
-      json: JSON.stringify([action, { community, account, permlink, notes }]),
-      required_auths: [],
-      required_posting_auths: [username]
+      id: "ecency_registration",
+      json: JSON.stringify({
+        name
+      }),
+      required_auths: [name],
+      required_posting_auths: []
     }
   ];
 }
-function buildMuteUserOp(username, community, account, notes, mute) {
-  if (!username || !community || !account || mute === void 0) {
-    throw new Error("[SDK][buildMuteUserOp] Missing required parameters");
+function buildActiveCustomJsonOp(username, operationId, json) {
+  if (!username || !operationId || !json) {
+    throw new Error("[SDK][buildActiveCustomJsonOp] 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]
+      id: operationId,
+      json: JSON.stringify(json),
+      required_auths: [username],
+      required_posting_auths: []
     }
   ];
 }
-function buildFlagPostOp(username, community, account, permlink, notes) {
-  if (!username || !community || !account || !permlink) {
-    throw new Error("[SDK][buildFlagPostOp] Missing required parameters");
+function buildPostingCustomJsonOp(username, operationId, json) {
+  if (!username || !operationId || !json) {
+    throw new Error("[SDK][buildPostingCustomJsonOp] Missing required parameters");
   }
   return [
     "custom_json",
     {
-      id: "community",
-      json: JSON.stringify(["flagPost", { community, account, permlink, notes }]),
+      id: operationId,
+      json: JSON.stringify(json),
       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
-    }
-  ];
+// 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
+  );
 }
-function formatNumber(value, decimals = 3) {
-  return value.toFixed(decimals);
+
+// 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
+  });
 }
-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 useAccountFavouriteDelete(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-delete",
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            account,
+            code
+          })
+        }
+      );
+      return response.json();
+    },
+    onSuccess: () => {
+      onSuccess();
+      getQueryClient().invalidateQueries({
+        queryKey: ["accounts", "favourites", username]
+      });
+    },
+    onError
+  });
 }
-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 dedupeAndSortKeyAuths(existing, additions) {
+  const merged = /* @__PURE__ */ new Map();
+  existing.forEach(([key, weight]) => {
+    merged.set(key.toString(), weight);
+  });
+  additions.forEach(([key, weight]) => {
+    merged.set(key.toString(), weight);
+  });
+  return Array.from(merged.entries()).sort(([keyA], [keyB]) => keyA.localeCompare(keyB)).map(([key, weight]) => [key, weight]);
 }
-function 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
-    }
-  ];
+function useAccountUpdateKeyAuths(username, options) {
+  const { data: accountData } = reactQuery.useQuery(getAccountFullQueryOptions(username));
+  return reactQuery.useMutation({
+    mutationKey: ["accounts", "keys-update", username],
+    mutationFn: async ({
+      keys,
+      keepCurrent = false,
+      currentKey,
+      keysToRevoke = [],
+      keysToRevokeByAuthority = {}
+    }) => {
+      if (keys.length === 0) {
+        throw new Error(
+          "[SDK][Update password] \u2013 no new keys provided"
+        );
+      }
+      if (!accountData) {
+        throw new Error(
+          "[SDK][Update password] \u2013 cannot update keys for anon user"
+        );
+      }
+      const prepareAuth = (keyName) => {
+        const auth = R4__namespace.clone(accountData[keyName]);
+        const keysToRevokeForAuthority = keysToRevokeByAuthority[keyName] || [];
+        const allKeysToRevoke = [
+          ...keysToRevokeForAuthority,
+          ...keysToRevokeByAuthority[keyName] === void 0 ? keysToRevoke : []
+        ];
+        const existingKeys = keepCurrent ? auth.key_auths.filter(([key]) => !allKeysToRevoke.includes(key.toString())) : [];
+        auth.key_auths = dedupeAndSortKeyAuths(
+          existingKeys,
+          keys.map(
+            (values, i) => [values[keyName].createPublic().toString(), i + 1]
+          )
+        );
+        return auth;
+      };
+      return CONFIG.hiveClient.broadcast.updateAccount(
+        {
+          account: username,
+          json_metadata: accountData.json_metadata,
+          owner: prepareAuth("owner"),
+          active: prepareAuth("active"),
+          posting: prepareAuth("posting"),
+          // Always use new memo key when adding new keys
+          memo_key: keys[0].memo_key.createPublic().toString()
+        },
+        currentKey
+      );
+    },
+    ...options
+  });
 }
-
-// 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 useAccountUpdatePassword(username, options) {
+  const { data: accountData } = reactQuery.useQuery(getAccountFullQueryOptions(username));
+  const { mutateAsync: updateKeys } = useAccountUpdateKeyAuths(username);
+  return reactQuery.useMutation({
+    mutationKey: ["accounts", "password-update", username],
+    mutationFn: async ({
+      newPassword,
+      currentPassword,
+      keepCurrent
+    }) => {
+      if (!accountData) {
+        throw new Error(
+          "[SDK][Update password] \u2013 cannot update password for anon user"
+        );
+      }
+      const currentKey = dhive.PrivateKey.fromLogin(
+        username,
+        currentPassword,
+        "owner"
+      );
+      return updateKeys({
+        currentKey,
+        keepCurrent,
+        keys: [
+          {
+            owner: dhive.PrivateKey.fromLogin(username, newPassword, "owner"),
+            active: dhive.PrivateKey.fromLogin(username, newPassword, "active"),
+            posting: dhive.PrivateKey.fromLogin(username, newPassword, "posting"),
+            memo_key: dhive.PrivateKey.fromLogin(username, newPassword, "memo")
+          }
+        ]
+      });
+    },
+    ...options
+  });
 }
-function 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 useAccountRevokePosting(username, options, auth) {
+  const queryClient = reactQuery.useQueryClient();
+  const { data } = reactQuery.useQuery(getAccountFullQueryOptions(username));
+  return reactQuery.useMutation({
+    mutationKey: ["accounts", "revoke-posting", data?.name],
+    mutationFn: async ({ accountName, type, key }) => {
+      if (!data) {
+        throw new Error(
+          "[SDK][Accounts] \u2013\xA0cannot revoke posting for anonymous user"
+        );
+      }
+      const posting = R4__namespace.pipe(
+        {},
+        R4__namespace.mergeDeep(data.posting)
+      );
+      posting.account_auths = posting.account_auths.filter(
+        ([account]) => account !== accountName
+      );
+      const operationBody = {
+        account: data.name,
+        posting,
+        memo_key: data.memo_key,
+        json_metadata: data.json_metadata
+      };
+      if (type === "key" && key) {
+        return CONFIG.hiveClient.broadcast.updateAccount(operationBody, key);
+      } else if (type === "keychain") {
+        if (!auth?.broadcast) {
+          throw new Error("[SDK][Accounts] \u2013 missing keychain broadcaster");
+        }
+        return auth.broadcast([["account_update", operationBody]], "active");
+      } else {
+        const params = {
+          callback: `https://ecency.com/@${data.name}/permissions`
+        };
+        return hs__default.default.sendOperation(
+          ["account_update", operationBody],
+          params,
+          () => {
+          }
+        );
+      }
+    },
+    onError: options.onError,
+    onSuccess: (resp, payload, ctx) => {
+      options.onSuccess?.(resp, payload, ctx);
+      queryClient.setQueryData(
+        getAccountFullQueryOptions(username).queryKey,
+        (data2) => ({
+          ...data2,
+          posting: {
+            ...data2?.posting,
+            account_auths: data2?.posting?.account_auths?.filter(
+              ([account]) => account !== payload.accountName
+            ) ?? []
+          }
+        })
+      );
     }
-  ];
+  });
 }
-function 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 useAccountUpdateRecovery(username, code, options, auth) {
+  const { data } = reactQuery.useQuery(getAccountFullQueryOptions(username));
+  return reactQuery.useMutation({
+    mutationKey: ["accounts", "recovery", data?.name],
+    mutationFn: async ({ accountName, type, key, email }) => {
+      if (!data) {
+        throw new Error(
+          "[SDK][Accounts] \u2013\xA0cannot change recovery for anonymous user"
+        );
+      }
+      const operationBody = {
+        account_to_recover: data.name,
+        new_recovery_account: accountName,
+        extensions: []
+      };
+      if (type === "ecency") {
+        if (!code) {
+          throw new Error("[SDK][Accounts] \u2013 missing access token");
+        }
+        const fetchApi = getBoundFetch();
+        return fetchApi(CONFIG.privateApiHost + "/private-api/recoveries-add", {
+          method: "POST",
+          body: JSON.stringify({
+            code,
+            email,
+            publicKeys: [
+              ...data.owner.key_auths,
+              ...data.active.key_auths,
+              ...data.posting.key_auths,
+              data.memo_key
+            ]
+          })
+        });
+      } else if (type === "key" && key) {
+        return CONFIG.hiveClient.broadcast.sendOperations(
+          [["change_recovery_account", operationBody]],
+          key
+        );
+      } else if (type === "keychain") {
+        if (!auth?.broadcast) {
+          throw new Error("[SDK][Accounts] \u2013 missing keychain broadcaster");
+        }
+        return auth.broadcast([["change_recovery_account", operationBody]], "owner");
+      } else {
+        const params = {
+          callback: `https://ecency.com/@${data.name}/permissions`
+        };
+        return hs__default.default.sendOperation(
+          ["change_recovery_account", operationBody],
+          params,
+          () => {
+          }
+        );
+      }
+    },
+    onError: options.onError,
+    onSuccess: options.onSuccess
+  });
 }
-function 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 useAccountRevokeKey(username, options) {
+  const { data: accountData } = reactQuery.useQuery(getAccountFullQueryOptions(username));
+  return reactQuery.useMutation({
+    mutationKey: ["accounts", "revoke-key", accountData?.name],
+    mutationFn: async ({ currentKey, revokingKey }) => {
+      if (!accountData) {
+        throw new Error(
+          "[SDK][Update password] \u2013 cannot update keys for anon user"
+        );
+      }
+      const prepareAuth = (keyName) => {
+        const auth = R4__namespace.clone(accountData[keyName]);
+        auth.key_auths = auth.key_auths.filter(
+          ([key]) => key !== revokingKey.toString()
+        );
+        return auth;
+      };
+      return CONFIG.hiveClient.broadcast.updateAccount(
+        {
+          account: accountData.name,
+          json_metadata: accountData.json_metadata,
+          owner: prepareAuth("owner"),
+          active: prepareAuth("active"),
+          posting: prepareAuth("posting"),
+          memo_key: accountData.memo_key
+        },
+        currentKey
+      );
+    },
+    ...options
+  });
 }
-function buildClaimAccountOp(creator, fee) {
-  if (!creator || !fee) {
-    throw new Error("[SDK][buildClaimAccountOp] Missing required parameters");
-  }
-  return [
-    "claim_account",
-    {
-      creator,
-      fee,
-      extensions: []
-    }
-  ];
+
+// src/modules/accounts/utils/account-power.ts
+var HIVE_VOTING_MANA_REGENERATION_SECONDS = 5 * 60 * 60 * 24;
+function vestsToRshares(vests, votingPowerValue, votePerc) {
+  const vestingShares = vests * 1e6;
+  const power = votingPowerValue * votePerc / 1e4 / 50 + 1;
+  return power * vestingShares / 1e4;
 }
-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
+function toDhiveAccountForVotingMana(account) {
+  return {
+    id: 0,
+    name: account.name,
+    owner: account.owner,
+    active: account.active,
+    posting: account.posting,
+    memo_key: account.memo_key,
+    json_metadata: account.json_metadata,
+    posting_json_metadata: account.posting_json_metadata,
+    proxy: account.proxy ?? "",
+    last_owner_update: "",
+    last_account_update: "",
+    created: account.created,
+    mined: false,
+    owner_challenged: false,
+    active_challenged: false,
+    last_owner_proved: "",
+    last_active_proved: "",
+    recovery_account: account.recovery_account ?? "",
+    reset_account: "",
+    last_account_recovery: "",
+    comment_count: 0,
+    lifetime_vote_count: 0,
+    post_count: account.post_count,
+    can_vote: true,
+    voting_power: account.voting_power,
+    last_vote_time: account.last_vote_time,
+    voting_manabar: account.voting_manabar,
+    balance: account.balance,
+    savings_balance: account.savings_balance,
+    hbd_balance: account.hbd_balance,
+    hbd_seconds: "0",
+    hbd_seconds_last_update: "",
+    hbd_last_interest_payment: "",
+    savings_hbd_balance: account.savings_hbd_balance,
+    savings_hbd_seconds: account.savings_hbd_seconds,
+    savings_hbd_seconds_last_update: account.savings_hbd_seconds_last_update,
+    savings_hbd_last_interest_payment: account.savings_hbd_last_interest_payment,
+    savings_withdraw_requests: 0,
+    reward_hbd_balance: account.reward_hbd_balance,
+    reward_hive_balance: account.reward_hive_balance,
+    reward_vesting_balance: account.reward_vesting_balance,
+    reward_vesting_hive: account.reward_vesting_hive,
+    curation_rewards: 0,
+    posting_rewards: 0,
+    vesting_shares: account.vesting_shares,
+    delegated_vesting_shares: account.delegated_vesting_shares,
+    received_vesting_shares: account.received_vesting_shares,
+    vesting_withdraw_rate: account.vesting_withdraw_rate,
+    next_vesting_withdrawal: account.next_vesting_withdrawal,
+    withdrawn: account.withdrawn,
+    to_withdraw: account.to_withdraw,
+    withdraw_routes: 0,
+    proxied_vsf_votes: account.proxied_vsf_votes ?? [],
+    witnesses_voted_for: 0,
+    average_bandwidth: 0,
+    lifetime_bandwidth: 0,
+    last_bandwidth_update: "",
+    average_market_bandwidth: 0,
+    lifetime_market_bandwidth: 0,
+    last_market_bandwidth_update: "",
+    last_post: account.last_post,
+    last_root_post: ""
   };
-  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 votingPower(account) {
+  const calc = CONFIG.hiveClient.rc.calculateVPMana(
+    toDhiveAccountForVotingMana(account)
+  );
+  return calc.percentage / 100;
 }
-function buildChangeRecoveryAccountOp(accountToRecover, newRecoveryAccount, extensions = []) {
-  if (!accountToRecover || !newRecoveryAccount) {
-    throw new Error("[SDK][buildChangeRecoveryAccountOp] Missing required parameters");
+function powerRechargeTime(power) {
+  if (!Number.isFinite(power)) {
+    throw new TypeError("Voting power must be a finite number");
   }
-  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");
+  if (power < 0 || power > 100) {
+    throw new RangeError("Voting power must be between 0 and 100");
   }
-  return [
-    "request_account_recovery",
-    {
-      recovery_account: recoveryAccount,
-      account_to_recover: accountToRecover,
-      new_owner_authority: newOwnerAuthority,
-      extensions
-    }
-  ];
+  const missingPower = 100 - power;
+  return missingPower * 100 * HIVE_VOTING_MANA_REGENERATION_SECONDS / 1e4;
 }
-function buildRecoverAccountOp(accountToRecover, newOwnerAuthority, recentOwnerAuthority, extensions = []) {
-  if (!accountToRecover || !newOwnerAuthority || !recentOwnerAuthority) {
-    throw new Error("[SDK][buildRecoverAccountOp] Missing required parameters");
+function downVotingPower(account) {
+  const totalShares = parseFloat(account.vesting_shares) + parseFloat(account.received_vesting_shares) - parseFloat(account.delegated_vesting_shares);
+  const elapsed = Math.floor(Date.now() / 1e3) - account.downvote_manabar.last_update_time;
+  const maxMana = totalShares * 1e6 / 4;
+  if (maxMana <= 0) {
+    return 0;
   }
-  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");
+  let currentMana = parseFloat(account.downvote_manabar.current_mana.toString()) + elapsed * maxMana / HIVE_VOTING_MANA_REGENERATION_SECONDS;
+  if (currentMana > maxMana) {
+    currentMana = maxMana;
   }
-  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");
+  const currentManaPerc = currentMana * 100 / maxMana;
+  if (isNaN(currentManaPerc)) {
+    return 0;
   }
-  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");
+  if (currentManaPerc > 100) {
+    return 100;
   }
-  return [
-    "custom_json",
-    {
-      id: "ecency_boost_plus",
-      json: JSON.stringify({
-        user,
-        account,
-        duration
-      }),
-      required_auths: [user],
-      required_posting_auths: []
-    }
-  ];
+  return currentManaPerc;
 }
-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 rcPower(account) {
+  const calc = CONFIG.hiveClient.rc.calculateRCMana(account);
+  return calc.percentage / 100;
 }
-function buildPointTransferOp(sender, receiver, amount, memo) {
-  if (!sender || !receiver || !amount) {
-    throw new Error("[SDK][buildPointTransferOp] Missing required parameters");
+function votingValue(account, dynamicProps, votingPowerValue, weight = 1e4) {
+  if (!Number.isFinite(votingPowerValue) || !Number.isFinite(weight)) {
+    return 0;
   }
-  return [
-    "custom_json",
-    {
-      id: "ecency_point_transfer",
-      json: JSON.stringify({
-        sender,
-        receiver,
-        amount,
-        memo: memo || ""
-      }),
-      required_auths: [sender],
-      required_posting_auths: []
+  const { fundRecentClaims, fundRewardBalance, base, quote } = dynamicProps;
+  if (!Number.isFinite(fundRecentClaims) || !Number.isFinite(fundRewardBalance) || !Number.isFinite(base) || !Number.isFinite(quote)) {
+    return 0;
+  }
+  if (fundRecentClaims === 0 || quote === 0) {
+    return 0;
+  }
+  let totalVests = 0;
+  try {
+    const vesting = parseAsset(account.vesting_shares).amount;
+    const received = parseAsset(account.received_vesting_shares).amount;
+    const delegated = parseAsset(account.delegated_vesting_shares).amount;
+    if (![vesting, received, delegated].every(Number.isFinite)) {
+      return 0;
     }
-  ];
-}
-function buildMultiPointTransferOps(sender, destinations, amount, memo) {
-  if (!sender || !destinations || !amount) {
-    throw new Error("[SDK][buildMultiPointTransferOps] Missing required parameters");
+    totalVests = vesting + received - delegated;
+  } catch {
+    return 0;
   }
-  const destArray = destinations.trim().split(/[\s,]+/).filter(Boolean);
-  if (destArray.length === 0) {
-    throw new Error("[SDK][buildMultiPointTransferOps] Missing valid destinations");
+  if (!Number.isFinite(totalVests)) {
+    return 0;
   }
-  return destArray.map(
-    (dest) => buildPointTransferOp(sender, dest.trim(), amount, memo)
-  );
+  const rShares = vestsToRshares(totalVests, votingPowerValue, weight);
+  if (!Number.isFinite(rShares)) {
+    return 0;
+  }
+  return rShares / fundRecentClaims * fundRewardBalance * (base / quote);
 }
-function buildCommunityRegistrationOp(name) {
-  if (!name) {
-    throw new Error("[SDK][buildCommunityRegistrationOp] Missing required parameters");
+
+// 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");
   }
-  return [
-    "custom_json",
-    {
-      id: "ecency_registration",
-      json: JSON.stringify({
-        name
-      }),
-      required_auths: [name],
-      required_posting_auths: []
-    }
-  ];
+  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 buildActiveCustomJsonOp(username, operationId, json) {
-  if (!username || !operationId || !json) {
-    throw new Error("[SDK][buildActiveCustomJsonOp] Missing required parameters");
+function getProposalAuthority(proposalOp) {
+  const opType = proposalOp[0];
+  if (opType !== "create_proposal" && opType !== "update_proposal") {
+    throw new Error("Operation is not a proposal operation");
   }
-  return [
-    "custom_json",
-    {
-      id: operationId,
-      json: JSON.stringify(json),
-      required_auths: [username],
-      required_posting_auths: []
-    }
-  ];
+  return "active";
 }
-function buildPostingCustomJsonOp(username, operationId, json) {
-  if (!username || !operationId || !json) {
-    throw new Error("[SDK][buildPostingCustomJsonOp] Missing required parameters");
+function getOperationAuthority(op) {
+  const opType = op[0];
+  if (opType === "custom_json") {
+    return getCustomJsonAuthority(op);
   }
-  return [
-    "custom_json",
-    {
-      id: operationId,
-      json: JSON.stringify(json),
-      required_auths: [],
-      required_posting_auths: [username]
+  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({
@@ -5458,7 +5734,9 @@ function useComment(username, auth) {
       if (auth?.adapter?.invalidateQueries) {
         const queriesToInvalidate = [
           ["posts", "feed", username],
-          ["posts", "blog", username]
+          ["posts", "blog", username],
+          ["account", username, "rc"]
+          // RC decreases after posting/commenting
         ];
         if (!isPost) {
           queriesToInvalidate.push([
@@ -7671,6 +7949,7 @@ 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;
@@ -7792,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;
@@ -7841,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;
@@ -7859,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;
@@ -7872,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;
@@ -7960,6 +8243,7 @@ exports.useDeleteDraft = useDeleteDraft;
 exports.useDeleteImage = useDeleteImage;
 exports.useDeleteSchedule = useDeleteSchedule;
 exports.useEditFragment = useEditFragment;
+exports.useFollow = useFollow;
 exports.useGameClaim = useGameClaim;
 exports.useMarkNotificationsRead = useMarkNotificationsRead;
 exports.useMoveSchedule = useMoveSchedule;
@@ -7971,6 +8255,7 @@ exports.useSignOperationByHivesigner = useSignOperationByHivesigner;
 exports.useSignOperationByKey = useSignOperationByKey;
 exports.useSignOperationByKeychain = useSignOperationByKeychain;
 exports.useTransfer = useTransfer;
+exports.useUnfollow = useUnfollow;
 exports.useUpdateDraft = useUpdateDraft;
 exports.useUploadImage = useUploadImage;
 exports.useVote = useVote;