hive-stream 2.0.6 → 3.0.1

package/dist/streamer.js

@@ -1,546 +1,1064 @@
-"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 = [];
+    escrowSubscriptions = [];
+    attempts = 0;
+    config = config_1.Config;
+    client;
+    hive;
+    username;
+    postingKey;
+    activeKey;
+    blockNumberTimeout = null;
+    latestBlockTimer = null;
+    lastBlockNumber = 0;
+    headBlockNumber = 0;
+    isPollingBlock = false;
+    isCatchingUp = false;
+    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}'`);
+        }
+        const actionDefinition = contract.actions?.[action.contractAction];
+        if (!actionDefinition || typeof actionDefinition.handler !== 'function') {
+            throw new Error(`Action '${action.contractAction}' not found in contract '${action.contractName}' for action '${action.id}'`);
+        }
+        if (!this.isActionTriggerAllowed(actionDefinition, 'time')) {
+            throw new Error(`Action '${action.contractAction}' does not allow time triggers for action '${action.id}'`);
+        }
+    }
+    isActionTriggerAllowed(actionDefinition, trigger) {
+        const configured = actionDefinition?.trigger;
+        const triggers = configured
+            ? (Array.isArray(configured) ? configured : [configured])
+            : ['custom_json'];
+        return triggers.includes(trigger);
+    }
+    /**
+     * 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;
+    }
+    async registerContract(contract) {
+        if (!contract || typeof contract !== 'object') {
+            throw new Error('Contract must be a valid definition object');
+        }
+        if (!contract.name || typeof contract.name !== 'string') {
+            throw new Error('Contract name must be a non-empty string');
+        }
+        if (this.contractCache.has(contract.name)) {
+            throw new Error(`Contract '${contract.name}' is already registered`);
+        }
+        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);
+        }
+        this.contracts.push(contract);
+        this.contractCache.set(contract.name, contract);
+    }
+    async unregisterContract(name) {
+        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
+                });
+            }
+            this.contracts.splice(contractIndex, 1);
+            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.RESUME_FROM_STATE && state?.lastBlockNumber) {
+            this.lastBlockNumber = state.lastBlockNumber;
+        }
+        else if (this.config.LAST_BLOCK_NUMBER) {
+            this.lastBlockNumber = this.config.LAST_BLOCK_NUMBER;
+        }
+        // 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) {
+            await 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() {
+        if (this.isPollingBlock) {
+            return;
+        }
+        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();
+            // We have no props, so try loading them again.
+            if (!props) {
+                return;
+            }
+            this.headBlockNumber = props.head_block_number;
+            // If the block number we've got is zero set it to the latest head block
+            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);
+            const maxBatchSize = Math.max(1, this.config.CATCH_UP_BATCH_SIZE || 1);
+            const blocksBehind = Math.max(0, props.head_block_number - this.lastBlockNumber);
+            const blocksToProcess = Math.min(blocksBehind, maxBatchSize);
+            if (blocksBehind >= BLOCKS_BEHIND && this.config.DEBUG_MODE) {
+                console.log(`[Streamer] ${blocksBehind} blocks behind head (${props.head_block_number}). Catching up...`);
+            }
+            if (!this.disableAllProcessing) {
+                for (let i = 0; i < blocksToProcess; i++) {
+                    await this.loadBlock(this.lastBlockNumber + 1);
+                }
+            }
+            const remainingBehind = Math.max(0, props.head_block_number - this.lastBlockNumber);
+            this.isCatchingUp = remainingBehind > 0;
+            if (remainingBehind > 0) {
+                nextDelay = Math.max(0, this.config.CATCH_UP_DELAY_MS);
+            }
+        }
+        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
+            nextDelay = this.config.BLOCK_CHECK_INTERVAL * 2;
+        }
+        finally {
+            this.isPollingBlock = false;
+            // Storing timeout allows us to clear it, as this just calls itself
+            if (!this.disableAllProcessing) {
+                this.blockNumberTimeout = setTimeout(() => { this.getBlock(); }, nextDelay);
+            }
+        }
+    }
+    // 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) {
+        const operationType = op[0];
+        const operationData = op[1];
+        const operationMetadata = {
+            blockNumber,
+            blockId,
+            previousBlockId: prevBlockId,
+            transactionId: trxId,
+            blockTime
+        };
+        if (this.adapter?.processOperation) {
+            await this.adapter.processOperation(op, blockNumber, blockId, prevBlockId, trxId, blockTime);
+        }
+        // Operation is a "comment" which could either be a post or comment
+        if (operationType === 'comment') {
+            // This is a post
+            if (operationData.parent_author === '') {
+                this.postSubscriptions.forEach(sub => {
+                    sub.callback(operationData, blockNumber, blockId, prevBlockId, trxId, blockTime);
+                });
+                // This is a comment
+            }
+            else {
+                this.commentSubscriptions.forEach(sub => {
+                    sub.callback(operationData, blockNumber, blockId, prevBlockId, trxId, blockTime);
+                });
+            }
+        }
+        // This is a transfer
+        if (operationType === 'transfer') {
+            const sender = operationData?.from;
+            const rawAmount = operationData?.amount;
+            const amountParts = typeof rawAmount === 'string' ? rawAmount.split(' ') : [];
+            const transferInfo = {
+                from: sender,
+                to: operationData?.to,
+                rawAmount: rawAmount || '',
+                amount: amountParts[0] || '',
+                asset: amountParts[1] || '',
+                memo: operationData?.memo
+            };
+            const json = utils_2.Utils.jsonParse(operationData.memo);
+            const payload = this.normalizeContractPayload(json?.[this.config.PAYLOAD_IDENTIFIER]);
+            if (payload) {
+                if (this?.adapter?.processTransfer) {
+                    await this.adapter.processTransfer(operationData, payload, {
+                        sender: sender || '',
+                        amount: rawAmount || '',
+                        ...operationMetadata
+                    });
+                }
+                const context = this.buildContractContext('transfer', blockNumber, blockId, prevBlockId, trxId, blockTime, {
+                    sender,
+                    transfer: transferInfo,
+                    operation: {
+                        type: operationType,
+                        data: operationData
+                    }
+                });
+                await this.dispatchContractAction(payload, context);
+            }
+            this.transferSubscriptions.forEach(sub => {
+                if (sub.account === operationData.to) {
+                    sub.callback(operationData, blockNumber, blockId, prevBlockId, trxId, blockTime);
+                }
+            });
+        }
+        // This is a custom JSON operation
+        if (operationType === 'custom_json') {
+            let isSignedWithActiveKey = false;
+            let sender;
+            const id = operationData?.id;
+            if (operationData?.required_auths?.length > 0) {
+                sender = operationData.required_auths[0];
+                isSignedWithActiveKey = true;
+            }
+            else if (operationData?.required_posting_auths?.length > 0) {
+                sender = operationData.required_posting_auths[0];
+                isSignedWithActiveKey = false;
+            }
+            const json = utils_2.Utils.jsonParse(operationData.json);
+            const payload = id === this.config.JSON_ID
+                ? this.normalizeContractPayload(json?.[this.config.PAYLOAD_IDENTIFIER])
+                : null;
+            if (payload) {
+                if (this?.adapter?.processCustomJson) {
+                    await this.adapter.processCustomJson(operationData, payload, {
+                        sender: sender || '',
+                        isSignedWithActiveKey,
+                        ...operationMetadata
+                    });
+                }
+                const context = this.buildContractContext('custom_json', blockNumber, blockId, prevBlockId, trxId, blockTime, {
+                    sender,
+                    customJson: {
+                        id,
+                        json,
+                        isSignedWithActiveKey
+                    },
+                    operation: {
+                        type: operationType,
+                        data: operationData
+                    }
+                });
+                await this.dispatchContractAction(payload, context);
+            }
+            this.customJsonSubscriptions.forEach(sub => {
+                sub.callback(operationData, { sender, isSignedWithActiveKey }, blockNumber, blockId, prevBlockId, trxId, blockTime);
+            });
+            this.customJsonIdSubscriptions.forEach(sub => {
+                if (sub.id === operationData.id) {
+                    sub.callback(operationData, { sender, isSignedWithActiveKey }, blockNumber, blockId, prevBlockId, trxId, blockTime);
+                }
+            });
+            if (id === this.config.HIVE_ENGINE_ID && this.customJsonHiveEngineSubscriptions.length > 0) {
+                const enginePayload = json || {};
+                const { contractName, contractAction, contractPayload } = enginePayload;
+                try {
+                    const txInfo = await this.hive.getTransactionInfo(trxId);
+                    const logs = txInfo && txInfo.logs ? utils_2.Utils.jsonParse(txInfo.logs) : null;
+                    if (txInfo && logs && typeof logs.errors === 'undefined') {
+                        await Promise.all(this.customJsonHiveEngineSubscriptions.map(async (sub) => {
+                            sub.callback(contractName, contractAction, contractPayload, sender, operationData, blockNumber, blockId, prevBlockId, trxId, blockTime);
+                        }));
+                    }
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+        }
+        // Recurrent transfers carry payloads in memo, similar to transfer.
+        if (operationType === 'recurrent_transfer') {
+            const sender = operationData?.from;
+            const json = utils_2.Utils.jsonParse(operationData?.memo);
+            const payload = this.normalizeContractPayload(json?.[this.config.PAYLOAD_IDENTIFIER]);
+            if (payload) {
+                const context = this.buildContractContext('recurrent_transfer', blockNumber, blockId, prevBlockId, trxId, blockTime, {
+                    sender,
+                    operation: {
+                        type: operationType,
+                        data: operationData
+                    }
+                });
+                await this.dispatchContractAction(payload, context);
+            }
+        }
+        if (this.isEscrowOperationType(operationType)) {
+            const escrow = this.buildEscrowDetails(operationType, operationData);
+            const sender = operationData?.from;
+            if (this.adapter?.processEscrow) {
+                await this.adapter.processEscrow(operationType, operationData, operationMetadata);
+            }
+            if (operationType === 'escrow_transfer') {
+                const jsonMeta = utils_2.Utils.jsonParse(operationData?.json_meta);
+                const payload = this.normalizeContractPayload(jsonMeta?.[this.config.PAYLOAD_IDENTIFIER]);
+                if (payload) {
+                    const context = this.buildContractContext('escrow_transfer', blockNumber, blockId, prevBlockId, trxId, blockTime, {
+                        sender,
+                        escrow,
+                        operation: {
+                            type: operationType,
+                            data: operationData
+                        }
+                    });
+                    await this.dispatchContractAction(payload, context);
+                }
+            }
+            this.escrowSubscriptions.forEach(sub => {
+                if (sub.type === operationType) {
+                    sub.callback(operationData, blockNumber, blockId, prevBlockId, trxId, blockTime);
+                }
+            });
+        }
+    }
+    normalizeContractPayload(payload) {
+        if (!payload || typeof payload !== 'object') {
+            return null;
+        }
+        const contract = typeof payload.contract === 'string'
+            ? payload.contract
+            : (typeof payload.name === 'string' ? payload.name : null);
+        const action = typeof payload.action === 'string' ? payload.action : null;
+        if (!contract || !action) {
+            return null;
+        }
+        if (!payload.contract && payload.name && this.config.DEBUG_MODE) {
+            console.warn('[Streamer] Legacy contract payload detected (name/action). Please migrate to { contract, action, payload }.');
+        }
+        return {
+            contract,
+            action,
+            payload: payload.payload ?? {},
+            meta: payload.meta ?? payload.metadata
+        };
+    }
+    isEscrowOperationType(operationType) {
+        return operationType === 'escrow_transfer'
+            || operationType === 'escrow_approve'
+            || operationType === 'escrow_dispute'
+            || operationType === 'escrow_release';
+    }
+    buildEscrowDetails(operationType, operation) {
+        return {
+            type: operationType,
+            from: operation?.from,
+            to: operation?.to,
+            agent: operation?.agent,
+            escrowId: operation?.escrow_id,
+            who: operation?.who,
+            receiver: operation?.receiver,
+            hiveAmount: operation?.hive_amount,
+            hbdAmount: operation?.hbd_amount,
+            fee: operation?.fee,
+            ratificationDeadline: operation?.ratification_deadline,
+            expiration: operation?.escrow_expiration,
+            approved: typeof operation?.approve === 'boolean' ? operation.approve : undefined
+        };
+    }
+    buildContractContext(trigger, blockNumber, blockId, previousBlockId, transactionId, blockTime, details) {
+        return {
+            trigger,
+            streamer: this,
+            adapter: this.adapter,
+            config: this.config,
+            block: {
+                number: blockNumber,
+                id: blockId,
+                previousId: previousBlockId,
+                time: blockTime
+            },
+            transaction: {
+                id: transactionId
+            },
+            sender: details.sender,
+            transfer: details.transfer,
+            customJson: details.customJson,
+            escrow: details.escrow,
+            operation: details.operation
+        };
+    }
+    async dispatchContractAction(payload, context) {
+        const contract = this.contractCache.get(payload.contract) ||
+            this.contracts.find(c => c.name === payload.contract);
+        if (!contract) {
+            console.warn(`[Streamer] Contract '${payload.contract}' not found for action '${payload.action}'`);
+            return;
+        }
+        if (contract && !this.contractCache.has(payload.contract)) {
+            this.contractCache.set(payload.contract, contract);
+        }
+        const actionDefinition = contract.actions?.[payload.action];
+        if (!actionDefinition || typeof actionDefinition.handler !== 'function') {
+            console.warn(`[Streamer] Action '${payload.action}' not found in contract '${payload.contract}'`);
+            return;
+        }
+        if (!this.isActionTriggerAllowed(actionDefinition, context.trigger)) {
+            console.warn(`[Streamer] Action '${payload.action}' does not allow trigger '${context.trigger}'`);
+            return;
+        }
+        if (actionDefinition.requiresActiveKey &&
+            context.trigger === 'custom_json' &&
+            !context.customJson?.isSignedWithActiveKey) {
+            console.warn(`[Streamer] Action '${payload.action}' requires active key signature`);
+            return;
+        }
+        let actionPayload = payload.payload ?? {};
+        if (actionDefinition.schema) {
+            const result = actionDefinition.schema.safeParse(actionPayload);
+            if (!result.success) {
+                console.warn(`[Streamer] Invalid payload for ${payload.contract}.${payload.action}`, {
+                    errors: result.error?.errors
+                });
+                return;
+            }
+            actionPayload = result.data;
+        }
+        try {
+            await actionDefinition.handler(actionPayload, context);
+        }
+        catch (error) {
+            console.error(`[Streamer] Contract action error for ${payload.contract}.${payload.action}:`, error);
+            if (context.trigger === 'time') {
+                throw error;
+            }
+        }
+    }
+    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;
+            }
+            const actionDefinition = contract.actions?.[action.contractAction];
+            if (!actionDefinition || typeof actionDefinition.handler !== 'function') {
+                console.warn(`[Streamer] Action '${action.contractAction}' not found in contract '${action.contractName}' for action '${action.id}'`);
+                continue;
+            }
+            if (!this.isActionTriggerAllowed(actionDefinition, 'time')) {
+                console.warn(`[Streamer] Action '${action.contractAction}' does not allow time triggers 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
+                    const context = this.buildContractContext('time', this.lastBlockNumber, this.blockId, this.previousBlockId, action.id, this.latestBlockchainTime || new Date(), {});
+                    await this.dispatchContractAction({
+                        contract: action.contractName,
+                        action: action.contractAction,
+                        payload: action.payload || {}
+                    }, context);
+                    // 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.contractAction}:`, {
+                        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();
+    }
+    /**
+     * 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);
+    }
+    broadcastOperations(operations, signingKeys) {
+        return utils_2.Utils.broadcastOperations(this.client, operations, signingKeys || this.config.ACTIVE_KEY);
+    }
+    broadcastMultiSigOperations(operations, signingKeys) {
+        return utils_2.Utils.broadcastMultiSigOperations(this.client, operations, signingKeys);
+    }
+    createAuthority(keyAuths = [], accountAuths = [], weightThreshold = 1) {
+        return utils_2.Utils.createAuthority(keyAuths, accountAuths, weightThreshold);
+    }
+    updateAccountAuthorities(account, authorityUpdate, signingKeys) {
+        return utils_2.Utils.updateAccountAuthorities(this.client, this.config, account, authorityUpdate, signingKeys);
+    }
+    escrowTransfer(options, signingKeys) {
+        return utils_2.Utils.escrowTransfer(this.client, this.config, options, signingKeys);
+    }
+    escrowApprove(options, signingKeys) {
+        return utils_2.Utils.escrowApprove(this.client, this.config, options, signingKeys);
+    }
+    escrowDispute(options, signingKeys) {
+        return utils_2.Utils.escrowDispute(this.client, this.config, options, signingKeys);
+    }
+    escrowRelease(options, signingKeys) {
+        return utils_2.Utils.escrowRelease(this.client, this.config, options, signingKeys);
+    }
+    recurrentTransfer(options, signingKeys) {
+        return utils_2.Utils.recurrentTransfer(this.client, this.config, options, signingKeys);
+    }
+    createProposal(options, signingKeys) {
+        return utils_2.Utils.createProposal(this.client, this.config, options, signingKeys);
+    }
+    updateProposalVotes(options, signingKeys) {
+        return utils_2.Utils.updateProposalVotes(this.client, this.config, options, signingKeys);
+    }
+    removeProposals(options, signingKeys) {
+        return utils_2.Utils.removeProposals(this.client, this.config, options, signingKeys);
+    }
+    transferHiveEngineTokens(from, to, symbol, quantity, memo = '') {
+        return utils_2.Utils.transferHiveEngineTokens(this.client, this.config, from, to, quantity, symbol, memo);
+    }
+    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);
+    }
+    getStatus() {
+        return {
+            lastBlockNumber: this.lastBlockNumber,
+            headBlockNumber: this.headBlockNumber,
+            blocksBehind: this.headBlockNumber
+                ? Math.max(0, this.headBlockNumber - this.lastBlockNumber)
+                : 0,
+            latestBlockchainTime: this.latestBlockchainTime,
+            isCatchingUp: this.isCatchingUp
+        };
+    }
+    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 });
+    }
+    onEscrowTransfer(callback) {
+        this.escrowSubscriptions.push({ type: 'escrow_transfer', callback });
+    }
+    onEscrowApprove(callback) {
+        this.escrowSubscriptions.push({ type: 'escrow_approve', callback });
+    }
+    onEscrowDispute(callback) {
+        this.escrowSubscriptions.push({ type: 'escrow_dispute', callback });
+    }
+    onEscrowRelease(callback) {
+        this.escrowSubscriptions.push({ type: 'escrow_release', 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`);
+        }
+        if (this.escrowSubscriptions.length > this.maxSubscriptions) {
+            this.escrowSubscriptions = this.escrowSubscriptions.slice(-this.maxSubscriptions);
+            console.warn(`[Streamer] Trimmed escrowSubscriptions 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);
+    }
+    removeEscrowSubscriptions(type) {
+        if (!type) {
+            this.escrowSubscriptions = [];
+            return;
+        }
+        this.escrowSubscriptions = this.escrowSubscriptions.filter(sub => sub.type !== type);
+    }
+}
+exports.Streamer = Streamer;
 //# sourceMappingURL=streamer.js.map