trac-msb 0.2.7 → 0.2.9

package/src/core/network/messaging/NetworkMessages.js

@@ -1,63 +0,0 @@
-
-import Protomux from 'protomux';
-import b4a from 'b4a';
-import c from 'compact-encoding';
-import NetworkMessageRouter from './routes/NetworkMessageRouter.js';
-
-class NetworkMessages {
-    #messageRouter;
-    #network;
-    #options;
-
-    constructor(network, options = {}) {
-        this.#network = network;
-        this.#options = options;
-    }
-
-    get network() {
-        return this.#network;
-    }
-
-    initializeMessageRouter(state, wallet) {
-        this.#messageRouter = new NetworkMessageRouter(
-            this.network,
-            state,
-            wallet,
-            this.#options
-        );
-    }
-
-    async setupProtomuxMessages(connection) {
-        const mux = Protomux.from(connection);
-        connection.userData = mux;
-        const message_channel = mux.createChannel({
-            protocol: b4a.toString(this.network.channel, 'utf8'),
-            onopen() { },
-            onclose() { }
-        });
-
-        message_channel.open();
-
-        const messageProtomux = message_channel.addMessage({
-            encoding: c.json,
-            onmessage: async (incomingMessage) => {
-                try {
-                    if (typeof incomingMessage === 'object' || typeof incomingMessage === 'string') {
-                        await this.#messageRouter.route(incomingMessage, connection, messageProtomux);
-                    } else {
-                        throw new Error('NetworkMessages: Received message is undefined');
-                    }
-                } catch (error) {
-                    console.error(`NetworkMessages: Failed to handle incoming message: ${error.message}`);
-                } finally {
-                    this.network.swarm.leavePeer(connection.remotePublicKey);
-                }
-            }
-        });
-
-        connection.messenger = messageProtomux;
-        return { message_channel, message: messageProtomux };
-    }
-}
-
-export default NetworkMessages;

package/src/core/network/messaging/handlers/GetRequestHandler.js

@@ -1,112 +0,0 @@
-import { NETWORK_MESSAGE_TYPES } from '../../../../utils/constants.js';
-import PeerWallet from 'trac-wallet';
-import b4a from 'b4a';
-import { blake3Hash } from '../../../../utils/crypto.js';
-
-class GetRequestHandler {
-    #wallet;
-    #state;
-
-    constructor(wallet, state) {
-        this.#wallet = wallet;
-        this.#state = state;
-    }
-
-    get state() {
-        return this.#state;
-    }
-
-    async handle(message, messageProtomux, connection, channelString) {
-        switch (message) {
-            case NETWORK_MESSAGE_TYPES.GET.VALIDATOR:
-                await this.handleGetValidatorResponse(messageProtomux, connection, channelString);
-                break;
-            case NETWORK_MESSAGE_TYPES.GET.ADMIN:
-                await this.handleGetAdminRequest(messageProtomux, connection, channelString);
-                break;
-            case NETWORK_MESSAGE_TYPES.GET.NODE:
-                await this.handleCustomNodeRequest(messageProtomux, connection, channelString);
-                break;
-            default:
-                throw new Error(`Unhandled GET type: ${message}`);
-        }
-    }
-
-    async handleGetValidatorResponse(messageProtomux, connection, channelString) {
-        const nonce = PeerWallet.generateNonce().toString('hex');
-        const payload = {
-            op: 'validatorResponse',
-            wk: this.state.writingKey.toString('hex'),
-            address: this.#wallet.address,
-            nonce: nonce,
-            channel: channelString,
-            issuer: connection.remotePublicKey.toString('hex'),
-            timestamp: Date.now(),
-        };
-
-        const hash = await blake3Hash(JSON.stringify(payload));
-        const sig = this.#wallet.sign(hash);
-
-        const responseMessage = {
-            ...payload,
-            sig: sig.toString('hex'),
-        };
-        messageProtomux.send(responseMessage);
-    }
-
-    async handleGetAdminRequest(messageProtomux, connection, channelString) {
-        const adminEntry = await this.state.getAdminEntry();
-        if (adminEntry === null) {
-            throw new Error("Admin entry is null. This is not possible to create admin stream.");
-        }
-
-        const adminPublicKey = PeerWallet.decodeBech32m(adminEntry.address);
-
-        if (!b4a.equals(this.#wallet.publicKey, adminPublicKey)) {
-            throw new Error("You are not an admin. This is not possible to create admin stream.");
-        }
-
-        const nonce = PeerWallet.generateNonce().toString('hex');
-        const payload = {
-            op: 'adminResponse',
-            wk: this.state.writingKey.toString('hex'),
-            address: this.#wallet.address,
-            nonce: nonce,
-            channel: channelString,
-            issuer: connection.remotePublicKey.toString('hex'),
-            timestamp: Date.now(),
-        };
-        const hash = await blake3Hash(JSON.stringify(payload));
-        const sig = this.#wallet.sign(hash);
-
-        const responseMessage = {
-            ...payload,
-            sig: sig.toString('hex'),
-        };
-        messageProtomux.send(responseMessage);
-    }
-
-    async handleCustomNodeRequest(messageProtomux, connection, channelString) {
-        const nonce = PeerWallet.generateNonce().toString('hex');
-        const payload = {
-            op: 'nodeResponse',
-            address: this.#wallet.address,
-            nonce: nonce,
-            channel: channelString,
-            issuer: connection.remotePublicKey.toString('hex'),
-            timestamp: Date.now(),
-        };
-        
-        const hash = await blake3Hash(JSON.stringify(payload));
-        const sig = this.#wallet.sign(hash);
-
-        const responseMessage = {
-            ...payload,
-            sig: sig.toString('hex'),
-        };
-        messageProtomux.send(responseMessage);
-
-    }
-}
-
-export default GetRequestHandler;

package/src/core/network/messaging/handlers/ResponseHandler.js

@@ -1,108 +0,0 @@
-import { NETWORK_MESSAGE_TYPES } from '../../../../utils/constants.js';
-import ValidatorResponse from '../validators/ValidatorResponse.js';
-import AdminResponse from '../validators/AdminResponse.js';
-import CustomNodeResponse from '../validators/CustomNodeResponse.js';
-import PeerWallet from 'trac-wallet';
-import b4a from "b4a";
-
-class ResponseHandler {
-    #network;
-    #state;
-    #responseValidator;
-    #adminValidator;
-    #customNodeValidator;
-    
-    constructor(network, state, wallet) {
-        this.#network = network;
-        this.#state = state;
-        this.#responseValidator = new ValidatorResponse(this.state, wallet);
-        this.#adminValidator = new AdminResponse(this.state, wallet);
-        this.#customNodeValidator = new CustomNodeResponse(this.state, wallet);
-
-    }
-
-    get network() {
-        return this.#network;
-    }
-
-    get state() {
-        return this.#state;
-    }
-
-    get responseValidator() {
-        return this.#responseValidator;
-    }
-
-    get adminValidator() {
-        return this.#adminValidator;
-    }
-    
-    get customNodeValidator() {
-        return this.#customNodeValidator;
-    }
-
-    async handle(message, connection, channelString) {
-        switch (message.op) {
-            case NETWORK_MESSAGE_TYPES.RESPONSE.VALIDATOR:
-                await this.#handleValidatorResponse(message, connection, channelString);
-                break;
-            case NETWORK_MESSAGE_TYPES.RESPONSE.ADMIN:
-                await this.#handleAdminResponse(message, connection, channelString);
-                break;
-            case NETWORK_MESSAGE_TYPES.RESPONSE.NODE:
-                await this.#handleCustomNodeResponse(message, connection, channelString);
-                break;
-            default:
-                throw new Error(`Unhandled RESPONSE type: ${message}`);
-        }
-    }
-
-    async #handleValidatorResponse(message, connection, channelString) {
-        const isValid = await this.responseValidator.validate(message, channelString);
-        if (isValid) {
-            const validatorAddressString = message.address;
-            const validatorPublicKey = PeerWallet.decodeBech32m(validatorAddressString);
-
-            if (this.network.validatorConnectionManager.connected(validatorPublicKey)) {
-                return;
-            }
-
-            console.log('Validator stream established', validatorAddressString);
-            this.network.validatorConnectionManager.addValidator(validatorPublicKey, connection)
-        } else {
-            throw new Error("Validator response verification failed");
-        }
-    }
-
-    async #handleAdminResponse(message, connection, channelString) {
-        const isValid = await this.adminValidator.validate(message, channelString);
-        if (isValid) {
-            const adminEntry = await this.state.getAdminEntry();
-            const adminPublicKey = PeerWallet.decodeBech32m(adminEntry.address);
-
-            console.log('Admin stream established:', adminEntry.address);
-            this.network.admin_stream = connection;
-            this.network.admin = adminPublicKey;
-        } else {
-            throw new Error("Admin response verification failed");
-        }
-    }
-
-    async #handleCustomNodeResponse(message, connection, channelString) {
-        const isValid = await this.customNodeValidator.validate(message, channelString);
-        if (isValid) {
-            const customNodeAddressString = message.address;
-            const customNodePublicKey = PeerWallet.decodeBech32m(customNodeAddressString);
-
-            console.log('Custom node stream established:', customNodeAddressString);
-            this.network.custom_stream = connection;
-            this.network.custom_node = customNodePublicKey;
-        } else {
-            throw new Error("Custom node response verification failed");
-        }
-    }
-
-
-}
-
-export default ResponseHandler;

package/src/core/network/messaging/handlers/RoleOperationHandler.js

@@ -1,116 +0,0 @@
-import {OperationType} from '../../../../utils/constants.js';
-import PartialRoleAccess from "../validators/PartialRoleAccess.js";
-import {addressToBuffer} from "../../../state/utils/address.js";
-import CompleteStateMessageOperations
-    from "../../../../messages/completeStateMessages/CompleteStateMessageOperations.js";
-import {normalizeHex} from "../../../../utils/helpers.js";
-import BaseOperationHandler from './base/BaseOperationHandler.js';
-
-class RoleOperationHandler extends BaseOperationHandler {
-    #partialRoleAccessValidator;
-    #wallet;
-    #network;
-
-    constructor(network, state, wallet, rateLimiter, options = {}) {
-        super(network, state, wallet, rateLimiter, options);
-        this.#wallet = wallet;
-        this.#network = network;
-        this.#partialRoleAccessValidator = new PartialRoleAccess(state)
-    }
-
-    get wallet() {
-        return this.#wallet;
-    }
-
-    get network() {
-        return this.#network;
-    }
-
-    get partialRoleAccessValidator() {
-        return this.#partialRoleAccessValidator;
-    }
-
-    async handleOperation(message, connection) {
-        const normalizedPartialRoleAccessPayload = this.#normalizePartialRoleAccess(message)
-        const isValid = await this.partialRoleAccessValidator.validate(normalizedPartialRoleAccessPayload)
-        let completePayload = null
-        if (!isValid) {
-            throw new Error("OperationHandler: partial role access payload validation failed.");
-        }
-        
-        switch (normalizedPartialRoleAccessPayload.type) {
-            case OperationType.ADD_WRITER:
-                completePayload = await CompleteStateMessageOperations.assembleAddWriterMessage(
-                    this.wallet,
-                    normalizedPartialRoleAccessPayload.address,
-                    normalizedPartialRoleAccessPayload.rao.tx,
-                    normalizedPartialRoleAccessPayload.rao.txv,
-                    normalizedPartialRoleAccessPayload.rao.iw,
-                    normalizedPartialRoleAccessPayload.rao.in,
-                    normalizedPartialRoleAccessPayload.rao.is,
-                );
-                break;
-            case OperationType.REMOVE_WRITER:
-                completePayload = await CompleteStateMessageOperations.assembleRemoveWriterMessage(
-                    this.wallet,
-                    normalizedPartialRoleAccessPayload.address,
-                    normalizedPartialRoleAccessPayload.rao.tx,
-                    normalizedPartialRoleAccessPayload.rao.txv,
-                    normalizedPartialRoleAccessPayload.rao.iw,
-                    normalizedPartialRoleAccessPayload.rao.in,
-                    normalizedPartialRoleAccessPayload.rao.is,
-                );
-                break;
-            case OperationType.ADMIN_RECOVERY:
-                completePayload = await CompleteStateMessageOperations.assembleAdminRecoveryMessage(
-                    this.wallet,
-                    normalizedPartialRoleAccessPayload.address,
-                    normalizedPartialRoleAccessPayload.rao.tx,
-                    normalizedPartialRoleAccessPayload.rao.txv,
-                    normalizedPartialRoleAccessPayload.rao.iw,
-                    normalizedPartialRoleAccessPayload.rao.in,
-                    normalizedPartialRoleAccessPayload.rao.is,
-                );
-                console.log("Assembled complete role access operation:", completePayload);
-                break;
-            default:
-                throw new Error("OperationHandler: Assembling complete role access operation failed due to unsupported operation type.");
-        }
-
-        if (!completePayload) {
-            throw new Error("OperationHandler: Assembling complete role access operation failed.");
-        }
-
-        this.network.transactionPoolService.addTransaction(completePayload)
-    }
-
-    #normalizePartialRoleAccess(payload) {
-        if (!payload || typeof payload !== 'object' || !payload.rao) {
-            throw new Error('Invalid payload for bootstrap deployment normalization.');
-        }
-        const {type, address, rao} = payload;
-        if (
-            !type ||
-            !address ||
-            !rao.tx || !rao.txv || !rao.iw || !rao.in || !rao.is
-        ) {
-            throw new Error('Missing required fields in bootstrap deployment payload.');
-        }
-
-        const normalizedRao = {
-            tx: normalizeHex(rao.tx),
-            txv: normalizeHex(rao.txv),
-            iw: normalizeHex(rao.iw),
-            in: normalizeHex(rao.in),
-            is: normalizeHex(rao.is)
-        };
-
-        return {
-            type,
-            address: addressToBuffer(address),
-            rao: normalizedRao
-        };
-    }
-}
-
-export default RoleOperationHandler;

package/src/core/network/messaging/handlers/SubnetworkOperationHandler.js

@@ -1,143 +0,0 @@
-import BaseOperationHandler from './base/BaseOperationHandler.js';
-import CompleteStateMessageOperations from "../../../../messages/completeStateMessages/CompleteStateMessageOperations.js";
-import {
-    OperationType
-} from '../../../../utils/constants.js';
-import PartialBootstrapDeployment from "../validators/PartialBootstrapDeployment.js";
-import {addressToBuffer, bufferToAddress} from "../../../state/utils/address.js";
-import PartialTransaction from "../validators/PartialTransaction.js";
-import {normalizeHex} from "../../../../utils/helpers.js";
-
-/**
- * THIS CLASS IS ULTRA IMPORTANT BECAUSE IF SOMEONE WILL SEND A TRASH TO VALIDATOR AND IT WON'T BE HANDLED PROPERTLY -
- * FOR EXAMPLE VALIDATOR WILL BROADCAST IT TO THE INDEXER LAYER THEN IT WILL BE BANNED. SO EVERYTHING WHAT IS TRASH
- * MUST BE REFUSED.
- * TODO: WE SHOULD AUDIT VALIDATORS AND MAKE SURE THEY ARE NOT BROADCASTING TRASH TO THE INDEXER LAYER.
- */
-
-class SubnetworkOperationHandler extends BaseOperationHandler {
-    #partialBootstrapDeploymentValidator;
-    #partialTransactionValidator;
-
-    constructor(network, state, wallet, rateLimiter, options = {}) {
-        super(network, state, wallet, rateLimiter, options);
-        this.#partialBootstrapDeploymentValidator = new PartialBootstrapDeployment(this.state);
-        this.#partialTransactionValidator = new PartialTransaction(this.state);
-    }
-
-    async handleOperation(payload) {
-        if (payload.type === OperationType.TX) {
-            await this.#partialTransactionSubHandler(payload);
-        } else if (payload.type === OperationType.BOOTSTRAP_DEPLOYMENT) {
-            await this.#partialBootstrapDeploymentSubHandler(payload);
-        } else {
-            throw new Error('Unsupported operation type for SubnetworkOperationHandler');
-        }
-    }
-
-    async #partialTransactionSubHandler(payload) {
-        const normalizedPayload = this.#normalizeTransactionOperation(payload);
-        const isValid = await this.#partialTransactionValidator.validate(normalizedPayload);
-        if (!isValid) {
-            throw new Error("SubnetworkHandler: Transaction validation failed.");
-        }
-
-        const completeTransactionOperation = await CompleteStateMessageOperations.assembleCompleteTransactionOperationMessage(
-            this.wallet,
-            normalizedPayload.address,
-            normalizedPayload.txo.tx,
-            normalizedPayload.txo.txv,
-            normalizedPayload.txo.iw,
-            normalizedPayload.txo.in,
-            normalizedPayload.txo.ch,
-            normalizedPayload.txo.is,
-            normalizedPayload.txo.bs,
-            normalizedPayload.txo.mbs
-        );
-        this.network.transactionPoolService.addTransaction(completeTransactionOperation);
-    }
-
-    async #partialBootstrapDeploymentSubHandler(payload) {
-        const normalizedPayload = this.#normalizeBootstrapDeployment(payload);
-        const isValid = await this.#partialBootstrapDeploymentValidator.validate(normalizedPayload);
-        if (!isValid) {
-            throw new Error("SubnetworkHandler: Bootstrap deployment validation failed.");
-        }
-
-        const completeBootstrapDeploymentOperation = await CompleteStateMessageOperations.assembleCompleteBootstrapDeployment(
-            this.wallet,
-            normalizedPayload.address,
-            normalizedPayload.bdo.tx,
-            normalizedPayload.bdo.txv,
-            normalizedPayload.bdo.bs,
-            normalizedPayload.bdo.ic,
-            normalizedPayload.bdo.in,
-            normalizedPayload.bdo.is,
-        )
-        this.network.transactionPoolService.addTransaction(completeBootstrapDeploymentOperation);
-
-    }
-
-    #normalizeBootstrapDeployment(payload) {
-        if (!payload || typeof payload !== 'object' || !payload.bdo) {
-            throw new Error('Invalid payload for bootstrap deployment normalization.');
-        }
-        const {type, address, bdo} = payload;
-        if (
-            type !== OperationType.BOOTSTRAP_DEPLOYMENT ||
-            !address ||
-            !bdo.tx || !bdo.bs || !bdo.in || !bdo.is || !bdo.txv
-        ) {
-            throw new Error('Missing required fields in bootstrap deployment payload.');
-        }
-
-        const normalizedBdo = {
-            tx: normalizeHex(bdo.tx),   // Transaction hash
-            txv: normalizeHex(bdo.txv), // Transaction validity
-            bs: normalizeHex(bdo.bs),   // External bootstrap
-            ic: normalizeHex(bdo.ic),   // Channel
-            in: normalizeHex(bdo.in),   // Nonce
-            is: normalizeHex(bdo.is)    // Signature
-        };
-
-        return {
-            type,
-            address: addressToBuffer(address),
-            bdo: normalizedBdo
-        };
-    }
-
-    #normalizeTransactionOperation(payload) {
-        if (!payload || typeof payload !== 'object' || !payload.txo) {
-            throw new Error('Invalid payload for transaction operation normalization.');
-        }
-        const {type, address, txo} = payload;
-        if (
-            type !== OperationType.TX ||
-            !address ||
-            !txo.tx || !txo.txv || !txo.iw || !txo.in ||
-            !txo.ch || !txo.is || !txo.bs || !txo.mbs
-        ) {
-            throw new Error('Missing required fields in transaction operation payload.');
-        }
-
-        const normalizedTxo = {
-            tx: normalizeHex(txo.tx),    // Transaction hash
-            txv: normalizeHex(txo.txv),  // Transaction validity
-            iw: normalizeHex(txo.iw),    // Writing key
-            in: normalizeHex(txo.in),    // Nonce
-            ch: normalizeHex(txo.ch),    // Content hash
-            is: normalizeHex(txo.is),    // Signature
-            bs: normalizeHex(txo.bs),    // External bootstrap
-            mbs: normalizeHex(txo.mbs)   // MSB bootstrap key
-        };
-
-        return {
-            type,
-            address: addressToBuffer(address),
-            txo: normalizedTxo
-        };
-    }
-}
-
-export default SubnetworkOperationHandler;

package/src/core/network/messaging/handlers/TransferOperationHandler.js

@@ -1,52 +0,0 @@
-import BaseOperationHandler from './base/BaseOperationHandler.js';
-import CompleteStateMessageOperations from "../../../../messages/completeStateMessages/CompleteStateMessageOperations.js";
-import { OperationType } from '../../../../utils/constants.js';
-import PartialTransfer from "../validators/PartialTransfer.js";
-import {normalizeTransferOperation} from "../../../../utils/normalizers.js"
-
-/**
- * THIS CLASS IS ULTRA IMPORTANT BECAUSE IF SOMEONE WILL SEND A TRASH TO VALIDATOR AND IT WON'T BE HANDLED PROPERTLY -
- * FOR EXAMPLE VALIDATOR WILL BROADCAST IT TO THE INDEXER LAYER THEN IT WILL BE BANNED. SO EVERYTHING WHAT IS TRASH
- * MUST BE REFUSED.
- * TODO: WE SHOULD AUDIT VALIDATORS AND MAKE SURE THEY ARE NOT BROADCASTING TRASH TO THE INDEXER LAYER.
- */
-
-
-class TransferOperationHandler extends BaseOperationHandler {
-    #partialTransferValidator;
-
-    constructor(network, state, wallet, rateLimiter, options = {}) {
-        super(network, state, wallet, rateLimiter, options);
-        this.#partialTransferValidator = new PartialTransfer(this.state);
-    }
-
-    async handleOperation(payload) {
-        if (payload.type !== OperationType.TRANSFER) {
-            throw new Error('Unsupported operation type for TransferOperationHandler');
-        }
-        await this.#handleTransfer(payload);
-    }
-
-    async #handleTransfer(payload) {
-        const normalizedPayload = normalizeTransferOperation(payload);
-        const isValid = await this.#partialTransferValidator.validate(normalizedPayload);
-        if (!isValid) {
-            throw new Error("TransferHandler: Transfer validation failed.");
-        }
-
-        const completeTransferOperation = await CompleteStateMessageOperations.assembleCompleteTransferOperationMessage(
-            this.wallet,
-            normalizedPayload.address,
-            normalizedPayload.tro.tx,
-            normalizedPayload.tro.txv,
-            normalizedPayload.tro.in,
-            normalizedPayload.tro.to,
-            normalizedPayload.tro.am,
-            normalizedPayload.tro.is
-        );
-
-        this.network.transactionPoolService.addTransaction(completeTransferOperation);
-    }
-}
-
-export default TransferOperationHandler;

package/src/core/network/messaging/routes/NetworkMessageRouter.js

@@ -1,94 +0,0 @@
-import b4a from "b4a";
-
-import GetRequestHandler from "../handlers/GetRequestHandler.js";
-import ResponseHandler from "../handlers/ResponseHandler.js";
-import RoleOperationHandler from "../handlers/RoleOperationHandler.js";
-import SubnetworkOperationHandler from "../handlers/SubnetworkOperationHandler.js";
-import TransferOperationHandler from "../handlers/TransferOperationHandler.js";
-import {NETWORK_MESSAGE_TYPES} from '../../../../utils/constants.js';
-import * as operation from '../../../../utils/operations.js';
-import TransactionRateLimiterService from "../../services/TransactionRateLimiterService.js";
-
-class NetworkMessageRouter {
-    #network;
-    #handlers;
-    #options;
-    #rateLimiter;
-    constructor(network, state, wallet, options = {}) {
-        this.#network = network;
-        this.#rateLimiter = new TransactionRateLimiterService();
-        this.#handlers = {
-            get: new GetRequestHandler(wallet, state),
-            response: new ResponseHandler(network, state, wallet),
-            RoleTransaction: new RoleOperationHandler(network, state, wallet, this.#rateLimiter, options),
-            subNetworkTransaction: new SubnetworkOperationHandler(network, state, wallet, this.#rateLimiter, options),
-            tracNetworkTransaction: new TransferOperationHandler(network, state, wallet, this.#rateLimiter, options),
-        }
-        this.#options = options;
-    }
-
-    get network() {
-        return this.#network;
-    }
-
-    async route(incomingMessage, connection, messageProtomux) {
-        try {
-            // TODO: Add a check here — only a writer should be able to process the handlers isRoleAccessOperation,isSubnetworkOperation
-            // and admin nodes until the writers' index is less than 25. OperationType.APPEND_WHITELIST can be processed by only READERS
-
-            const channelString = b4a.toString(this.network.channel, 'utf8');
-            if (this.#isGetRequest(incomingMessage)) {
-                await this.#handlers.get.handle(incomingMessage, messageProtomux, connection, channelString);
-                this.network.swarm.leavePeer(connection.remotePublicKey);
-            }
-            else if (this.#isResponse(incomingMessage)) {
-                await this.#handlers.response.handle(incomingMessage, connection, channelString);
-                this.network.swarm.leavePeer(connection.remotePublicKey);
-            }
-            else if (this.#isRoleAccessOperation(incomingMessage)) {
-                await this.#handlers.RoleTransaction.handle(incomingMessage, connection);
-                this.network.swarm.leavePeer(connection.remotePublicKey);
-
-            }
-            else if (this.#isSubnetworkOperation(incomingMessage)) {
-                await this.#handlers.subNetworkTransaction.handle(incomingMessage, connection);
-                this.network.swarm.leavePeer(connection.remotePublicKey);
-            }
-            else if(this.#isTransferOperation(incomingMessage)) {
-                await this.#handlers.tracNetworkTransaction.handle(incomingMessage, connection);
-                this.network.swarm.leavePeer(connection.remotePublicKey);
-            }
-            else {
-                this.network.swarm.leavePeer(connection.remotePublicKey);
-            }
-            
-        } catch (error) {
-            throw new Error(`Failed to route message: ${error.message}. Pubkey of requester is ${connection.remotePublicKey ? b4a.toString(connection.remotePublicKey, 'hex') : 'unknown'}`);
-        }
-    }
-
-    #isGetRequest(message) {
-        return Object.values(NETWORK_MESSAGE_TYPES.GET).includes(message);
-    }
-
-
-    #isResponse(message) {
-        return Object.values(NETWORK_MESSAGE_TYPES.RESPONSE).includes(message.op);
-    }
-
-    #isRoleAccessOperation(message) {
-        return operation.isRoleAccess(message.type)
-    }
-
-    #isSubnetworkOperation(message) {
-        return operation.isTransaction(message.type) ||
-            operation.isBootstrapDeployment(message.type)
-    }
-
-    #isTransferOperation(message) {
-        return operation.isTransfer(message.type)
-    }
-}
-
-
-export default NetworkMessageRouter;