trac-msb 0.2.8 → 0.2.10

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

@@ -1,107 +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';
-
-class ResponseHandler {
-    #network;
-    #state;
-    #responseValidator;
-    #adminValidator;
-    #customNodeValidator;
-    
-    constructor(network, state, wallet, config) {
-        this.#network = network;
-        this.#state = state;
-        this.#responseValidator = new ValidatorResponse(this.state, wallet, config);
-        this.#adminValidator = new AdminResponse(this.state, wallet, config);
-        this.#customNodeValidator = new CustomNodeResponse(this.state, wallet, config);
-
-    }
-
-    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,114 +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;
-    #config;
-
-    /**
-     * @param {Network} network
-     * @param {State} state
-     * @param {PeerWallet} wallet
-     * @param {TransactionRateLimiterService} rateLimiter
-     * @param {object} config
-     **/
-    constructor(network, state, wallet, rateLimiter, config) {
-        super(network, state, wallet, rateLimiter, config);
-        this.#wallet = wallet;
-        this.#config = config;
-        this.#network = network;
-        this.#partialRoleAccessValidator = new PartialRoleAccess(state, wallet ,this.#config)
-    }
-
-    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 new CompleteStateMessageOperations(this.#wallet, this.#config).assembleAddWriterMessage(
-                    normalizedPartialRoleAccessPayload.address,
-                    normalizedPartialRoleAccessPayload.rao.tx,
-                    normalizedPartialRoleAccessPayload.rao.txv,
-                    normalizedPartialRoleAccessPayload.rao.iw,
-                    normalizedPartialRoleAccessPayload.rao.in,
-                    normalizedPartialRoleAccessPayload.rao.is,
-                );
-                break;
-            case OperationType.REMOVE_WRITER:
-                completePayload = await new CompleteStateMessageOperations(this.#wallet, this.#config).assembleRemoveWriterMessage(
-                    normalizedPartialRoleAccessPayload.address,
-                    normalizedPartialRoleAccessPayload.rao.tx,
-                    normalizedPartialRoleAccessPayload.rao.txv,
-                    normalizedPartialRoleAccessPayload.rao.iw,
-                    normalizedPartialRoleAccessPayload.rao.in,
-                    normalizedPartialRoleAccessPayload.rao.is,
-                );
-                break;
-            case OperationType.ADMIN_RECOVERY:
-                completePayload = await new CompleteStateMessageOperations(this.#wallet, this.#config).assembleAdminRecoveryMessage(
-                    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, this.#config.addressPrefix),
-            rao: normalizedRao
-        };
-    }
-}
-
-export default RoleOperationHandler;

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

@@ -1,149 +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} from "../../../state/utils/address.js";
-import PartialTransaction from "../validators/PartialTransaction.js";
-import {normalizeHex} from "../../../../utils/helpers.js";
-
-
-class SubnetworkOperationHandler extends BaseOperationHandler {
-    #partialBootstrapDeploymentValidator;
-    #partialTransactionValidator;
-    #config;
-    #wallet;
-
-    /**
-     * @param {Network} network
-     * @param {State} state
-     * @param {PeerWallet} wallet
-     * @param {TransactionRateLimiterService} rateLimiter
-     * @param {object} config
-     **/
-    constructor(network, state, wallet, rateLimiter, config) {
-        super(network, state, wallet, rateLimiter, config);
-        this.#config = config
-        this.#wallet = wallet
-        this.#partialBootstrapDeploymentValidator = new PartialBootstrapDeployment(state, wallet, config);
-        this.#partialTransactionValidator = new PartialTransaction(state, wallet, config);
-    }
-
-    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, this.#config);
-        const isValid = await this.#partialTransactionValidator.validate(normalizedPayload);
-        if (!isValid) {
-            throw new Error("SubnetworkHandler: Transaction validation failed.");
-        }
-
-        const completeTransactionOperation = await new CompleteStateMessageOperations(this.#wallet, this.#config)
-            .assembleCompleteTransactionOperationMessage(
-                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 new CompleteStateMessageOperations(this.#wallet, this.#config)
-            .assembleCompleteBootstrapDeployment(
-                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, this.#config.addressPrefix),
-            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, this.#config.addressPrefix),
-            txo: normalizedTxo
-        };
-    }
-}
-
-export default SubnetworkOperationHandler;

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

@@ -1,98 +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";
-import State from "../../../state/State.js";
-import PeerWallet from "trac-wallet";
-
-class NetworkMessageRouter {
-    #network;
-    #handlers;
-    #config;
-    #rateLimiter;
-
-    /**
-     * @param {Network} network
-     * @param {State} state
-     * @param {PeerWallet} wallet
-     * @param {object} config
-     **/
-    constructor(network, state, wallet, config) {
-        this.#network = network;
-        this.#config = config;
-        this.#rateLimiter = new TransactionRateLimiterService();
-        this.#handlers = {
-            get: new GetRequestHandler(wallet, state),
-            response: new ResponseHandler(network, state, wallet, this.#config),
-            roleTransaction: new RoleOperationHandler(network, state, wallet, this.#rateLimiter, this.#config),
-            subNetworkTransaction: new SubnetworkOperationHandler(network, state, wallet, this.#rateLimiter, this.#config),
-            tracNetworkTransaction: new TransferOperationHandler(network, state, wallet, this.#rateLimiter, this.#config),
-        }
-    }
-
-    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.#config.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;

package/src/core/network/messaging/validators/AdminResponse.js

@@ -1,58 +0,0 @@
-import b4a from 'b4a';
-import PeerWallet from 'trac-wallet';
-import BaseResponse from './base/BaseResponse.js';
-
-class AdminResponse extends BaseResponse {
-
-    constructor(state, wallet, config) {
-        super(state, wallet, config);
-    }
-
-    async validate(message, channelString) {
-        if (
-            !this.validatePayload(message) ||
-            !this.validateIssuerPublicKey(message) ||
-            !this.validateTimestamp(message) ||
-            !await this.validateAdminData(message) ||
-            !await this.validateSignature(message) ||
-            !this.validateChannel(message, channelString)
-        ) {
-            throw new Error("Admin response validation failed");
-        }
-
-        return true;
-    }
-
-    validatePayload(message) {
-        if (!message ||
-            !message.op ||
-            !message.wk ||
-            !message.address ||
-            !message.nonce ||
-            !message.channel ||
-            !message.issuer ||
-            !message.timestamp) {
-            throw new Error("Admin response is missing required fields.");
-        }
-        return true;
-    }
-
-    async validateAdminData(message) {
-        const adminEntry = await this.state.getAdminEntry();
-        if (!adminEntry) {
-            throw new Error("Admin entry is null"); 
-        }
-
-        const adminPublicKey = PeerWallet.decodeBech32m(adminEntry.address);
-        const receivedAdminPublicKey = PeerWallet.decodeBech32m(message.address);
-        const adminWritingKey = b4a.from(message.wk, 'hex');
-
-        if (!b4a.equals(adminPublicKey, receivedAdminPublicKey) || !b4a.equals(adminEntry.wk, adminWritingKey)) {
-            throw new Error("Admin public key or writing key mismatch in response.");
-        }
-
-        return true;
-    }
-}
-
-export default AdminResponse;

package/src/core/network/messaging/validators/CustomNodeResponse.js

@@ -1,46 +0,0 @@
-import BaseResponse from './base/BaseResponse.js';
-
-class CustomNodeResponse extends BaseResponse {
-
-    constructor(state, wallet, config) {
-        super(state, wallet, config);
-    }
-
-    async validate(message, channelString) {
-        if (
-            !this.validatePayload(message) ||
-            !this.validateIssuerPublicKey(message) ||
-            !this.validateTimestamp(message) ||
-            !await this.validateCustomNodeEntry(message) ||
-            !await this.validateSignature(message) ||
-            !this.validateChannel(message, channelString)
-        ) {
-            throw new Error("Custom node response validation failed");
-        }
-
-        return true;
-    }
-
-    validatePayload(message) {
-        if (!message ||
-            !message.op ||
-            !message.address ||
-            !message.nonce ||
-            !message.channel ||
-            !message.issuer ||
-            !message.timestamp) {
-            throw new Error("Custom node response is missing required fields.");
-        }
-        return true;
-    }
-
-    async validateCustomNodeEntry(message) {
-        const customNodeAddressString = message.address;
-        const customNodeEntry = await this.state.getNodeEntry(customNodeAddressString);
-        if (customNodeEntry === null) {
-            throw new Error("Custom node entry is null - entry is not initialized.");
-        }
-        return true;
-    }
-}
-export default CustomNodeResponse;

package/src/messages/base/StateBuilder.js

@@ -1,25 +0,0 @@
-class StateBuilder {
-
-    constructor() {
-        if (this.constructor === StateBuilder) {
-            throw new Error("Builder is an abstract class and cannot be instantiated directly.");
-        }
-    }
-    reset() { throw new Error("Method 'reset()' must be implemented.");}
-    forOperationType(operationType) {throw new Error("Method 'forOperationType()' must be implemented.");}
-    withAddress(address) { throw new Error("Method 'withAddress()' must be implemented.");}
-    withWriterKey(writerKey) { throw new Error("Method 'withWriterKey()' must be implemented.");}
-    async buildValueAndSign() { throw new Error("Method 'buildValueAndSign()' must be implemented.");}
-    withIncomingAddress(address) { throw new Error("Method 'withIncomingAddress()' must be implemented.");}
-    withIncomingWriterKey(writerKey) { throw new Error("Method 'withIncomingWriterKey()' must be implemented.");}
-    withIncomingNonce(nonce) { throw new Error("Method 'withIncomingNonce()' must be implemented.");}
-    withContentHash(contentHash) { throw new Error("Method 'withContentHash()' must be implemented.");}
-    withIncomingSignature(signature) { throw new Error("Method 'withIncomingSignature()' must be implemented.");}
-    withExternalBootstrap(bootstrapKey) { throw new Error("Method 'withExternalBootstrap()' must be implemented.");}
-    withMsbBootstrap(msbBootstrap) { throw new Error("Method 'withMsbBootstrap()' must be implemented.");}
-    withTxHash(txHash) { throw new Error("Method 'withTxHash()' must be implemented.");}
-    withTxValidity(txValidity) { throw new Error("Method 'withTxValidity()' must be implemented.");}
-    withAmount(amount) { throw new Error("Method 'withAmount()' must be implemented.");}
-}
-
-export default StateBuilder;