hive-stream 3.0.2 → 3.0.4

package/dist/streamer.js

@@ -9,8 +9,11 @@ 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"));
 class Streamer {
     customJsonSubscriptions = [];
@@ -39,8 +42,14 @@ class Streamer {
     blockTime;
     latestBlockchainTime;
     disableAllProcessing = false;
+    isStarted = false;
     contracts = [];
+    blockProvider;
     adapter;
+    adapterInitializationPromise = null;
+    adapterInitialized = false;
+    initializedContracts = new Set();
+    apiServer = null;
     actions = [];
     // Performance optimization properties
     lastStateSave = Date.now();
@@ -66,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;
@@ -74,23 +116,388 @@ class Streamer {
         this.activeKey = this.config.ACTIVE_KEY;
         this.hive = new sscjs_1.default(this.config.HIVE_ENGINE_API);
         this.client = new dhive_1.Client(this.config.API_NODES);
-        if (process?.env?.NODE_ENV !== 'test') {
-            this._initializeAdapter(new sqlite_adapter_1.SqliteAdapter());
-            new api_1.Api(this);
+        this.adapter = new sqlite_adapter_1.SqliteAdapter();
+        if (userConfig.blockProvider) {
+            this.blockProvider = userConfig.blockProvider;
+        }
+        else {
+            this.blockProvider = new hive_provider_1.HiveProvider({ apiNodes: this.config.API_NODES });
+        }
+    }
+    async ensureAdapterReady() {
+        if (this.adapterInitialized) {
+            return;
+        }
+        if (!this.adapter) {
+            throw new Error('No adapter registered');
+        }
+        if (!this.adapterInitializationPromise) {
+            this.adapterInitializationPromise = Promise.resolve(this.adapter.create?.())
+                .then(() => {
+                this.adapterInitialized = true;
+            })
+                .catch((error) => {
+                this.adapterInitializationPromise = null;
+                this.adapterInitialized = false;
+                throw error;
+            });
+        }
+        await this.adapterInitializationPromise;
+    }
+    getLifecycleContext() {
+        return {
+            streamer: this,
+            adapter: this.adapter,
+            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;
+        }
+        await this.ensureAdapterReady();
+        if (contract.hooks?.create) {
+            await contract.hooks.create(this.getLifecycleContext());
+        }
+        this.initializedContracts.add(contract.name);
+    }
+    async initializeContracts() {
+        for (const contract of this.contracts) {
+            await this.initializeContract(contract);
+        }
+    }
+    async destroyContractLifecycle(contract) {
+        if (!this.initializedContracts.has(contract.name)) {
+            return;
+        }
+        if (contract.hooks?.destroy) {
+            await contract.hooks.destroy(this.getLifecycleContext());
+        }
+        this.initializedContracts.delete(contract.name);
+    }
+    async destroyContracts() {
+        for (const contract of [...this.contracts]) {
+            await this.destroyContractLifecycle(contract);
+        }
+    }
+    startSubscriptionCleanupInterval() {
+        if (this.subscriptionCleanupInterval) {
+            return;
         }
-        // Start subscription cleanup interval
         this.subscriptionCleanupInterval = setInterval(() => {
             this.cleanupSubscriptions();
-        }, 60000); // Cleanup every minute
+        }, 60000);
     }
-    _initializeAdapter(adapter) {
-        this.adapter = adapter;
-        if (this?.adapter?.create) {
-            this.adapter.create();
+    clearRuntimeTimers() {
+        if (this.blockNumberTimeout) {
+            clearTimeout(this.blockNumberTimeout);
+            this.blockNumberTimeout = null;
+        }
+        if (this.latestBlockTimer) {
+            clearInterval(this.latestBlockTimer);
+            this.latestBlockTimer = null;
         }
+        if (this.subscriptionCleanupInterval) {
+            clearInterval(this.subscriptionCleanupInterval);
+            this.subscriptionCleanupInterval = null;
+        }
+        this.isPollingBlock = false;
     }
     async registerAdapter(adapter) {
-        if (this.adapter && this.adapter.destroy) {
+        if (!adapter) {
+            throw new Error('Adapter must be provided');
+        }
+        await this.destroyContracts();
+        if (this.adapterInitialized && this.adapter?.destroy) {
             try {
                 await this.adapter.destroy();
             }
@@ -99,9 +506,10 @@ class Streamer {
             }
         }
         this.adapter = adapter;
-        if (this?.adapter?.create) {
-            await this.adapter.create();
-        }
+        this.adapterInitialized = false;
+        this.adapterInitializationPromise = null;
+        await this.ensureAdapterReady();
+        await this.initializeContracts();
     }
     getAdapter() {
         return this.adapter;
@@ -113,6 +521,7 @@ class Streamer {
         if (!action || !(action instanceof actions_1.TimeAction)) {
             throw new Error('Invalid action: must be an instance of TimeAction');
         }
+        await this.ensureAdapterReady();
         const loadedActions = await this.adapter.loadActions();
         for (const a of loadedActions) {
             const exists = this.actions.find(i => i.id === a.id);
@@ -217,7 +626,7 @@ class Streamer {
      */
     async saveActionsToDisk() {
         try {
-            if (this.adapter?.saveState) {
+            if (this.adapterInitialized && this.adapter?.saveState) {
                 await this.adapter.saveState({
                     lastBlockNumber: this.lastBlockNumber,
                     actions: this.actions.map(a => a.toJSON())
@@ -258,14 +667,7 @@ class Streamer {
         if (!contract.actions || typeof contract.actions !== 'object') {
             throw new Error(`Contract '${contract.name}' must define actions`);
         }
-        const lifecycleContext = {
-            streamer: this,
-            adapter: this.adapter,
-            config: this.config
-        };
-        if (contract.hooks?.create) {
-            await contract.hooks.create(lifecycleContext);
-        }
+        await this.initializeContract(contract);
         this.contracts.push(contract);
         this.contractCache.set(contract.name, contract);
     }
@@ -273,13 +675,7 @@ class Streamer {
         const contractIndex = this.contracts.findIndex(c => c.name === name);
         if (contractIndex >= 0) {
             const contract = this.contracts[contractIndex];
-            if (contract?.hooks?.destroy) {
-                await contract.hooks.destroy({
-                    streamer: this,
-                    adapter: this.adapter,
-                    config: this.config
-                });
-            }
+            await this.destroyContractLifecycle(contract);
             this.contracts.splice(contractIndex, 1);
             this.contractCache.delete(name);
         }
@@ -292,11 +688,37 @@ class Streamer {
      * @param config
      */
     setConfig(config) {
-        Object.assign(this.config, (0, config_1.normalizeConfigInput)(config));
+        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;
         this.activeKey = this.config.ACTIVE_KEY;
+        if (shouldRecreateClient) {
+            this.client = new dhive_1.Client(this.config.API_NODES);
+            if (this.blockProvider instanceof hive_provider_1.HiveProvider) {
+                this.blockProvider.updateClient(this.config.API_NODES);
+            }
+        }
+        if (shouldRecreateHiveEngine) {
+            this.hive = new sscjs_1.default(this.config.HIVE_ENGINE_API);
+        }
+        if (shouldSyncApiServer && (this.apiServer || this.isStarted)) {
+            const syncApiServer = this.config.API_ENABLED
+                ? this.startApiServer(this.config.API_PORT)
+                : this.stopApiServer();
+            syncApiServer.catch((error) => {
+                console.error('[Streamer] Failed to sync API server after config update:', error);
+            });
+        }
         return this;
     }
     /**
@@ -306,10 +728,17 @@ class Streamer {
      *
      */
     async start() {
+        if (this.isStarted) {
+            return this;
+        }
         if (this.config.DEBUG_MODE) {
             console.log('Starting to stream the Hive blockchain');
         }
         this.disableAllProcessing = false;
+        await this.ensureAdapterReady();
+        await this.blockProvider.create?.();
+        await this.initializeContracts();
+        this.startSubscriptionCleanupInterval();
         const state = await this.adapter.loadState();
         if (this.config.DEBUG_MODE) {
             console.log(`Restoring state from file`);
@@ -320,9 +749,13 @@ class Streamer {
         else if (this.config.LAST_BLOCK_NUMBER) {
             this.lastBlockNumber = this.config.LAST_BLOCK_NUMBER;
         }
+        if (this.config.API_ENABLED) {
+            await this.startApiServer(this.config.API_PORT);
+        }
         // Kicks off the blockchain streaming and operation parsing
         this.getBlock();
         this.latestBlockTimer = setInterval(() => { this.getLatestBlock(); }, this.config.BLOCK_CHECK_INTERVAL);
+        this.isStarted = true;
         return this;
     }
     /**
@@ -332,23 +765,52 @@ class Streamer {
      */
     async stop() {
         this.disableAllProcessing = true;
-        if (this.blockNumberTimeout) {
-            clearTimeout(this.blockNumberTimeout);
+        this.isStarted = false;
+        this.clearRuntimeTimers();
+        await this.stopApiServer();
+        await this.destroyContracts();
+        if (this.adapterInitialized && this?.adapter?.destroy) {
+            await this.adapter.destroy();
         }
-        if (this.latestBlockTimer) {
-            clearInterval(this.latestBlockTimer);
+        await this.blockProvider.destroy?.();
+        this.adapterInitialized = false;
+        this.adapterInitializationPromise = null;
+        await (0, utils_1.sleep)(25);
+    }
+    async startApiServer(port = this.config.API_PORT) {
+        await this.ensureAdapterReady();
+        if (this.apiServer?.server && this.apiServer.port === port) {
+            return this.apiServer;
         }
-        if (this.subscriptionCleanupInterval) {
-            clearInterval(this.subscriptionCleanupInterval);
+        if (this.apiServer) {
+            await this.stopApiServer();
         }
-        if (this?.adapter?.destroy) {
-            await this.adapter.destroy();
+        this.apiServer = new api_1.Api(this, { port });
+        await this.apiServer.start();
+        return this.apiServer;
+    }
+    async stopApiServer() {
+        if (!this.apiServer) {
+            return;
         }
-        await (0, utils_1.sleep)(800);
+        const apiServer = this.apiServer;
+        this.apiServer = null;
+        await apiServer.stop();
+    }
+    getApiServer() {
+        return this.apiServer;
+    }
+    async registerBlockProvider(provider) {
+        await this.blockProvider.destroy?.();
+        this.blockProvider = provider;
+        await this.blockProvider.create?.();
+    }
+    getBlockProvider() {
+        return this.blockProvider;
     }
     async getLatestBlock() {
         try {
-            const props = await this.client.database.getDynamicGlobalProperties();
+            const props = await this.blockProvider.getDynamicGlobalProperties();
             if (props) {
                 this.latestBlockchainTime = new Date(`${props.time}Z`);
             }
@@ -365,8 +827,8 @@ class Streamer {
         this.isPollingBlock = true;
         let nextDelay = this.config.BLOCK_CHECK_INTERVAL;
         try {
-            // Load global properties from the Hive API
-            const props = await this.client.database.getDynamicGlobalProperties();
+            // Load global properties from the block provider
+            const props = await this.blockProvider.getDynamicGlobalProperties();
             // We have no props, so try loading them again.
             if (!props) {
                 return;
@@ -420,8 +882,8 @@ class Streamer {
         // Check cache first
         let block = this.blockCache.get(blockNumber);
         if (!block) {
-            // Load the block itself from the Hive API
-            block = await this.client.database.getBlock(blockNumber);
+            // Load the block from the active block provider
+            block = await this.blockProvider.getBlock(blockNumber);
             // Cache the block for potential reuse
             if (block) {
                 this.blockCache.set(blockNumber, block);
@@ -451,37 +913,26 @@ class Streamer {
         if (this.adapter?.processBlock) {
             this.adapter.processBlock(block);
         }
-        // Process transactions with improved concurrency
+        // Hive operations are order-sensitive, so process them sequentially.
         const transactions = block.transactions;
         const transactionIds = block.transaction_ids;
-        // Create operation processing promises for better concurrency
-        const operationPromises = [];
         for (let i = 0; i < transactions.length; i++) {
             const transaction = transactions[i];
             const operations = transaction.operations;
-            // Process operations in batch for better performance
             for (let opIndex = 0; opIndex < operations.length; opIndex++) {
                 const op = operations[opIndex];
-                // Create promise for each operation (but don't await yet)
-                const operationPromise = this.processOperation(op, blockNumber, block.block_id, block.previous, transactionIds[i], blockTime).catch(error => {
+                try {
+                    await this.processOperation(op, blockNumber, block.block_id, block.previous, transactionIds[i], blockTime);
+                }
+                catch (error) {
                     console.error('[Streamer] Operation processing error:', error, {
                         blockNumber,
                         transactionIndex: i,
                         operationIndex: opIndex
                     });
-                });
-                operationPromises.push(operationPromise);
-                // Process in batches to avoid overwhelming the system
-                if (operationPromises.length >= 50) {
-                    await Promise.all(operationPromises);
-                    operationPromises.length = 0; // Clear array
                 }
             }
         }
-        // Process any remaining operations
-        if (operationPromises.length > 0) {
-            await Promise.all(operationPromises);
-        }
         this.lastBlockNumber = blockNumber;
         this.saveStateThrottled();
     }
@@ -517,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);
@@ -546,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') {
@@ -880,8 +1339,11 @@ class Streamer {
         }
     }
     async saveStateToDisk() {
-        if (this.adapter?.saveState) {
-            await this.adapter.saveState({ lastBlockNumber: this.lastBlockNumber, actions: this.actions });
+        if (this.adapterInitialized && this.adapter?.saveState) {
+            await this.adapter.saveState({
+                lastBlockNumber: this.lastBlockNumber,
+                actions: this.actions.map(action => action.toJSON())
+            });
         }
     }
     // Throttled state saving for performance
@@ -904,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);
     }
@@ -946,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);
     }
@@ -1048,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);