hive-stream 3.0.3 → 3.0.5

package/dist/utils.js

@@ -11,6 +11,7 @@ const config_1 = require("./config");
 const seedrandom_1 = __importDefault(require("seedrandom"));
 const MAX_PAYLOAD_SIZE = 2000;
 const MAX_ACCOUNTS_CHECK = 999;
+const NULL_ACCOUNT = 'null';
 /**
  * Utility functions for Hive blockchain operations and general helpers
  */
@@ -57,6 +58,168 @@ exports.Utils = {
         }
         return JSON.stringify(meta);
     },
+    parseAssetAmount(rawAmount) {
+        if (typeof rawAmount !== 'string' || rawAmount.trim().length === 0) {
+            throw new Error('Asset amount must be a non-empty string');
+        }
+        const parts = rawAmount.trim().split(/\s+/);
+        if (parts.length !== 2) {
+            throw new Error(`Invalid asset amount '${rawAmount}'`);
+        }
+        const value = new bignumber_js_1.default(parts[0]);
+        if (value.isNaN() || !value.isFinite()) {
+            throw new Error(`Invalid asset amount '${rawAmount}'`);
+        }
+        return {
+            rawAmount: rawAmount.trim(),
+            amount: parts[0],
+            asset: parts[1],
+            value
+        };
+    },
+    calculateBasisPointsAmount(amount, basisPoints, precision = 3, roundingMode = bignumber_js_1.default.ROUND_DOWN) {
+        if (!Number.isInteger(basisPoints) || basisPoints < 0 || basisPoints > 10000) {
+            throw new Error('basisPoints must be an integer between 0 and 10000');
+        }
+        if (!Number.isInteger(precision) || precision < 0) {
+            throw new Error('precision must be a non-negative integer');
+        }
+        const value = bignumber_js_1.default.isBigNumber(amount) ? amount : new bignumber_js_1.default(amount);
+        if (value.isNaN() || !value.isFinite()) {
+            throw new Error('Invalid amount');
+        }
+        return value
+            .multipliedBy(basisPoints)
+            .dividedBy(10000)
+            .decimalPlaces(precision, roundingMode)
+            .toFixed(precision);
+    },
+    formatAmount(amount, precision = 3, roundingMode = bignumber_js_1.default.ROUND_DOWN) {
+        if (!Number.isInteger(precision) || precision < 0) {
+            throw new Error('precision must be a non-negative integer');
+        }
+        const value = bignumber_js_1.default.isBigNumber(amount) ? amount : new bignumber_js_1.default(amount);
+        if (value.isNaN() || !value.isFinite()) {
+            throw new Error('Invalid amount');
+        }
+        return value.decimalPlaces(precision, roundingMode).toFixed(precision);
+    },
+    formatAssetAmount(amount, symbol, precision = 3, roundingMode = bignumber_js_1.default.ROUND_DOWN) {
+        if (typeof symbol !== 'string' || symbol.trim().length === 0) {
+            throw new Error('Asset symbol is required');
+        }
+        return `${this.formatAmount(amount, precision, roundingMode)} ${symbol.trim()}`;
+    },
+    calculatePercentageAmount(amount, percentage, precision = 3, roundingMode = bignumber_js_1.default.ROUND_DOWN) {
+        if (!Number.isInteger(precision) || precision < 0) {
+            throw new Error('precision must be a non-negative integer');
+        }
+        const value = bignumber_js_1.default.isBigNumber(amount) ? amount : new bignumber_js_1.default(amount);
+        const percentageValue = bignumber_js_1.default.isBigNumber(percentage) ? percentage : new bignumber_js_1.default(percentage);
+        if (value.isNaN() || !value.isFinite()) {
+            throw new Error('Invalid amount');
+        }
+        if (percentageValue.isNaN() || !percentageValue.isFinite()) {
+            throw new Error('Invalid percentage');
+        }
+        if (percentageValue.lt(0) || percentageValue.gt(100)) {
+            throw new Error('percentage must be between 0 and 100');
+        }
+        return value
+            .multipliedBy(percentageValue)
+            .dividedBy(100)
+            .decimalPlaces(precision, roundingMode)
+            .toFixed(precision);
+    },
+    splitAmountByBasisPoints(amount, basisPoints, precision = 3, roundingMode = bignumber_js_1.default.ROUND_DOWN) {
+        if (!Array.isArray(basisPoints) || basisPoints.length === 0) {
+            throw new Error('basisPoints array cannot be empty');
+        }
+        if (!Number.isInteger(precision) || precision < 0) {
+            throw new Error('precision must be a non-negative integer');
+        }
+        const totalBps = basisPoints.reduce((sum, value) => sum + value, 0);
+        if (totalBps !== 10000) {
+            throw new Error('basisPoints allocations must total 10000');
+        }
+        const value = bignumber_js_1.default.isBigNumber(amount) ? amount : new bignumber_js_1.default(amount);
+        if (value.isNaN() || !value.isFinite()) {
+            throw new Error('Invalid amount');
+        }
+        let allocated = new bignumber_js_1.default(0);
+        return basisPoints.map((bps, index) => {
+            if (!Number.isInteger(bps) || bps < 0 || bps > 10000) {
+                throw new Error('basisPoints must be integers between 0 and 10000');
+            }
+            const share = index === basisPoints.length - 1
+                ? value.minus(allocated)
+                : value.multipliedBy(bps).dividedBy(10000).decimalPlaces(precision, roundingMode);
+            allocated = allocated.plus(share);
+            return share.toFixed(precision);
+        });
+    },
+    splitAmountByPercentage(amount, percentages, precision = 3, roundingMode = bignumber_js_1.default.ROUND_DOWN) {
+        if (!Array.isArray(percentages) || percentages.length === 0) {
+            throw new Error('percentages array cannot be empty');
+        }
+        const normalized = percentages.map((percentage) => {
+            const value = bignumber_js_1.default.isBigNumber(percentage) ? percentage : new bignumber_js_1.default(percentage);
+            if (value.isNaN() || !value.isFinite()) {
+                throw new Error('Invalid percentage');
+            }
+            if (value.lt(0) || value.gt(100)) {
+                throw new Error('percentage must be between 0 and 100');
+            }
+            return value;
+        });
+        const total = normalized.reduce((sum, value) => sum.plus(value), new bignumber_js_1.default(0));
+        if (!total.eq(100)) {
+            throw new Error('percentages must total 100');
+        }
+        const value = bignumber_js_1.default.isBigNumber(amount) ? amount : new bignumber_js_1.default(amount);
+        if (value.isNaN() || !value.isFinite()) {
+            throw new Error('Invalid amount');
+        }
+        let allocated = new bignumber_js_1.default(0);
+        return normalized.map((percentage, index) => {
+            const share = index === normalized.length - 1
+                ? value.minus(allocated)
+                : value.multipliedBy(percentage).dividedBy(100).decimalPlaces(precision, roundingMode);
+            allocated = allocated.plus(share);
+            return share.toFixed(precision);
+        });
+    },
+    splitAmountByWeights(amount, weights, precision = 3, roundingMode = bignumber_js_1.default.ROUND_DOWN) {
+        if (!Array.isArray(weights) || weights.length === 0) {
+            throw new Error('weights array cannot be empty');
+        }
+        if (!Number.isInteger(precision) || precision < 0) {
+            throw new Error('precision must be a non-negative integer');
+        }
+        const normalized = weights.map((weight) => {
+            const value = bignumber_js_1.default.isBigNumber(weight) ? weight : new bignumber_js_1.default(weight);
+            if (value.isNaN() || !value.isFinite()) {
+                throw new Error('Invalid weight');
+            }
+            if (value.lte(0)) {
+                throw new Error('weights must be greater than zero');
+            }
+            return value;
+        });
+        const totalWeight = normalized.reduce((sum, value) => sum.plus(value), new bignumber_js_1.default(0));
+        const value = bignumber_js_1.default.isBigNumber(amount) ? amount : new bignumber_js_1.default(amount);
+        if (value.isNaN() || !value.isFinite()) {
+            throw new Error('Invalid amount');
+        }
+        let allocated = new bignumber_js_1.default(0);
+        return normalized.map((weight, index) => {
+            const share = index === normalized.length - 1
+                ? value.minus(allocated)
+                : value.multipliedBy(weight).dividedBy(totalWeight).decimalPlaces(precision, roundingMode);
+            allocated = allocated.plus(share);
+            return share.toFixed(precision);
+        });
+    },
     /**
      * Shuffles an array in place using the Fisher-Yates algorithm
      * @param array - The array to shuffle (modified in place)
@@ -260,14 +423,29 @@ exports.Utils = {
         if (!client || !config.ACTIVE_KEY || !from || !to || !amount || !symbol) {
             throw new Error('Missing required parameters for Hive token transfer');
         }
-        const amountBN = new bignumber_js_1.default(amount);
-        if (amountBN.isNaN() || !amountBN.isFinite()) {
+        let formattedAmount;
+        try {
+            formattedAmount = this.formatAssetAmount(amount, symbol);
+        }
+        catch (error) {
             throw new Error('Invalid transfer amount');
         }
         const key = dhive_1.PrivateKey.fromString(config.ACTIVE_KEY);
-        const formattedAmount = `${amountBN.toFixed(3)} ${symbol}`;
         return client.broadcast.transfer({ from, to, amount: formattedAmount, memo }, key);
     },
+    /**
+     * Burns HIVE or HBD by transferring the amount to the null account.
+     * @param client - The Hive client instance
+     * @param config - Configuration containing the active key
+     * @param from - Sender account name
+     * @param amount - Amount to burn
+     * @param symbol - Asset symbol (HIVE or HBD)
+     * @param memo - Optional memo for the burn transfer
+     * @returns Promise resolving to the broadcast result
+     */
+    burnHiveTokens(client, config, from, amount, symbol, memo = '') {
+        return this.transferHiveTokens(client, config, from, NULL_ACCOUNT, amount, symbol, memo);
+    },
     /**
      * Broadcasts one or more Hive operations signed by one or multiple private keys.
      */
@@ -462,13 +640,9 @@ exports.Utils = {
         }
         const key = dhive_1.PrivateKey.fromString(config.ACTIVE_KEY);
         let completed = 0;
-        const amountBN = new bignumber_js_1.default(amount);
-        if (amountBN.isNaN() || !amountBN.isFinite()) {
-            throw new Error('Invalid transfer amount');
-        }
         for (const user of accounts) {
             const to = user.replace('@', '');
-            const formattedAmount = `${amountBN.toFixed(3)} ${symbol}`;
+            const formattedAmount = this.formatAssetAmount(amount, symbol);
             try {
                 await client.broadcast.transfer({ from, to, amount: formattedAmount, memo }, key);
                 completed++;
@@ -595,6 +769,19 @@ exports.Utils = {
             json: JSON.stringify(json)
         }, key);
     },
+    /**
+     * Burns Hive Engine tokens by transferring them to the null account.
+     * @param client - The Hive client instance
+     * @param config - Configuration containing the active key and Hive Engine ID
+     * @param from - Sender account name
+     * @param symbol - Token symbol
+     * @param quantity - Token quantity to burn
+     * @param memo - Optional memo for the burn transfer
+     * @returns Promise resolving to the broadcast result
+     */
+    burnHiveEngineTokens(client, config, from, symbol, quantity, memo = '') {
+        return this.transferHiveEngineTokens(client, config, from, NULL_ACCOUNT, quantity, symbol, memo);
+    },
     /**
      * Transfers Hive Engine tokens to multiple accounts in batches
      * @param client - The Hive client instance
@@ -965,6 +1152,1429 @@ exports.Utils = {
         const encodedAmount = encodeURIComponent(amount);
         const encodedRedirectUri = encodeURIComponent(redirectUri);
         return `https://hivesigner.com/sign/transfer?to=${encodedTo}&memo=${encodedMemo}&amount=${encodedAmount}&redirect_uri=${encodedRedirectUri}`;
+    },
+    // ─── Social Operations ───────────────────────────────────────────────
+    /**
+     * Follows a Hive user by broadcasting a custom_json 'follow' operation
+     * @param client - The Hive client instance
+     * @param config - Configuration containing the posting key
+     * @param follower - The account doing the following
+     * @param following - The account to follow
+     * @returns Promise resolving to the broadcast result
+     */
+    follow(client, config, follower, following) {
+        if (!client || !config.POSTING_KEY || !follower || !following) {
+            throw new Error('Missing required parameters for follow operation');
+        }
+        const json = JSON.stringify(['follow', {
+                follower,
+                following,
+                what: ['blog']
+            }]);
+        const key = dhive_1.PrivateKey.fromString(config.POSTING_KEY);
+        return client.broadcast.json({
+            required_auths: [],
+            required_posting_auths: [follower],
+            id: 'follow',
+            json
+        }, key);
+    },
+    /**
+     * Unfollows a Hive user by broadcasting a custom_json 'follow' operation with empty what
+     * @param client - The Hive client instance
+     * @param config - Configuration containing the posting key
+     * @param follower - The account doing the unfollowing
+     * @param following - The account to unfollow
+     * @returns Promise resolving to the broadcast result
+     */
+    unfollow(client, config, follower, following) {
+        if (!client || !config.POSTING_KEY || !follower || !following) {
+            throw new Error('Missing required parameters for unfollow operation');
+        }
+        const json = JSON.stringify(['follow', {
+                follower,
+                following,
+                what: []
+            }]);
+        const key = dhive_1.PrivateKey.fromString(config.POSTING_KEY);
+        return client.broadcast.json({
+            required_auths: [],
+            required_posting_auths: [follower],
+            id: 'follow',
+            json
+        }, key);
+    },
+    /**
+     * Mutes a Hive user by broadcasting a custom_json 'follow' operation with 'ignore'
+     * @param client - The Hive client instance
+     * @param config - Configuration containing the posting key
+     * @param follower - The account doing the muting
+     * @param following - The account to mute
+     * @returns Promise resolving to the broadcast result
+     */
+    mute(client, config, follower, following) {
+        if (!client || !config.POSTING_KEY || !follower || !following) {
+            throw new Error('Missing required parameters for mute operation');
+        }
+        const json = JSON.stringify(['follow', {
+                follower,
+                following,
+                what: ['ignore']
+            }]);
+        const key = dhive_1.PrivateKey.fromString(config.POSTING_KEY);
+        return client.broadcast.json({
+            required_auths: [],
+            required_posting_auths: [follower],
+            id: 'follow',
+            json
+        }, key);
+    },
+    /**
+     * Reblogs (resteems) a post on Hive
+     * @param client - The Hive client instance
+     * @param config - Configuration containing the posting key
+     * @param account - The account performing the reblog
+     * @param author - The original post author
+     * @param permlink - The permlink of the post to reblog
+     * @returns Promise resolving to the broadcast result
+     */
+    reblog(client, config, account, author, permlink) {
+        if (!client || !config.POSTING_KEY || !account || !author || !permlink) {
+            throw new Error('Missing required parameters for reblog operation');
+        }
+        const json = JSON.stringify(['reblog', {
+                account,
+                author,
+                permlink
+            }]);
+        const key = dhive_1.PrivateKey.fromString(config.POSTING_KEY);
+        return client.broadcast.json({
+            required_auths: [],
+            required_posting_auths: [account],
+            id: 'follow',
+            json
+        }, key);
+    },
+    // ─── Staking Operations ─────────────────────────────────────────────
+    /**
+     * Powers up HIVE to Hive Power (VESTS) for an account
+     * @param client - The Hive client instance
+     * @param config - Configuration containing the active key
+     * @param from - The account providing the HIVE
+     * @param to - The account receiving the Hive Power (can be same as from)
+     * @param amount - The amount of HIVE to power up
+     * @returns Promise resolving to the broadcast result
+     */
+    powerUp(client, config, from, to, amount) {
+        if (!client || !config.ACTIVE_KEY || !from || !to || !amount) {
+            throw new Error('Missing required parameters for power up operation');
+        }
+        const formattedAmount = this.formatAssetAmount(amount, 'HIVE');
+        const key = dhive_1.PrivateKey.fromString(config.ACTIVE_KEY);
+        const operation = ['transfer_to_vesting', {
+                from,
+                to,
+                amount: formattedAmount
+            }];
+        return this.broadcastOperations(client, [operation], key);
+    },
+    /**
+     * Initiates a power down (withdrawal of vesting shares) for an account
+     * @param client - The Hive client instance
+     * @param config - Configuration containing the active key
+     * @param account - The account to power down
+     * @param vestingShares - The amount of VESTS to power down (e.g. '1000.000000 VESTS')
+     * @returns Promise resolving to the broadcast result
+     */
+    powerDown(client, config, account, vestingShares) {
+        if (!client || !config.ACTIVE_KEY || !account || !vestingShares) {
+            throw new Error('Missing required parameters for power down operation');
+        }
+        const key = dhive_1.PrivateKey.fromString(config.ACTIVE_KEY);
+        const operation = ['withdraw_vesting', {
+                account,
+                vesting_shares: vestingShares.includes('VESTS') ? vestingShares : `${vestingShares} VESTS`
+            }];
+        return this.broadcastOperations(client, [operation], key);
+    },
+    /**
+     * Cancels an active power down by setting vesting shares to 0
+     * @param client - The Hive client instance
+     * @param config - Configuration containing the active key
+     * @param account - The account to cancel power down for
+     * @returns Promise resolving to the broadcast result
+     */
+    cancelPowerDown(client, config, account) {
+        if (!client || !config.ACTIVE_KEY || !account) {
+            throw new Error('Missing required parameters for cancel power down operation');
+        }
+        return this.powerDown(client, config, account, '0.000000 VESTS');
+    },
+    /**
+     * Delegates vesting shares (Hive Power) to another account
+     * @param client - The Hive client instance
+     * @param config - Configuration containing the active key
+     * @param delegator - The account delegating HP
+     * @param delegatee - The account receiving the delegation
+     * @param vestingShares - The amount of VESTS to delegate (e.g. '1000.000000 VESTS')
+     * @returns Promise resolving to the broadcast result
+     */
+    delegateVestingShares(client, config, delegator, delegatee, vestingShares) {
+        if (!client || !config.ACTIVE_KEY || !delegator || !delegatee || !vestingShares) {
+            throw new Error('Missing required parameters for delegate vesting shares operation');
+        }
+        const key = dhive_1.PrivateKey.fromString(config.ACTIVE_KEY);
+        const operation = ['delegate_vesting_shares', {
+                delegator,
+                delegatee,
+                vesting_shares: vestingShares.includes('VESTS') ? vestingShares : `${vestingShares} VESTS`
+            }];
+        return this.broadcastOperations(client, [operation], key);
+    },
+    /**
+     * Removes a vesting shares delegation by delegating 0 VESTS
+     * @param client - The Hive client instance
+     * @param config - Configuration containing the active key
+     * @param delegator - The account removing the delegation
+     * @param delegatee - The account to remove delegation from
+     * @returns Promise resolving to the broadcast result
+     */
+    undelegateVestingShares(client, config, delegator, delegatee) {
+        if (!client || !config.ACTIVE_KEY || !delegator || !delegatee) {
+            throw new Error('Missing required parameters for undelegate vesting shares operation');
+        }
+        return this.delegateVestingShares(client, config, delegator, delegatee, '0.000000 VESTS');
+    },
+    // ─── Account Operations ─────────────────────────────────────────────
+    /**
+     * Claims pending rewards for an account
+     * @param client - The Hive client instance
+     * @param config - Configuration containing the posting key
+     * @param account - The account to claim rewards for
+     * @param rewardHive - HIVE rewards to claim (e.g. '0.000 HIVE')
+     * @param rewardHbd - HBD rewards to claim (e.g. '0.000 HBD')
+     * @param rewardVests - VESTS rewards to claim (e.g. '0.000000 VESTS')
+     * @returns Promise resolving to the broadcast result
+     */
+    claimRewards(client, config, account, rewardHive, rewardHbd, rewardVests) {
+        if (!client || !config.POSTING_KEY || !account) {
+            throw new Error('Missing required parameters for claim rewards operation');
+        }
+        const key = dhive_1.PrivateKey.fromString(config.POSTING_KEY);
+        const operation = ['claim_reward_balance', {
+                account,
+                reward_hive: rewardHive || '0.000 HIVE',
+                reward_hbd: rewardHbd || '0.000 HBD',
+                reward_vests: rewardVests || '0.000000 VESTS'
+            }];
+        return this.broadcastOperations(client, [operation], key);
+    },
+    /**
+     * Votes for or unvotes a witness
+     * @param client - The Hive client instance
+     * @param config - Configuration containing the active key
+     * @param account - The account casting the witness vote
+     * @param witness - The witness account to vote for
+     * @param approve - true to vote, false to remove vote
+     * @returns Promise resolving to the broadcast result
+     */
+    witnessVote(client, config, account, witness, approve = true) {
+        if (!client || !config.ACTIVE_KEY || !account || !witness) {
+            throw new Error('Missing required parameters for witness vote operation');
+        }
+        const key = dhive_1.PrivateKey.fromString(config.ACTIVE_KEY);
+        const operation = ['account_witness_vote', {
+                account,
+                witness,
+                approve
+            }];
+        return this.broadcastOperations(client, [operation], key);
+    },
+    /**
+     * Sets a governance proxy for an account (delegates witness voting to another account)
+     * @param client - The Hive client instance
+     * @param config - Configuration containing the active key
+     * @param account - The account setting the proxy
+     * @param proxy - The account to proxy votes to
+     * @returns Promise resolving to the broadcast result
+     */
+    setProxy(client, config, account, proxy) {
+        if (!client || !config.ACTIVE_KEY || !account || proxy === undefined || proxy === null) {
+            throw new Error('Missing required parameters for set proxy operation');
+        }
+        const key = dhive_1.PrivateKey.fromString(config.ACTIVE_KEY);
+        const operation = ['account_witness_proxy', {
+                account,
+                proxy
+            }];
+        return this.broadcastOperations(client, [operation], key);
+    },
+    /**
+     * Clears the governance proxy for an account
+     * @param client - The Hive client instance
+     * @param config - Configuration containing the active key
+     * @param account - The account clearing the proxy
+     * @returns Promise resolving to the broadcast result
+     */
+    clearProxy(client, config, account) {
+        if (!client || !config.ACTIVE_KEY || !account) {
+            throw new Error('Missing required parameters for clear proxy operation');
+        }
+        return this.setProxy(client, config, account, '');
+    },
+    /**
+     * Updates an account's profile metadata using account_update2
+     * @param client - The Hive client instance
+     * @param config - Configuration containing the posting key
+     * @param account - The account to update
+     * @param profile - Profile data (name, about, location, website, profile_image, cover_image)
+     * @returns Promise resolving to the broadcast result
+     */
+    async updateProfile(client, config, account, profile) {
+        if (!client || !config.POSTING_KEY || !account) {
+            throw new Error('Missing required parameters for update profile operation');
+        }
+        const accounts = await client.database.getAccounts([account]);
+        const existingAccount = Array.isArray(accounts) ? accounts[0] : null;
+        if (!existingAccount) {
+            throw new Error(`Unable to load account '${account}' for profile update`);
+        }
+        let existingMeta = {};
+        try {
+            existingMeta = JSON.parse(existingAccount.posting_json_metadata || '{}');
+        }
+        catch {
+            existingMeta = {};
+        }
+        const updatedMeta = {
+            ...existingMeta,
+            profile: {
+                ...(existingMeta.profile || {}),
+                ...profile
+            }
+        };
+        const key = dhive_1.PrivateKey.fromString(config.POSTING_KEY);
+        const operation = ['account_update2', {
+                account,
+                json_metadata: '',
+                posting_json_metadata: JSON.stringify(updatedMeta),
+                extensions: []
+            }];
+        return this.broadcastOperations(client, [operation], key);
+    },
+    /**
+     * Fetches account data for a single account
+     * @param client - The Hive client instance
+     * @param username - The account name to look up
+     * @returns Promise resolving to the account data, or null if not found
+     */
+    async getAccount(client, username) {
+        if (!client || !username) {
+            throw new Error('Client and username are required');
+        }
+        const accounts = await client.database.getAccounts([username]);
+        return Array.isArray(accounts) && accounts.length > 0 ? accounts[0] : null;
+    },
+    /**
+     * Fetches account data for multiple accounts
+     * @param client - The Hive client instance
+     * @param usernames - Array of account names to look up
+     * @returns Promise resolving to array of account data
+     */
+    async getAccounts(client, usernames) {
+        if (!client || !Array.isArray(usernames) || usernames.length === 0) {
+            throw new Error('Client and at least one username are required');
+        }
+        if (usernames.length > MAX_ACCOUNTS_CHECK) {
+            throw new Error(`Cannot look up more than ${MAX_ACCOUNTS_CHECK} accounts at once`);
+        }
+        const accounts = await client.database.getAccounts(usernames);
+        return Array.isArray(accounts) ? accounts : [];
+    },
+    // ─── Blockchain Helpers ─────────────────────────────────────────────
+    /**
+     * Converts raw Hive reputation value to a human-readable score (roughly 25-75 range)
+     * @param rawReputation - The raw reputation value from the blockchain (can be string or number)
+     * @returns The human-readable reputation score
+     */
+    calculateReputation(rawReputation) {
+        const rep = new bignumber_js_1.default(rawReputation);
+        if (rep.isZero()) {
+            return 25;
+        }
+        const negative = rep.isNegative();
+        const absRep = rep.abs();
+        let score = absRep.toNumber();
+        score = Math.log10(score);
+        score = (score - 9) * 9 + 25;
+        if (negative) {
+            score = 50 - (score - 50);
+        }
+        return Math.floor(score * 100) / 100;
+    },
+    /**
+     * Converts VESTS to Hive Power (HP)
+     * @param vests - The amount of VESTS (as string or number)
+     * @param totalVestingFundHive - Total vesting fund in HIVE from dynamic global properties
+     * @param totalVestingShares - Total vesting shares from dynamic global properties
+     * @returns The equivalent Hive Power amount as a string with 3 decimal places
+     */
+    vestToHP(vests, totalVestingFundHive, totalVestingShares) {
+        const vestsValue = new bignumber_js_1.default(String(vests).replace(' VESTS', ''));
+        const fundValue = new bignumber_js_1.default(String(totalVestingFundHive).replace(' HIVE', ''));
+        const sharesValue = new bignumber_js_1.default(String(totalVestingShares).replace(' VESTS', ''));
+        if (vestsValue.isNaN() || fundValue.isNaN() || sharesValue.isNaN()) {
+            throw new Error('Invalid numeric input for VESTS to HP conversion');
+        }
+        if (sharesValue.isZero()) {
+            throw new Error('Total vesting shares cannot be zero');
+        }
+        return vestsValue.multipliedBy(fundValue).dividedBy(sharesValue).toFixed(3);
+    },
+    /**
+     * Converts Hive Power (HP) to VESTS
+     * @param hp - The amount of HP (as string or number)
+     * @param totalVestingFundHive - Total vesting fund in HIVE from dynamic global properties
+     * @param totalVestingShares - Total vesting shares from dynamic global properties
+     * @returns The equivalent VESTS amount as a string with 6 decimal places
+     */
+    hpToVest(hp, totalVestingFundHive, totalVestingShares) {
+        const hpValue = new bignumber_js_1.default(String(hp).replace(' HIVE', ''));
+        const fundValue = new bignumber_js_1.default(String(totalVestingFundHive).replace(' HIVE', ''));
+        const sharesValue = new bignumber_js_1.default(String(totalVestingShares).replace(' VESTS', ''));
+        if (hpValue.isNaN() || fundValue.isNaN() || sharesValue.isNaN()) {
+            throw new Error('Invalid numeric input for HP to VESTS conversion');
+        }
+        if (fundValue.isZero()) {
+            throw new Error('Total vesting fund cannot be zero');
+        }
+        return hpValue.multipliedBy(sharesValue).dividedBy(fundValue).toFixed(6);
+    },
+    /**
+     * Parses Hive account profile metadata from json_metadata or posting_json_metadata
+     * @param jsonMetadata - The raw JSON metadata string from the account
+     * @returns Parsed profile object, or empty object if parsing fails
+     */
+    parseProfileMetadata(jsonMetadata) {
+        if (!jsonMetadata || typeof jsonMetadata !== 'string') {
+            return {};
+        }
+        try {
+            const parsed = JSON.parse(jsonMetadata);
+            if (parsed && typeof parsed === 'object' && parsed.profile && typeof parsed.profile === 'object') {
+                return parsed.profile;
+            }
+            return {};
+        }
+        catch {
+            return {};
+        }
+    },
+    /**
+     * Converts a Hive Power (HP) amount to a formatted VESTS string suitable for delegation/power down
+     * @param hp - The amount of HP
+     * @param totalVestingFundHive - Total vesting fund in HIVE
+     * @param totalVestingShares - Total vesting shares
+     * @returns Formatted VESTS string (e.g. '1234.567890 VESTS')
+     */
+    hpToVestString(hp, totalVestingFundHive, totalVestingShares) {
+        const vests = this.hpToVest(hp, totalVestingFundHive, totalVestingShares);
+        return `${vests} VESTS`;
+    },
+    // ─── Savings Operations ─────────────────────────────────────────────
+    transferToSavings(client, config, from, to, amount, symbol, memo = '') {
+        if (!client || !config.ACTIVE_KEY || !from || !to || !amount || !symbol) {
+            throw new Error('Missing required parameters for transfer to savings');
+        }
+        const formattedAmount = this.formatAssetAmount(amount, symbol);
+        const key = dhive_1.PrivateKey.fromString(config.ACTIVE_KEY);
+        const operation = ['transfer_to_savings', {
+                from,
+                to,
+                amount: formattedAmount,
+                memo
+            }];
+        return this.broadcastOperations(client, [operation], key);
+    },
+    transferFromSavings(client, config, from, to, amount, symbol, requestId, memo = '') {
+        if (!client || !config.ACTIVE_KEY || !from || !to || !amount || !symbol) {
+            throw new Error('Missing required parameters for transfer from savings');
+        }
+        const formattedAmount = this.formatAssetAmount(amount, symbol);
+        const key = dhive_1.PrivateKey.fromString(config.ACTIVE_KEY);
+        const operation = ['transfer_from_savings', {
+                from,
+                to,
+                amount: formattedAmount,
+                memo,
+                request_id: requestId || 0
+            }];
+        return this.broadcastOperations(client, [operation], key);
+    },
+    cancelTransferFromSavings(client, config, from, requestId) {
+        if (!client || !config.ACTIVE_KEY || !from || typeof requestId !== 'number') {
+            throw new Error('Missing required parameters for cancel transfer from savings');
+        }
+        const key = dhive_1.PrivateKey.fromString(config.ACTIVE_KEY);
+        const operation = ['cancel_transfer_from_savings', {
+                from,
+                request_id: requestId
+            }];
+        return this.broadcastOperations(client, [operation], key);
+    },
+    // ─── Convert Operations ─────────────────────────────────────────────
+    convert(client, config, owner, amount, requestId = 0) {
+        if (!client || !config.ACTIVE_KEY || !owner || !amount) {
+            throw new Error('Missing required parameters for convert operation');
+        }
+        const formattedAmount = amount.includes('HBD') ? amount : this.formatAssetAmount(amount, 'HBD');
+        const key = dhive_1.PrivateKey.fromString(config.ACTIVE_KEY);
+        const operation = ['convert', {
+                owner,
+                requestid: requestId,
+                amount: formattedAmount
+            }];
+        return this.broadcastOperations(client, [operation], key);
+    },
+    collateralizedConvert(client, config, owner, amount, requestId = 0) {
+        if (!client || !config.ACTIVE_KEY || !owner || !amount) {
+            throw new Error('Missing required parameters for collateralized convert operation');
+        }
+        const formattedAmount = amount.includes('HIVE') ? amount : this.formatAssetAmount(amount, 'HIVE');
+        const key = dhive_1.PrivateKey.fromString(config.ACTIVE_KEY);
+        const operation = ['collateralized_convert', {
+                owner,
+                requestid: requestId,
+                amount: formattedAmount
+            }];
+        return this.broadcastOperations(client, [operation], key);
+    },
+    // ─── Content Operations ─────────────────────────────────────────────
+    deleteComment(client, config, author, permlink) {
+        if (!client || !config.POSTING_KEY || !author || !permlink) {
+            throw new Error('Missing required parameters for delete comment');
+        }
+        const key = dhive_1.PrivateKey.fromString(config.POSTING_KEY);
+        const operation = ['delete_comment', {
+                author,
+                permlink
+            }];
+        return this.broadcastOperations(client, [operation], key);
+    },
+    commentOptions(client, config, author, permlink, options) {
+        if (!client || !config.POSTING_KEY || !author || !permlink) {
+            throw new Error('Missing required parameters for comment options');
+        }
+        const key = dhive_1.PrivateKey.fromString(config.POSTING_KEY);
+        const operation = ['comment_options', {
+                author,
+                permlink,
+                max_accepted_payout: options.max_accepted_payout || '1000000.000 HBD',
+                percent_hbd: options.percent_hbd !== undefined ? options.percent_hbd : 10000,
+                allow_votes: options.allow_votes !== false,
+                allow_curation_rewards: options.allow_curation_rewards !== false,
+                extensions: options.extensions || []
+            }];
+        return this.broadcastOperations(client, [operation], key);
+    },
+    // ─── Market Operations ──────────────────────────────────────────────
+    limitOrderCreate(client, config, owner, orderId, amountToSell, minToReceive, fillOrKill = false, expiration) {
+        if (!client || !config.ACTIVE_KEY || !owner || !amountToSell || !minToReceive) {
+            throw new Error('Missing required parameters for limit order create');
+        }
+        const key = dhive_1.PrivateKey.fromString(config.ACTIVE_KEY);
+        const expirationDate = expiration
+            ? this.toHiveTimestamp(expiration)
+            : this.toHiveTimestamp(new Date(Date.now() + 28 * 24 * 60 * 60 * 1000));
+        const operation = ['limit_order_create', {
+                owner,
+                orderid: orderId,
+                amount_to_sell: amountToSell,
+                min_to_receive: minToReceive,
+                fill_or_kill: fillOrKill,
+                expiration: expirationDate
+            }];
+        return this.broadcastOperations(client, [operation], key);
+    },
+    limitOrderCancel(client, config, owner, orderId) {
+        if (!client || !config.ACTIVE_KEY || !owner || typeof orderId !== 'number') {
+            throw new Error('Missing required parameters for limit order cancel');
+        }
+        const key = dhive_1.PrivateKey.fromString(config.ACTIVE_KEY);
+        const operation = ['limit_order_cancel', {
+                owner,
+                orderid: orderId
+            }];
+        return this.broadcastOperations(client, [operation], key);
+    },
+    // ─── Vesting Route ──────────────────────────────────────────────────
+    setWithdrawVestingRoute(client, config, fromAccount, toAccount, percent, autoVest = false, signingKeys) {
+        if (!client || !fromAccount || !toAccount) {
+            throw new Error('Missing required parameters for set withdraw vesting route');
+        }
+        if (percent < 0 || percent > 10000) {
+            throw new Error('Percent must be between 0 and 10000');
+        }
+        const keys = signingKeys || config.ACTIVE_KEY;
+        if (!keys) {
+            throw new Error('Active key or explicit signing keys are required');
+        }
+        const operation = ['set_withdraw_vesting_route', {
+                from_account: fromAccount,
+                to_account: toAccount,
+                percent,
+                auto_vest: autoVest
+            }];
+        return this.broadcastOperations(client, [operation], keys);
+    },
+    // ─── Account Creation ───────────────────────────────────────────────
+    claimAccount(client, config, creator, fee = '0.000 HIVE') {
+        if (!client || !config.ACTIVE_KEY || !creator) {
+            throw new Error('Missing required parameters for claim account');
+        }
+        const key = dhive_1.PrivateKey.fromString(config.ACTIVE_KEY);
+        const operation = ['claim_account', {
+                creator,
+                fee,
+                extensions: []
+            }];
+        return this.broadcastOperations(client, [operation], key);
+    },
+    createClaimedAccount(client, config, creator, newAccountName, owner, active, posting, memoKey, jsonMetadata = '') {
+        if (!client || !config.ACTIVE_KEY || !creator || !newAccountName || !owner || !active || !posting || !memoKey) {
+            throw new Error('Missing required parameters for create claimed account');
+        }
+        const key = dhive_1.PrivateKey.fromString(config.ACTIVE_KEY);
+        const operation = ['create_claimed_account', {
+                creator,
+                new_account_name: newAccountName,
+                owner,
+                active,
+                posting,
+                memo_key: memoKey,
+                json_metadata: jsonMetadata,
+                extensions: []
+            }];
+        return this.broadcastOperations(client, [operation], key);
+    },
+    // ─── Witness Operations ─────────────────────────────────────────────
+    feedPublish(client, config, publisher, baseAmount, quoteAmount = '1.000 HIVE') {
+        if (!client || !config.ACTIVE_KEY || !publisher || !baseAmount) {
+            throw new Error('Missing required parameters for feed publish');
+        }
+        const key = dhive_1.PrivateKey.fromString(config.ACTIVE_KEY);
+        const operation = ['feed_publish', {
+                publisher,
+                exchange_rate: {
+                    base: baseAmount,
+                    quote: quoteAmount
+                }
+            }];
+        return this.broadcastOperations(client, [operation], key);
+    },
+    // ─── Comprehensive Utility Helpers ──────────────────────────────────
+    /**
+     * Calculates current voting mana percentage for an account
+     * @param account - Extended account object from getAccounts()
+     * @returns Voting mana as a percentage (0-100)
+     */
+    calculateVotingMana(account) {
+        if (!account || !account.voting_manabar) {
+            throw new Error('Invalid account object');
+        }
+        const lastMana = parseInt(account.voting_manabar.current_mana, 10);
+        const lastUpdate = parseInt(account.voting_manabar.last_update_time, 10);
+        const now = Math.floor(Date.now() / 1000);
+        const maxMana = this.getEffectiveVestingShares(account);
+        if (maxMana === 0) {
+            return 0;
+        }
+        const elapsed = now - lastUpdate;
+        const regenerated = (maxMana * elapsed) / (5 * 24 * 60 * 60);
+        const currentMana = Math.min(lastMana + regenerated, maxMana);
+        return Math.min(100, (currentMana / maxMana) * 100);
+    },
+    /**
+     * Gets the effective vesting shares for an account (own + received - delegated)
+     * @param account - Extended account object
+     * @returns Effective vesting shares as a number
+     */
+    getEffectiveVestingShares(account) {
+        const own = parseFloat(String(account.vesting_shares || '0').replace(' VESTS', ''));
+        const received = parseFloat(String(account.received_vesting_shares || '0').replace(' VESTS', ''));
+        const delegated = parseFloat(String(account.delegated_vesting_shares || '0').replace(' VESTS', ''));
+        return own + received - delegated;
+    },
+    /**
+     * Estimates the value of a vote in USD
+     * @param votingPower - Current voting power percentage (0-100)
+     * @param weight - Vote weight percentage (0-100)
+     * @param effectiveVests - Effective vesting shares as number
+     * @param rewardFund - Reward fund object from condenser_api.get_reward_fund
+     * @param medianPrice - Median price object from getDynamicGlobalProperties
+     * @returns Estimated vote value in USD
+     */
+    estimateVoteValue(votingPower, weight, effectiveVests, rewardFund, medianPrice) {
+        if (!rewardFund || !medianPrice) {
+            throw new Error('Reward fund and median price are required');
+        }
+        const voteWeight = Math.floor(votingPower * 100 * weight);
+        const rshares = effectiveVests * 1e6 * (voteWeight / 10000);
+        const rewardBalance = parseFloat(rewardFund.reward_balance.replace(' HIVE', ''));
+        const recentClaims = parseFloat(rewardFund.recent_claims);
+        const base = parseFloat(medianPrice.base.replace(' HBD', ''));
+        const quote = parseFloat(medianPrice.quote.replace(' HIVE', ''));
+        if (recentClaims === 0 || quote === 0) {
+            return 0;
+        }
+        const hivePerRshare = rewardBalance / recentClaims;
+        const voteValue = rshares * hivePerRshare * (base / quote);
+        return Math.max(0, Math.round(voteValue * 1000) / 1000);
+    },
+    /**
+     * Generates a URL-safe permlink from a title
+     * @param title - The post title
+     * @returns A valid Hive permlink string
+     */
+    generatePermlink(title) {
+        if (!title || typeof title !== 'string') {
+            throw new Error('Title is required');
+        }
+        return title
+            .toLowerCase()
+            .replace(/[^\w\s-]/g, '')
+            .replace(/\s+/g, '-')
+            .replace(/-+/g, '-')
+            .replace(/^-|-$/g, '')
+            .substring(0, 255) || 'untitled';
+    },
+    /**
+     * Validates a Hive account name according to blockchain rules
+     * @param name - The account name to validate
+     * @returns null if valid, or an error message string
+     */
+    validateAccountName(name) {
+        if (!name) {
+            return 'Account name is required';
+        }
+        if (typeof name !== 'string') {
+            return 'Account name must be a string';
+        }
+        const length = name.length;
+        if (length < 3) {
+            return 'Account name must be at least 3 characters';
+        }
+        if (length > 16) {
+            return 'Account name must be at most 16 characters';
+        }
+        if (!/^[a-z]/.test(name)) {
+            return 'Account name must start with a letter';
+        }
+        if (!/^[a-z0-9.-]+$/.test(name)) {
+            return 'Account name may only contain lowercase letters, digits, dots, and hyphens';
+        }
+        if (/\.\./.test(name) || /--/.test(name)) {
+            return 'Account name may not contain consecutive dots or hyphens';
+        }
+        if (/\.$/.test(name) || /-$/.test(name)) {
+            return 'Account name may not end with a dot or hyphen';
+        }
+        const segments = name.split('.');
+        for (const segment of segments) {
+            if (segment.length < 3) {
+                return 'Each account name segment must be at least 3 characters';
+            }
+            if (!/^[a-z]/.test(segment)) {
+                return 'Each account name segment must start with a letter';
+            }
+        }
+        return null;
+    },
+    /**
+     * Returns true if the given string is a valid Hive account name
+     * @param name - The account name to check
+     * @returns true if valid, false otherwise
+     */
+    isValidAccountName(name) {
+        return this.validateAccountName(name) === null;
+    },
+    /**
+     * Checks if an account exists on the blockchain
+     * @param client - The Hive client instance
+     * @param username - Account name to check
+     * @returns Promise resolving to true if account exists
+     */
+    async accountExists(client, username) {
+        const account = await this.getAccount(client, username);
+        return account !== null;
+    },
+    /**
+     * Parses a Hive URL or link into its components
+     * @param url - URL like https://hive.blog/@author/permlink or @author/permlink
+     * @returns Parsed components { author, permlink, category? } or null if invalid
+     */
+    parseHiveUrl(url) {
+        if (!url || typeof url !== 'string') {
+            return null;
+        }
+        const cleaned = url.trim();
+        // Handle @author/permlink format
+        const atMatch = cleaned.match(/^@([a-z0-9.-]+)\/([a-z0-9-]+)$/);
+        if (atMatch) {
+            return { author: atMatch[1], permlink: atMatch[2] };
+        }
+        // Handle full URLs: https://hive.blog/category/@author/permlink
+        const urlMatch = cleaned.match(/(?:https?:\/\/[^\/]+)?\/(?:([^\/]+)\/)?@([a-z0-9.-]+)\/([a-z0-9-]+)/);
+        if (urlMatch) {
+            return {
+                author: urlMatch[2],
+                permlink: urlMatch[3],
+                category: urlMatch[1] || undefined
+            };
+        }
+        return null;
+    },
+    /**
+     * Generates a unique permlink with timestamp for replies
+     * @param parentPermlink - The parent post's permlink (optional)
+     * @returns A unique permlink string
+     */
+    generateReplyPermlink(parentPermlink) {
+        const timestamp = new Date().toISOString().replace(/[^a-z0-9]/gi, '').toLowerCase();
+        const prefix = parentPermlink ? `re-${parentPermlink.substring(0, 100)}` : 're';
+        return `${prefix}-${timestamp}`;
+    },
+    /**
+     * Creates the json_metadata string for a Hive post
+     * @param options - Post metadata options
+     * @returns JSON string for json_metadata field
+     */
+    createPostMetadata(options = {}) {
+        const metadata = {
+            tags: options.tags || [],
+            image: options.image || [],
+            links: options.links || [],
+            app: options.app || 'hive-stream',
+            format: options.format || 'markdown'
+        };
+        if (options.description) {
+            metadata.description = options.description;
+        }
+        // Include any additional custom fields
+        for (const [key, value] of Object.entries(options)) {
+            if (!['tags', 'image', 'links', 'app', 'format', 'description'].includes(key)) {
+                metadata[key] = value;
+            }
+        }
+        return JSON.stringify(metadata);
+    },
+    /**
+     * Encodes a memo with a shared secret (requires sender private memo key and receiver public memo key)
+     * Note: Requires @hiveio/dhive Memo support
+     */
+    encodeMemo(privateKey, publicKey, message) {
+        // Dynamic import to avoid hard dependency on Memo
+        try {
+            const { Memo } = require('@hiveio/dhive');
+            return Memo.encode(dhive_1.PrivateKey.fromString(privateKey), publicKey, `#${message}`);
+        }
+        catch {
+            throw new Error('Memo encoding requires @hiveio/dhive with Memo support');
+        }
+    },
+    /**
+     * Decodes an encrypted memo
+     * Note: Requires @hiveio/dhive Memo support
+     */
+    decodeMemo(privateKey, encodedMemo) {
+        try {
+            const { Memo } = require('@hiveio/dhive');
+            return Memo.decode(dhive_1.PrivateKey.fromString(privateKey), encodedMemo);
+        }
+        catch {
+            throw new Error('Memo decoding requires @hiveio/dhive with Memo support');
+        }
+    },
+    // ─── Authority Management ───────────────────────────────────────────
+    /**
+     * Checks if an account has granted posting authority to an app/account
+     */
+    async hasPostingAuth(client, account, authAccount) {
+        const acc = await this.getAccount(client, account);
+        if (!acc || !acc.posting || !Array.isArray(acc.posting.account_auths)) {
+            return false;
+        }
+        return acc.posting.account_auths.some(([name]) => name === authAccount);
+    },
+    /**
+     * Grants posting authority to an app/account
+     */
+    async grantPostingAuth(client, config, account, authAccount, signingKeys) {
+        const acc = await this.getAccount(client, account);
+        if (!acc) {
+            throw new Error(`Account '${account}' not found`);
+        }
+        const existing = acc.posting.account_auths || [];
+        if (existing.some(([name]) => name === authAccount)) {
+            return; // Already authorized
+        }
+        const newAuths = [...existing, [authAccount, 1]].sort((a, b) => a[0].localeCompare(b[0]));
+        const keys = signingKeys || config.ACTIVE_KEY;
+        if (!keys) {
+            throw new Error('Active key is required to grant posting authority');
+        }
+        const operation = ['account_update', {
+                account,
+                memo_key: acc.memo_key,
+                json_metadata: acc.json_metadata || '',
+                posting: {
+                    ...acc.posting,
+                    account_auths: newAuths
+                }
+            }];
+        return this.broadcastOperations(client, [operation], keys);
+    },
+    /**
+     * Revokes posting authority from an app/account
+     */
+    async revokePostingAuth(client, config, account, authAccount, signingKeys) {
+        const acc = await this.getAccount(client, account);
+        if (!acc) {
+            throw new Error(`Account '${account}' not found`);
+        }
+        const existing = acc.posting.account_auths || [];
+        const filtered = existing.filter(([name]) => name !== authAccount);
+        if (filtered.length === existing.length) {
+            return; // Was not authorized
+        }
+        const keys = signingKeys || config.ACTIVE_KEY;
+        if (!keys) {
+            throw new Error('Active key is required to revoke posting authority');
+        }
+        const operation = ['account_update', {
+                account,
+                memo_key: acc.memo_key,
+                json_metadata: acc.json_metadata || '',
+                posting: {
+                    ...acc.posting,
+                    account_auths: filtered
+                }
+            }];
+        return this.broadcastOperations(client, [operation], keys);
+    },
+    // ─── Power Down Schedule ────────────────────────────────────────────
+    /**
+     * Calculates the remaining power down schedule for an account
+     * @param account - Extended account object from getAccounts()
+     * @returns Array of weekly payment entries with dates and amounts
+     */
+    calculatePowerDownSchedule(account) {
+        const withdrawRate = parseFloat(String(account.vesting_withdraw_rate || '0').replace(' VESTS', ''));
+        const nextDate = new Date(account.next_vesting_withdrawal + 'Z');
+        const toWithdraw = parseFloat(String(account.to_withdraw || '0'));
+        const withdrawn = parseFloat(String(account.withdrawn || '0'));
+        if (withdrawRate <= 0 || toWithdraw <= withdrawn) {
+            return [];
+        }
+        const remaining = toWithdraw - withdrawn;
+        const weeksLeft = Math.ceil(remaining / (withdrawRate * 1e6));
+        const schedule = [];
+        let totalPaid = 0;
+        for (let i = 0; i < Math.min(weeksLeft, 13); i++) {
+            const isLast = i === weeksLeft - 1;
+            const weekAmount = isLast
+                ? (remaining / 1e6) - totalPaid
+                : withdrawRate;
+            const date = new Date(nextDate.getTime() + i * 7 * 24 * 60 * 60 * 1000);
+            totalPaid += weekAmount;
+            schedule.push({
+                week: i + 1,
+                date,
+                amount: weekAmount.toFixed(6),
+                vestingShares: `${weekAmount.toFixed(6)} VESTS`
+            });
+        }
+        return schedule;
+    },
+    // ─── HBD Interest Calculator ────────────────────────────────────────
+    /**
+     * Calculates pending HBD savings interest
+     * @param hbdBalance - HBD savings balance (e.g. '100.000 HBD')
+     * @param lastInterestPayment - Date of last interest payment
+     * @param annualRate - Annual interest rate as percentage (default: 15)
+     * @returns Pending interest amount as a string
+     */
+    calculateHbdInterest(hbdBalance, lastInterestPayment, annualRate = 15) {
+        const balance = new bignumber_js_1.default(String(hbdBalance).replace(' HBD', ''));
+        if (balance.isZero() || balance.isNaN()) {
+            return '0.000';
+        }
+        const lastPayment = new Date(typeof lastInterestPayment === 'string'
+            ? lastInterestPayment + (lastInterestPayment.endsWith('Z') ? '' : 'Z')
+            : lastInterestPayment);
+        const now = new Date();
+        const daysSincePayment = (now.getTime() - lastPayment.getTime()) / (1000 * 60 * 60 * 24);
+        if (daysSincePayment <= 0) {
+            return '0.000';
+        }
+        const dailyRate = annualRate / 365 / 100;
+        const interest = balance.multipliedBy(dailyRate).multipliedBy(daysSincePayment);
+        return interest.decimalPlaces(3, bignumber_js_1.default.ROUND_DOWN).toFixed(3);
+    },
+    // ─── Payout Helpers ─────────────────────────────────────────────────
+    /**
+     * Checks if a post is still within its payout window (7 days)
+     */
+    isInPayoutWindow(post) {
+        if (!post || !post.cashout_time) {
+            return false;
+        }
+        const cashout = new Date(post.cashout_time + (post.cashout_time.endsWith('Z') ? '' : 'Z'));
+        const epoch = new Date('1969-12-31T23:59:59Z');
+        // Posts past payout have cashout_time set to epoch
+        if (cashout.getTime() <= epoch.getTime()) {
+            return false;
+        }
+        return cashout.getTime() > Date.now();
+    },
+    /**
+     * Returns milliseconds until payout, or 0 if already paid out
+     */
+    timeUntilPayout(post) {
+        if (!this.isInPayoutWindow(post)) {
+            return 0;
+        }
+        const cashout = new Date(post.cashout_time + (post.cashout_time.endsWith('Z') ? '' : 'Z'));
+        return Math.max(0, cashout.getTime() - Date.now());
+    },
+    /**
+     * Calculates the pending payout value of a post in HBD
+     */
+    getPendingPayout(post) {
+        if (!post) {
+            return '0.000';
+        }
+        const pending = parseFloat(String(post.pending_payout_value || '0').replace(' HBD', ''));
+        const total = parseFloat(String(post.total_payout_value || '0').replace(' HBD', ''));
+        const curator = parseFloat(String(post.curator_payout_value || '0').replace(' HBD', ''));
+        if (pending > 0) {
+            return pending.toFixed(3);
+        }
+        return (total + curator).toFixed(3);
+    },
+    // ─── Account Value Calculator ───────────────────────────────────────
+    /**
+     * Calculates total account value breakdown
+     * @param account - Extended account object
+     * @param hivePrice - Current HIVE price in USD
+     * @param hbdPrice - Current HBD price in USD (usually ~1.00)
+     * @param totalVestingFundHive - From dynamic global properties
+     * @param totalVestingShares - From dynamic global properties
+     * @returns Breakdown of account value
+     */
+    calculateAccountValue(account, hivePrice, hbdPrice = 1.0, totalVestingFundHive = '0', totalVestingShares = '1') {
+        const hive = parseFloat(String(account.balance || '0').replace(' HIVE', ''));
+        const hbd = parseFloat(String(account.hbd_balance || '0').replace(' HBD', ''));
+        const savingsHive = parseFloat(String(account.savings_balance || '0').replace(' HIVE', ''));
+        const savingsHbd = parseFloat(String(account.savings_hbd_balance || '0').replace(' HBD', ''));
+        const effectiveVests = this.getEffectiveVestingShares(account);
+        const hp = parseFloat(this.vestToHP(String(effectiveVests), totalVestingFundHive, totalVestingShares));
+        const totalHive = hive + savingsHive + hp;
+        const totalHbd = hbd + savingsHbd;
+        const totalUsd = (totalHive * hivePrice) + (totalHbd * hbdPrice);
+        return {
+            hive,
+            hbd,
+            savings_hive: savingsHive,
+            savings_hbd: savingsHbd,
+            hp,
+            total_hive: totalHive,
+            total_usd: Math.round(totalUsd * 1000) / 1000
+        };
+    },
+    // ─── Content Helpers ────────────────────────────────────────────────
+    /**
+     * Extracts all image URLs from a post body (markdown/HTML)
+     */
+    extractImagesFromBody(body) {
+        if (!body || typeof body !== 'string') {
+            return [];
+        }
+        const images = [];
+        const seen = new Set();
+        // Markdown images: ![alt](url)
+        const mdRegex = /!\[.*?\]\((https?:\/\/[^)\s]+)\)/g;
+        let match;
+        while ((match = mdRegex.exec(body)) !== null) {
+            if (!seen.has(match[1])) {
+                seen.add(match[1]);
+                images.push(match[1]);
+            }
+        }
+        // HTML images: <img src="url">
+        const htmlRegex = /<img[^>]+src=["'](https?:\/\/[^"']+)["']/gi;
+        while ((match = htmlRegex.exec(body)) !== null) {
+            if (!seen.has(match[1])) {
+                seen.add(match[1]);
+                images.push(match[1]);
+            }
+        }
+        return images;
+    },
+    /**
+     * Extracts all hyperlinks from a post body
+     */
+    extractLinksFromBody(body) {
+        if (!body || typeof body !== 'string') {
+            return [];
+        }
+        const links = [];
+        const seen = new Set();
+        // Markdown links: [text](url) but NOT images
+        const mdRegex = /(?<!!)\[.*?\]\((https?:\/\/[^)\s]+)\)/g;
+        let match;
+        while ((match = mdRegex.exec(body)) !== null) {
+            if (!seen.has(match[1])) {
+                seen.add(match[1]);
+                links.push(match[1]);
+            }
+        }
+        // HTML links: <a href="url">
+        const htmlRegex = /<a[^>]+href=["'](https?:\/\/[^"']+)["']/gi;
+        while ((match = htmlRegex.exec(body)) !== null) {
+            if (!seen.has(match[1])) {
+                seen.add(match[1]);
+                links.push(match[1]);
+            }
+        }
+        return links;
+    },
+    /**
+     * Generates a plain-text summary from a post body by stripping markdown/HTML
+     */
+    generatePostSummary(body, maxLength = 200) {
+        if (!body || typeof body !== 'string') {
+            return '';
+        }
+        let text = body
+            // Remove images
+            .replace(/!\[.*?\]\(.*?\)/g, '')
+            // Convert links to text
+            .replace(/\[([^\]]+)\]\(.*?\)/g, '$1')
+            // Remove HTML tags
+            .replace(/<[^>]+>/g, '')
+            // Remove headers
+            .replace(/^#{1,6}\s+/gm, '')
+            // Remove bold/italic
+            .replace(/[*_]{1,3}([^*_]+)[*_]{1,3}/g, '$1')
+            // Remove strikethrough
+            .replace(/~~([^~]+)~~/g, '$1')
+            // Remove blockquotes
+            .replace(/^>\s+/gm, '')
+            // Remove horizontal rules
+            .replace(/^[-*_]{3,}$/gm, '')
+            // Remove code blocks
+            .replace(/```[\s\S]*?```/g, '')
+            .replace(/`([^`]+)`/g, '$1')
+            // Collapse whitespace
+            .replace(/\n+/g, ' ')
+            .replace(/\s+/g, ' ')
+            .trim();
+        if (text.length > maxLength) {
+            text = text.substring(0, maxLength).replace(/\s+\S*$/, '') + '...';
+        }
+        return text;
+    },
+    // ─── Hivesigner URL Generators ──────────────────────────────────────
+    /**
+     * Generates a Hivesigner signing URL for any operation
+     */
+    getHivesignerSignUrl(operationType, params, redirectUri) {
+        const queryParams = Object.entries(params)
+            .filter(([, v]) => v !== undefined && v !== null)
+            .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`)
+            .join('&');
+        let url = `https://hivesigner.com/sign/${operationType}?${queryParams}`;
+        if (redirectUri) {
+            url += `&redirect_uri=${encodeURIComponent(redirectUri)}`;
+        }
+        return url;
+    },
+    /**
+     * Generates a Hivesigner vote URL
+     */
+    getVoteUrl(voter, author, permlink, weight, redirectUri) {
+        return this.getHivesignerSignUrl('vote', { voter, author, permlink, weight }, redirectUri);
+    },
+    /**
+     * Generates a Hivesigner delegation URL
+     */
+    getDelegateUrl(delegator, delegatee, vestingShares, redirectUri) {
+        return this.getHivesignerSignUrl('delegate-vesting-shares', {
+            delegator, delegatee, vesting_shares: vestingShares
+        }, redirectUri);
+    },
+    /**
+     * Generates a Hivesigner follow URL
+     */
+    getFollowUrl(follower, following, redirectUri) {
+        return this.getHivesignerSignUrl('follow', { follower, following }, redirectUri);
+    },
+    // ─── Transfer Memo Helpers ──────────────────────────────────────────
+    /**
+     * Checks if a memo is encrypted (starts with #)
+     */
+    isEncryptedMemo(memo) {
+        return typeof memo === 'string' && memo.startsWith('#');
+    },
+    /**
+     * Creates a JSON-encoded memo string for structured data in transfers
+     */
+    createJsonMemo(data) {
+        return JSON.stringify(data);
+    },
+    /**
+     * Attempts to parse a transfer memo as JSON, returns null if not valid JSON
+     */
+    parseJsonMemo(memo) {
+        if (!memo || typeof memo !== 'string') {
+            return null;
+        }
+        const trimmed = memo.trim();
+        if (!trimmed.startsWith('{') && !trimmed.startsWith('[')) {
+            return null;
+        }
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+            return null;
+        }
+    },
+    // ─── Key Derivation ─────────────────────────────────────────────────
+    /**
+     * Derives all private and public keys from a Hive master password
+     * @param account - The Hive account name
+     * @param password - The master password
+     * @returns Object with owner, active, posting, memo keys (private and public)
+     */
+    deriveKeys(account, password) {
+        if (!account || !password) {
+            throw new Error('Account and password are required for key derivation');
+        }
+        const roles = ['owner', 'active', 'posting', 'memo'];
+        const result = {};
+        for (const role of roles) {
+            const privateKey = dhive_1.PrivateKey.fromLogin(account, password, role);
+            result[role] = privateKey.toString();
+            result[`${role}Public`] = privateKey.createPublic().toString();
+        }
+        return result;
+    },
+    /**
+     * Gets the public key from a private key string
+     */
+    getPublicKey(privateKey) {
+        return dhive_1.PrivateKey.fromString(privateKey).createPublic().toString();
+    },
+    // ─── Hive Engine Write Operations ───────────────────────────────────
+    stakeEngineTokens(client, config, from, to, symbol, quantity) {
+        if (!client || !config.ACTIVE_KEY || !from || !symbol || !quantity) {
+            throw new Error('Missing required parameters for stake engine tokens');
+        }
+        const key = dhive_1.PrivateKey.fromString(config.ACTIVE_KEY);
+        const json = JSON.stringify({
+            contractName: 'tokens',
+            contractAction: 'stake',
+            contractPayload: { to: to || from, symbol, quantity: String(quantity) }
+        });
+        return client.broadcast.json({
+            required_auths: [from],
+            required_posting_auths: [],
+            id: config.HIVE_ENGINE_ID || 'ssc-mainnet-hive',
+            json
+        }, key);
+    },
+    unstakeEngineTokens(client, config, from, symbol, quantity) {
+        if (!client || !config.ACTIVE_KEY || !from || !symbol || !quantity) {
+            throw new Error('Missing required parameters for unstake engine tokens');
+        }
+        const key = dhive_1.PrivateKey.fromString(config.ACTIVE_KEY);
+        const json = JSON.stringify({
+            contractName: 'tokens',
+            contractAction: 'unstake',
+            contractPayload: { symbol, quantity: String(quantity) }
+        });
+        return client.broadcast.json({
+            required_auths: [from],
+            required_posting_auths: [],
+            id: config.HIVE_ENGINE_ID || 'ssc-mainnet-hive',
+            json
+        }, key);
+    },
+    buyEngineTokens(client, config, from, symbol, quantity, price) {
+        if (!client || !config.ACTIVE_KEY || !from || !symbol || !quantity || !price) {
+            throw new Error('Missing required parameters for buy engine tokens');
+        }
+        const key = dhive_1.PrivateKey.fromString(config.ACTIVE_KEY);
+        const json = JSON.stringify({
+            contractName: 'market',
+            contractAction: 'buy',
+            contractPayload: { symbol, quantity: String(quantity), price: String(price) }
+        });
+        return client.broadcast.json({
+            required_auths: [from],
+            required_posting_auths: [],
+            id: config.HIVE_ENGINE_ID || 'ssc-mainnet-hive',
+            json
+        }, key);
+    },
+    sellEngineTokens(client, config, from, symbol, quantity, price) {
+        if (!client || !config.ACTIVE_KEY || !from || !symbol || !quantity || !price) {
+            throw new Error('Missing required parameters for sell engine tokens');
+        }
+        const key = dhive_1.PrivateKey.fromString(config.ACTIVE_KEY);
+        const json = JSON.stringify({
+            contractName: 'market',
+            contractAction: 'sell',
+            contractPayload: { symbol, quantity: String(quantity), price: String(price) }
+        });
+        return client.broadcast.json({
+            required_auths: [from],
+            required_posting_auths: [],
+            id: config.HIVE_ENGINE_ID || 'ssc-mainnet-hive',
+            json
+        }, key);
+    },
+    cancelEngineOrder(client, config, from, type, orderId) {
+        if (!client || !config.ACTIVE_KEY || !from || !type || !orderId) {
+            throw new Error('Missing required parameters for cancel engine order');
+        }
+        const key = dhive_1.PrivateKey.fromString(config.ACTIVE_KEY);
+        const json = JSON.stringify({
+            contractName: 'market',
+            contractAction: 'cancel',
+            contractPayload: { type, id: orderId }
+        });
+        return client.broadcast.json({
+            required_auths: [from],
+            required_posting_auths: [],
+            id: config.HIVE_ENGINE_ID || 'ssc-mainnet-hive',
+            json
+        }, key);
+    },
+    delegateEngineTokens(client, config, from, to, symbol, quantity) {
+        if (!client || !config.ACTIVE_KEY || !from || !to || !symbol || !quantity) {
+            throw new Error('Missing required parameters for delegate engine tokens');
+        }
+        const key = dhive_1.PrivateKey.fromString(config.ACTIVE_KEY);
+        const json = JSON.stringify({
+            contractName: 'tokens',
+            contractAction: 'delegate',
+            contractPayload: { to, symbol, quantity: String(quantity) }
+        });
+        return client.broadcast.json({
+            required_auths: [from],
+            required_posting_auths: [],
+            id: config.HIVE_ENGINE_ID || 'ssc-mainnet-hive',
+            json
+        }, key);
+    },
+    undelegateEngineTokens(client, config, from, to, symbol, quantity) {
+        if (!client || !config.ACTIVE_KEY || !from || !to || !symbol || !quantity) {
+            throw new Error('Missing required parameters for undelegate engine tokens');
+        }
+        const key = dhive_1.PrivateKey.fromString(config.ACTIVE_KEY);
+        const json = JSON.stringify({
+            contractName: 'tokens',
+            contractAction: 'undelegate',
+            contractPayload: { from: to, symbol, quantity: String(quantity) }
+        });
+        return client.broadcast.json({
+            required_auths: [from],
+            required_posting_auths: [],
+            id: config.HIVE_ENGINE_ID || 'ssc-mainnet-hive',
+            json
+        }, key);
+    },
+    // ─── Community Operations ───────────────────────────────────────────
+    subscribeCommunity(client, config, account, community) {
+        if (!client || !config.POSTING_KEY || !account || !community) {
+            throw new Error('Missing required parameters for subscribe to community');
+        }
+        const key = dhive_1.PrivateKey.fromString(config.POSTING_KEY);
+        const json = JSON.stringify(['subscribe', { community }]);
+        return client.broadcast.json({
+            required_auths: [],
+            required_posting_auths: [account],
+            id: 'community',
+            json
+        }, key);
+    },
+    unsubscribeCommunity(client, config, account, community) {
+        if (!client || !config.POSTING_KEY || !account || !community) {
+            throw new Error('Missing required parameters for unsubscribe from community');
+        }
+        const key = dhive_1.PrivateKey.fromString(config.POSTING_KEY);
+        const json = JSON.stringify(['unsubscribe', { community }]);
+        return client.broadcast.json({
+            required_auths: [],
+            required_posting_auths: [account],
+            id: 'community',
+            json
+        }, key);
+    },
+    pinCommunityPost(client, config, account, community, author, permlink) {
+        if (!client || !config.POSTING_KEY || !account || !community || !author || !permlink) {
+            throw new Error('Missing required parameters for pin community post');
+        }
+        const key = dhive_1.PrivateKey.fromString(config.POSTING_KEY);
+        const json = JSON.stringify(['pinPost', { community, account: author, permlink }]);
+        return client.broadcast.json({
+            required_auths: [],
+            required_posting_auths: [account],
+            id: 'community',
+            json
+        }, key);
+    },
+    unpinCommunityPost(client, config, account, community, author, permlink) {
+        if (!client || !config.POSTING_KEY || !account || !community || !author || !permlink) {
+            throw new Error('Missing required parameters for unpin community post');
+        }
+        const key = dhive_1.PrivateKey.fromString(config.POSTING_KEY);
+        const json = JSON.stringify(['unpinPost', { community, account: author, permlink }]);
+        return client.broadcast.json({
+            required_auths: [],
+            required_posting_auths: [account],
+            id: 'community',
+            json
+        }, key);
+    },
+    muteCommunityUser(client, config, account, community, targetAccount, notes = '') {
+        if (!client || !config.POSTING_KEY || !account || !community || !targetAccount) {
+            throw new Error('Missing required parameters for mute community user');
+        }
+        const key = dhive_1.PrivateKey.fromString(config.POSTING_KEY);
+        const json = JSON.stringify(['mutePost', { community, account: targetAccount, notes }]);
+        return client.broadcast.json({
+            required_auths: [],
+            required_posting_auths: [account],
+            id: 'community',
+            json
+        }, key);
+    },
+    unmuteCommunityUser(client, config, account, community, targetAccount, notes = '') {
+        if (!client || !config.POSTING_KEY || !account || !community || !targetAccount) {
+            throw new Error('Missing required parameters for unmute community user');
+        }
+        const key = dhive_1.PrivateKey.fromString(config.POSTING_KEY);
+        const json = JSON.stringify(['unmutePost', { community, account: targetAccount, notes }]);
+        return client.broadcast.json({
+            required_auths: [],
+            required_posting_auths: [account],
+            id: 'community',
+            json
+        }, key);
     }
 };
 //# sourceMappingURL=utils.js.map