minBlockTimestamp not working with contract.watchEvents

[sjaiswal1701]

When you supply additional optional like minBlockTimeStamp it will not work because of extra call to the eventWatcher function at line no 129.

Under file src/lib/core/Contract.js

async watchEvent(contractAddress, eventName, options = {}, callback = false) {
        let listener = false;
        let lastBlock = false;
        let since = Date.now() - 1000;

        if (utils.isFunction(options)) {
            callback = options;
            options = {};
        }

        if(!utils.isFunction(callback)) {
            throw new Error('Invalid callback function provided');
        }

        const eventWatcher = async () => {
            try {
                options = Object.assign({
                    eventName,
                    minBlockTimestamp: since,
                    orderBy: 'timestamp,desc',
                    // TODO:
                    // add filters => eventron is already equipped for them
                    // filters: options.filters
                }, options)

                let events;

                if(options.only_data_and_fingerprint) {
                    events = await this.getEvents(contractAddress, options);
                } else {
                    const response = await this.getEvents(contractAddress, options);
                    events = response.data;
                }

                const [latestEvent] = events.sort((a, b) => b.block_timestamp - a.block_timestamp);

                const newEvents = events.filter((event, index) => {
                    const duplicate = events.slice(0, index).some(priorEvent => (
                        JSON.stringify(priorEvent) == JSON.stringify(event)
                    ));

                    if (duplicate) return false;

                    if (!lastBlock) return true;

                    return event.block_timestamp > lastBlock;
                });

                if (latestEvent) lastBlock = latestEvent.block_timestamp;
                return newEvents;

            } catch (ex) {
                return Promise.reject(ex);
            }
        };

        const bindListener = () => {
            if (listener)
                clearInterval(listener);

            listener = setInterval(() => {
                eventWatcher().then(events => events.forEach(event => {
                    callback(null, event)
                })).catch(err => callback(err));
            }, 3000);
        };

        await eventWatcher(); // here it will load the previous events but did not call the callback with those events.
        bindListener();

        return {
            start: bindListener(),
            stop: () => {
                if (!listener)
                    return;

                clearInterval(listener);
                listener = false;
            }
        }
    }