hive-stream 3.0.3 → 3.0.4

package/dist/streamer.js

@@ -9,7 +9,9 @@ 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 builders_1 = require("./builders");
 const config_1 = require("./config");
 const hive_provider_1 = require("./providers/hive-provider");
 const sscjs_1 = __importDefault(require("sscjs"));
@@ -73,6 +75,39 @@ class Streamer {
     cacheTimeout = 300000; // 5 minutes
     maxCacheSize = 1000;
     utils = utils_2.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),
+    };
+    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'),
+    };
     constructor(userConfig = {}) {
         this.config = (0, config_1.createConfig)(userConfig);
         this.lastBlockNumber = this.config.LAST_BLOCK_NUMBER;
@@ -116,6 +151,295 @@ 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_2.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);
+                }
+            };
+        }
+        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_2.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_2.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_2.Utils.splitAmountByWeights(parsed.value, [10000, ...onTopAllocations]);
+            baseAmount = pools[0];
+            onTopRouteAmounts = pools.slice(1);
+        }
+        const baseRouteAmounts = utils_2.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_2.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_2.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);
+        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 +688,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;
@@ -639,13 +968,23 @@ 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_2.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);
@@ -668,11 +1007,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') {
@@ -1029,6 +1366,229 @@ class Streamer {
     transferHiveTokens(from, to, amount, symbol, memo = '') {
         return utils_2.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);
+    }
+    burnTransferPortion(from, transfer, basisPoints, memo = '', allowedSymbols = ['HIVE', 'HBD']) {
+        const rawAmount = typeof transfer === 'string' ? transfer : transfer?.amount || '';
+        const parsed = utils_2.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);
+        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_2.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);
+        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);
     }
@@ -1071,6 +1631,9 @@ class Streamer {
     transferHiveEngineTokens(from, to, symbol, quantity, memo = '') {
         return utils_2.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);
+    }
     transferHiveEngineTokensMultiple(from, accounts = [], symbol, memo = '', amount = '0') {
         return utils_2.Utils.transferHiveEngineTokensMultiple(this.client, this.config, from, accounts, symbol, memo, amount);
     }
@@ -1173,8 +1736,16 @@ class Streamer {
         }
     }
     // 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);