@gear-js/api/lib/cjs/events/Events.js

A JavaScript library that provides functionality to connect GEAR Component APIs.

'use strict';

class GearEvents {
    api;
    constructor(gearApi) {
        this.api = gearApi;
    }
    subscribeToGearEvent(method, callback, fromBlock, blocks = 'latest') {
        const handler = (events) => {
            events
                .filter(({ event }) => event.method === method)
                .forEach(({ event }) => {
                callback(event);
            });
        };
        if (fromBlock) {
            return this.api.blocks.subscribeToHeadsFrom(fromBlock, (header) => {
                this.api
                    .at(header.hash)
                    .then((apiAt) => apiAt.query.system.events())
                    .then(handler);
            }, blocks);
        }
        if (blocks === 'latest') {
            return this.api.query.system.events(handler);
        }
        return this.api.rpc.chain.subscribeFinalizedHeads((header) => {
            this.api
                .at(header.hash)
                .then((apiAt) => apiAt.query.system.events())
                .then(handler);
        });
    }
    subscribeToGearVoucherEvent(method, callback) {
        return this.api.query.system.events((events) => {
            events
                .filter(({ event }) => event.method === method)
                .forEach(({ event }) => {
                callback(event);
            });
        });
    }
    #umsActorsMatch(from, to, event) {
        if (event.data.message.source.eq(from) || event.data.message.destination.eq(to)) {
            return true;
        }
        return false;
    }
    subscribeToUserMessageSentByActor(options, callback) {
        return this.api.query.system.events((events) => {
            events
                .filter(({ event }) => event.method === 'UserMessageSent')
                .forEach(({ event }) => {
                if (this.#umsActorsMatch(options.from, options.to, event)) {
                    callback(event);
                }
            });
        });
    }
    subscribeToTransferEvents(callback) {
        return this.api.query.system.events((events) => {
            events
                .filter(({ event }) => this.api.events.balances.Transfer.is(event))
                .forEach(({ event }) => {
                callback(event);
            });
        });
    }
    /**
     * @deprecated Use api.blocks.subscribeNewHeads instead
     */
    subscribeToNewBlocks(callback) {
        return this.api.rpc.chain.subscribeNewHeads((header) => {
            callback(header);
        });
    }
    async subscribeToBalanceChanges(accountAddress, callback) {
        let { data: { free: previousFree }, } = (await this.api.query.system.account(accountAddress));
        return this.api.query.system.account(accountAddress, ({ data: { free: currentFree } }) => {
            if (!currentFree.sub(previousFree).isZero()) {
                callback(this.api.createType('Balance', currentFree));
                previousFree = currentFree;
            }
        });
    }
}

exports.GearEvents = GearEvents;