hive-stream 3.0.0 → 3.0.1

package/dist/streamer.js

@@ -19,6 +19,7 @@ class Streamer {
     commentSubscriptions = [];
     postSubscriptions = [];
     transferSubscriptions = [];
+    escrowSubscriptions = [];
     attempts = 0;
     config = config_1.Config;
     client;
@@ -29,6 +30,9 @@ class Streamer {
     blockNumberTimeout = null;
     latestBlockTimer = null;
     lastBlockNumber = 0;
+    headBlockNumber = 0;
+    isPollingBlock = false;
+    isCatchingUp = false;
     blockId;
     previousBlockId;
     transactionId;
@@ -146,9 +150,20 @@ class Streamer {
         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}'`);
+        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
@@ -230,33 +245,42 @@ class Streamer {
         }
         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;
+    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);
     }
-    unregisterContract(name) {
-        // Find the registered contract by it's ID
+    async unregisterContract(name) {
         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();
+            const contract = this.contracts[contractIndex];
+            if (contract?.hooks?.destroy) {
+                await contract.hooks.destroy({
+                    streamer: this,
+                    adapter: this.adapter,
+                    config: this.config
+                });
             }
-            // Remove the contract
             this.contracts.splice(contractIndex, 1);
-            // Remove from cache
             this.contractCache.delete(name);
         }
     }
@@ -290,10 +314,11 @@ class Streamer {
         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;
-            }
+        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();
@@ -317,7 +342,7 @@ class Streamer {
             clearInterval(this.subscriptionCleanupInterval);
         }
         if (this?.adapter?.destroy) {
-            this.adapter.destroy();
+            await this.adapter.destroy();
         }
         await (0, utils_1.sleep)(800);
     }
@@ -334,18 +359,20 @@ class Streamer {
         }
     }
     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 && !this.disableAllProcessing) {
-                this.blockNumberTimeout = setTimeout(() => {
-                    this.getBlock();
-                }, this.config.BLOCK_CHECK_INTERVAL);
+            if (!props) {
                 return;
             }
-            // If the block number we've got is zero
-            // set it to the last irreversible block number
+            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;
             }
@@ -354,20 +381,21 @@ class Streamer {
                 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) {
-                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;
+                for (let i = 0; i < blocksToProcess; i++) {
+                    await this.loadBlock(this.lastBlockNumber + 1);
                 }
             }
-            // 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);
+            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) {
@@ -377,8 +405,13 @@ class Streamer {
                 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(); }, this.config.BLOCK_CHECK_INTERVAL * 2);
+                this.blockNumberTimeout = setTimeout(() => { this.getBlock(); }, nextDelay);
             }
         }
     }
@@ -453,123 +486,292 @@ class Streamer {
         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) {
-            this.adapter.processOperation(op, blockNumber, blockId, prevBlockId, trxId, blockTime);
+            await 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') {
+        if (operationType === 'comment') {
             // This is a post
-            if (op[1].parent_author === '') {
+            if (operationData.parent_author === '') {
                 this.postSubscriptions.forEach(sub => {
-                    sub.callback(op[1], blockNumber, blockId, prevBlockId, trxId, blockTime);
+                    sub.callback(operationData, blockNumber, blockId, prevBlockId, trxId, blockTime);
                 });
                 // This is a comment
             }
             else {
                 this.commentSubscriptions.forEach(sub => {
-                    sub.callback(op[1], blockNumber, blockId, prevBlockId, trxId, blockTime);
+                    sub.callback(operationData, 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 });
-                    }
+        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 === op[1].to) {
-                    sub.callback(op[1], blockNumber, blockId, prevBlockId, trxId, blockTime);
+                if (sub.account === operationData.to) {
+                    sub.callback(operationData, blockNumber, blockId, prevBlockId, trxId, blockTime);
                 }
             });
         }
         // This is a custom JSON operation
-        if (op[0] === 'custom_json') {
+        if (operationType === '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];
+            const id = operationData?.id;
+            if (operationData?.required_auths?.length > 0) {
+                sender = operationData.required_auths[0];
                 isSignedWithActiveKey = true;
             }
-            else if (op[1]?.required_posting_auths?.length > 0) {
-                sender = op[1].required_posting_auths[0];
+            else if (operationData?.required_posting_auths?.length > 0) {
+                sender = operationData.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);
-                    }
+            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(op[1], { sender, isSignedWithActiveKey }, blockNumber, blockId, prevBlockId, trxId, blockTime);
+                sub.callback(operationData, { 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);
+                if (sub.id === operationData.id) {
+                    sub.callback(operationData, { 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;
+            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);
+                        }));
+                    }
                 }
-                else {
-                    sender = op[1].required_posting_auths[0];
-                    isSignedWithActiveKey = false;
+                catch (e) {
+                    console.error(e);
                 }
-                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;
+            }
+        }
+        // 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;
@@ -596,8 +798,13 @@ class Streamer {
                 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}'`);
+            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
@@ -613,7 +820,12 @@ class Streamer {
             if (differenceSeconds >= frequencySeconds) {
                 try {
                     // Execute the action with error isolation
-                    await this.executeAction(action, contract);
+                    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();
@@ -624,7 +836,7 @@ class Streamer {
                 }
                 catch (error) {
                     const err = error instanceof Error ? error : new Error(String(error));
-                    console.error(`[Streamer] Action execution error for ${action.contractName}.${action.contractMethod}:`, {
+                    console.error(`[Streamer] Action execution error for ${action.contractName}.${action.contractAction}:`, {
                         actionId: action.id,
                         error: err.message,
                         stack: err.stack,
@@ -642,18 +854,6 @@ class Streamer {
         // 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
      */
@@ -705,8 +905,44 @@ class Streamer {
     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, 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);
@@ -726,6 +962,17 @@ class Streamer {
     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);
     }
@@ -754,6 +1001,18 @@ class Streamer {
     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
@@ -781,6 +1040,10 @@ class Streamer {
             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) {
@@ -789,6 +1052,13 @@ class Streamer {
     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