@rsksmart/rif-storage-pinning/lib/communication/index.js

Application for providing your storage space to other to use in exchange of RIF Tokens

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.broadcast = exports.stop = exports.start = void 0;
const config_1 = __importDefault(require("config"));
const transport_1 = require("./transport");
const logger_1 = require("../logger");
const message_model_1 = __importDefault(require("../models/message.model"));
const definitions_1 = require("../definitions");
const logger = logger_1.loggingFactory('comms');
const COMMUNICATION_PROTOCOL_VERSION = 1;
let transport;
function start(offerId, contractAddress) {
    return __awaiter(this, void 0, void 0, function* () {
        const transportType = config_1.default.get('comms.transport');
        switch (transportType.toLowerCase()) {
            case definitions_1.CommunicationTransport.Libp2p:
                transport = yield transport_1.initLibp2pTransport(offerId, contractAddress);
                break;
            case definitions_1.CommunicationTransport.Cache:
                transport = yield transport_1.initCacheTransport(offerId, contractAddress);
                break;
            default:
                transport = yield transport_1.initCacheTransport(offerId, contractAddress);
                break;
        }
    });
}
exports.start = start;
function stop() {
    transport.stop();
}
exports.stop = stop;
function broadcast(code, payload) {
    return __awaiter(this, void 0, void 0, function* () {
        if (!transport) {
            throw new Error('Communication was not started yet!');
        }
        if (code !== definitions_1.MessageCodesEnum.E_GENERAL && !payload.agreementReference) {
            throw new Error('Every broadcasted message has to have Agreement Reference!');
        }
        const msg = {
            code,
            payload,
            version: COMMUNICATION_PROTOCOL_VERSION,
            timestamp: Date.now()
        };
        logger.verbose(`Broadcasting message with code: ${code}`);
        yield message_model_1.default.create({
            code,
            agreementReference: payload.agreementReference,
            message: JSON.stringify(msg)
        });
        // Remove old messages
        const messageLimit = config_1.default.get('comms.countOfMessagesPersistedPerAgreement');
        if (payload.agreementReference) {
            const messagesToDelete = yield message_model_1.default.findAll({
                offset: messageLimit,
                order: [['id', 'DESC']],
                where: { agreementReference: payload.agreementReference }
            });
            yield Promise.all(messagesToDelete.map(msg => msg.destroy()));
        }
        else {
            const messagesWithoutAgreement = yield message_model_1.default.findAll({
                offset: messageLimit,
                order: [['id', 'DESC']],
                where: { agreementReference: null }
            });
            yield Promise.all(messagesWithoutAgreement.map(msg => msg.destroy()));
        }
        yield transport.broadcast(msg).catch(logger.error);
    });
}
exports.broadcast = broadcast;