hive-stream 3.0.4 → 3.0.5

package/dist/streamer.js

@@ -6,11 +6,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Streamer = void 0;
 const api_1 = require("./api");
 const sqlite_adapter_1 = require("./adapters/sqlite.adapter");
-const utils_1 = require("@hiveio/dhive/lib/utils");
 const actions_1 = require("./actions");
 const dhive_1 = require("@hiveio/dhive");
 const bignumber_js_1 = __importDefault(require("bignumber.js"));
-const utils_2 = require("./utils");
+const utils_1 = require("./utils");
 const builders_1 = require("./builders");
 const config_1 = require("./config");
 const hive_provider_1 = require("./providers/hive-provider");
@@ -23,6 +22,21 @@ class Streamer {
     postSubscriptions = [];
     transferSubscriptions = [];
     escrowSubscriptions = [];
+    voteSubscriptions = [];
+    delegateSubscriptions = [];
+    powerUpSubscriptions = [];
+    powerDownSubscriptions = [];
+    claimRewardsSubscriptions = [];
+    witnessVoteSubscriptions = [];
+    followSubscriptions = [];
+    reblogSubscriptions = [];
+    accountUpdateSubscriptions = [];
+    deleteCommentSubscriptions = [];
+    limitOrderSubscriptions = [];
+    savingsSubscriptions = [];
+    convertSubscriptions = [];
+    blockSubscriptions = [];
+    anyOperationSubscriptions = [];
     attempts = 0;
     config = (0, config_1.createConfig)();
     client;
@@ -74,16 +88,17 @@ class Streamer {
     accountCache = new Map();
     cacheTimeout = 300000; // 5 minutes
     maxCacheSize = 1000;
-    utils = utils_2.Utils;
+    lastCacheCleanup = Date.now();
+    utils = utils_1.Utils;
     money = {
-        parseAssetAmount: (rawAmount) => utils_2.Utils.parseAssetAmount(rawAmount),
-        formatAmount: (amount, precision) => utils_2.Utils.formatAmount(amount, precision),
-        formatAssetAmount: (amount, symbol, precision) => utils_2.Utils.formatAssetAmount(amount, symbol, precision),
-        calculatePercentageAmount: (amount, percentage, precision) => utils_2.Utils.calculatePercentageAmount(amount, percentage, precision),
-        calculateBasisPointsAmount: (amount, basisPoints, precision) => utils_2.Utils.calculateBasisPointsAmount(amount, basisPoints, precision),
-        splitAmountByBasisPoints: (amount, basisPoints, precision) => utils_2.Utils.splitAmountByBasisPoints(amount, basisPoints, precision),
-        splitAmountByPercentage: (amount, percentages, precision) => utils_2.Utils.splitAmountByPercentage(amount, percentages, precision),
-        splitAmountByWeights: (amount, weights, precision) => utils_2.Utils.splitAmountByWeights(amount, weights, precision),
+        parseAssetAmount: (rawAmount) => utils_1.Utils.parseAssetAmount(rawAmount),
+        formatAmount: (amount, precision) => utils_1.Utils.formatAmount(amount, precision),
+        formatAssetAmount: (amount, symbol, precision) => utils_1.Utils.formatAssetAmount(amount, symbol, precision),
+        calculatePercentageAmount: (amount, percentage, precision) => utils_1.Utils.calculatePercentageAmount(amount, percentage, precision),
+        calculateBasisPointsAmount: (amount, basisPoints, precision) => utils_1.Utils.calculateBasisPointsAmount(amount, basisPoints, precision),
+        splitAmountByBasisPoints: (amount, basisPoints, precision) => utils_1.Utils.splitAmountByBasisPoints(amount, basisPoints, precision),
+        splitAmountByPercentage: (amount, percentages, precision) => utils_1.Utils.splitAmountByPercentage(amount, percentages, precision),
+        splitAmountByWeights: (amount, weights, precision) => utils_1.Utils.splitAmountByWeights(amount, weights, precision),
     };
     flows = {
         incomingTransfers: (account) => new builders_1.IncomingTransfersBuilder(this, account),
@@ -107,6 +122,114 @@ class Streamer {
         removeProposals: () => new builders_1.HiveRemoveProposalsBuilder(this),
         upvote: () => new builders_1.HiveVoteBuilder(this, 'upvote'),
         downvote: () => new builders_1.HiveVoteBuilder(this, 'downvote'),
+        follow: () => new builders_1.HiveFollowBuilder(this, 'follow'),
+        unfollow: () => new builders_1.HiveFollowBuilder(this, 'unfollow'),
+        mute: () => new builders_1.HiveFollowBuilder(this, 'mute'),
+        reblog: () => new builders_1.HiveReblogBuilder(this),
+        powerUp: () => new builders_1.HivePowerUpBuilder(this),
+        powerDown: () => new builders_1.HivePowerDownBuilder(this),
+        cancelPowerDown: () => new builders_1.HivePowerDownBuilder(this, true),
+        delegate: () => new builders_1.HiveDelegateBuilder(this),
+        undelegate: () => new builders_1.HiveDelegateBuilder(this, true),
+        claimRewards: () => new builders_1.HiveClaimRewardsBuilder(this),
+        witnessVote: () => new builders_1.HiveWitnessVoteBuilder(this),
+        setProxy: () => new builders_1.HiveSetProxyBuilder(this),
+        clearProxy: () => new builders_1.HiveSetProxyBuilder(this, true),
+        updateProfile: () => new builders_1.HiveUpdateProfileBuilder(this),
+        transferToSavings: () => new builders_1.HiveSavingsTransferBuilder(this, 'to'),
+        transferFromSavings: () => new builders_1.HiveSavingsTransferBuilder(this, 'from'),
+        convert: () => new builders_1.HiveConvertBuilder(this),
+        collateralizedConvert: () => new builders_1.HiveCollateralizedConvertBuilder(this),
+        deleteComment: () => new builders_1.HiveDeleteCommentBuilder(this),
+        limitOrder: () => new builders_1.HiveLimitOrderBuilder(this),
+        cancelOrder: () => new builders_1.HiveCancelOrderBuilder(this),
+        withdrawRoute: () => new builders_1.HiveWithdrawRouteBuilder(this),
+        commentOptions: () => new builders_1.HiveCommentOptionsBuilder(this),
+        post: () => new builders_1.HivePostBuilder(this),
+        stakeEngine: () => new builders_1.HiveEngineStakeBuilder(this),
+        unstakeEngine: () => new builders_1.HiveEngineUnstakeBuilder(this),
+        buyEngine: () => new builders_1.HiveEngineMarketOrderBuilder(this, 'buy'),
+        sellEngine: () => new builders_1.HiveEngineMarketOrderBuilder(this, 'sell'),
+        cancelEngineOrder: () => new builders_1.HiveEngineCancelOrderBuilder(this),
+        delegateEngine: () => new builders_1.HiveEngineDelegateBuilder(this),
+        undelegateEngine: () => new builders_1.HiveEngineDelegateBuilder(this, true),
+        subscribeCommunity: () => new builders_1.HiveCommunityOperationBuilder(this, 'subscribe'),
+        unsubscribeCommunity: () => new builders_1.HiveCommunityOperationBuilder(this, 'unsubscribe'),
+        cancelRecurrentTransfer: () => new builders_1.HiveRecurrentTransferBuilder(this),
+    };
+    query = {
+        getDynamicGlobalProperties: () => this.client.database.getDynamicGlobalProperties(),
+        getChainProperties: () => this.client.database.getChainProperties(),
+        getCurrentMedianHistoryPrice: () => this.client.database.getCurrentMedianHistoryPrice(),
+        getRewardFund: (name = 'post') => this.client.database.call('get_reward_fund', [name]),
+        getFollowers: (account, start = '', type = 'blog', limit = 1000) => this.client.call('condenser_api', 'get_followers', [account, start, type, limit]),
+        getFollowing: (account, start = '', type = 'blog', limit = 1000) => this.client.call('condenser_api', 'get_following', [account, start, type, limit]),
+        getFollowCount: (account) => this.client.call('condenser_api', 'get_follow_count', [account]),
+        getContent: (author, permlink) => this.client.call('condenser_api', 'get_content', [author, permlink]),
+        getContentReplies: (author, permlink) => this.client.call('condenser_api', 'get_content_replies', [author, permlink]),
+        getDiscussions: (by, query) => this.client.database.getDiscussions(by, query),
+        getBlog: (account, options = {}) => this.client.database.getDiscussions('blog', { tag: account, limit: 20, ...options }),
+        getFeed: (account, options = {}) => this.client.database.getDiscussions('feed', { tag: account, limit: 20, ...options }),
+        getTrending: (options = {}) => this.client.database.getDiscussions('trending', { limit: 20, ...options }),
+        getHot: (options = {}) => this.client.database.getDiscussions('hot', { limit: 20, ...options }),
+        getCreated: (options = {}) => this.client.database.getDiscussions('created', { limit: 20, ...options }),
+        getActiveVotes: (author, permlink) => this.client.call('condenser_api', 'get_active_votes', [author, permlink]),
+        getVestingDelegations: (account, from = '', limit = 100) => this.client.database.getVestingDelegations(account, from, limit),
+        getAccountHistory: (account, from = -1, limit = 100) => this.client.database.getAccountHistory(account, from, limit),
+        getOrderBook: (limit = 50) => this.client.call('condenser_api', 'get_order_book', [limit]),
+        getOpenOrders: (account) => this.client.call('condenser_api', 'get_open_orders', [account]),
+        getRCMana: (account) => this.client.rc.getRCMana(account),
+        getVPMana: (account) => this.client.rc.getVPMana(account),
+        findRCAccounts: (accounts) => this.client.rc.findRCAccounts(accounts),
+        getCommunity: (name) => this.client.call('bridge', 'get_community', { name }),
+        listCommunities: (options = {}) => this.client.call('bridge', 'list_communities', { limit: 100, ...options }),
+        getAccountNotifications: (account, options = {}) => this.client.call('bridge', 'account_notifications', { account, limit: 50, ...options }),
+        listAllSubscriptions: (account) => this.client.call('bridge', 'list_all_subscriptions', { account }),
+        findTransaction: (transactionId) => this.client.transaction.findTransaction(transactionId),
+        getWitnessByAccount: (account) => this.client.call('condenser_api', 'get_witness_by_account', [account]),
+        getWitnesses: (ids) => this.client.call('condenser_api', 'get_witnesses', [ids]),
+        getWitnessesByVote: (from, limit) => this.client.call('condenser_api', 'get_witnesses_by_vote', [from, limit]),
+        getBlock: (blockNumber) => this.client.database.getBlock(blockNumber),
+        getBlockHeader: (blockNumber) => this.client.database.getBlockHeader(blockNumber),
+        getOperations: (blockNumber, onlyVirtual = false) => this.client.database.getOperations(blockNumber, onlyVirtual),
+        getConfig: () => this.client.database.getConfig(),
+        lookupAccounts: (lowerBound, limit) => this.client.call('condenser_api', 'lookup_accounts', [lowerBound, limit]),
+        lookupWitnessAccounts: (lowerBound, limit) => this.client.call('condenser_api', 'lookup_witness_accounts', [lowerBound, limit]),
+        getConversionRequests: (account) => this.client.call('condenser_api', 'get_conversion_requests', [account]),
+        getCollateralizedConversionRequests: (account) => this.client.call('condenser_api', 'get_collateralized_conversion_requests', [account]),
+        getSavingsWithdrawFrom: (account) => this.client.call('condenser_api', 'get_savings_withdraw_from', [account]),
+        getProposals: (options = {}) => this.client.call('condenser_api', 'list_proposals', [
+            options.start || '',
+            options.limit || 100,
+            options.order || 'by_total_votes',
+            options.order_direction || 'descending',
+            options.status || 'votable'
+        ]),
+    };
+    engine = {
+        getTokenBalances: (account) => this.hive.find('tokens', 'balances', { account }),
+        getTokenBalance: (account, symbol) => this.hive.findOne('tokens', 'balances', { account, symbol }),
+        getToken: (symbol) => this.hive.findOne('tokens', 'tokens', { symbol }),
+        getTokens: (query = {}, limit = 1000, offset = 0) => this.hive.find('tokens', 'tokens', query, limit, offset),
+        getMarketBuyBook: (symbol, limit = 100, offset = 0) => this.hive.find('market', 'buyBook', { symbol }, limit, offset, [{ index: 'priceDec', descending: true }]),
+        getMarketSellBook: (symbol, limit = 100, offset = 0) => this.hive.find('market', 'sellBook', { symbol }, limit, offset, [{ index: 'priceDec', descending: false }]),
+        getMarketHistory: (symbol, limit = 100, offset = 0) => this.hive.find('market', 'tradesHistory', { symbol }, limit, offset, [{ index: '_id', descending: true }]),
+        getMarketMetrics: (query = {}) => this.hive.find('market', 'metrics', query),
+        getNFT: (symbol) => this.hive.findOne('nft', 'nfts', { symbol }),
+        getNFTInstances: (symbol, query = {}, limit = 100, offset = 0) => this.hive.find('nft', `${symbol}instances`, query, limit, offset),
+        getNFTBalance: (account, symbol) => this.hive.find('nft', `${symbol}instances`, { account }),
+        getNFTSellBook: (symbol, limit = 100, offset = 0) => this.hive.find('nftmarket', `${symbol}sellBook`, {}, limit, offset),
+        getPendingUnstakes: (account, symbol) => {
+            const query = { account };
+            if (symbol) {
+                query.symbol = symbol;
+            }
+            return this.hive.find('tokens', 'pendingUnstakes', query);
+        },
+        getDelegations: (from, symbol) => this.hive.find('tokens', 'delegations', { from, symbol }),
+        getContractInfo: (name) => this.hive.getContractInfo(name),
+        find: (contract, table, query, limit = 1000, offset = 0) => this.hive.find(contract, table, query, limit, offset),
+        findOne: (contract, table, query) => this.hive.findOne(contract, table, query),
     };
     constructor(userConfig = {}) {
         this.config = (0, config_1.createConfig)(userConfig);
@@ -156,7 +279,7 @@ class Streamer {
         let amount = '';
         let asset = '';
         try {
-            const parsed = utils_2.Utils.parseAssetAmount(rawAmount);
+            const parsed = utils_1.Utils.parseAssetAmount(rawAmount);
             amount = parsed.amount;
             asset = parsed.asset;
         }
@@ -214,6 +337,10 @@ class Streamer {
                 has: (key) => store.has(key),
                 add: (key) => {
                     store.add(key);
+                    if (store.size > 10000) {
+                        const oldest = store.values().next().value;
+                        store.delete(oldest);
+                    }
                 }
             };
         }
@@ -334,7 +461,7 @@ class Streamer {
         }
         if ('group' in route) {
             const weights = this.resolveGroupWeights(route, routeIndex);
-            const amounts = utils_2.Utils.splitAmountByWeights(amount, weights);
+            const amounts = utils_1.Utils.splitAmountByWeights(amount, weights);
             return route.group.map((recipient, groupIndex) => {
                 const destination = typeof recipient.account === 'function' ? recipient.account(event) : recipient.account;
                 if (typeof destination !== 'string' || destination.trim().length === 0) {
@@ -373,7 +500,7 @@ class Streamer {
         if (!Array.isArray(routes) || routes.length === 0) {
             throw new Error('At least one flow route is required');
         }
-        const parsed = utils_2.Utils.parseAssetAmount(event.transfer.rawAmount);
+        const parsed = utils_1.Utils.parseAssetAmount(event.transfer.rawAmount);
         if (Array.isArray(allowedSymbols) && allowedSymbols.length > 0 && !allowedSymbols.includes(parsed.asset)) {
             throw new Error(`Asset '${parsed.asset}' is not allowed for this flow`);
         }
@@ -387,11 +514,11 @@ class Streamer {
         let onTopRouteAmounts = [];
         if (onTopRoutes.length > 0) {
             const onTopAllocations = this.normalizeOnTopRouteAllocations(onTopRoutes);
-            const pools = utils_2.Utils.splitAmountByWeights(parsed.value, [10000, ...onTopAllocations]);
+            const pools = utils_1.Utils.splitAmountByWeights(parsed.value, [10000, ...onTopAllocations]);
             baseAmount = pools[0];
             onTopRouteAmounts = pools.slice(1);
         }
-        const baseRouteAmounts = utils_2.Utils.splitAmountByBasisPoints(baseAmount, baseAllocations);
+        const baseRouteAmounts = utils_1.Utils.splitAmountByBasisPoints(baseAmount, baseAllocations);
         const routesPlan = routes.flatMap((route, index) => {
             const memo = this.resolvePlannedRouteMemo(event, route, index, defaultMemo);
             const amount = this.resolveFlowMode(route) === 'base'
@@ -401,7 +528,7 @@ class Streamer {
         });
         const onTopPlannedRoutes = routesPlan.filter((route) => route.mode === 'onTop');
         return {
-            incomingAmount: utils_2.Utils.formatAssetAmount(parsed.value, parsed.asset),
+            incomingAmount: utils_1.Utils.formatAssetAmount(parsed.value, parsed.asset),
             asset: parsed.asset,
             baseAmount,
             onTopAmount: this.sumPlannedRouteAmounts(onTopPlannedRoutes),
@@ -427,11 +554,11 @@ class Streamer {
     }
     calculateSingleFlowAmount(transfer, basisPoints, allowedSymbols, errorContext) {
         const rawAmount = typeof transfer === 'string' ? transfer : transfer?.amount || '';
-        const parsed = utils_2.Utils.parseAssetAmount(rawAmount);
+        const parsed = utils_1.Utils.parseAssetAmount(rawAmount);
         if (Array.isArray(allowedSymbols) && allowedSymbols.length > 0 && !allowedSymbols.includes(parsed.asset)) {
             throw new Error(`Asset '${parsed.asset}' is not allowed for ${errorContext}`);
         }
-        const amount = basisPoints === null ? parsed.amount : utils_2.Utils.calculateBasisPointsAmount(parsed.value, basisPoints);
+        const amount = basisPoints === null ? parsed.amount : utils_1.Utils.calculateBasisPointsAmount(parsed.value, basisPoints);
         if (amount === '0.000') {
             throw new Error('Route amount must be greater than zero');
         }
@@ -775,7 +902,7 @@ class Streamer {
         await this.blockProvider.destroy?.();
         this.adapterInitialized = false;
         this.adapterInitializationPromise = null;
-        await (0, utils_1.sleep)(25);
+        await utils_1.Utils.sleep(25);
     }
     async startApiServer(port = this.config.API_PORT) {
         await this.ensureAdapterReady();
@@ -842,7 +969,7 @@ class Streamer {
                 console.log(`Head block number: `, props.head_block_number);
                 console.log(`Last block number: `, this.lastBlockNumber);
             }
-            const BLOCKS_BEHIND = parseInt(this.config.BLOCKS_BEHIND_WARNING, 10);
+            const BLOCKS_BEHIND = this.config.BLOCKS_BEHIND_WARNING;
             const maxBatchSize = Math.max(1, this.config.CATCH_UP_BATCH_SIZE || 1);
             const blocksBehind = Math.max(0, props.head_block_number - this.lastBlockNumber);
             const blocksToProcess = Math.min(blocksBehind, maxBatchSize);
@@ -896,7 +1023,7 @@ class Streamer {
         }
         // The block doesn't exist, wait and try again
         if (!block) {
-            await utils_2.Utils.sleep(this.config.BLOCK_CHECK_INTERVAL);
+            await utils_1.Utils.sleep(this.config.BLOCK_CHECK_INTERVAL);
             return;
         }
         // Get the block date and time
@@ -908,11 +1035,15 @@ class Streamer {
         }
         this.blockId = block.block_id;
         this.previousBlockId = block.previous;
-        this.transactionId = block.transaction_ids[1];
+        this.transactionId = block.transaction_ids[0];
         this.blockTime = blockTime;
         if (this.adapter?.processBlock) {
-            this.adapter.processBlock(block);
+            await this.adapter.processBlock(block);
         }
+        // Fire onBlock subscribers
+        this.blockSubscriptions.forEach(sub => {
+            sub.callback(block, this.lastBlockNumber);
+        });
         // Hive operations are order-sensitive, so process them sequentially.
         const transactions = block.transactions;
         const transactionIds = block.transaction_ids;
@@ -935,6 +1066,30 @@ class Streamer {
         }
         this.lastBlockNumber = blockNumber;
         this.saveStateThrottled();
+        this.cleanupCaches();
+    }
+    cleanupCaches() {
+        const now = Date.now();
+        if (now - this.lastCacheCleanup < 60000) {
+            return;
+        }
+        this.lastCacheCleanup = now;
+        if (this.blockCache.size > 100) {
+            const entriesToRemove = this.blockCache.size - 100;
+            const iterator = this.blockCache.keys();
+            for (let i = 0; i < entriesToRemove; i++) {
+                const key = iterator.next().value;
+                this.blockCache.delete(key);
+            }
+        }
+        for (const [key, value] of this.accountCache) {
+            if (now - value.timestamp > this.cacheTimeout) {
+                this.accountCache.delete(key);
+            }
+        }
+        if (this.transactionCache.size > this.maxCacheSize) {
+            this.transactionCache.clear();
+        }
     }
     async processOperation(op, blockNumber, blockId, prevBlockId, trxId, blockTime) {
         const operationType = op[0];
@@ -949,6 +1104,10 @@ class Streamer {
         if (this.adapter?.processOperation) {
             await this.adapter.processOperation(op, blockNumber, blockId, prevBlockId, trxId, blockTime);
         }
+        // Fire onAnyOperation subscribers
+        this.anyOperationSubscriptions.forEach(sub => {
+            sub.callback(op, blockNumber, blockId, prevBlockId, trxId, blockTime);
+        });
         // Operation is a "comment" which could either be a post or comment
         if (operationType === 'comment') {
             // This is a post
@@ -971,7 +1130,7 @@ class Streamer {
             let amount = '';
             let asset = '';
             try {
-                const parsedAmount = utils_2.Utils.parseAssetAmount(String(rawAmount || ''));
+                const parsedAmount = utils_1.Utils.parseAssetAmount(String(rawAmount || ''));
                 amount = parsedAmount.amount;
                 asset = parsedAmount.asset;
             }
@@ -987,7 +1146,7 @@ class Streamer {
                 asset,
                 memo: operationData?.memo
             };
-            const json = utils_2.Utils.jsonParse(operationData.memo);
+            const json = utils_1.Utils.jsonParse(operationData.memo);
             const payload = this.normalizeContractPayload(json?.[this.config.PAYLOAD_IDENTIFIER]);
             if (payload) {
                 if (this?.adapter?.processTransfer) {
@@ -1024,7 +1183,7 @@ class Streamer {
                 sender = operationData.required_posting_auths[0];
                 isSignedWithActiveKey = false;
             }
-            const json = utils_2.Utils.jsonParse(operationData.json);
+            const json = utils_1.Utils.jsonParse(operationData.json);
             const payload = id === this.config.JSON_ID
                 ? this.normalizeContractPayload(json?.[this.config.PAYLOAD_IDENTIFIER])
                 : null;
@@ -1064,7 +1223,7 @@ class Streamer {
                 let hasVerificationErrors = false;
                 try {
                     const txInfo = await this.hive.getTransactionInfo(trxId);
-                    const logs = txInfo && txInfo.logs ? utils_2.Utils.jsonParse(txInfo.logs) : null;
+                    const logs = txInfo && txInfo.logs ? utils_1.Utils.jsonParse(txInfo.logs) : null;
                     hasVerificationErrors = Boolean(txInfo && logs && typeof logs.errors !== 'undefined');
                 }
                 catch (e) {
@@ -1080,7 +1239,7 @@ class Streamer {
         // Recurrent transfers carry payloads in memo, similar to transfer.
         if (operationType === 'recurrent_transfer') {
             const sender = operationData?.from;
-            const json = utils_2.Utils.jsonParse(operationData?.memo);
+            const json = utils_1.Utils.jsonParse(operationData?.memo);
             const payload = this.normalizeContractPayload(json?.[this.config.PAYLOAD_IDENTIFIER]);
             if (payload) {
                 const context = this.buildContractContext('recurrent_transfer', blockNumber, blockId, prevBlockId, trxId, blockTime, {
@@ -1100,7 +1259,7 @@ class Streamer {
                 await this.adapter.processEscrow(operationType, operationData, operationMetadata);
             }
             if (operationType === 'escrow_transfer') {
-                const jsonMeta = utils_2.Utils.jsonParse(operationData?.json_meta);
+                const jsonMeta = utils_1.Utils.jsonParse(operationData?.json_meta);
                 const payload = this.normalizeContractPayload(jsonMeta?.[this.config.PAYLOAD_IDENTIFIER]);
                 if (payload) {
                     const context = this.buildContractContext('escrow_transfer', blockNumber, blockId, prevBlockId, trxId, blockTime, {
@@ -1120,6 +1279,89 @@ class Streamer {
                 }
             });
         }
+        // Vote operations
+        if (operationType === 'vote') {
+            this.voteSubscriptions.forEach(sub => {
+                sub.callback(operationData, blockNumber, blockId, prevBlockId, trxId, blockTime);
+            });
+        }
+        // Delegation operations
+        if (operationType === 'delegate_vesting_shares') {
+            this.delegateSubscriptions.forEach(sub => {
+                sub.callback(operationData, blockNumber, blockId, prevBlockId, trxId, blockTime);
+            });
+        }
+        // Power up (transfer_to_vesting)
+        if (operationType === 'transfer_to_vesting') {
+            this.powerUpSubscriptions.forEach(sub => {
+                sub.callback(operationData, blockNumber, blockId, prevBlockId, trxId, blockTime);
+            });
+        }
+        // Power down (withdraw_vesting)
+        if (operationType === 'withdraw_vesting') {
+            this.powerDownSubscriptions.forEach(sub => {
+                sub.callback(operationData, blockNumber, blockId, prevBlockId, trxId, blockTime);
+            });
+        }
+        // Claim reward balance
+        if (operationType === 'claim_reward_balance') {
+            this.claimRewardsSubscriptions.forEach(sub => {
+                sub.callback(operationData, blockNumber, blockId, prevBlockId, trxId, blockTime);
+            });
+        }
+        // Witness vote
+        if (operationType === 'account_witness_vote') {
+            this.witnessVoteSubscriptions.forEach(sub => {
+                sub.callback(operationData, blockNumber, blockId, prevBlockId, trxId, blockTime);
+            });
+        }
+        // Follow/unfollow/mute/reblog via custom_json with id 'follow'
+        if (operationType === 'custom_json' && operationData?.id === 'follow') {
+            const json = utils_1.Utils.jsonParse(operationData.json);
+            if (Array.isArray(json) && json.length === 2) {
+                const [type, payload] = json;
+                if (type === 'follow' && payload && (this.followSubscriptions.length > 0)) {
+                    this.followSubscriptions.forEach(sub => {
+                        sub.callback(payload, blockNumber, blockId, prevBlockId, trxId, blockTime);
+                    });
+                }
+                if (type === 'reblog' && payload && (this.reblogSubscriptions.length > 0)) {
+                    this.reblogSubscriptions.forEach(sub => {
+                        sub.callback(payload, blockNumber, blockId, prevBlockId, trxId, blockTime);
+                    });
+                }
+            }
+        }
+        // Account updates
+        if (operationType === 'account_update' || operationType === 'account_update2') {
+            this.accountUpdateSubscriptions.forEach(sub => {
+                sub.callback(operationData, blockNumber, blockId, prevBlockId, trxId, blockTime);
+            });
+        }
+        // Delete comment
+        if (operationType === 'delete_comment') {
+            this.deleteCommentSubscriptions.forEach(sub => {
+                sub.callback(operationData, blockNumber, blockId, prevBlockId, trxId, blockTime);
+            });
+        }
+        // Limit orders
+        if (operationType === 'limit_order_create' || operationType === 'limit_order_create2' || operationType === 'limit_order_cancel') {
+            this.limitOrderSubscriptions.forEach(sub => {
+                sub.callback(operationData, blockNumber, blockId, prevBlockId, trxId, blockTime);
+            });
+        }
+        // Savings transfers
+        if (operationType === 'transfer_to_savings' || operationType === 'transfer_from_savings' || operationType === 'cancel_transfer_from_savings') {
+            this.savingsSubscriptions.forEach(sub => {
+                sub.callback(operationData, blockNumber, blockId, prevBlockId, trxId, blockTime);
+            });
+        }
+        // Convert operations
+        if (operationType === 'convert' || operationType === 'collateralized_convert') {
+            this.convertSubscriptions.forEach(sub => {
+                sub.callback(operationData, blockNumber, blockId, prevBlockId, trxId, blockTime);
+            });
+        }
     }
     normalizeContractPayload(payload) {
         if (!payload || typeof payload !== 'object') {
@@ -1358,24 +1600,24 @@ class Streamer {
         }
     }
     saveToHiveApi(from, data) {
-        return utils_2.Utils.transferHiveTokens(this.client, this.config, from, 'hiveapi', '0.001', 'HIVE', data);
+        return utils_1.Utils.transferHiveTokens(this.client, this.config, from, 'hiveapi', '0.001', 'HIVE', data);
     }
     getAccountTransfers(account, from = -1, limit = 100) {
-        return utils_2.Utils.getAccountTransfers(this.client, account, from, limit);
+        return utils_1.Utils.getAccountTransfers(this.client, account, from, limit);
     }
     transferHiveTokens(from, to, amount, symbol, memo = '') {
-        return utils_2.Utils.transferHiveTokens(this.client, this.config, from, to, amount, symbol, memo);
+        return utils_1.Utils.transferHiveTokens(this.client, this.config, from, to, amount, symbol, memo);
     }
     burnHiveTokens(from, amount, symbol, memo = '') {
-        return utils_2.Utils.burnHiveTokens(this.client, this.config, from, amount, symbol, memo);
+        return utils_1.Utils.burnHiveTokens(this.client, this.config, from, amount, symbol, memo);
     }
     burnTransferPortion(from, transfer, basisPoints, memo = '', allowedSymbols = ['HIVE', 'HBD']) {
         const rawAmount = typeof transfer === 'string' ? transfer : transfer?.amount || '';
-        const parsed = utils_2.Utils.parseAssetAmount(rawAmount);
+        const parsed = utils_1.Utils.parseAssetAmount(rawAmount);
         if (Array.isArray(allowedSymbols) && allowedSymbols.length > 0 && !allowedSymbols.includes(parsed.asset)) {
             throw new Error(`Asset '${parsed.asset}' is not allowed for burn`);
         }
-        const burnAmount = utils_2.Utils.calculateBasisPointsAmount(parsed.value, basisPoints);
+        const burnAmount = utils_1.Utils.calculateBasisPointsAmount(parsed.value, basisPoints);
         if (burnAmount === '0.000') {
             throw new Error('Burn amount must be greater than zero');
         }
@@ -1383,11 +1625,11 @@ class Streamer {
     }
     burnTransferPercentage(from, transfer, percentage, memo = '', allowedSymbols = ['HIVE', 'HBD']) {
         const rawAmount = typeof transfer === 'string' ? transfer : transfer?.amount || '';
-        const parsed = utils_2.Utils.parseAssetAmount(rawAmount);
+        const parsed = utils_1.Utils.parseAssetAmount(rawAmount);
         if (Array.isArray(allowedSymbols) && allowedSymbols.length > 0 && !allowedSymbols.includes(parsed.asset)) {
             throw new Error(`Asset '${parsed.asset}' is not allowed for burn`);
         }
-        const burnAmount = utils_2.Utils.calculatePercentageAmount(parsed.value, percentage);
+        const burnAmount = utils_1.Utils.calculatePercentageAmount(parsed.value, percentage);
         if (burnAmount === '0.000') {
             throw new Error('Burn amount must be greater than zero');
         }
@@ -1590,67 +1832,85 @@ class Streamer {
         };
     }
     transferHiveTokensMultiple(from, accounts = [], amount = '0', symbol, memo = '') {
-        return utils_2.Utils.transferHiveTokensMultiple(this.client, this.config, from, accounts, amount, symbol, memo);
+        return utils_1.Utils.transferHiveTokensMultiple(this.client, this.config, from, accounts, amount, symbol, memo);
     }
     broadcastOperations(operations, signingKeys) {
-        return utils_2.Utils.broadcastOperations(this.client, operations, signingKeys || this.config.ACTIVE_KEY);
+        if (signingKeys) {
+            return utils_1.Utils.broadcastOperations(this.client, operations, signingKeys);
+        }
+        // Auto-detect key: use posting key for posting-level ops, active key for active-level ops
+        const activeOps = new Set([
+            'transfer', 'transfer_to_vesting', 'withdraw_vesting', 'delegate_vesting_shares',
+            'transfer_to_savings', 'transfer_from_savings', 'cancel_transfer_from_savings',
+            'convert', 'collateralized_convert', 'limit_order_create', 'limit_order_create2',
+            'limit_order_cancel', 'escrow_transfer', 'escrow_approve', 'escrow_dispute',
+            'escrow_release', 'account_update', 'account_witness_vote', 'account_witness_proxy',
+            'set_withdraw_vesting_route', 'claim_account', 'create_claimed_account',
+            'create_proposal', 'update_proposal_votes', 'remove_proposal', 'recurrent_transfer',
+            'feed_publish'
+        ]);
+        const needsActive = operations.some(([opType]) => activeOps.has(opType));
+        const key = needsActive
+            ? (this.config.ACTIVE_KEY || this.config.POSTING_KEY)
+            : (this.config.POSTING_KEY || this.config.ACTIVE_KEY);
+        return utils_1.Utils.broadcastOperations(this.client, operations, key);
     }
     broadcastMultiSigOperations(operations, signingKeys) {
-        return utils_2.Utils.broadcastMultiSigOperations(this.client, operations, signingKeys);
+        return utils_1.Utils.broadcastMultiSigOperations(this.client, operations, signingKeys);
     }
     createAuthority(keyAuths = [], accountAuths = [], weightThreshold = 1) {
-        return utils_2.Utils.createAuthority(keyAuths, accountAuths, weightThreshold);
+        return utils_1.Utils.createAuthority(keyAuths, accountAuths, weightThreshold);
     }
     updateAccountAuthorities(account, authorityUpdate, signingKeys) {
-        return utils_2.Utils.updateAccountAuthorities(this.client, this.config, account, authorityUpdate, signingKeys);
+        return utils_1.Utils.updateAccountAuthorities(this.client, this.config, account, authorityUpdate, signingKeys);
     }
     escrowTransfer(options, signingKeys) {
-        return utils_2.Utils.escrowTransfer(this.client, this.config, options, signingKeys);
+        return utils_1.Utils.escrowTransfer(this.client, this.config, options, signingKeys);
     }
     escrowApprove(options, signingKeys) {
-        return utils_2.Utils.escrowApprove(this.client, this.config, options, signingKeys);
+        return utils_1.Utils.escrowApprove(this.client, this.config, options, signingKeys);
     }
     escrowDispute(options, signingKeys) {
-        return utils_2.Utils.escrowDispute(this.client, this.config, options, signingKeys);
+        return utils_1.Utils.escrowDispute(this.client, this.config, options, signingKeys);
     }
     escrowRelease(options, signingKeys) {
-        return utils_2.Utils.escrowRelease(this.client, this.config, options, signingKeys);
+        return utils_1.Utils.escrowRelease(this.client, this.config, options, signingKeys);
     }
     recurrentTransfer(options, signingKeys) {
-        return utils_2.Utils.recurrentTransfer(this.client, this.config, options, signingKeys);
+        return utils_1.Utils.recurrentTransfer(this.client, this.config, options, signingKeys);
     }
     createProposal(options, signingKeys) {
-        return utils_2.Utils.createProposal(this.client, this.config, options, signingKeys);
+        return utils_1.Utils.createProposal(this.client, this.config, options, signingKeys);
     }
     updateProposalVotes(options, signingKeys) {
-        return utils_2.Utils.updateProposalVotes(this.client, this.config, options, signingKeys);
+        return utils_1.Utils.updateProposalVotes(this.client, this.config, options, signingKeys);
     }
     removeProposals(options, signingKeys) {
-        return utils_2.Utils.removeProposals(this.client, this.config, options, signingKeys);
+        return utils_1.Utils.removeProposals(this.client, this.config, options, signingKeys);
     }
     transferHiveEngineTokens(from, to, symbol, quantity, memo = '') {
-        return utils_2.Utils.transferHiveEngineTokens(this.client, this.config, from, to, quantity, symbol, memo);
+        return utils_1.Utils.transferHiveEngineTokens(this.client, this.config, from, to, quantity, symbol, memo);
     }
     burnHiveEngineTokens(from, symbol, quantity, memo = '') {
-        return utils_2.Utils.burnHiveEngineTokens(this.client, this.config, from, symbol, quantity, memo);
+        return utils_1.Utils.burnHiveEngineTokens(this.client, this.config, from, symbol, quantity, memo);
     }
     transferHiveEngineTokensMultiple(from, accounts = [], symbol, memo = '', amount = '0') {
-        return utils_2.Utils.transferHiveEngineTokensMultiple(this.client, this.config, from, accounts, symbol, memo, amount);
+        return utils_1.Utils.transferHiveEngineTokensMultiple(this.client, this.config, from, accounts, symbol, memo, amount);
     }
     issueHiveEngineTokens(from, to, symbol, quantity, memo = '') {
-        return utils_2.Utils.issueHiveEngineTokens(this.client, this.config, from, to, symbol, quantity, memo);
+        return utils_1.Utils.issueHiveEngineTokens(this.client, this.config, from, to, symbol, quantity, memo);
     }
     issueHiveEngineTokensMultiple(from, accounts = [], symbol, memo = '', amount = '0') {
-        return utils_2.Utils.issueHiveEngineTokensMultiple(this.client, this.config, from, accounts, symbol, memo, amount);
+        return utils_1.Utils.issueHiveEngineTokensMultiple(this.client, this.config, from, accounts, symbol, memo, amount);
     }
     upvote(votePercentage = '100.0', username, permlink) {
-        return utils_2.Utils.upvote(this.client, this.config, this.username, votePercentage, username, permlink);
+        return utils_1.Utils.upvote(this.client, this.config, this.username, votePercentage, username, permlink);
     }
     downvote(votePercentage = '100.0', username, permlink) {
-        return utils_2.Utils.downvote(this.client, this.config, this.username, votePercentage, username, permlink);
+        return utils_1.Utils.downvote(this.client, this.config, this.username, votePercentage, username, permlink);
     }
     getTransaction(blockNumber, transactionId) {
-        return utils_2.Utils.getTransaction(this.client, blockNumber, transactionId);
+        return utils_1.Utils.getTransaction(this.client, blockNumber, transactionId);
     }
     getStatus() {
         return {
@@ -1664,7 +1924,7 @@ class Streamer {
         };
     }
     verifyTransfer(transaction, from, to, amount) {
-        return utils_2.Utils.verifyTransfer(transaction, from, to, amount);
+        return utils_1.Utils.verifyTransfer(transaction, from, to, amount);
     }
     onComment(callback) {
         this.commentSubscriptions.push({
@@ -1685,7 +1945,7 @@ class Streamer {
     onCustomJson(callback) {
         this.customJsonSubscriptions.push({ callback });
     }
-    onCustomJsonId(callback, id) {
+    onCustomJsonId(id, callback) {
         this.customJsonIdSubscriptions.push({ callback, id });
     }
     onHiveEngine(callback) {
@@ -1703,6 +1963,189 @@ class Streamer {
     onEscrowRelease(callback) {
         this.escrowSubscriptions.push({ type: 'escrow_release', callback });
     }
+    // ─── New Event Subscriptions ────────────────────────────────────────
+    onVote(callback) {
+        this.voteSubscriptions.push({ callback });
+    }
+    onDelegate(callback) {
+        this.delegateSubscriptions.push({ callback });
+    }
+    onPowerUp(callback) {
+        this.powerUpSubscriptions.push({ callback });
+    }
+    onPowerDown(callback) {
+        this.powerDownSubscriptions.push({ callback });
+    }
+    onClaimRewards(callback) {
+        this.claimRewardsSubscriptions.push({ callback });
+    }
+    onAccountWitnessVote(callback) {
+        this.witnessVoteSubscriptions.push({ callback });
+    }
+    // ─── Social Operations ──────────────────────────────────────────────
+    follow(follower, following) {
+        return utils_1.Utils.follow(this.client, this.config, follower, following);
+    }
+    unfollow(follower, following) {
+        return utils_1.Utils.unfollow(this.client, this.config, follower, following);
+    }
+    mute(follower, following) {
+        return utils_1.Utils.mute(this.client, this.config, follower, following);
+    }
+    reblog(account, author, permlink) {
+        return utils_1.Utils.reblog(this.client, this.config, account, author, permlink);
+    }
+    // ─── Staking Operations ─────────────────────────────────────────────
+    powerUp(from, to, amount) {
+        return utils_1.Utils.powerUp(this.client, this.config, from, to, amount);
+    }
+    powerDown(account, vestingShares) {
+        return utils_1.Utils.powerDown(this.client, this.config, account, vestingShares);
+    }
+    cancelPowerDown(account) {
+        return utils_1.Utils.cancelPowerDown(this.client, this.config, account);
+    }
+    delegateVestingShares(delegator, delegatee, vestingShares) {
+        return utils_1.Utils.delegateVestingShares(this.client, this.config, delegator, delegatee, vestingShares);
+    }
+    undelegateVestingShares(delegator, delegatee) {
+        return utils_1.Utils.undelegateVestingShares(this.client, this.config, delegator, delegatee);
+    }
+    // ─── Account Operations ─────────────────────────────────────────────
+    claimRewards(account, rewardHive, rewardHbd, rewardVests) {
+        return utils_1.Utils.claimRewards(this.client, this.config, account, rewardHive, rewardHbd, rewardVests);
+    }
+    witnessVote(account, witness, approve = true) {
+        return utils_1.Utils.witnessVote(this.client, this.config, account, witness, approve);
+    }
+    setProxy(account, proxy) {
+        return utils_1.Utils.setProxy(this.client, this.config, account, proxy);
+    }
+    clearProxy(account) {
+        return utils_1.Utils.clearProxy(this.client, this.config, account);
+    }
+    updateProfile(account, profile) {
+        return utils_1.Utils.updateProfile(this.client, this.config, account, profile);
+    }
+    getAccount(username) {
+        return utils_1.Utils.getAccount(this.client, username);
+    }
+    getAccounts(usernames) {
+        return utils_1.Utils.getAccounts(this.client, usernames);
+    }
+    // ─── Savings Operations ─────────────────────────────────────────────
+    transferToSavings(from, to, amount, symbol, memo = '') {
+        return utils_1.Utils.transferToSavings(this.client, this.config, from, to, amount, symbol, memo);
+    }
+    transferFromSavings(from, to, amount, symbol, requestId = 0, memo = '') {
+        return utils_1.Utils.transferFromSavings(this.client, this.config, from, to, amount, symbol, requestId, memo);
+    }
+    cancelTransferFromSavings(from, requestId) {
+        return utils_1.Utils.cancelTransferFromSavings(this.client, this.config, from, requestId);
+    }
+    // ─── Convert Operations ─────────────────────────────────────────────
+    convert(owner, amount, requestId = 0) {
+        return utils_1.Utils.convert(this.client, this.config, owner, amount, requestId);
+    }
+    collateralizedConvert(owner, amount, requestId = 0) {
+        return utils_1.Utils.collateralizedConvert(this.client, this.config, owner, amount, requestId);
+    }
+    // ─── Content Operations ─────────────────────────────────────────────
+    deleteComment(author, permlink) {
+        return utils_1.Utils.deleteComment(this.client, this.config, author, permlink);
+    }
+    commentOptions(author, permlink, options) {
+        return utils_1.Utils.commentOptions(this.client, this.config, author, permlink, options);
+    }
+    // ─── Market Operations ──────────────────────────────────────────────
+    limitOrderCreate(owner, orderId, amountToSell, minToReceive, fillOrKill = false, expiration, signingKeys) {
+        return utils_1.Utils.limitOrderCreate(this.client, this.config, owner, orderId, amountToSell, minToReceive, fillOrKill, expiration);
+    }
+    limitOrderCancel(owner, orderId, signingKeys) {
+        return utils_1.Utils.limitOrderCancel(this.client, this.config, owner, orderId);
+    }
+    // ─── Vesting Route ──────────────────────────────────────────────────
+    setWithdrawVestingRoute(fromAccount, toAccount, percent, autoVest = false, signingKeys) {
+        return utils_1.Utils.setWithdrawVestingRoute(this.client, this.config, fromAccount, toAccount, percent, autoVest, signingKeys);
+    }
+    // ─── Account Creation ───────────────────────────────────────────────
+    claimAccount(creator, fee = '0.000 HIVE') {
+        return utils_1.Utils.claimAccount(this.client, this.config, creator, fee);
+    }
+    feedPublish(publisher, baseAmount, quoteAmount = '1.000 HIVE') {
+        return utils_1.Utils.feedPublish(this.client, this.config, publisher, baseAmount, quoteAmount);
+    }
+    // ─── Batch Builder ────────────────────────────────────────────────
+    batch() {
+        return new builders_1.HiveBatchBuilder(this);
+    }
+    // ─── Authority Management ───────────────────────────────────────────
+    hasPostingAuth(account, authAccount) {
+        return utils_1.Utils.hasPostingAuth(this.client, account, authAccount);
+    }
+    grantPostingAuth(account, authAccount, signingKeys) {
+        return utils_1.Utils.grantPostingAuth(this.client, this.config, account, authAccount, signingKeys);
+    }
+    revokePostingAuth(account, authAccount, signingKeys) {
+        return utils_1.Utils.revokePostingAuth(this.client, this.config, account, authAccount, signingKeys);
+    }
+    // ─── Additional Event Subscriptions ─────────────────────────────────
+    onFollow(callback) {
+        this.followSubscriptions.push({ callback });
+    }
+    onReblog(callback) {
+        this.reblogSubscriptions.push({ callback });
+    }
+    onAccountUpdate(callback) {
+        this.accountUpdateSubscriptions.push({ callback });
+    }
+    onDeleteComment(callback) {
+        this.deleteCommentSubscriptions.push({ callback });
+    }
+    onLimitOrder(callback) {
+        this.limitOrderSubscriptions.push({ callback });
+    }
+    onSavingsTransfer(callback) {
+        this.savingsSubscriptions.push({ callback });
+    }
+    onConvert(callback) {
+        this.convertSubscriptions.push({ callback });
+    }
+    onBlock(callback) {
+        this.blockSubscriptions.push({ callback });
+    }
+    onAnyOperation(callback) {
+        this.anyOperationSubscriptions.push({ callback });
+    }
+    // ─── Hive Engine Write Operations ───────────────────────────────────
+    stakeEngineTokens(from, to, symbol, quantity) {
+        return utils_1.Utils.stakeEngineTokens(this.client, this.config, from, to, symbol, quantity);
+    }
+    unstakeEngineTokens(from, symbol, quantity) {
+        return utils_1.Utils.unstakeEngineTokens(this.client, this.config, from, symbol, quantity);
+    }
+    buyEngineTokens(from, symbol, quantity, price) {
+        return utils_1.Utils.buyEngineTokens(this.client, this.config, from, symbol, quantity, price);
+    }
+    sellEngineTokens(from, symbol, quantity, price) {
+        return utils_1.Utils.sellEngineTokens(this.client, this.config, from, symbol, quantity, price);
+    }
+    cancelEngineOrder(from, type, orderId) {
+        return utils_1.Utils.cancelEngineOrder(this.client, this.config, from, type, orderId);
+    }
+    delegateEngineTokens(from, to, symbol, quantity) {
+        return utils_1.Utils.delegateEngineTokens(this.client, this.config, from, to, symbol, quantity);
+    }
+    undelegateEngineTokens(from, to, symbol, quantity) {
+        return utils_1.Utils.undelegateEngineTokens(this.client, this.config, from, to, symbol, quantity);
+    }
+    // ─── Community Operations ───────────────────────────────────────────
+    subscribeCommunity(account, community) {
+        return utils_1.Utils.subscribeCommunity(this.client, this.config, account, community);
+    }
+    unsubscribeCommunity(account, community) {
+        return utils_1.Utils.unsubscribeCommunity(this.client, this.config, account, community);
+    }
     // Memory management: cleanup subscriptions
     cleanupSubscriptions() {
         // Limit subscription arrays to prevent memory leaks
@@ -1734,6 +2177,41 @@ class Streamer {
             this.escrowSubscriptions = this.escrowSubscriptions.slice(-this.maxSubscriptions);
             console.warn(`[Streamer] Trimmed escrowSubscriptions to ${this.maxSubscriptions} items`);
         }
+        if (this.voteSubscriptions.length > this.maxSubscriptions) {
+            this.voteSubscriptions = this.voteSubscriptions.slice(-this.maxSubscriptions);
+            console.warn(`[Streamer] Trimmed voteSubscriptions to ${this.maxSubscriptions} items`);
+        }
+        if (this.delegateSubscriptions.length > this.maxSubscriptions) {
+            this.delegateSubscriptions = this.delegateSubscriptions.slice(-this.maxSubscriptions);
+            console.warn(`[Streamer] Trimmed delegateSubscriptions to ${this.maxSubscriptions} items`);
+        }
+        if (this.powerUpSubscriptions.length > this.maxSubscriptions) {
+            this.powerUpSubscriptions = this.powerUpSubscriptions.slice(-this.maxSubscriptions);
+            console.warn(`[Streamer] Trimmed powerUpSubscriptions to ${this.maxSubscriptions} items`);
+        }
+        if (this.powerDownSubscriptions.length > this.maxSubscriptions) {
+            this.powerDownSubscriptions = this.powerDownSubscriptions.slice(-this.maxSubscriptions);
+            console.warn(`[Streamer] Trimmed powerDownSubscriptions to ${this.maxSubscriptions} items`);
+        }
+        if (this.claimRewardsSubscriptions.length > this.maxSubscriptions) {
+            this.claimRewardsSubscriptions = this.claimRewardsSubscriptions.slice(-this.maxSubscriptions);
+            console.warn(`[Streamer] Trimmed claimRewardsSubscriptions to ${this.maxSubscriptions} items`);
+        }
+        if (this.witnessVoteSubscriptions.length > this.maxSubscriptions) {
+            this.witnessVoteSubscriptions = this.witnessVoteSubscriptions.slice(-this.maxSubscriptions);
+            console.warn(`[Streamer] Trimmed witnessVoteSubscriptions to ${this.maxSubscriptions} items`);
+        }
+        const extraArrays = [
+            'followSubscriptions', 'reblogSubscriptions', 'accountUpdateSubscriptions',
+            'deleteCommentSubscriptions', 'limitOrderSubscriptions', 'savingsSubscriptions',
+            'convertSubscriptions'
+        ];
+        for (const name of extraArrays) {
+            if (this[name].length > this.maxSubscriptions) {
+                this[name] = this[name].slice(-this.maxSubscriptions);
+                console.warn(`[Streamer] Trimmed ${name} to ${this.maxSubscriptions} items`);
+            }
+        }
     }
     // Add method to remove specific subscriptions
     removeTransferSubscription(account, callback) {