hive-stream 3.0.3 → 3.0.5

package/dist/streamer.js

@@ -6,10 +6,11 @@ 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 utils_2 = require("./utils");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const utils_1 = require("./utils");
+const builders_1 = require("./builders");
 const config_1 = require("./config");
 const hive_provider_1 = require("./providers/hive-provider");
 const sscjs_1 = __importDefault(require("sscjs"));
@@ -21,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;
@@ -72,7 +88,149 @@ 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_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),
+        autoBurnIncomingTransfers: (options = {}) => this.autoBurnIncomingTransfers(options),
+        autoForwardIncomingTransfers: (options) => this.autoForwardIncomingTransfers(options),
+        autoRefundIncomingTransfers: (options = {}) => this.autoRefundIncomingTransfers(options),
+        autoSplitIncomingTransfers: (options) => this.autoSplitIncomingTransfers(options),
+        autoRouteIncomingTransfers: (options) => this.autoRouteIncomingTransfers(options),
+        planIncomingTransferRoutes: (transfer, options) => this.planIncomingTransferRoutes(transfer, options),
+    };
+    ops = {
+        transfer: () => new builders_1.HiveTransferBuilder(this),
+        burn: () => new builders_1.HiveBurnBuilder(this),
+        escrowTransfer: () => new builders_1.HiveEscrowTransferBuilder(this),
+        recurrentTransfer: () => new builders_1.HiveRecurrentTransferBuilder(this),
+        createProposal: () => new builders_1.HiveProposalBuilder(this),
+        transferEngine: () => new builders_1.HiveEngineTokenTransferBuilder(this),
+        burnEngine: () => new builders_1.HiveEngineTokenBurnBuilder(this),
+        issueEngine: () => new builders_1.HiveEngineTokenIssueBuilder(this),
+        voteProposals: () => new builders_1.HiveProposalVotesBuilder(this),
+        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);
         this.lastBlockNumber = this.config.LAST_BLOCK_NUMBER;
@@ -116,6 +274,299 @@ class Streamer {
             config: this.config
         };
     }
+    createTransferEvent(op, blockNumber, blockId, prevBlockId, trxId, blockTime) {
+        const rawAmount = String(op?.amount || '');
+        let amount = '';
+        let asset = '';
+        try {
+            const parsed = utils_1.Utils.parseAssetAmount(rawAmount);
+            amount = parsed.amount;
+            asset = parsed.asset;
+        }
+        catch (error) {
+            amount = '';
+            asset = '';
+        }
+        return {
+            op,
+            transfer: {
+                from: op?.from || '',
+                to: op?.to || '',
+                rawAmount,
+                amount,
+                asset,
+                memo: op?.memo
+            },
+            block: {
+                number: blockNumber,
+                id: blockId,
+                previousId: prevBlockId,
+                time: blockTime
+            },
+            transaction: {
+                id: trxId
+            }
+        };
+    }
+    normalizeTransferPreviewInput(transfer) {
+        if (typeof transfer === 'object' && transfer !== null && 'transfer' in transfer && 'transaction' in transfer && 'block' in transfer) {
+            return transfer;
+        }
+        const op = typeof transfer === 'string'
+            ? { amount: transfer }
+            : transfer || {};
+        return this.createTransferEvent(op, 0, '', '', '', new Date(0));
+    }
+    resolveAccount(account) {
+        const resolved = account || this.username || this.config.USERNAME;
+        if (!resolved) {
+            throw new Error('Account is required');
+        }
+        return resolved;
+    }
+    async dedupeHas(store, key) {
+        return Boolean(await store.has(key));
+    }
+    async dedupeAdd(store, key) {
+        await store.add(key);
+    }
+    normalizeDedupeStore(dedupeStore) {
+        const store = dedupeStore || new Set();
+        if (store instanceof Set) {
+            return {
+                has: (key) => store.has(key),
+                add: (key) => {
+                    store.add(key);
+                    if (store.size > 10000) {
+                        const oldest = store.values().next().value;
+                        store.delete(oldest);
+                    }
+                }
+            };
+        }
+        return store;
+    }
+    isZeroAmountFlowError(error) {
+        return error instanceof Error
+            && (error.message === 'Burn amount must be greater than zero' || error.message === 'Route amount must be greater than zero');
+    }
+    resolveFlowBasisPoints(options, context, allowUnspecified = true) {
+        const percentage = options.percentage ?? options.percent;
+        const basisPoints = options.basisPoints;
+        if (percentage !== undefined && basisPoints !== undefined) {
+            throw new Error(`${context} accepts either percentage or basisPoints, not both`);
+        }
+        if (percentage === undefined && basisPoints === undefined) {
+            if (allowUnspecified) {
+                return null;
+            }
+            throw new Error(`${context} requires percentage or basisPoints`);
+        }
+        if (basisPoints !== undefined) {
+            if (!Number.isInteger(basisPoints) || basisPoints < 0 || basisPoints > 10000) {
+                throw new Error(`${context} basisPoints must be an integer between 0 and 10000`);
+            }
+            return basisPoints;
+        }
+        const percentageValue = new bignumber_js_1.default(percentage);
+        if (percentageValue.isNaN() || !percentageValue.isFinite()) {
+            throw new Error(`${context} percentage must be a valid number`);
+        }
+        if (percentageValue.lt(0) || percentageValue.gt(100)) {
+            throw new Error(`${context} percentage must be between 0 and 100`);
+        }
+        const bps = percentageValue.multipliedBy(100);
+        if (!bps.isInteger()) {
+            throw new Error(`${context} percentage supports up to 2 decimal places; use basisPoints for finer control`);
+        }
+        return bps.toNumber();
+    }
+    resolveFlowMode(route) {
+        return route.mode === 'onTop' ? 'onTop' : 'base';
+    }
+    normalizeBaseRouteAllocations(routes) {
+        const allocations = routes.map((route, index) => this.resolveFlowBasisPoints(route, `Route ${index + 1}`, true));
+        const unspecified = allocations.filter((allocation) => allocation === null).length;
+        const explicitTotal = allocations.reduce((sum, allocation) => sum + (allocation || 0), 0);
+        if (unspecified > 1) {
+            throw new Error('Only one flow route can omit percentage or basisPoints');
+        }
+        if (explicitTotal > 10000) {
+            throw new Error('Flow route allocations cannot exceed 10000 basis points');
+        }
+        if (unspecified === 0 && explicitTotal !== 10000) {
+            throw new Error('Flow route allocations must total 100%');
+        }
+        if (unspecified === 1) {
+            const remainder = 10000 - explicitTotal;
+            return allocations.map((allocation) => allocation === null ? remainder : allocation);
+        }
+        return allocations;
+    }
+    normalizeOnTopRouteAllocations(routes) {
+        const allocations = routes.map((route, index) => this.resolveFlowBasisPoints(route, `On-top route ${index + 1}`, false));
+        const explicitTotal = allocations.reduce((sum, allocation) => sum + allocation, 0);
+        if (explicitTotal <= 0) {
+            throw new Error('On-top flow route allocations must be greater than zero');
+        }
+        return allocations;
+    }
+    resolvePlannedRouteMemo(event, route, index, defaultMemo) {
+        if (typeof route.memo === 'function') {
+            return route.memo(event);
+        }
+        if (typeof route.memo === 'string') {
+            return route.memo;
+        }
+        if (typeof defaultMemo === 'function') {
+            return defaultMemo(event, route, index);
+        }
+        return defaultMemo || '';
+    }
+    resolveGroupSplitStrategy(route) {
+        if (route.split) {
+            return route.split;
+        }
+        return route.group.some((recipient) => recipient.weight !== undefined) ? 'weighted' : 'equal';
+    }
+    resolveGroupWeights(route, routeIndex) {
+        if (!Array.isArray(route.group) || route.group.length === 0) {
+            throw new Error(`Route ${routeIndex + 1} group must include at least one account`);
+        }
+        if (this.resolveGroupSplitStrategy(route) === 'equal') {
+            return route.group.map(() => 1);
+        }
+        return route.group.map((recipient, groupIndex) => {
+            if (recipient.weight === undefined) {
+                return 1;
+            }
+            const weight = new bignumber_js_1.default(recipient.weight);
+            if (weight.isNaN() || !weight.isFinite() || weight.lte(0)) {
+                throw new Error(`Route ${routeIndex + 1} recipient ${groupIndex + 1} weight must be greater than zero`);
+            }
+            return weight.toString();
+        });
+    }
+    expandPlannedRoute(event, route, routeIndex, amount, asset, memo) {
+        const mode = this.resolveFlowMode(route);
+        if (route.type === 'burn') {
+            return [{
+                    type: 'burn',
+                    mode,
+                    amount,
+                    asset,
+                    memo,
+                    routeIndex
+                }];
+        }
+        if ('group' in route) {
+            const weights = this.resolveGroupWeights(route, routeIndex);
+            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) {
+                    throw new Error(`Route ${routeIndex + 1} recipient ${groupIndex + 1} destination account is required`);
+                }
+                return {
+                    type: 'transfer',
+                    mode,
+                    amount: amounts[groupIndex],
+                    asset,
+                    memo,
+                    to: destination.trim(),
+                    routeIndex,
+                    groupIndex
+                };
+            });
+        }
+        const destination = typeof route.to === 'function' ? route.to(event) : route.to;
+        if (typeof destination !== 'string' || destination.trim().length === 0) {
+            throw new Error(`Route ${routeIndex + 1} destination account is required`);
+        }
+        return [{
+                type: 'transfer',
+                mode,
+                amount,
+                asset,
+                memo,
+                to: destination.trim(),
+                routeIndex
+            }];
+    }
+    sumPlannedRouteAmounts(plan) {
+        return plan.reduce((sum, route) => sum.plus(route.amount), new bignumber_js_1.default(0)).toFixed(3);
+    }
+    buildPlannedIncomingTransferRoutes(event, routes, allowedSymbols, defaultMemo) {
+        if (!Array.isArray(routes) || routes.length === 0) {
+            throw new Error('At least one flow route is required');
+        }
+        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`);
+        }
+        const baseRoutes = routes.filter((route) => this.resolveFlowMode(route) === 'base');
+        const onTopRoutes = routes.filter((route) => this.resolveFlowMode(route) === 'onTop');
+        if (baseRoutes.length === 0) {
+            throw new Error('At least one base flow route is required');
+        }
+        const baseAllocations = this.normalizeBaseRouteAllocations(baseRoutes);
+        let baseAmount = parsed.amount;
+        let onTopRouteAmounts = [];
+        if (onTopRoutes.length > 0) {
+            const onTopAllocations = this.normalizeOnTopRouteAllocations(onTopRoutes);
+            const pools = utils_1.Utils.splitAmountByWeights(parsed.value, [10000, ...onTopAllocations]);
+            baseAmount = pools[0];
+            onTopRouteAmounts = pools.slice(1);
+        }
+        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'
+                ? baseRouteAmounts.shift()
+                : onTopRouteAmounts.shift();
+            return this.expandPlannedRoute(event, route, index, amount, parsed.asset, memo);
+        });
+        const onTopPlannedRoutes = routesPlan.filter((route) => route.mode === 'onTop');
+        return {
+            incomingAmount: utils_1.Utils.formatAssetAmount(parsed.value, parsed.asset),
+            asset: parsed.asset,
+            baseAmount,
+            onTopAmount: this.sumPlannedRouteAmounts(onTopPlannedRoutes),
+            routes: routesPlan
+        };
+    }
+    async executePlannedFlowRoutes(from, plan, ignoreZeroAmount) {
+        const results = [];
+        for (const route of plan) {
+            if (route.amount === '0.000') {
+                if (ignoreZeroAmount) {
+                    continue;
+                }
+                throw new Error('Route amount must be greater than zero');
+            }
+            if (route.type === 'burn') {
+                results.push(await this.burnHiveTokens(from, route.amount, route.asset, route.memo));
+                continue;
+            }
+            results.push(await this.transferHiveTokens(from, route.to, route.amount, route.asset, route.memo));
+        }
+        return results;
+    }
+    calculateSingleFlowAmount(transfer, basisPoints, allowedSymbols, errorContext) {
+        const rawAmount = typeof transfer === 'string' ? transfer : transfer?.amount || '';
+        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_1.Utils.calculateBasisPointsAmount(parsed.value, basisPoints);
+        if (amount === '0.000') {
+            throw new Error('Route amount must be greater than zero');
+        }
+        return {
+            amount,
+            asset: parsed.asset
+        };
+    }
     async initializeContract(contract) {
         if (this.initializedContracts.has(contract.name)) {
             return;
@@ -364,11 +815,16 @@ class Streamer {
      * @param config
      */
     setConfig(config) {
-        const normalized = (0, config_1.normalizeConfigInput)(config);
-        const shouldRecreateClient = normalized.API_NODES !== undefined;
-        const shouldRecreateHiveEngine = normalized.HIVE_ENGINE_API !== undefined;
-        const shouldSyncApiServer = normalized.API_ENABLED !== undefined || normalized.API_PORT !== undefined;
-        Object.assign(this.config, normalized);
+        const normalizedInput = (0, config_1.normalizeConfigInput)(config);
+        const nextConfig = (0, config_1.createConfig)({
+            ...this.config,
+            ...normalizedInput,
+            env: config.env,
+        });
+        const shouldRecreateClient = JSON.stringify(this.config.API_NODES) !== JSON.stringify(nextConfig.API_NODES);
+        const shouldRecreateHiveEngine = this.config.HIVE_ENGINE_API !== nextConfig.HIVE_ENGINE_API;
+        const shouldSyncApiServer = this.config.API_ENABLED !== nextConfig.API_ENABLED || this.config.API_PORT !== nextConfig.API_PORT;
+        Object.assign(this.config, nextConfig);
         // Set keys and username incase they have changed
         this.username = this.config.USERNAME;
         this.postingKey = this.config.POSTING_KEY;
@@ -446,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();
@@ -513,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);
@@ -567,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
@@ -579,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;
@@ -606,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];
@@ -620,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
@@ -639,16 +1127,26 @@ class Streamer {
         if (operationType === 'transfer') {
             const sender = operationData?.from;
             const rawAmount = operationData?.amount;
-            const amountParts = typeof rawAmount === 'string' ? rawAmount.split(' ') : [];
+            let amount = '';
+            let asset = '';
+            try {
+                const parsedAmount = utils_1.Utils.parseAssetAmount(String(rawAmount || ''));
+                amount = parsedAmount.amount;
+                asset = parsedAmount.asset;
+            }
+            catch (error) {
+                amount = '';
+                asset = '';
+            }
             const transferInfo = {
                 from: sender,
                 to: operationData?.to,
                 rawAmount: rawAmount || '',
-                amount: amountParts[0] || '',
-                asset: amountParts[1] || '',
+                amount,
+                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) {
@@ -668,11 +1166,9 @@ class Streamer {
                 });
                 await this.dispatchContractAction(payload, context);
             }
-            this.transferSubscriptions.forEach(sub => {
-                if (sub.account === operationData.to) {
-                    sub.callback(operationData, blockNumber, blockId, prevBlockId, trxId, blockTime);
-                }
-            });
+            await Promise.all(this.transferSubscriptions
+                .filter((sub) => sub.account === operationData.to)
+                .map((sub) => Promise.resolve(sub.callback(operationData, blockNumber, blockId, prevBlockId, trxId, blockTime))));
         }
         // This is a custom JSON operation
         if (operationType === 'custom_json') {
@@ -687,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;
@@ -727,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) {
@@ -743,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, {
@@ -763,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, {
@@ -783,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') {
@@ -1021,73 +1600,317 @@ 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_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_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_1.Utils.calculateBasisPointsAmount(parsed.value, basisPoints);
+        if (burnAmount === '0.000') {
+            throw new Error('Burn amount must be greater than zero');
+        }
+        return this.burnHiveTokens(from, burnAmount, parsed.asset, memo);
+    }
+    burnTransferPercentage(from, transfer, percentage, memo = '', allowedSymbols = ['HIVE', 'HBD']) {
+        const rawAmount = typeof transfer === 'string' ? transfer : transfer?.amount || '';
+        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_1.Utils.calculatePercentageAmount(parsed.value, percentage);
+        if (burnAmount === '0.000') {
+            throw new Error('Burn amount must be greater than zero');
+        }
+        return this.burnHiveTokens(from, burnAmount, parsed.asset, memo);
+    }
+    autoBurnIncomingTransfers(options = {}) {
+        const basisPoints = this.resolveFlowBasisPoints(options, 'autoBurnIncomingTransfers', false);
+        const account = this.resolveAccount(options.account);
+        const normalizedStore = this.normalizeDedupeStore(options.dedupeStore);
+        const allowedSymbols = options.allowedSymbols || ['HIVE', 'HBD'];
+        const ignoreZeroAmount = options.ignoreZeroAmount !== false;
+        const callback = async (op, blockNumber, blockId, prevBlockId, trxId, blockTime) => {
+            const event = this.createTransferEvent(op, blockNumber, blockId, prevBlockId, trxId, blockTime);
+            try {
+                if (await this.dedupeHas(normalizedStore, trxId)) {
+                    return;
+                }
+                const memo = typeof options.memo === 'function' ? options.memo(event) : options.memo || '';
+                const amount = this.calculateSingleFlowAmount(op, basisPoints, allowedSymbols, 'burn');
+                const result = await this.burnHiveTokens(account, amount.amount, amount.asset, memo);
+                await this.dedupeAdd(normalizedStore, trxId);
+                if (options.onBurned) {
+                    await options.onBurned(result, event);
+                }
+            }
+            catch (error) {
+                if (ignoreZeroAmount && this.isZeroAmountFlowError(error)) {
+                    return;
+                }
+                if (options.onError) {
+                    await options.onError(error, event);
+                    return;
+                }
+                throw error;
+            }
+        };
+        this.onTransfer(account, callback);
+        return {
+            account,
+            stop: () => {
+                this.removeTransferSubscription(account, callback);
+            }
+        };
+    }
+    autoForwardIncomingTransfers(options) {
+        if (!options || typeof options.to !== 'string' || options.to.trim().length === 0) {
+            throw new Error('autoForwardIncomingTransfers requires a destination account');
+        }
+        const account = this.resolveAccount(options.account);
+        const normalizedStore = this.normalizeDedupeStore(options.dedupeStore);
+        const allowedSymbols = options.allowedSymbols || ['HIVE', 'HBD'];
+        const ignoreZeroAmount = options.ignoreZeroAmount !== false;
+        const basisPoints = this.resolveFlowBasisPoints(options, 'autoForwardIncomingTransfers', true);
+        const destination = options.to.trim();
+        const callback = async (op, blockNumber, blockId, prevBlockId, trxId, blockTime) => {
+            const event = this.createTransferEvent(op, blockNumber, blockId, prevBlockId, trxId, blockTime);
+            try {
+                if (await this.dedupeHas(normalizedStore, trxId)) {
+                    return;
+                }
+                const memo = typeof options.memo === 'function' ? options.memo(event) : options.memo || '';
+                const amount = this.calculateSingleFlowAmount(op, basisPoints, allowedSymbols, 'forward');
+                const result = await this.transferHiveTokens(account, destination, amount.amount, amount.asset, memo);
+                await this.dedupeAdd(normalizedStore, trxId);
+                if (options.onForwarded) {
+                    await options.onForwarded(result, event);
+                }
+            }
+            catch (error) {
+                if (ignoreZeroAmount && this.isZeroAmountFlowError(error)) {
+                    return;
+                }
+                if (options.onError) {
+                    await options.onError(error, event);
+                    return;
+                }
+                throw error;
+            }
+        };
+        this.onTransfer(account, callback);
+        return {
+            account,
+            stop: () => {
+                this.removeTransferSubscription(account, callback);
+            }
+        };
+    }
+    autoRefundIncomingTransfers(options = {}) {
+        const account = this.resolveAccount(options.account);
+        const normalizedStore = this.normalizeDedupeStore(options.dedupeStore);
+        const allowedSymbols = options.allowedSymbols || ['HIVE', 'HBD'];
+        const ignoreZeroAmount = options.ignoreZeroAmount !== false;
+        const basisPoints = this.resolveFlowBasisPoints(options, 'autoRefundIncomingTransfers', true);
+        const callback = async (op, blockNumber, blockId, prevBlockId, trxId, blockTime) => {
+            const event = this.createTransferEvent(op, blockNumber, blockId, prevBlockId, trxId, blockTime);
+            try {
+                if (await this.dedupeHas(normalizedStore, trxId)) {
+                    return;
+                }
+                const memo = typeof options.memo === 'function' ? options.memo(event) : options.memo || '';
+                const amount = this.calculateSingleFlowAmount(op, basisPoints, allowedSymbols, 'refund');
+                const result = await this.transferHiveTokens(account, event.transfer.from, amount.amount, amount.asset, memo);
+                await this.dedupeAdd(normalizedStore, trxId);
+                if (options.onRefunded) {
+                    await options.onRefunded(result, event);
+                }
+            }
+            catch (error) {
+                if (ignoreZeroAmount && this.isZeroAmountFlowError(error)) {
+                    return;
+                }
+                if (options.onError) {
+                    await options.onError(error, event);
+                    return;
+                }
+                throw error;
+            }
+        };
+        this.onTransfer(account, callback);
+        return {
+            account,
+            stop: () => {
+                this.removeTransferSubscription(account, callback);
+            }
+        };
+    }
+    autoSplitIncomingTransfers(options) {
+        if (!options || !Array.isArray(options.recipients) || options.recipients.length === 0) {
+            throw new Error('autoSplitIncomingTransfers requires at least one recipient');
+        }
+        const defaultMemo = options.memo;
+        return this.autoRouteIncomingTransfers({
+            account: options.account,
+            routes: options.recipients.map((recipient, index) => ({
+                to: recipient.account,
+                percentage: recipient.percentage,
+                percent: recipient.percent,
+                basisPoints: recipient.basisPoints,
+                memo: recipient.memo || (typeof defaultMemo === 'function'
+                    ? (event) => defaultMemo(event, { account: recipient.account }, index)
+                    : defaultMemo)
+            })),
+            allowedSymbols: options.allowedSymbols,
+            dedupeStore: options.dedupeStore,
+            ignoreZeroAmount: options.ignoreZeroAmount,
+            onRouted: async (results, event, plan) => {
+                if (options.onSplit) {
+                    await options.onSplit(results, event, plan);
+                }
+            },
+            onError: options.onError
+        });
+    }
+    planIncomingTransferRoutes(transfer, options) {
+        if (!options || !Array.isArray(options.routes) || options.routes.length === 0) {
+            throw new Error('planIncomingTransferRoutes requires at least one route');
+        }
+        const event = this.normalizeTransferPreviewInput(transfer);
+        const allowedSymbols = options.allowedSymbols || ['HIVE', 'HBD'];
+        return this.buildPlannedIncomingTransferRoutes(event, options.routes, allowedSymbols, options.memo);
+    }
+    autoRouteIncomingTransfers(options) {
+        if (!options || !Array.isArray(options.routes) || options.routes.length === 0) {
+            throw new Error('autoRouteIncomingTransfers requires at least one route');
+        }
+        const account = this.resolveAccount(options.account);
+        const normalizedStore = this.normalizeDedupeStore(options.dedupeStore);
+        const allowedSymbols = options.allowedSymbols || ['HIVE', 'HBD'];
+        const ignoreZeroAmount = options.ignoreZeroAmount !== false;
+        const callback = async (op, blockNumber, blockId, prevBlockId, trxId, blockTime) => {
+            const event = this.createTransferEvent(op, blockNumber, blockId, prevBlockId, trxId, blockTime);
+            try {
+                if (await this.dedupeHas(normalizedStore, trxId)) {
+                    return;
+                }
+                const plan = this.buildPlannedIncomingTransferRoutes(event, options.routes, allowedSymbols, options.memo);
+                const results = await this.executePlannedFlowRoutes(account, plan.routes, ignoreZeroAmount);
+                await this.dedupeAdd(normalizedStore, trxId);
+                if (options.onRouted) {
+                    await options.onRouted(results, event, plan.routes);
+                }
+            }
+            catch (error) {
+                if (ignoreZeroAmount && this.isZeroAmountFlowError(error)) {
+                    return;
+                }
+                if (options.onError) {
+                    await options.onError(error, event);
+                    return;
+                }
+                throw error;
+            }
+        };
+        this.onTransfer(account, callback);
+        return {
+            account,
+            stop: () => {
+                this.removeTransferSubscription(account, callback);
+            }
+        };
     }
     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_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 {
@@ -1101,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({
@@ -1122,7 +1945,7 @@ class Streamer {
     onCustomJson(callback) {
         this.customJsonSubscriptions.push({ callback });
     }
-    onCustomJsonId(callback, id) {
+    onCustomJsonId(id, callback) {
         this.customJsonIdSubscriptions.push({ callback, id });
     }
     onHiveEngine(callback) {
@@ -1140,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
@@ -1171,10 +2177,53 @@ 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) {
-        this.transferSubscriptions = this.transferSubscriptions.filter(sub => sub.account !== account);
+    removeTransferSubscription(account, callback) {
+        this.transferSubscriptions = this.transferSubscriptions.filter((sub) => {
+            if (sub.account !== account) {
+                return true;
+            }
+            if (!callback) {
+                return false;
+            }
+            return sub.callback !== callback;
+        });
     }
     removeCustomJsonIdSubscription(id) {
         this.customJsonIdSubscriptions = this.customJsonIdSubscriptions.filter(sub => sub.id !== id);