hive-stream 2.0.5 → 3.0.0

package/dist/streamer.js

@@ -1,546 +1,794 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-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 config_1 = require("./config");
-const moment_1 = __importDefault(require("moment"));
-const sscjs_1 = __importDefault(require("sscjs"));
-class Streamer {
-    customJsonSubscriptions = [];
-    customJsonIdSubscriptions = [];
-    customJsonHiveEngineSubscriptions = [];
-    commentSubscriptions = [];
-    postSubscriptions = [];
-    transferSubscriptions = [];
-    attempts = 0;
-    config = config_1.Config;
-    client;
-    hive;
-    username;
-    postingKey;
-    activeKey;
-    blockNumberTimeout = null;
-    latestBlockTimer = null;
-    lastBlockNumber = 0;
-    blockId;
-    previousBlockId;
-    transactionId;
-    blockTime;
-    latestBlockchainTime;
-    disableAllProcessing = false;
-    contracts = [];
-    adapter;
-    actions = [];
-    utils = utils_2.Utils;
-    constructor(userConfig = {}) {
-        this.config = Object.assign(config_1.Config, userConfig);
-        this.lastBlockNumber = this.config.LAST_BLOCK_NUMBER;
-        this.username = this.config.USERNAME;
-        this.postingKey = this.config.POSTING_KEY;
-        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);
-        this.registerAdapter(new sqlite_adapter_1.SqliteAdapter());
-        if (process?.env?.NODE_ENV !== 'test') {
-            new api_1.Api(this);
-        }
-    }
-    registerAdapter(adapter) {
-        this.adapter = adapter;
-        if (this?.adapter?.create) {
-            this.adapter.create();
-        }
-    }
-    getAdapter() {
-        return this.adapter;
-    }
-    /**
-     * Register a new action
-     *
-     */
-    async registerAction(action) {
-        const loadedActions = await this.adapter.loadActions();
-        for (const a of loadedActions) {
-            const exists = this.actions.find(i => i.id === a.id);
-            if (!exists) {
-                this.actions.push(new actions_1.TimeAction(a.timeValue, a.id, a.contractName, a.contractMethod, a.date));
-            }
-        }
-        const exists = this.actions.find(a => a.id === action.id);
-        if (!exists) {
-            this.actions.push(action);
-        }
-    }
-    /**
-     * Resets a specific action time value
-     *
-     * @param id
-     *
-     */
-    resetAction(id) {
-        const action = this.actions.find(i => i.id === id);
-        if (action) {
-            action.reset();
-        }
-    }
-    registerContract(name, contract) {
-        // Store an instance of the streamer
-        contract['_instance'] = this;
-        // Call the contract create lifecycle method if it exists
-        if (contract && typeof contract['create'] !== 'undefined') {
-            contract.create();
-        }
-        const storedReference = { name, contract };
-        // Push the contract reference to be called later on
-        this.contracts.push(storedReference);
-        return this;
-    }
-    unregisterContract(name) {
-        // Find the registered contract by it's ID
-        const contractIndex = this.contracts.findIndex(c => c.name === name);
-        if (contractIndex >= 0) {
-            // Get the contract itself
-            const contract = this.contracts.find(c => c.name === name);
-            // Call the contract destroy lifecycle method if it exists
-            if (contract && typeof contract.contract['destroy'] !== 'undefined') {
-                contract.contract.destroy();
-            }
-            // Remove the contract
-            this.contracts.splice(contractIndex, 1);
-        }
-    }
-    /**
-     * setConfig
-     *
-     * Allows specific configuration settings to be overridden
-     *
-     * @param config
-     */
-    setConfig(config) {
-        Object.assign(this.config, config);
-        // 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;
-        return this;
-    }
-    /**
-     * Start
-     *
-     * Starts the streamer bot to get blocks from the Hive API
-     *
-     */
-    async start() {
-        if (this.config.DEBUG_MODE) {
-            console.log('Starting to stream the Hive blockchain');
-        }
-        this.disableAllProcessing = false;
-        const state = await this.adapter.loadState();
-        if (this.config.DEBUG_MODE) {
-            console.log(`Restoring state from file`);
-        }
-        if (!this.config.LAST_BLOCK_NUMBER && state?.lastBlockNumber) {
-            if (state.lastBlockNumber) {
-                this.lastBlockNumber = state.lastBlockNumber;
-            }
-        }
-        // Kicks off the blockchain streaming and operation parsing
-        this.getBlock();
-        this.latestBlockTimer = setInterval(() => { this.getLatestBlock(); }, this.config.BLOCK_CHECK_INTERVAL);
-        return this;
-    }
-    /**
-     * Stop
-     *
-     * Stops the streamer from running
-     */
-    async stop() {
-        this.disableAllProcessing = true;
-        if (this.blockNumberTimeout) {
-            clearTimeout(this.blockNumberTimeout);
-        }
-        if (this.latestBlockTimer) {
-            clearInterval(this.latestBlockTimer);
-        }
-        if (this?.adapter?.destroy) {
-            this.adapter.destroy();
-        }
-        await (0, utils_1.sleep)(800);
-    }
-    async getLatestBlock() {
-        const props = await this.client.database.getDynamicGlobalProperties();
-        if (props) {
-            this.latestBlockchainTime = new Date(`${props.time}Z`);
-        }
-    }
-    async getBlock() {
-        try {
-            // Load global properties from the Hive API
-            const props = await this.client.database.getDynamicGlobalProperties();
-            // We have no props, so try loading them again.
-            if (!props && !this.disableAllProcessing) {
-                this.blockNumberTimeout = setTimeout(() => {
-                    this.getBlock();
-                }, this.config.BLOCK_CHECK_INTERVAL);
-                return;
-            }
-            // If the block number we've got is zero
-            // set it to the last irreversible block number
-            if (this.lastBlockNumber === 0) {
-                this.lastBlockNumber = props.head_block_number - 1;
-            }
-            if (this.config.DEBUG_MODE) {
-                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);
-            if (!this.disableAllProcessing) {
-                await this.loadBlock(this.lastBlockNumber + 1);
-            }
-            // We are more than 25 blocks behind, uh oh, we gotta catch up
-            if (props.head_block_number >= (this.lastBlockNumber + BLOCKS_BEHIND) && this.config.DEBUG_MODE) {
-                console.log(`We are more than ${BLOCKS_BEHIND} blocks behind ${props.head_block_number}, ${(this.lastBlockNumber + BLOCKS_BEHIND)}`);
-                if (!this.disableAllProcessing) {
-                    this.getBlock();
-                    return;
-                }
-            }
-            // Storing timeout allows us to clear it, as this just calls itself
-            if (!this.disableAllProcessing) {
-                this.blockNumberTimeout = setTimeout(() => { this.getBlock(); }, this.config.BLOCK_CHECK_INTERVAL);
-            }
-        }
-        catch (e) {
-            const message = e.message.toLowerCase();
-            console.error(message);
-        }
-    }
-    // Takes the block from Hive and allows us to work with it
-    async loadBlock(blockNumber) {
-        // Load the block itself from the Hive API
-        const block = await this.client.database.getBlock(blockNumber);
-        // The block doesn't exist, wait and try again
-        if (!block) {
-            await utils_2.Utils.sleep(this.config.BLOCK_CHECK_INTERVAL);
-            return;
-        }
-        // Get the block date and time
-        const blockTime = new Date(`${block.timestamp}Z`);
-        if (this.lastBlockNumber !== blockNumber) {
-            this.processActions();
-        }
-        this.blockId = block.block_id;
-        this.previousBlockId = block.previous;
-        this.transactionId = block.transaction_ids[1];
-        this.blockTime = blockTime;
-        if (this.adapter?.processBlock) {
-            this.adapter.processBlock(block);
-        }
-        // Loop over all transactions in the block
-        for (const [i, transaction] of Object.entries(block.transactions)) {
-            // Loop over operations in the block
-            for (const [opIndex, op] of Object.entries(transaction.operations)) {
-                // For every operation, process it
-                await this.processOperation(op, blockNumber, block.block_id, block.previous, block.transaction_ids[i], blockTime);
-            }
-        }
-        this.lastBlockNumber = blockNumber;
-        this.saveStateToDisk();
-    }
-    processOperation(op, blockNumber, blockId, prevBlockId, trxId, blockTime) {
-        if (this.adapter?.processOperation) {
-            this.adapter.processOperation(op, blockNumber, blockId, prevBlockId, trxId, blockTime);
-        }
-        // Operation is a "comment" which could either be a post or comment
-        if (op[0] === 'comment') {
-            // This is a post
-            if (op[1].parent_author === '') {
-                this.postSubscriptions.forEach(sub => {
-                    sub.callback(op[1], blockNumber, blockId, prevBlockId, trxId, blockTime);
-                });
-                // This is a comment
-            }
-            else {
-                this.commentSubscriptions.forEach(sub => {
-                    sub.callback(op[1], blockNumber, blockId, prevBlockId, trxId, blockTime);
-                });
-            }
-        }
-        // This is a transfer
-        if (op[0] === 'transfer') {
-            const sender = op[1]?.from;
-            const amount = op[1]?.amount;
-            const json = utils_2.Utils.jsonParse(op[1].memo);
-            if (json?.[this.config.PAYLOAD_IDENTIFIER] && json?.[this.config.PAYLOAD_IDENTIFIER]?.id === this.config.JSON_ID) {
-                // Pull out details of contract
-                const { name, action, payload } = json[this.config.PAYLOAD_IDENTIFIER];
-                // Do we have a contract that matches the name in the payload?
-                const contract = this.contracts.find(c => c.name === name);
-                if (contract) {
-                    if (this?.adapter?.processTransfer) {
-                        this.adapter.processTransfer(op[1], { name, action, payload }, { sender, amount });
-                    }
-                    if (contract?.contract?.updateBlockInfo) {
-                        contract.contract.updateBlockInfo(blockNumber, blockId, prevBlockId, trxId);
-                    }
-                    if (contract?.contract[action]) {
-                        contract.contract[action](payload, { sender, amount });
-                    }
-                }
-            }
-            this.transferSubscriptions.forEach(sub => {
-                if (sub.account === op[1].to) {
-                    sub.callback(op[1], blockNumber, blockId, prevBlockId, trxId, blockTime);
-                }
-            });
-        }
-        // This is a custom JSON operation
-        if (op[0] === 'custom_json') {
-            let isSignedWithActiveKey = false;
-            let sender;
-            const id = op[1]?.id;
-            if (op[1]?.required_auths?.length > 0) {
-                sender = op[1].required_auths[0];
-                isSignedWithActiveKey = true;
-            }
-            else if (op[1]?.required_posting_auths?.length > 0) {
-                sender = op[1].required_posting_auths[0];
-                isSignedWithActiveKey = false;
-            }
-            const json = utils_2.Utils.jsonParse(op[1].json);
-            if (json && json?.[this.config.PAYLOAD_IDENTIFIER] && id === this.config.JSON_ID) {
-                // Pull out details of contract
-                const { name, action, payload } = json[this.config.PAYLOAD_IDENTIFIER];
-                // Do we have a contract that matches the name in the payload?
-                const contract = this.contracts.find(c => c.name === name);
-                if (contract) {
-                    this.adapter.processCustomJson(op[1], { name, action, payload }, { sender, isSignedWithActiveKey });
-                    if (contract?.contract?.updateBlockInfo) {
-                        contract.contract.updateBlockInfo(blockNumber, blockId, prevBlockId, trxId);
-                    }
-                    if (contract?.contract[action]) {
-                        contract.contract[action](payload, { sender, isSignedWithActiveKey }, id);
-                    }
-                }
-            }
-            this.customJsonSubscriptions.forEach(sub => {
-                sub.callback(op[1], { sender, isSignedWithActiveKey }, blockNumber, blockId, prevBlockId, trxId, blockTime);
-            });
-            this.customJsonIdSubscriptions.forEach(sub => {
-                const byId = this.customJsonIdSubscriptions.find(s => s.id === op[1].id);
-                if (byId) {
-                    sub.callback(op[1], { sender, isSignedWithActiveKey }, blockNumber, blockId, prevBlockId, trxId, blockTime);
-                }
-            });
-            utils_2.Utils.asyncForEach(this.customJsonHiveEngineSubscriptions, async (sub) => {
-                let isSignedWithActiveKey = null;
-                let sender;
-                if (op[1].required_auths.length > 0) {
-                    sender = op[1].required_auths[0];
-                    isSignedWithActiveKey = true;
-                }
-                else {
-                    sender = op[1].required_posting_auths[0];
-                    isSignedWithActiveKey = false;
-                }
-                const id = op[1].id;
-                const json = utils_2.Utils.jsonParse(op[1].json);
-                // Hive Engine JSON operation
-                if (id === this.config.HIVE_ENGINE_ID) {
-                    const { contractName, contractAction, contractPayload } = json;
-                    try {
-                        // Attempt to get the transaction from Hive Engine itself
-                        const txInfo = await this.hive.getTransactionInfo(trxId);
-                        const logs = txInfo && txInfo.logs ? utils_2.Utils.jsonParse(txInfo.logs) : null;
-                        // Do we have a valid transaction and are there no errors? It's a real transaction
-                        if (txInfo && logs && typeof logs.errors === 'undefined') {
-                            sub.callback(contractName, contractAction, contractPayload, sender, op[1], blockNumber, blockId, prevBlockId, trxId, blockTime);
-                        }
-                    }
-                    catch (e) {
-                        console.error(e);
-                        return;
-                    }
-                }
-            });
-        }
-    }
-    processActions() {
-        const blockDate = moment_1.default.utc(this.latestBlockchainTime);
-        for (const action of this.actions) {
-            const date = moment_1.default.utc(action.date);
-            const frequency = action.timeValue;
-            const contract = this.contracts.find(c => c.name === action.contractName);
-            // Contract doesn't exist or action doesn't exist, carry on
-            if (!contract || !contract?.contract?.[action.contractMethod]) {
-                continue;
-            }
-            let difference = 0;
-            switch (frequency) {
-                case '3s':
-                case 'block':
-                    difference = date.diff(blockDate, 's');
-                    // 3 seconds or more has passed
-                    if (difference >= 3) {
-                        contract.contract[action.contractMethod](action.payload);
-                        action.reset();
-                    }
-                    break;
-                case '10s':
-                    difference = blockDate.diff(date, 's');
-                    // 10 seconds or more has passed
-                    if (difference >= 10) {
-                        contract.contract[action.contractMethod](action.payload);
-                        action.reset();
-                    }
-                    break;
-                case '30s':
-                    difference = blockDate.diff(date, 's');
-                    // 30 seconds or more has passed
-                    if (difference >= 30) {
-                        contract.contract[action.contractMethod](action.payload);
-                        action.reset();
-                    }
-                    break;
-                case '1m':
-                case 'minute':
-                    difference = blockDate.diff(date, 'm');
-                    // One minute has passed
-                    if (difference >= 1) {
-                        contract.contract[action.contractMethod](action.payload);
-                        action.reset();
-                    }
-                    break;
-                case '15m':
-                case 'quarter':
-                    difference = blockDate.diff(date, 'm');
-                    // 15 minutes has passed
-                    if (difference >= 15) {
-                        contract.contract[action.contractMethod](action.payload);
-                        action.reset();
-                    }
-                    break;
-                case '30m':
-                case 'halfhour':
-                    difference = blockDate.diff(date, 'm');
-                    // 30 minutes has passed
-                    if (difference >= 30) {
-                        contract.contract[action.contractMethod](action.payload);
-                        action.reset();
-                    }
-                    break;
-                case 'hourly':
-                case '1h':
-                    difference = blockDate.diff(date, 'h');
-                    // One our or more has passed
-                    if (difference >= 1) {
-                        contract.contract[action.contractMethod](action.payload);
-                        action.reset();
-                    }
-                    break;
-                case '12h':
-                case 'halfday':
-                    difference = blockDate.diff(date, 'h');
-                    // Twelve hours or more has passed
-                    if (difference >= 12) {
-                        contract.contract[action.contractMethod](action.payload);
-                        action.reset();
-                    }
-                    break;
-                case '24h':
-                case 'day':
-                    difference = blockDate.diff(date, 'd');
-                    // One day (24 hours) has passed
-                    if (difference >= 1) {
-                        contract.contract[action.contractMethod](action.payload);
-                        action.reset();
-                    }
-                    break;
-                case 'week':
-                    difference = blockDate.diff(date, 'w');
-                    // One week has passed
-                    if (difference >= 1) {
-                        contract.contract[action.contractMethod](action.payload);
-                        action.reset();
-                    }
-                    break;
-            }
-        }
-    }
-    async saveStateToDisk() {
-        if (this.adapter?.saveState) {
-            this.adapter.saveState({ lastBlockNumber: this.lastBlockNumber, actions: this.actions });
-        }
-    }
-    saveToHiveApi(from, data) {
-        return utils_2.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);
-    }
-    transferHiveTokens(from, to, amount, symbol, memo = '') {
-        return utils_2.Utils.transferHiveTokens(this.client, this.config, from, to, amount, symbol, memo);
-    }
-    transferHiveTokensMultiple(from, accounts = [], amount = '0', symbol, memo = '') {
-        return utils_2.Utils.transferHiveTokensMultiple(this.client, this.config, from, accounts, amount, symbol, memo);
-    }
-    transferHiveEngineTokens(from, to, symbol, quantity, memo = '') {
-        return utils_2.Utils.transferHiveEngineTokens(this.client, this.config, from, to, symbol, quantity, memo);
-    }
-    transferHiveEngineTokensMultiple(from, accounts = [], symbol, memo = '', amount = '0') {
-        return utils_2.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);
-    }
-    issueHiveEngineTokensMultiple(from, accounts = [], symbol, memo = '', amount = '0') {
-        return utils_2.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);
-    }
-    downvote(votePercentage = '100.0', username, permlink) {
-        return utils_2.Utils.downvote(this.client, this.config, this.username, votePercentage, username, permlink);
-    }
-    getTransaction(blockNumber, transactionId) {
-        return utils_2.Utils.getTransaction(this.client, blockNumber, transactionId);
-    }
-    verifyTransfer(transaction, from, to, amount) {
-        return utils_2.Utils.verifyTransfer(transaction, from, to, amount);
-    }
-    onComment(callback) {
-        this.commentSubscriptions.push({
-            callback
-        });
-    }
-    onPost(callback) {
-        this.postSubscriptions.push({
-            callback
-        });
-    }
-    onTransfer(account, callback) {
-        this.transferSubscriptions.push({
-            account,
-            callback
-        });
-    }
-    onCustomJson(callback) {
-        this.customJsonSubscriptions.push({ callback });
-    }
-    onCustomJsonId(callback, id) {
-        this.customJsonIdSubscriptions.push({ callback, id });
-    }
-    onHiveEngine(callback) {
-        this.customJsonHiveEngineSubscriptions.push({ callback });
-    }
-}
-exports.Streamer = Streamer;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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 config_1 = require("./config");
+const sscjs_1 = __importDefault(require("sscjs"));
+class Streamer {
+    customJsonSubscriptions = [];
+    customJsonIdSubscriptions = [];
+    customJsonHiveEngineSubscriptions = [];
+    commentSubscriptions = [];
+    postSubscriptions = [];
+    transferSubscriptions = [];
+    attempts = 0;
+    config = config_1.Config;
+    client;
+    hive;
+    username;
+    postingKey;
+    activeKey;
+    blockNumberTimeout = null;
+    latestBlockTimer = null;
+    lastBlockNumber = 0;
+    blockId;
+    previousBlockId;
+    transactionId;
+    blockTime;
+    latestBlockchainTime;
+    disableAllProcessing = false;
+    contracts = [];
+    adapter;
+    actions = [];
+    // Performance optimization properties
+    lastStateSave = Date.now();
+    stateSaveInterval = 5000; // Save state every 5 seconds instead of every block
+    blockProcessingQueue = [];
+    isProcessingQueue = false;
+    // Memory management
+    maxSubscriptions = 1000;
+    subscriptionCleanupInterval = null;
+    // Action processing optimization
+    actionFrequencyMap = new Map([
+        ['3s', 3], ['block', 3], ['10s', 10], ['30s', 30],
+        ['1m', 60], ['5m', 300], ['minute', 60], ['15m', 900], ['quarter', 900],
+        ['30m', 1800], ['halfhour', 1800], ['hourly', 3600], ['1h', 3600],
+        ['12h', 43200], ['halfday', 43200], ['24h', 86400], ['day', 86400], ['daily', 86400],
+        ['week', 604800], ['weekly', 604800]
+    ]);
+    contractCache = new Map();
+    // Data caching for performance
+    blockCache = new Map();
+    transactionCache = new Map();
+    accountCache = new Map();
+    cacheTimeout = 300000; // 5 minutes
+    maxCacheSize = 1000;
+    utils = utils_2.Utils;
+    constructor(userConfig = {}) {
+        this.config = Object.assign(config_1.Config, userConfig);
+        this.lastBlockNumber = this.config.LAST_BLOCK_NUMBER;
+        this.username = this.config.USERNAME;
+        this.postingKey = this.config.POSTING_KEY;
+        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);
+        }
+        // Start subscription cleanup interval
+        this.subscriptionCleanupInterval = setInterval(() => {
+            this.cleanupSubscriptions();
+        }, 60000); // Cleanup every minute
+    }
+    _initializeAdapter(adapter) {
+        this.adapter = adapter;
+        if (this?.adapter?.create) {
+            this.adapter.create();
+        }
+    }
+    async registerAdapter(adapter) {
+        if (this.adapter && this.adapter.destroy) {
+            try {
+                await this.adapter.destroy();
+            }
+            catch (error) {
+                console.warn('[Streamer] Error destroying existing adapter:', error);
+            }
+        }
+        this.adapter = adapter;
+        if (this?.adapter?.create) {
+            await this.adapter.create();
+        }
+    }
+    getAdapter() {
+        return this.adapter;
+    }
+    /**
+     * Register a new action with improved validation and persistence
+     */
+    async registerAction(action) {
+        if (!action || !(action instanceof actions_1.TimeAction)) {
+            throw new Error('Invalid action: must be an instance of TimeAction');
+        }
+        const loadedActions = await this.adapter.loadActions();
+        for (const a of loadedActions) {
+            const exists = this.actions.find(i => i.id === a.id);
+            if (!exists) {
+                try {
+                    const restoredAction = actions_1.TimeAction.fromJSON(a);
+                    this.actions.push(restoredAction);
+                }
+                catch (error) {
+                    console.warn(`[Streamer] Failed to restore action ${a.id}:`, error);
+                }
+            }
+        }
+        const exists = this.actions.find(a => a.id === action.id);
+        if (!exists) {
+            this.validateActionContract(action);
+            this.actions.push(action);
+            await this.saveActionsToDisk();
+            if (this.config.DEBUG_MODE) {
+                console.log(`[Streamer] Registered time-based action: ${action.id} (${action.timeValue})`);
+            }
+        }
+        else {
+            if (this.config.DEBUG_MODE) {
+                console.warn(`[Streamer] Action with ID ${action.id} already exists, skipping registration`);
+            }
+        }
+    }
+    /**
+     * Validate that the contract and method exist for the action
+     */
+    validateActionContract(action) {
+        const contract = this.contractCache.get(action.contractName) ||
+            this.contracts.find(c => c.name === action.contractName);
+        if (!contract) {
+            throw new Error(`Contract '${action.contractName}' not found for action '${action.id}'`);
+        }
+        if (!contract.contract[action.contractMethod] || typeof contract.contract[action.contractMethod] !== 'function') {
+            throw new Error(`Method '${action.contractMethod}' not found in contract '${action.contractName}' for action '${action.id}'`);
+        }
+    }
+    /**
+     * Remove an action by ID
+     */
+    async removeAction(actionId) {
+        const index = this.actions.findIndex(a => a.id === actionId);
+        if (index >= 0) {
+            const removedAction = this.actions.splice(index, 1)[0];
+            await this.saveActionsToDisk();
+            if (this.config.DEBUG_MODE) {
+                console.log(`[Streamer] Removed time-based action: ${actionId}`);
+            }
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Get all registered actions
+     */
+    getActions() {
+        return [...this.actions];
+    }
+    /**
+     * Get action by ID
+     */
+    getAction(actionId) {
+        return this.actions.find(a => a.id === actionId);
+    }
+    /**
+     * Enable/disable an action
+     */
+    async setActionEnabled(actionId, enabled) {
+        const action = this.actions.find(a => a.id === actionId);
+        if (action) {
+            if (enabled) {
+                action.enable();
+            }
+            else {
+                action.disable();
+            }
+            await this.saveActionsToDisk();
+            if (this.config.DEBUG_MODE) {
+                console.log(`[Streamer] Action ${actionId} ${enabled ? 'enabled' : 'disabled'}`);
+            }
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Save actions to disk asynchronously
+     */
+    async saveActionsToDisk() {
+        try {
+            if (this.adapter?.saveState) {
+                await this.adapter.saveState({
+                    lastBlockNumber: this.lastBlockNumber,
+                    actions: this.actions.map(a => a.toJSON())
+                });
+            }
+        }
+        catch (error) {
+            if (error?.code !== 'SQLITE_MISUSE') {
+                console.error('[Streamer] Failed to save actions to disk:', error);
+            }
+        }
+    }
+    /**
+     * Resets a specific action time value
+     */
+    async resetAction(id) {
+        const action = this.actions.find(i => i.id === id);
+        if (action) {
+            action.reset();
+            await this.saveActionsToDisk();
+            if (this.config.DEBUG_MODE) {
+                console.log(`[Streamer] Reset action: ${id}`);
+            }
+            return true;
+        }
+        return false;
+    }
+    registerContract(name, contract) {
+        // Store an instance of the streamer
+        contract['_instance'] = this;
+        // Call the contract create lifecycle method if it exists
+        if (contract && typeof contract['create'] !== 'undefined') {
+            contract.create();
+        }
+        const storedReference = { name, contract };
+        // Push the contract reference to be called later on
+        this.contracts.push(storedReference);
+        // Cache the contract for faster lookups
+        this.contractCache.set(name, storedReference);
+        return this;
+    }
+    unregisterContract(name) {
+        // Find the registered contract by it's ID
+        const contractIndex = this.contracts.findIndex(c => c.name === name);
+        if (contractIndex >= 0) {
+            // Get the contract itself
+            const contract = this.contracts.find(c => c.name === name);
+            // Call the contract destroy lifecycle method if it exists
+            if (contract && typeof contract.contract['destroy'] !== 'undefined') {
+                contract.contract.destroy();
+            }
+            // Remove the contract
+            this.contracts.splice(contractIndex, 1);
+            // Remove from cache
+            this.contractCache.delete(name);
+        }
+    }
+    /**
+     * setConfig
+     *
+     * Allows specific configuration settings to be overridden
+     *
+     * @param config
+     */
+    setConfig(config) {
+        Object.assign(this.config, config);
+        // 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;
+        return this;
+    }
+    /**
+     * Start
+     *
+     * Starts the streamer bot to get blocks from the Hive API
+     *
+     */
+    async start() {
+        if (this.config.DEBUG_MODE) {
+            console.log('Starting to stream the Hive blockchain');
+        }
+        this.disableAllProcessing = false;
+        const state = await this.adapter.loadState();
+        if (this.config.DEBUG_MODE) {
+            console.log(`Restoring state from file`);
+        }
+        if (!this.config.LAST_BLOCK_NUMBER && state?.lastBlockNumber) {
+            if (state.lastBlockNumber) {
+                this.lastBlockNumber = state.lastBlockNumber;
+            }
+        }
+        // Kicks off the blockchain streaming and operation parsing
+        this.getBlock();
+        this.latestBlockTimer = setInterval(() => { this.getLatestBlock(); }, this.config.BLOCK_CHECK_INTERVAL);
+        return this;
+    }
+    /**
+     * Stop
+     *
+     * Stops the streamer from running
+     */
+    async stop() {
+        this.disableAllProcessing = true;
+        if (this.blockNumberTimeout) {
+            clearTimeout(this.blockNumberTimeout);
+        }
+        if (this.latestBlockTimer) {
+            clearInterval(this.latestBlockTimer);
+        }
+        if (this.subscriptionCleanupInterval) {
+            clearInterval(this.subscriptionCleanupInterval);
+        }
+        if (this?.adapter?.destroy) {
+            this.adapter.destroy();
+        }
+        await (0, utils_1.sleep)(800);
+    }
+    async getLatestBlock() {
+        try {
+            const props = await this.client.database.getDynamicGlobalProperties();
+            if (props) {
+                this.latestBlockchainTime = new Date(`${props.time}Z`);
+            }
+        }
+        catch (error) {
+            console.error('[Streamer] Error getting latest block:', error);
+            // Continue with cached time if available
+        }
+    }
+    async getBlock() {
+        try {
+            // Load global properties from the Hive API
+            const props = await this.client.database.getDynamicGlobalProperties();
+            // We have no props, so try loading them again.
+            if (!props && !this.disableAllProcessing) {
+                this.blockNumberTimeout = setTimeout(() => {
+                    this.getBlock();
+                }, this.config.BLOCK_CHECK_INTERVAL);
+                return;
+            }
+            // If the block number we've got is zero
+            // set it to the last irreversible block number
+            if (this.lastBlockNumber === 0) {
+                this.lastBlockNumber = props.head_block_number - 1;
+            }
+            if (this.config.DEBUG_MODE) {
+                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);
+            if (!this.disableAllProcessing) {
+                await this.loadBlock(this.lastBlockNumber + 1);
+            }
+            // We are more than 25 blocks behind, uh oh, we gotta catch up
+            if (props.head_block_number >= (this.lastBlockNumber + BLOCKS_BEHIND) && this.config.DEBUG_MODE) {
+                console.log(`We are more than ${BLOCKS_BEHIND} blocks behind ${props.head_block_number}, ${(this.lastBlockNumber + BLOCKS_BEHIND)}`);
+                if (!this.disableAllProcessing) {
+                    this.getBlock();
+                    return;
+                }
+            }
+            // Storing timeout allows us to clear it, as this just calls itself
+            if (!this.disableAllProcessing) {
+                this.blockNumberTimeout = setTimeout(() => { this.getBlock(); }, this.config.BLOCK_CHECK_INTERVAL);
+            }
+        }
+        catch (e) {
+            const error = e instanceof Error ? e : new Error(String(e));
+            console.error(`[Streamer] Block processing error: ${error.message}`, {
+                stack: error.stack,
+                blockNumber: this.lastBlockNumber + 1
+            });
+            // Retry after a longer delay on error
+            if (!this.disableAllProcessing) {
+                this.blockNumberTimeout = setTimeout(() => { this.getBlock(); }, this.config.BLOCK_CHECK_INTERVAL * 2);
+            }
+        }
+    }
+    // Takes the block from Hive and allows us to work with it
+    async loadBlock(blockNumber) {
+        // 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);
+            // Cache the block for potential reuse
+            if (block) {
+                this.blockCache.set(blockNumber, block);
+                // Cleanup old cache entries
+                if (this.blockCache.size > this.maxCacheSize) {
+                    const oldestKey = this.blockCache.keys().next().value;
+                    this.blockCache.delete(oldestKey);
+                }
+            }
+        }
+        // The block doesn't exist, wait and try again
+        if (!block) {
+            await utils_2.Utils.sleep(this.config.BLOCK_CHECK_INTERVAL);
+            return;
+        }
+        // Get the block date and time
+        const blockTime = new Date(`${block.timestamp}Z`);
+        if (this.lastBlockNumber !== blockNumber) {
+            this.processActions().catch(error => {
+                console.error('[Streamer] Error processing actions:', error);
+            });
+        }
+        this.blockId = block.block_id;
+        this.previousBlockId = block.previous;
+        this.transactionId = block.transaction_ids[1];
+        this.blockTime = blockTime;
+        if (this.adapter?.processBlock) {
+            this.adapter.processBlock(block);
+        }
+        // Process transactions with improved concurrency
+        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 => {
+                    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();
+    }
+    async processOperation(op, blockNumber, blockId, prevBlockId, trxId, blockTime) {
+        if (this.adapter?.processOperation) {
+            this.adapter.processOperation(op, blockNumber, blockId, prevBlockId, trxId, blockTime);
+        }
+        // Operation is a "comment" which could either be a post or comment
+        if (op[0] === 'comment') {
+            // This is a post
+            if (op[1].parent_author === '') {
+                this.postSubscriptions.forEach(sub => {
+                    sub.callback(op[1], blockNumber, blockId, prevBlockId, trxId, blockTime);
+                });
+                // This is a comment
+            }
+            else {
+                this.commentSubscriptions.forEach(sub => {
+                    sub.callback(op[1], blockNumber, blockId, prevBlockId, trxId, blockTime);
+                });
+            }
+        }
+        // This is a transfer
+        if (op[0] === 'transfer') {
+            const sender = op[1]?.from;
+            const amount = op[1]?.amount;
+            const json = utils_2.Utils.jsonParse(op[1].memo);
+            if (json?.[this.config.PAYLOAD_IDENTIFIER] && json?.[this.config.PAYLOAD_IDENTIFIER]?.id === this.config.JSON_ID) {
+                // Pull out details of contract
+                const { name, action, payload } = json[this.config.PAYLOAD_IDENTIFIER];
+                // Do we have a contract that matches the name in the payload?
+                const contract = this.contracts.find(c => c.name === name);
+                if (contract) {
+                    if (this?.adapter?.processTransfer) {
+                        this.adapter.processTransfer(op[1], { name, action, payload }, { sender, amount });
+                    }
+                    if (contract?.contract?.updateBlockInfo) {
+                        contract.contract.updateBlockInfo(blockNumber, blockId, prevBlockId, trxId);
+                    }
+                    if (contract?.contract[action]) {
+                        contract.contract[action](payload, { sender, amount });
+                    }
+                }
+            }
+            this.transferSubscriptions.forEach(sub => {
+                if (sub.account === op[1].to) {
+                    sub.callback(op[1], blockNumber, blockId, prevBlockId, trxId, blockTime);
+                }
+            });
+        }
+        // This is a custom JSON operation
+        if (op[0] === 'custom_json') {
+            let isSignedWithActiveKey = false;
+            let sender;
+            const id = op[1]?.id;
+            if (op[1]?.required_auths?.length > 0) {
+                sender = op[1].required_auths[0];
+                isSignedWithActiveKey = true;
+            }
+            else if (op[1]?.required_posting_auths?.length > 0) {
+                sender = op[1].required_posting_auths[0];
+                isSignedWithActiveKey = false;
+            }
+            const json = utils_2.Utils.jsonParse(op[1].json);
+            if (json && json?.[this.config.PAYLOAD_IDENTIFIER] && id === this.config.JSON_ID) {
+                // Pull out details of contract
+                const { name, action, payload } = json[this.config.PAYLOAD_IDENTIFIER];
+                // Do we have a contract that matches the name in the payload?
+                const contract = this.contracts.find(c => c.name === name);
+                if (contract) {
+                    this.adapter.processCustomJson(op[1], { name, action, payload }, { sender, isSignedWithActiveKey });
+                    if (contract?.contract?.updateBlockInfo) {
+                        contract.contract.updateBlockInfo(blockNumber, blockId, prevBlockId, trxId);
+                    }
+                    if (contract?.contract[action]) {
+                        contract.contract[action](payload, { sender, isSignedWithActiveKey }, id);
+                    }
+                }
+            }
+            this.customJsonSubscriptions.forEach(sub => {
+                sub.callback(op[1], { sender, isSignedWithActiveKey }, blockNumber, blockId, prevBlockId, trxId, blockTime);
+            });
+            this.customJsonIdSubscriptions.forEach(sub => {
+                const byId = this.customJsonIdSubscriptions.find(s => s.id === op[1].id);
+                if (byId) {
+                    sub.callback(op[1], { sender, isSignedWithActiveKey }, blockNumber, blockId, prevBlockId, trxId, blockTime);
+                }
+            });
+            utils_2.Utils.asyncForEach(this.customJsonHiveEngineSubscriptions, async (sub) => {
+                let isSignedWithActiveKey = null;
+                let sender;
+                if (op[1].required_auths.length > 0) {
+                    sender = op[1].required_auths[0];
+                    isSignedWithActiveKey = true;
+                }
+                else {
+                    sender = op[1].required_posting_auths[0];
+                    isSignedWithActiveKey = false;
+                }
+                const id = op[1].id;
+                const json = utils_2.Utils.jsonParse(op[1].json);
+                // Hive Engine JSON operation
+                if (id === this.config.HIVE_ENGINE_ID) {
+                    const { contractName, contractAction, contractPayload } = json;
+                    try {
+                        // Attempt to get the transaction from Hive Engine itself
+                        const txInfo = await this.hive.getTransactionInfo(trxId);
+                        const logs = txInfo && txInfo.logs ? utils_2.Utils.jsonParse(txInfo.logs) : null;
+                        // Do we have a valid transaction and are there no errors? It's a real transaction
+                        if (txInfo && logs && typeof logs.errors === 'undefined') {
+                            sub.callback(contractName, contractAction, contractPayload, sender, op[1], blockNumber, blockId, prevBlockId, trxId, blockTime);
+                        }
+                    }
+                    catch (e) {
+                        console.error(e);
+                        return;
+                    }
+                }
+            });
+        }
+    }
+    async processActions() {
+        if (!this.latestBlockchainTime || this.actions.length === 0) {
+            return;
+        }
+        const currentTime = this.latestBlockchainTime.getTime();
+        const executedActions = [];
+        // Process actions in batch with optimized time calculations
+        for (let i = 0; i < this.actions.length; i++) {
+            const action = this.actions[i];
+            // Skip disabled actions or actions that have reached max executions
+            if (!action.enabled || action.hasReachedMaxExecutions()) {
+                continue;
+            }
+            // Get contract from cache or find and cache it
+            let contract = this.contractCache.get(action.contractName);
+            if (!contract) {
+                contract = this.contracts.find(c => c.name === action.contractName);
+                if (contract) {
+                    this.contractCache.set(action.contractName, contract);
+                }
+            }
+            // Contract doesn't exist or method doesn't exist, log warning and skip
+            if (!contract) {
+                console.warn(`[Streamer] Contract '${action.contractName}' not found for action '${action.id}'`);
+                continue;
+            }
+            if (!contract?.contract?.[action.contractMethod] || typeof contract.contract[action.contractMethod] !== 'function') {
+                console.warn(`[Streamer] Method '${action.contractMethod}' not found in contract '${action.contractName}' for action '${action.id}'`);
+                continue;
+            }
+            // Get frequency in seconds from optimized map
+            const frequencySeconds = this.actionFrequencyMap.get(action.timeValue);
+            if (!frequencySeconds) {
+                console.warn(`[Streamer] Invalid time value '${action.timeValue}' for action '${action.id}'`);
+                continue;
+            }
+            // Optimized time difference calculation using timestamps
+            const actionTime = action.date.getTime();
+            const differenceSeconds = (currentTime - actionTime) / 1000;
+            // Check if enough time has passed
+            if (differenceSeconds >= frequencySeconds) {
+                try {
+                    // Execute the action with error isolation
+                    await this.executeAction(action, contract);
+                    // Reset the action timer and increment execution count
+                    action.reset();
+                    action.incrementExecutionCount();
+                    executedActions.push(action.id);
+                    if (this.config.DEBUG_MODE) {
+                        console.log(`[Streamer] Executed action: ${action.id} (execution #${action.executionCount})`);
+                    }
+                }
+                catch (error) {
+                    const err = error instanceof Error ? error : new Error(String(error));
+                    console.error(`[Streamer] Action execution error for ${action.contractName}.${action.contractMethod}:`, {
+                        actionId: action.id,
+                        error: err.message,
+                        stack: err.stack,
+                        payload: action.payload
+                    });
+                    // Optionally disable action after repeated failures
+                    // This could be configurable in the future
+                }
+            }
+        }
+        // Save state if any actions were executed
+        if (executedActions.length > 0) {
+            await this.saveActionsToDisk();
+        }
+        // Clean up disabled or completed actions periodically
+        this.cleanupActions();
+    }
+    /**
+     * Execute a single action with proper isolation
+     */
+    async executeAction(action, contract) {
+        const method = contract.contract[action.contractMethod];
+        if (method.constructor.name === 'AsyncFunction') {
+            await method.call(contract.contract, action.payload);
+        }
+        else {
+            method.call(contract.contract, action.payload);
+        }
+    }
+    /**
+     * Clean up completed or disabled actions to prevent memory leaks
+     */
+    cleanupActions() {
+        const beforeCount = this.actions.length;
+        // Remove actions that have reached their max executions
+        this.actions = this.actions.filter(action => {
+            if (action.hasReachedMaxExecutions()) {
+                if (this.config.DEBUG_MODE) {
+                    console.log(`[Streamer] Removing completed action: ${action.id} (${action.executionCount}/${action.maxExecutions} executions)`);
+                }
+                return false;
+            }
+            return true;
+        });
+        const afterCount = this.actions.length;
+        if (beforeCount !== afterCount) {
+            // Save state if we removed any actions
+            this.saveActionsToDisk().catch(error => {
+                console.error('[Streamer] Failed to save state after action cleanup:', error);
+            });
+        }
+    }
+    async saveStateToDisk() {
+        if (this.adapter?.saveState) {
+            await this.adapter.saveState({ lastBlockNumber: this.lastBlockNumber, actions: this.actions });
+        }
+    }
+    // Throttled state saving for performance
+    saveStateThrottled() {
+        const now = Date.now();
+        if (now - this.lastStateSave > this.stateSaveInterval) {
+            this.lastStateSave = now;
+            // Save state asynchronously without blocking block processing
+            this.saveStateToDisk().catch(error => {
+                console.error('[Streamer] State save error:', error);
+            });
+        }
+    }
+    saveToHiveApi(from, data) {
+        return utils_2.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);
+    }
+    transferHiveTokens(from, to, amount, symbol, memo = '') {
+        return utils_2.Utils.transferHiveTokens(this.client, this.config, from, to, amount, symbol, memo);
+    }
+    transferHiveTokensMultiple(from, accounts = [], amount = '0', symbol, memo = '') {
+        return utils_2.Utils.transferHiveTokensMultiple(this.client, this.config, from, accounts, amount, symbol, memo);
+    }
+    transferHiveEngineTokens(from, to, symbol, quantity, memo = '') {
+        return utils_2.Utils.transferHiveEngineTokens(this.client, this.config, from, to, symbol, quantity, memo);
+    }
+    transferHiveEngineTokensMultiple(from, accounts = [], symbol, memo = '', amount = '0') {
+        return utils_2.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);
+    }
+    issueHiveEngineTokensMultiple(from, accounts = [], symbol, memo = '', amount = '0') {
+        return utils_2.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);
+    }
+    downvote(votePercentage = '100.0', username, permlink) {
+        return utils_2.Utils.downvote(this.client, this.config, this.username, votePercentage, username, permlink);
+    }
+    getTransaction(blockNumber, transactionId) {
+        return utils_2.Utils.getTransaction(this.client, blockNumber, transactionId);
+    }
+    verifyTransfer(transaction, from, to, amount) {
+        return utils_2.Utils.verifyTransfer(transaction, from, to, amount);
+    }
+    onComment(callback) {
+        this.commentSubscriptions.push({
+            callback
+        });
+    }
+    onPost(callback) {
+        this.postSubscriptions.push({
+            callback
+        });
+    }
+    onTransfer(account, callback) {
+        this.transferSubscriptions.push({
+            account,
+            callback
+        });
+    }
+    onCustomJson(callback) {
+        this.customJsonSubscriptions.push({ callback });
+    }
+    onCustomJsonId(callback, id) {
+        this.customJsonIdSubscriptions.push({ callback, id });
+    }
+    onHiveEngine(callback) {
+        this.customJsonHiveEngineSubscriptions.push({ callback });
+    }
+    // Memory management: cleanup subscriptions
+    cleanupSubscriptions() {
+        // Limit subscription arrays to prevent memory leaks
+        if (this.customJsonSubscriptions.length > this.maxSubscriptions) {
+            this.customJsonSubscriptions = this.customJsonSubscriptions.slice(-this.maxSubscriptions);
+            console.warn(`[Streamer] Trimmed customJsonSubscriptions to ${this.maxSubscriptions} items`);
+        }
+        if (this.customJsonIdSubscriptions.length > this.maxSubscriptions) {
+            this.customJsonIdSubscriptions = this.customJsonIdSubscriptions.slice(-this.maxSubscriptions);
+            console.warn(`[Streamer] Trimmed customJsonIdSubscriptions to ${this.maxSubscriptions} items`);
+        }
+        if (this.customJsonHiveEngineSubscriptions.length > this.maxSubscriptions) {
+            this.customJsonHiveEngineSubscriptions = this.customJsonHiveEngineSubscriptions.slice(-this.maxSubscriptions);
+            console.warn(`[Streamer] Trimmed customJsonHiveEngineSubscriptions to ${this.maxSubscriptions} items`);
+        }
+        if (this.commentSubscriptions.length > this.maxSubscriptions) {
+            this.commentSubscriptions = this.commentSubscriptions.slice(-this.maxSubscriptions);
+            console.warn(`[Streamer] Trimmed commentSubscriptions to ${this.maxSubscriptions} items`);
+        }
+        if (this.postSubscriptions.length > this.maxSubscriptions) {
+            this.postSubscriptions = this.postSubscriptions.slice(-this.maxSubscriptions);
+            console.warn(`[Streamer] Trimmed postSubscriptions to ${this.maxSubscriptions} items`);
+        }
+        if (this.transferSubscriptions.length > this.maxSubscriptions) {
+            this.transferSubscriptions = this.transferSubscriptions.slice(-this.maxSubscriptions);
+            console.warn(`[Streamer] Trimmed transferSubscriptions to ${this.maxSubscriptions} items`);
+        }
+    }
+    // Add method to remove specific subscriptions
+    removeTransferSubscription(account) {
+        this.transferSubscriptions = this.transferSubscriptions.filter(sub => sub.account !== account);
+    }
+    removeCustomJsonIdSubscription(id) {
+        this.customJsonIdSubscriptions = this.customJsonIdSubscriptions.filter(sub => sub.id !== id);
+    }
+}
+exports.Streamer = Streamer;
 //# sourceMappingURL=streamer.js.map