trac-msb 0.2.7 → 0.2.8

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

@@ -1,23 +1,27 @@
 import BaseOperationHandler from './base/BaseOperationHandler.js';
-import CompleteStateMessageOperations from "../../../../messages/completeStateMessages/CompleteStateMessageOperations.js";
-import { OperationType } from '../../../../utils/constants.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);
+    #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.#partialTransferValidator = new PartialTransfer(state, wallet, this.#config);
     }
 
     async handleOperation(payload) {
@@ -28,22 +32,22 @@ class TransferOperationHandler extends BaseOperationHandler {
     }
 
     async #handleTransfer(payload) {
-        const normalizedPayload = normalizeTransferOperation(payload);
+        const normalizedPayload = normalizeTransferOperation(payload, this.#config);
         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
-        );
+        const completeTransferOperation = await new CompleteStateMessageOperations(this.#wallet, this.#config)
+            .assembleCompleteTransferOperationMessage(
+                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);
     }

package/src/core/network/messaging/handlers/base/BaseOperationHandler.js

@@ -1,13 +1,21 @@
 import b4a from 'b4a';
-import {MAX_PARTIAL_TX_PAYLOAD_BYTE_SIZE, TRANSACTION_POOL_SIZE, MAX_WRITERS_FOR_ADMIN_INDEXER_CONNECTION} from '../../../../../utils/constants.js';
+import {MAX_PARTIAL_TX_PAYLOAD_BYTE_SIZE, TRANSACTION_POOL_SIZE} from '../../../../../utils/constants.js';
+
 class BaseOperationHandler {
     #network;
     #state;
     #wallet;
     #rateLimiter;
-    #disable_rate_limit;
-    #options;
-    constructor(network, state, wallet, rateLimiter, options = {}) {
+    #config;
+
+    /**
+     * @param {Network} network
+     * @param {State} state
+     * @param {PeerWallet} wallet
+     * @param {TransactionRateLimiterService} rateLimiter
+     * @param {object} config
+     **/
+    constructor(network, state, wallet, rateLimiter, config) {
         if (new.target === BaseOperationHandler) {
             throw new Error('BaseOperationHandler is abstract and cannot be instantiated directly');
         }
@@ -15,35 +23,26 @@ class BaseOperationHandler {
         this.#state = state;
         this.#wallet = wallet;
         this.#rateLimiter = rateLimiter;
-        this.#disable_rate_limit = options.disable_rate_limit === true;
-        this.#options = options;
+        this.#config = config;
     }
+
     get network() {
         return this.#network;
     }
-    get state() {
-        return this.#state;
-    }
-    get wallet() {
-        return this.#wallet;
-    }
-    get options() {
-        return this.#options;
-    }
-    
+
     async validateBasicRequirements(payload, connection) {
         // Validate if operation can be processed:
         // - Non-writable nodes cannot process operations
         // - Regular indexers cannot process operations
         // - Admin-indexer can process operations only when network has less than MAX_WRITERS_FOR_ADMIN_INDEXER_CONNECTION writers
-        const isAllowedToValidate = await this.state.allowedToValidate(this.wallet.address);
-        const isAdminAllowedToValidate = await this.state.isAdminAllowedToValidate();
+        const isAllowedToValidate = await this.#state.allowedToValidate(this.#wallet.address);
+        const isAdminAllowedToValidate = await this.#state.isAdminAllowedToValidate();
         const canValidate = isAllowedToValidate || isAdminAllowedToValidate;
         if (!canValidate) {
             throw new Error('OperationHandler: State is not writable or is an indexer without admin privileges.');
         }
 
-        if (this.network.transactionPoolService.tx_pool.length >= TRANSACTION_POOL_SIZE) {
+        if (this.#network.transactionPoolService.tx_pool.length >= TRANSACTION_POOL_SIZE) {
             throw new Error("OperationHandler: Transaction pool is full, ignoring incoming transaction.");
         }
 
@@ -51,8 +50,8 @@ class BaseOperationHandler {
             throw new Error(`OperationHandler: Payload size exceeds maximum limit of ${MAX_PARTIAL_TX_PAYLOAD_BYTE_SIZE} bytes by ${b4a.byteLength(JSON.stringify(payload)) - MAX_PARTIAL_TX_PAYLOAD_BYTE_SIZE} bytes.`);
         }
         
-        if (this.#disable_rate_limit !== true) {
-            const shouldDisconnect = this.#rateLimiter.handleRateLimit(connection, this.network);
+        if (!this.#config.disableRateLimit) {
+            const shouldDisconnect = this.#rateLimiter.handleRateLimit(connection, this.#network);
             if (shouldDisconnect) {
                 throw new Error(`OperationHandler: Rate limit exceeded for peer ${b4a.toString(connection.remotePublicKey, 'hex')}. Disconnecting...`);
             }

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

@@ -1,5 +1,4 @@
 import b4a from "b4a";
-
 import GetRequestHandler from "../handlers/GetRequestHandler.js";
 import ResponseHandler from "../handlers/ResponseHandler.js";
 import RoleOperationHandler from "../handlers/RoleOperationHandler.js";
@@ -8,27 +7,32 @@ 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;
-    #options;
+    #config;
     #rateLimiter;
-    constructor(network, state, wallet, options = {}) {
+
+    /**
+     * @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),
-            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),
+            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),
         }
-        this.#options = options;
-    }
-
-    get network() {
-        return this.#network;
     }
 
     async route(incomingMessage, connection, messageProtomux) {
@@ -36,30 +40,30 @@ class NetworkMessageRouter {
             // 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');
+            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);
+                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);
+                this.#network.swarm.leavePeer(connection.remotePublicKey);
             }
             else if (this.#isRoleAccessOperation(incomingMessage)) {
-                await this.#handlers.RoleTransaction.handle(incomingMessage, connection);
-                this.network.swarm.leavePeer(connection.remotePublicKey);
+                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);
+                this.#network.swarm.leavePeer(connection.remotePublicKey);
             }
             else if(this.#isTransferOperation(incomingMessage)) {
                 await this.#handlers.tracNetworkTransaction.handle(incomingMessage, connection);
-                this.network.swarm.leavePeer(connection.remotePublicKey);
+                this.#network.swarm.leavePeer(connection.remotePublicKey);
             }
             else {
-                this.network.swarm.leavePeer(connection.remotePublicKey);
+                this.#network.swarm.leavePeer(connection.remotePublicKey);
             }
             
         } catch (error) {

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

@@ -4,8 +4,8 @@ import BaseResponse from './base/BaseResponse.js';
 
 class AdminResponse extends BaseResponse {
 
-    constructor(state, wallet) {
-        super(state, wallet);
+    constructor(state, wallet, config) {
+        super(state, wallet, config);
     }
 
     async validate(message, channelString) {

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

@@ -2,8 +2,8 @@ import BaseResponse from './base/BaseResponse.js';
 
 class CustomNodeResponse extends BaseResponse {
 
-    constructor(state, wallet) {
-        super(state, wallet);
+    constructor(state, wallet, config) {
+        super(state, wallet, config);
     }
 
     async validate(message, channelString) {

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

@@ -1,13 +1,13 @@
 import PartialOperation from './base/PartialOperation.js';
 
-
 class PartialBootstrapDeployment extends PartialOperation {
-    constructor(state) {
-        super(state);
+    constructor(state, wallet , config) {
+        super(state, wallet , config);
     }
 
     async validate(payload) {
         this.isPayloadSchemaValid(payload);
+        this.validateNoSelfValidation(payload);
         this.validateRequesterAddress(payload);
         await this.validateTransactionUniqueness(payload);
         await this.validateSignature(payload);

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

@@ -1,17 +1,20 @@
 import b4a from 'b4a';
-
-import { OperationType } from "../../../../utils/constants.js";
-import { bufferToAddress } from "../../../state/utils/address.js";
+import {OperationType} from "../../../../utils/constants.js";
+import {bufferToAddress} from "../../../state/utils/address.js";
 import PartialOperation from './base/PartialOperation.js';
-import { bufferToBigInt } from "../../../../utils/amountSerialization.js";
+import {bufferToBigInt} from "../../../../utils/amountSerialization.js";
 
 class PartialRoleAccess extends PartialOperation {
-    constructor(state) {
-        super(state);
+    #config;
+
+    constructor(state, wallet, config) {
+        super(state, wallet, config);
+        this.#config = config
     }
 
     async validate(payload) {
         this.isPayloadSchemaValid(payload);
+        this.validateNoSelfValidation(payload);
         this.validateRequesterAddress(payload);
         await this.validateTransactionUniqueness(payload);
         await this.validateSignature(payload);
@@ -33,10 +36,10 @@ class PartialRoleAccess extends PartialOperation {
     }
 
     async isRequesterAllowedToChangeRole(payload) {
-        const { type } = payload;
+        const {type} = payload;
 
         if (type === OperationType.ADD_WRITER) {
-            const nodeAddress = bufferToAddress(payload.address);
+            const nodeAddress = bufferToAddress(payload.address, this.#config.addressPrefix);
             const nodeEntry = await this.state.getNodeEntry(nodeAddress);
             if (!nodeEntry) {
                 throw new Error(`Node with address ${nodeAddress} entry does not exist.`);
@@ -54,7 +57,7 @@ class PartialRoleAccess extends PartialOperation {
             return;
 
         } else if (type === OperationType.REMOVE_WRITER) {
-            const nodeAddress = bufferToAddress(payload.address);
+            const nodeAddress = bufferToAddress(payload.address, this.#config.addressPrefix);
             const nodeEntry = await this.state.getNodeEntry(nodeAddress);
             if (!nodeEntry) {
                 throw new Error(`Node with address ${nodeAddress} entry does not exist.`);
@@ -78,7 +81,7 @@ class PartialRoleAccess extends PartialOperation {
             }
 
             const adminAddressBuffer = payload.address;
-            const adminAddress = bufferToAddress(adminAddressBuffer);
+            const adminAddress = bufferToAddress(adminAddressBuffer, this.#config.addressPrefix);
             const isRecoveryCase = !!(
                 adminEntry.address === adminAddress &&
                 !b4a.equals(payload.rao.iw, adminEntry.wk)
@@ -94,7 +97,7 @@ class PartialRoleAccess extends PartialOperation {
     }
 
     async validateWriterKey(payload) {
-        const requesterAddress = bufferToAddress(payload.address);
+        const requesterAddress = bufferToAddress(payload.address, this.#config.addressPrefix);
         const nodeEntry = await this.state.getNodeEntry(requesterAddress);
         if (!nodeEntry) {
             throw new Error(`Node entry not found for address ${requesterAddress}`);
@@ -114,7 +117,7 @@ class PartialRoleAccess extends PartialOperation {
     }
 
     async validateRequesterBalanceForAddWriterOperation(payload, signed = false) {
-        const requesterAddress = bufferToAddress(payload.address);
+        const requesterAddress = bufferToAddress(payload.address, this.#config.addressPrefix);
         let requesterEntry;
         if (signed) {
             requesterEntry = await this.state.getNodeEntry(requesterAddress);

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

@@ -1,18 +1,19 @@
 import b4a from 'b4a';
-
-import { safeDecodeApplyOperation } from "../../../../utils/protobuf/operationHelpers.js";
+import {safeDecodeApplyOperation} from "../../../../utils/protobuf/operationHelpers.js";
 import deploymentEntryUtils from "../../../state/utils/deploymentEntry.js";
 import PartialOperation from './base/PartialOperation.js';
 
 class PartialTransaction extends PartialOperation {
+    #config
 
-
-    constructor(state) {
-        super(state);
+    constructor(state, wallet, config) {
+        super(state, wallet, config);
+        this.#config = config
     }
 
     async validate(payload) {
         this.isPayloadSchemaValid(payload);
+        this.validateNoSelfValidation(payload);
         this.validateRequesterAddress(payload);
         await this.validateTransactionUniqueness(payload);
         await this.validateSignature(payload);
@@ -21,8 +22,6 @@ class PartialTransaction extends PartialOperation {
         await this.validateRequesterBalance(payload);
         await this.validateRequesterBalance(payload, true);
         this.validateSubnetworkBootstrapEquality(payload);
-        
-
 
         // non common validations below
         this.validateMsbBootstrap(payload);
@@ -32,7 +31,7 @@ class PartialTransaction extends PartialOperation {
     }
 
     validateMsbBootstrap(payload) {
-        if (!b4a.equals(this.state.bootstrap, payload.txo.mbs)) {
+        if (!b4a.equals(this.#config.bootstrap, payload.txo.mbs)) {
             throw new Error(`Declared MSB bootstrap is different than network bootstrap in transaction operation: ${payload.txo.mbs.toString('hex')}`);
         }
     }
@@ -43,10 +42,10 @@ class PartialTransaction extends PartialOperation {
             throw new Error(`External bootstrap with hash ${payload.txo.bs.toString('hex')} is not registered as deployment entry.`);
         }
 
-        const decodedPayload = deploymentEntryUtils.decode(externalBootstrapResult);
+        const decodedPayload = deploymentEntryUtils.decode(externalBootstrapResult, this.#config.addressLength);
         const txHash = decodedPayload.txHash
         const getBootstrapTransactionTxPayload = await this.state.get(txHash.toString('hex'));
-        
+
         if (getBootstrapTransactionTxPayload === null) {
             throw new Error(`External bootstrap is not registered as usual tx ${externalBootstrapResult.toString('hex')}: ${payload}`);
         }

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

@@ -1,17 +1,20 @@
 import PeerWallet from 'trac-wallet';
 
-import { bufferToAddress } from "../../../state/utils/address.js";
-import { bufferToBigInt } from "../../../../utils/amountSerialization.js";
+import {bufferToAddress} from "../../../state/utils/address.js";
+import {bufferToBigInt} from "../../../../utils/amountSerialization.js";
 import PartialOperation from './base/PartialOperation.js';
 
 class PartialTransfer extends PartialOperation {
+    #config
 
-    constructor(state) {
-        super(state);
+    constructor(state, wallet, config) {
+        super(state, wallet, config);
+        this.#config = config
     }
 
     async validate(payload) {
         this.isPayloadSchemaValid(payload);
+        this.validateNoSelfValidation(payload);
         this.validateRequesterAddress(payload);
         await this.validateTransactionUniqueness(payload);
         await this.validateSignature(payload);
@@ -26,7 +29,7 @@ class PartialTransfer extends PartialOperation {
     }
 
     #validateRecipientAddress(payload) {
-        const incomingAddress = bufferToAddress(payload.tro.to);
+        const incomingAddress = bufferToAddress(payload.tro.to, this.#config.addressPrefix);
         if (!incomingAddress) {
             throw new Error('Invalid recipient address in transfer payload.');
         }
@@ -39,8 +42,8 @@ class PartialTransfer extends PartialOperation {
     }
 
     async #validateStateBalances(payload) {
-        const senderAddress = bufferToAddress(payload.address);
-        const recipientAddress = bufferToAddress(payload.tro.to);
+        const senderAddress = bufferToAddress(payload.address, this.#config.addressPrefix);
+        const recipientAddress = bufferToAddress(payload.tro.to, this.#config.addressPrefix);
 
         const transferAmount = bufferToBigInt(payload.tro.am);
         if (transferAmount > this.max_amount) {

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

@@ -2,8 +2,8 @@ import b4a from 'b4a';
 import BaseResponse from './base/BaseResponse.js';
 class ValidatorResponse extends BaseResponse {
 
-    constructor(state, wallet) {
-        super(state, wallet);
+    constructor(state, wallet, config) {
+        super(state, wallet, config);
     }
 
     async validate(message, channelString) {

package/src/core/network/messaging/validators/base/BaseResponse.js

@@ -1,7 +1,7 @@
 import b4a from 'b4a';
 import PeerWallet from 'trac-wallet';
 import { bufferToAddress } from '../../../../state/utils/address.js';
-import { blake3Hash } from '../../../../../utils/crypto.js';
+import State from '../../../../state/State.js';
 
 /*
     BaseResponse class for handling common validation logic for network responses.
@@ -10,10 +10,18 @@ import { blake3Hash } from '../../../../../utils/crypto.js';
 class BaseResponse {
     #wallet;
     #state;
+    #config
 
-    constructor(state, wallet) {
+    /**
+     * 
+     * @param {State} state 
+     * @param {PeerWallet} wallet 
+     * @param {object} config
+     */
+    constructor(state, wallet, config) {
         this.#state = state;
         this.#wallet = wallet;
+        this.#config = config;
     }
 
     get state() {
@@ -63,8 +71,7 @@ class BaseResponse {
 
                 break;
             default:
-                const addressString = bufferToAddress(message.address);
-                publicKey = PeerWallet.decodeBech32m(addressString);
+                publicKey = PeerWallet.decodeBech32m(message.address);
         }
 
         if (!publicKey) {
@@ -73,7 +80,8 @@ class BaseResponse {
 
         const messageWithoutSig = { ...message };
         delete messageWithoutSig.sig;
-        const hash = await blake3Hash(JSON.stringify(messageWithoutSig));
+        const hashInput = b4a.from(JSON.stringify(messageWithoutSig), 'utf8');
+        const hash = await PeerWallet.blake3(hashInput);
         const signature = b4a.from(message.sig, 'hex');
         const verified = this.#wallet.verify(signature, hash, publicKey);