trac-msb 0.2.13 → 0.2.15

package/src/core/network/services/PendingRequestService.js

@@ -1,172 +0,0 @@
-import {NetworkOperationType, ResultCode} from '../../../utils/constants.js';
-import {isHexString} from '../../../utils/helpers.js';
-import {V1ProtocolError, V1TimeoutError, V1UnexpectedError} from "../protocols/v1/V1ProtocolError.js";
-import {Config} from '../../../config/config.js';
-import b4a from 'b4a';
-
-const PEER_PUBLIC_KEY_HEX_LENGTH = 64;
-
-class PendingRequestService {
-    #pendingRequests;
-    #requestMessageTypes = [NetworkOperationType.LIVENESS_REQUEST, NetworkOperationType.BROADCAST_TRANSACTION_REQUEST];
-    #config;
-
-    constructor(config) {
-        this.#pendingRequests = new Map(); // Map<id, pendingRequestEntry>
-        this.#config = config;
-    }
-
-    has(id) {
-        return this.#pendingRequests.has(id);
-    }
-
-    isProbePending(peerPubKeyHex) {
-        for (const [, entry] of this.#pendingRequests) {
-            if (entry.requestedTo === peerPubKeyHex && entry.requestType === NetworkOperationType.LIVENESS_REQUEST) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    #validateRegisterInput(peerPubKeyHex, message) {
-        if (!isHexString(peerPubKeyHex) || peerPubKeyHex.length !== PEER_PUBLIC_KEY_HEX_LENGTH) {
-            throw new Error('Invalid peer public key. Expected 32-byte hex string.');
-        }
-
-        if (!message || typeof message !== 'object') {
-            throw new Error('Pending request message must be an object.');
-        }
-
-        if (typeof message.id !== 'string' || message.id.length === 0) {
-            throw new Error('Pending request ID must be a non-empty string.');
-        }
-
-        if (!this.#requestMessageTypes.includes(message.type)) {
-            throw new Error('Unsupported pending request type.');
-        }
-    }
-
-    /*
-    @returns {Promise}
-    */
-    registerPendingRequest(peerPubKeyHex, message) {
-        this.#validateRegisterInput(peerPubKeyHex, message);
-        const id = message.id;
-        if (this.#pendingRequests.size >= this.#config.maxPendingRequestsInPendingRequestsService) {
-            throw new Error('Maximum number of pending requests reached.');
-        }
-
-        if (this.#pendingRequests.has(id)) {
-            throw new Error(`Pending request with ID ${id} from peer ${peerPubKeyHex} already exists.`);
-        }
-
-        const entry = {
-            id: id,
-            requestType: message.type,
-            requestTxData: this.#extractRequestTxData(message),
-            requestedTo: peerPubKeyHex,
-            timeoutMs: this.#config.pendingRequestTimeout,
-            timeoutId: null,
-            resolve: null,
-            reject: null,
-        }
-
-        const promise = new Promise((resolve, reject) => {
-            entry.resolve = resolve;
-            entry.reject = reject;
-        });
-
-        entry.timeoutId = setTimeout(() => {
-            this.rejectPendingRequest(
-                id,
-                new V1TimeoutError(
-                    `Pending request with ID ${id} from peer ${peerPubKeyHex} timed out after ${entry.timeoutMs} ms.`,
-                    true
-                ));
-
-        }, entry.timeoutMs);
-
-        this.#pendingRequests.set(id, entry);
-        return promise;
-    }
-
-    #extractRequestTxData(message) {
-        if (message.type !== NetworkOperationType.BROADCAST_TRANSACTION_REQUEST) return null;
-        const txData = message.broadcast_transaction_request?.data;
-        return b4a.isBuffer(txData) ? txData : null;
-    }
-
-    getAndDeletePendingRequest(id) {
-        const entry = this.#pendingRequests.get(id);
-        if (!entry) return null;
-
-        clearTimeout(entry.timeoutId);
-        this.#pendingRequests.delete(id);
-        return entry;
-    }
-
-    getPendingRequest(id) {
-        const entry = this.#pendingRequests.get(id);
-        if (!entry) return null;
-        return entry;
-    }
-
-    // for now, we are resolving only resultCode, but we can extend it in the future if needed...
-    resolvePendingRequest(id, resultCode = ResultCode.OK) {
-        const entry = this.getAndDeletePendingRequest(id);
-        if (!entry) return false;
-        entry.resolve(resultCode);
-        return true;
-    }
-
-    rejectPendingRequest(id, error) {
-        const entry = this.getAndDeletePendingRequest(id);
-        if (!entry) return false;
-        const err = error instanceof V1ProtocolError
-            ? error
-            : new V1UnexpectedError(error?.message ?? 'Unexpected error');
-        entry.reject(err);
-        return true;
-    }
-
-    rejectPendingRequestsForPeer(peerPubKeyHex, error) {
-        const idsToReject = [];
-        for (const [id, entry] of this.#pendingRequests) {
-            if (entry.requestedTo === peerPubKeyHex) idsToReject.push(id);
-        }
-
-        for (const id of idsToReject) {
-            this.rejectPendingRequest(id, error);
-        }
-
-        return idsToReject.length;
-    }
-
-    stopPendingRequestTimeout(id) {
-        const entry = this.#pendingRequests.get(id);
-        if (!entry) return false;
-
-        clearTimeout(entry.timeoutId);
-        entry.timeoutId = null;
-        return true;
-    }
-
-    close() {
-        for (const [id, entry] of this.#pendingRequests) {
-            clearTimeout(entry.timeoutId);
-            try {
-                entry.reject(
-                    new V1UnexpectedError(
-                        `Pending request ${id} cancelled (shutdown).`,
-                        false)
-                );
-            } catch (error) {
-                console.error(`PendingRequestService.close: failed to reject pending request ${id}:`, error);
-            }
-        }
-        this.#pendingRequests.clear();
-    }
-}
-
-export default PendingRequestService;

package/src/core/network/services/TransactionCommitService.js

@@ -1,149 +0,0 @@
-import {isHexString} from '../../../utils/helpers.js';
-import {TRANSACTION_COMMIT_SERVICE_BUFFER_SIZE} from '../../../utils/constants.js';
-
-const TX_HASH_HEX_STRING_LENGTH = 64;
-
-class TransactionCommitService {
-    #pendingCommits;
-    #config;
-
-    constructor(config) {
-        this.#pendingCommits = new Map(); // Map<txHash, pendingCommitEntry>
-        this.#config = config;
-    }
-
-    #assertTxHash(txHash) {
-        if (!isHexString(txHash) || txHash.length !== TX_HASH_HEX_STRING_LENGTH) {
-            throw new PendingCommitInvalidTxHashError(txHash);
-        }
-    }
-
-    has(txHash) {
-        this.#assertTxHash(txHash);
-        return this.#pendingCommits.has(txHash);
-    }
-
-    /*
-        @returns {Promise}
-    */
-    registerPendingCommit(txHash) {
-        this.#assertTxHash(txHash);
-
-        if (this.#pendingCommits.size >= TRANSACTION_COMMIT_SERVICE_BUFFER_SIZE) {
-            throw new PendingCommitBufferFullError(TRANSACTION_COMMIT_SERVICE_BUFFER_SIZE);
-        }
-
-        if (this.#pendingCommits.has(txHash)) {
-            throw new PendingCommitAlreadyExistsError(txHash);
-        }
-
-        const timeoutMs = this.#config.txCommitTimeout;
-
-        const entry = {
-            txHash,
-            timeoutMs,
-            timeoutId: null,
-            resolve: null,
-            reject: null,
-        };
-
-        const promise = new Promise((resolve, reject) => {
-            entry.resolve = resolve;
-            entry.reject = reject;
-        });
-
-        entry.timeoutId = setTimeout(() => {
-            this.rejectPendingCommit(
-                txHash,
-                new PendingCommitTimeoutError(txHash, timeoutMs)
-            );
-        }, timeoutMs);
-
-        this.#pendingCommits.set(txHash, entry);
-        return promise;
-    }
-
-    getAndDeletePendingCommit(txHash) {
-        this.#assertTxHash(txHash);
-        const entry = this.#pendingCommits.get(txHash);
-        if (!entry) return null;
-
-        clearTimeout(entry.timeoutId);
-        this.#pendingCommits.delete(txHash);
-        return entry;
-    }
-
-    resolvePendingCommit(txHash, receipt = null) {
-        this.#assertTxHash(txHash);
-        const entry = this.getAndDeletePendingCommit(txHash);
-        if (!entry) return false;
-        entry.resolve(receipt);
-        return true;
-    }
-
-    rejectPendingCommit(txHash, error) {
-        this.#assertTxHash(txHash);
-        const entry = this.getAndDeletePendingCommit(txHash);
-        if (!entry) return false;
-
-        entry.reject(
-            error instanceof Error
-                ? error
-                : new PendingCommitUnexpectedError('Unexpected commit error')
-        );
-
-        return true;
-    }
-
-    close() {
-        for (const [txHash, entry] of this.#pendingCommits) {
-            clearTimeout(entry.timeoutId);
-            try {
-                entry.reject(
-                    new PendingCommitCancelledError(txHash)
-                );
-            } catch (error) {
-                console.error(`TransactionCommitService.close: failed to reject pending commit ${txHash}:`, error);
-            }
-        }
-        this.#pendingCommits.clear();
-    }
-}
-
-export default TransactionCommitService;
-
-export class PendingCommitInvalidTxHashError extends Error {
-    constructor(txHash) {
-        super(`Invalid txHash format: ${txHash}`);
-    }
-}
-
-export class PendingCommitBufferFullError extends Error {
-    constructor(limit) {
-        super(`Maximum number of pending commits reached (limit=${limit}).`);
-    }
-}
-
-export class PendingCommitAlreadyExistsError extends Error {
-    constructor(txHash) {
-        super(`Pending commit for txHash ${txHash} already exists.`);
-    }
-}
-
-export class PendingCommitTimeoutError extends Error {
-    constructor(txHash, timeoutMs) {
-        super(`Pending commit for txHash ${txHash} timed out after ${timeoutMs} ms.`);
-    }
-}
-
-export class PendingCommitCancelledError extends Error {
-    constructor(txHash) {
-        super(`Pending commit ${txHash} cancelled (shutdown).`);
-    }
-}
-
-export class PendingCommitUnexpectedError extends Error {
-    constructor(message = 'Unexpected commit error') {
-        super(message);
-    }
-}

package/src/core/network/services/ValidatorHealthCheckService.js

@@ -1,127 +0,0 @@
-import ReadyResource from 'ready-resource';
-import b4a from 'b4a';
-import { generateUUID } from '../../../utils/helpers.js';
-import { EventType } from '../../../utils/constants.js';
-import { Logger } from '../../../utils/logger.js';
-
-const DEFAULT_HEALTH_CHECK_INTERVAL_MS = 300000; // 5 minutes
-class ValidatorHealthCheckService extends ReadyResource {
-    #config;
-    #intervalMs;
-    #timers;
-    #logger;
-
-    /**
-     * @param {object} config
-     */
-    constructor(config = {}) {
-        super();
-        this.#config = config;
-        this.#timers = new Map();
-        this.#logger = new Logger(config);
-
-        const interval = this.#config.validatorHealthCheckInterval;
-        this.#intervalMs = interval ? this.#checkInterval(interval) : DEFAULT_HEALTH_CHECK_INTERVAL_MS;
-
-        this.#logger.debug(`initialized with intervalMs ${this.#intervalMs}`);
-    }
-
-    get size() {
-        return this.#timers.size;
-    }
-
-    async _open() {
-        this.#logger.debug('open: health check service ready');
-    }
-
-    async _close() {
-        this.#logger.debug('close: stopping all health checks');
-        this.#stopAll();
-        this.#timers.clear();
-    }
-
-    /**
-     * Start periodic health checks for a validator.
-     * @param {String} publicKey
-     */
-    start(publicKey) {
-        if (!this.opened) {
-            throw new Error('start: service not ready. Call ready() before start().');
-        }
-        const publicKeyHex = this.#normalizePublicKey(publicKey);
-        if (this.#timers.has(publicKeyHex)) {
-            this.#logger.debug(`start: already scheduled for ${publicKey}`);
-            return false; // TODO: Implement better error handling
-        }
-
-        const timerId = setInterval(() => {
-            this.#emitHealthCheck(publicKeyHex);
-        }, this.#intervalMs);
-
-        this.#timers.set(publicKeyHex, { timerId, intervalMs: this.#intervalMs });
-        this.#logger.debug(`start: scheduled health checks for ${publicKeyHex} every ${this.#intervalMs} ms`);
-
-        return true;
-    }
-
-    /**
-     * Stop periodic health checks for a validator.
-     * @param {String} publicKey
-     * @returns {boolean} true if stopped, false if not scheduled
-     */
-    stop(publicKey) {
-        const publicKeyHex = this.#normalizePublicKey(publicKey);
-        const entry = this.#timers.get(publicKeyHex);
-        if (!entry) {
-            this.#logger.debug(`stop: did not find scheduled health check for public key ${publicKey}. Aborting`);
-            return false;
-        }
-        clearInterval(entry.timerId);
-        this.#timers.delete(publicKeyHex);
-        this.#logger.debug(`stop: cancelled health checks for ${publicKeyHex}`);
-        return true;
-    }
-
-    /**
-     * Check if a validator is scheduled.
-     * @param {String} publicKey
-     * @returns {boolean}
-     */
-    has(publicKey) {
-        return this.#timers.has(this.#normalizePublicKey(publicKey));
-    }
-
-    async #emitHealthCheck(publicKey) {
-        try {
-            const requestId = generateUUID();
-            this.emit(EventType.VALIDATOR_HEALTH_CHECK, publicKey, requestId);
-            this.#logger.debug(`Emitted health check event for ${publicKey} with requestId ${requestId}`);
-        } catch (error) {
-            this.#logger.error(`ValidatorHealthCheckService: Failed to emit health check for ${publicKey}: ${error?.message || error}`);
-        }
-    }
-
-    #stopAll() {
-        this.#logger.debug(`stopAll: cancelling health checks for ${this.#timers.size} validators`);
-        for (const publicKey of this.#timers.keys()) {
-            this.stop(publicKey);
-        }
-    }
-
-    #checkInterval(intervalMs) {
-        const ms = Number(intervalMs);
-        if (!Number.isFinite(ms) || ms <= 0) {
-            throw new RangeError(`ValidatorHealthCheckService: invalid intervalMs value: ${intervalMs}`);
-        }
-        return ms;
-    }
-
-    // TODO: This method is used in multiple places. Consider moving it to a utility file or exposing it from PeerWallet.
-    #normalizePublicKey(publicKey) {
-        if (b4a.isBuffer(publicKey)) return publicKey.toString('hex');
-        if (typeof publicKey === 'string') return publicKey.toLowerCase();
-        throw new TypeError('ValidatorHealthCheckService: publicKey must be a Buffer or hex string');
-    }
-}
-
-export default ValidatorHealthCheckService;

package/src/utils/deepEqualApplyPayload.js

@@ -1,40 +0,0 @@
-import b4a from 'b4a';
-import _ from 'lodash';
-
-export const isDeepEqualApplyPayload = (left, right) => {
-    if (left === right) return true;
-
-    const leftIsBuffer = b4a.isBuffer(left);
-    const rightIsBuffer = b4a.isBuffer(right);
-
-    if (leftIsBuffer || rightIsBuffer) {
-        return leftIsBuffer && rightIsBuffer && b4a.equals(left, right);
-    }
-
-    const leftIsArray = Array.isArray(left);
-    const rightIsArray = Array.isArray(right);
-
-    if (leftIsArray || rightIsArray) {
-        if (!leftIsArray || !rightIsArray) return false;
-        if (left.length !== right.length) return false;
-
-        for (let i = 0; i < left.length; i++) {
-            if (!isDeepEqualApplyPayload(left[i], right[i])) return false;
-        }
-        return true;
-    }
-
-    if (!_.isObject(left) || !_.isObject(right)) return false;
-
-    const leftKeys = Object.keys(left);
-    const rightKeys = Object.keys(right);
-
-    if (leftKeys.length !== rightKeys.length) return false;
-
-    for (const key of leftKeys) {
-        if (!Object.prototype.hasOwnProperty.call(right, key)) return false;
-        if (!isDeepEqualApplyPayload(left[key], right[key])) return false;
-    }
-
-    return true;
-};

package/src/utils/logger.js

@@ -1,25 +0,0 @@
-export class Logger {
-    #config
-    constructor(config) {
-        this.#config = config;
-    }
-
-    info(message) {
-        console.log("i: " + message);
-    }
-
-    debug(message) {
-        if (this.#config.debug) {
-            console.debug("d: " + message);
-        }
-    }
-
-    error(message) {
-        console.error("e: " + message);
-    }
-
-    warn(message) {
-        console.warn("w: " + message);
-    }
-
-}