trac-msb 0.2.18 → 0.2.19

package/src/core/network/protocols/v1/handlers/broadcastTransaction/BroadcastTransactionOperationStrategies.js

@@ -0,0 +1,128 @@
+import {OperationType, ResultCode} from "../../../../../../utils/constants.js";
+import {V1ProtocolError} from "../../V1ProtocolError.js";
+
+function createOperationStrategy(payloadKey, validator, buildCompleteOperation) {
+    return {
+        payloadKey,
+        async build(decodedTransaction) {
+            await validator.validate(decodedTransaction);
+            return buildCompleteOperation(decodedTransaction);
+        }
+    };
+}
+
+export function createBroadcastTransactionOperationStrategies({
+    partialRoleAccessValidator,
+    partialBootstrapDeploymentValidator,
+    partialTransactionValidator,
+    partialTransferValidator,
+    createApplyStateMessageFactory
+}) {
+    return new Map([
+        [
+            OperationType.ADD_WRITER,
+            createOperationStrategy(
+                'rao',
+                partialRoleAccessValidator,
+                decodedTransaction => createApplyStateMessageFactory().buildCompleteAddWriterMessage(
+                    decodedTransaction.address,
+                    decodedTransaction.rao.tx,
+                    decodedTransaction.rao.txv,
+                    decodedTransaction.rao.iw,
+                    decodedTransaction.rao.in,
+                    decodedTransaction.rao.is
+                )
+            )
+        ],
+        [
+            OperationType.REMOVE_WRITER,
+            createOperationStrategy(
+                'rao',
+                partialRoleAccessValidator,
+                decodedTransaction => createApplyStateMessageFactory().buildCompleteRemoveWriterMessage(
+                    decodedTransaction.address,
+                    decodedTransaction.rao.tx,
+                    decodedTransaction.rao.txv,
+                    decodedTransaction.rao.iw,
+                    decodedTransaction.rao.in,
+                    decodedTransaction.rao.is
+                )
+            )
+        ],
+        [
+            OperationType.ADMIN_RECOVERY,
+            createOperationStrategy(
+                'rao',
+                partialRoleAccessValidator,
+                decodedTransaction => createApplyStateMessageFactory().buildCompleteAdminRecoveryMessage(
+                    decodedTransaction.address,
+                    decodedTransaction.rao.tx,
+                    decodedTransaction.rao.txv,
+                    decodedTransaction.rao.iw,
+                    decodedTransaction.rao.in,
+                    decodedTransaction.rao.is
+                )
+            )
+        ],
+        [
+            OperationType.TX,
+            createOperationStrategy(
+                'txo',
+                partialTransactionValidator,
+                decodedTransaction => createApplyStateMessageFactory().buildCompleteTransactionOperationMessage(
+                    decodedTransaction.address,
+                    decodedTransaction.txo.tx,
+                    decodedTransaction.txo.txv,
+                    decodedTransaction.txo.iw,
+                    decodedTransaction.txo.in,
+                    decodedTransaction.txo.ch,
+                    decodedTransaction.txo.is,
+                    decodedTransaction.txo.bs,
+                    decodedTransaction.txo.mbs
+                )
+            )
+        ],
+        [
+            OperationType.BOOTSTRAP_DEPLOYMENT,
+            createOperationStrategy(
+                'bdo',
+                partialBootstrapDeploymentValidator,
+                decodedTransaction => createApplyStateMessageFactory().buildCompleteBootstrapDeploymentMessage(
+                    decodedTransaction.address,
+                    decodedTransaction.bdo.tx,
+                    decodedTransaction.bdo.txv,
+                    decodedTransaction.bdo.bs,
+                    decodedTransaction.bdo.ic,
+                    decodedTransaction.bdo.in,
+                    decodedTransaction.bdo.is
+                )
+            )
+        ],
+        [
+            OperationType.TRANSFER,
+            createOperationStrategy(
+                'tro',
+                partialTransferValidator,
+                decodedTransaction => createApplyStateMessageFactory().buildCompleteTransferOperationMessage(
+                    decodedTransaction.address,
+                    decodedTransaction.tro.tx,
+                    decodedTransaction.tro.txv,
+                    decodedTransaction.tro.in,
+                    decodedTransaction.tro.to,
+                    decodedTransaction.tro.am,
+                    decodedTransaction.tro.is
+                )
+            )
+        ]
+    ]);
+}
+
+export function resolveBroadcastTransactionOperationStrategy(type, operationStrategies) {
+    const operationStrategy = operationStrategies.get(type);
+
+    if (!operationStrategy) {
+        throw new V1ProtocolError(ResultCode.TX_INVALID_PAYLOAD, `Unsupported transaction type: ${type}`);
+    }
+
+    return operationStrategy;
+}

package/src/core/network/protocols/v1/handlers/broadcastTransaction/BroadcastTransactionPayloadUtils.js

@@ -0,0 +1,26 @@
+import b4a from "b4a";
+
+import { operationToPayload } from "../../../../../../utils/applyOperations.js";
+
+const COMPLETION_FIELDS = ['va', 'vn', 'vs'];
+
+export function sanitizeDecodedPartialTransaction(decodedTransaction) {
+    const operationKey = operationToPayload(decodedTransaction?.type);
+    const operation = decodedTransaction?.[operationKey];
+
+    if (!operation || typeof operation !== 'object') {
+        return;
+    }
+
+    for (const completionField of COMPLETION_FIELDS) {
+        // Protobuf decode sets optional completion fields as null, but partial validators expect those fields to be absent.
+        // Otherwise, the presence of null fields causes validation to fail with "Expected type X but got null" errors.
+        if (operation[completionField] === null) {
+            delete operation[completionField];
+        }
+    }
+}
+
+export function getTxHashFromDecodedTransaction(decodedTransaction, payloadKey = operationToPayload(decodedTransaction?.type)) {
+    return b4a.toString(decodedTransaction[payloadKey].tx, 'hex');
+}

package/src/core/network/protocols/v1/validators/V1BaseOperation.js

@@ -1,6 +1,6 @@
 import V1ValidationSchema from "./V1ValidationSchema.js";
 import {NetworkOperationType, ResultCode} from "../../../../../utils/constants.js";
-import PeerWallet from "trac-wallet";
+import tracCryptoApi from "trac-crypto-api";
 import b4a from "b4a";
 import {
     createMessage,
@@ -10,34 +10,30 @@ import {
     timestampToBuffer
 } from "../../../../../utils/buffer.js";
 import {
-    V1InvalidPayloadError,
     V1ProtocolError,
-    V1SignatureInvalidError,
-    V1UnexpectedError,
 } from "../V1ProtocolError.js";
 import _ from 'lodash';
+
 class V1BaseOperation {
     #v1ValidationSchema
-    #config
 
-    constructor(config) {
-        this.#config = config;
+    constructor(_config) {
         this.#v1ValidationSchema = new V1ValidationSchema();
     }
 
-    async validate(payload, connection, pendingRequestServiceEntry) {
+    async validate(_payload, _connection, _pendingRequestServiceEntry) {
         throw new Error("Method 'validate()' must be implemented.");
     }
 
     isPayloadSchemaValid(payload) {
         if (_.isNil(payload?.type)) {
-            throw new V1InvalidPayloadError('Payload or payload type is missing.');
+            throw new V1ProtocolError(ResultCode.INVALID_PAYLOAD,'Payload or payload type is missing.');
         }
 
         const selectedValidator = this.#selectCheckSchemaValidator(payload.type);
         const isPayloadValid = selectedValidator(payload);
         if (!isPayloadValid) {
-            throw new V1InvalidPayloadError('Payload is invalid.');
+            throw new V1ProtocolError(ResultCode.INVALID_PAYLOAD, 'Payload is invalid.');
         }
     }
 
@@ -52,33 +48,33 @@ class V1BaseOperation {
             if (error instanceof V1ProtocolError) {
                 throw error;
             }
-            throw new V1InvalidPayloadError(`Failed to build signature message: ${error.message}`);
+            throw new V1ProtocolError(ResultCode.INVALID_PAYLOAD, `Failed to build signature message: ${error.message}`);
         }
 
         let hash;
         try {
-            hash = await PeerWallet.blake3(message);
-        } catch (error) {
-            throw new V1InvalidPayloadError('Failed to hash signature message.');
+            hash = await tracCryptoApi.hash.blake3(message);
+        } catch {
+            throw new V1ProtocolError(ResultCode.INVALID_PAYLOAD, 'Failed to hash signature message.');
         }
 
         let verified = false;
         try {
-            verified = PeerWallet.verify(signature, hash, remotePublicKey);
-        } catch (error) {
+            verified = tracCryptoApi.signature.verify(signature, hash, remotePublicKey);
+        } catch {
             verified = false;
         }
         if (!verified) {
-            throw new V1SignatureInvalidError('signature verification failed.');
+            throw new V1ProtocolError(ResultCode.SIGNATURE_INVALID, 'signature verification failed.');
         }
     }
 
     #buildSignatureMessage(payload) {
         if (!Number.isInteger(payload.type)) {
-            throw new V1InvalidPayloadError('Operation type must be an integer.');
+            throw new V1ProtocolError(ResultCode.INVALID_PAYLOAD, 'Operation type must be an integer.');
         }
         if (payload.type === 0) {
-            throw new V1InvalidPayloadError('Operation type is unspecified.');
+            throw new V1ProtocolError(ResultCode.INVALID_PAYLOAD, 'Operation type is unspecified.');
         }
 
         const idBuf = idToBuffer(payload.id);
@@ -119,21 +115,21 @@ class V1BaseOperation {
 
                 if (result === ResultCode.OK) {
                     if (!hasProof || !hasTimestamp) {
-                        throw new V1InvalidPayloadError('Result code OK requires non-empty proof and timestamp > 0.');
+                        throw new V1ProtocolError(ResultCode.INVALID_PAYLOAD, 'Result code OK requires non-empty proof and timestamp > 0.');
                     }
                 } else if (result === ResultCode.TX_ACCEPTED_PROOF_UNAVAILABLE) {
                     if (hasProof) {
-                        throw new V1InvalidPayloadError('Result code TX_ACCEPTED_PROOF_UNAVAILABLE requires empty proof.');
+                        throw new V1ProtocolError(ResultCode.INVALID_PAYLOAD, 'Result code TX_ACCEPTED_PROOF_UNAVAILABLE requires empty proof.');
                     }
                     if (!hasTimestamp) {
-                        throw new V1InvalidPayloadError('Result code TX_ACCEPTED_PROOF_UNAVAILABLE requires timestamp > 0.');
+                        throw new V1ProtocolError(ResultCode.INVALID_PAYLOAD, 'Result code TX_ACCEPTED_PROOF_UNAVAILABLE requires timestamp > 0.');
                     }
                 } else {
                     if (hasProof) {
-                        throw new V1InvalidPayloadError('Non-OK result code requires empty proof.');
+                        throw new V1ProtocolError(ResultCode.INVALID_PAYLOAD, 'Non-OK result code requires empty proof.');
                     }
                     if (timestamp !== 0) {
-                        throw new V1InvalidPayloadError('Non-OK result code requires timestamp to be 0, except TX_ACCEPTED_PROOF_UNAVAILABLE.');
+                        throw new V1ProtocolError(ResultCode.INVALID_PAYLOAD, 'Non-OK result code requires timestamp to be 0, except TX_ACCEPTED_PROOF_UNAVAILABLE.');
                     }
                 }
 
@@ -151,16 +147,16 @@ class V1BaseOperation {
                 return {signature, message};
             }
             default:
-                throw new V1UnexpectedError(`Unknown operation type: ${payload.type}`);
+                throw new V1ProtocolError(ResultCode.UNEXPECTED_ERROR, `Unknown operation type: ${payload.type}`);
         }
     }
 
     #selectCheckSchemaValidator(type) {
         if (!Number.isInteger(type)) {
-            throw new V1InvalidPayloadError('Operation type must be an integer.');
+            throw new V1ProtocolError(ResultCode.INVALID_PAYLOAD, 'Operation type must be an integer.');
         }
         if (type === 0) {
-            throw new V1InvalidPayloadError('Operation type is unspecified.');
+            throw new V1ProtocolError(ResultCode.INVALID_PAYLOAD, 'Operation type is unspecified.');
         }
 
         switch (type) {
@@ -173,14 +169,15 @@ class V1BaseOperation {
             case NetworkOperationType.BROADCAST_TRANSACTION_RESPONSE:
                 return this.#v1ValidationSchema.validateV1BroadcastTransactionResponse.bind(this.#v1ValidationSchema);
             default:
-                throw new V1UnexpectedError(`Unknown operation type: ${type}`);
+                throw new V1ProtocolError(ResultCode.UNEXPECTED_ERROR, `Unknown operation type: ${type}`);
         }
     }
 
     validatePeerCorrectness(remotePublicKey, pendingRequestServiceEntry) {
         const senderPublicKeyHex = b4a.toString(remotePublicKey, 'hex');
         if (senderPublicKeyHex !== pendingRequestServiceEntry.requestedTo) {
-            throw new V1InvalidPayloadError(
+            throw new V1ProtocolError(
+                ResultCode.INVALID_PAYLOAD,
                 `Response sender mismatch. Expected ${pendingRequestServiceEntry.requestedTo}, got ${senderPublicKeyHex}.`
             );
         }
@@ -196,11 +193,15 @@ class V1BaseOperation {
                 expectedResponseType = NetworkOperationType.BROADCAST_TRANSACTION_RESPONSE;
                 break;
             default:
-                throw new V1UnexpectedError(`Unsupported pending request type: ${pendingRequestServiceEntry.requestType}.`);
+                throw new V1ProtocolError(
+                    ResultCode.UNEXPECTED_ERROR,
+                    `Unsupported pending request type: ${pendingRequestServiceEntry.requestType}.`
+                );
         }
 
         if (payload.type !== expectedResponseType) {
-            throw new V1InvalidPayloadError(
+            throw new V1ProtocolError(
+                ResultCode.INVALID_PAYLOAD,
                 `Response type mismatch for id ${pendingRequestServiceEntry.id}. Expected ${expectedResponseType}, got ${payload.type}.`
             );
         }

package/src/core/network/protocols/v1/validators/V1BroadcastTransactionRequest.js

@@ -1,7 +1,7 @@
 import V1BaseOperation from "./V1BaseOperation.js";
 import b4a from "b4a";
-import { MAX_PARTIAL_TX_PAYLOAD_BYTE_SIZE } from '../../../../../utils/constants.js';
-import {V1InvalidPayloadError} from "../V1ProtocolError.js";
+import {MAX_PARTIAL_TX_PAYLOAD_BYTE_SIZE, ResultCode} from '../../../../../utils/constants.js';
+import {V1ProtocolError} from "../V1ProtocolError.js";
 
 class V1BroadcastTransactionRequest extends V1BaseOperation {
     constructor(config) {
@@ -17,7 +17,9 @@ class V1BroadcastTransactionRequest extends V1BaseOperation {
 
     isDataPropertySizeValid(payload) {
         if (b4a.byteLength(payload.broadcast_transaction_request.data) > MAX_PARTIAL_TX_PAYLOAD_BYTE_SIZE) {
-            throw new V1InvalidPayloadError(`The 'data' field exceeds the maximum allowed byte size of ${MAX_PARTIAL_TX_PAYLOAD_BYTE_SIZE}. Actual size: ${b4a.byteLength(payload.broadcast_transaction_request.data)}`);
+            throw new V1ProtocolError(
+                ResultCode.INVALID_PAYLOAD,
+                `The 'data' field exceeds the maximum allowed byte size of ${MAX_PARTIAL_TX_PAYLOAD_BYTE_SIZE}. Actual size: ${b4a.byteLength(payload.broadcast_transaction_request.data)}`);
         }
     }
 

package/src/core/network/protocols/v1/validators/V1BroadcastTransactionResponse.js

@@ -12,6 +12,24 @@ import {V1ProtocolError} from "../V1ProtocolError.js";
 
 const VALIDATOR_METADATA_FIELDS = new Set(["va", "vn", "vs"]);
 
+const stripValidatorMetadata = (value) => {
+
+    if (value === null || value === undefined) return value;
+    if (b4a.isBuffer(value)) return value;
+    if (Array.isArray(value)) return value.map(stripValidatorMetadata);
+    if (typeof value !== "object") return value;
+
+    const result = {};
+    for (const [key, nestedValue] of Object.entries(value)) {
+        if (VALIDATOR_METADATA_FIELDS.has(key)) {
+            result[key] = null;
+            continue;
+        }
+        result[key] = stripValidatorMetadata(nestedValue);
+    }
+    return result;
+};
+
 class V1BroadcastTransactionResponse extends V1BaseOperation {
     #config;
     #check;
@@ -59,16 +77,14 @@ class V1BroadcastTransactionResponse extends V1BaseOperation {
         if (!Number.isInteger(type)) {
             throw new V1ProtocolError(
                 ResultCode.VALIDATOR_RESPONSE_TX_TYPE_INVALID,
-                'Decoded validator transaction type is missing or invalid.',
-                false
+                'Decoded validator transaction type is missing or invalid.'
             );
         }
 
         if (!Object.values(OperationType).includes(type)) {
             throw new V1ProtocolError(
                 ResultCode.VALIDATOR_RESPONSE_TX_TYPE_UNKNOWN,
-                `Decoded validator transaction type ${type} is not defined in OperationType constants.`,
-                false
+                `Decoded validator transaction type ${type} is not defined in OperationType constants.`
             );
         }
 
@@ -91,16 +107,14 @@ class V1BroadcastTransactionResponse extends V1BaseOperation {
             default:
                 throw new V1ProtocolError(
                     ResultCode.VALIDATOR_RESPONSE_TX_TYPE_UNSUPPORTED,
-                    `Unsupported decoded validator transaction type: ${type}`,
-                    false
+                    `Unsupported decoded validator transaction type: ${type}`
                 );
         }
 
         if (!isValid) {
             throw new V1ProtocolError(
                 ResultCode.VALIDATOR_RESPONSE_SCHEMA_INVALID,
-                `Decoded validator transaction schema validation failed for type ${type}.`,
-                false
+                `Decoded validator transaction schema validation failed for type ${type}.`
             );
         }
     }
@@ -115,8 +129,7 @@ class V1BroadcastTransactionResponse extends V1BaseOperation {
         if (!b4a.isBuffer(stateTxEncodedFromRequest) || stateTxEncodedFromRequest.length === 0) {
             throw new V1ProtocolError(
                 ResultCode.PENDING_REQUEST_MISSING_TX_DATA,
-                'Missing transaction data in pending request entry.',
-                false
+                'Missing transaction data in pending request entry.'
             );
         }
         const provenBlock = proofResult.proof.block.value;
@@ -130,8 +143,7 @@ class V1BroadcastTransactionResponse extends V1BaseOperation {
         if (!isDeepEqualApplyPayload(stateTxDecodedFromRequest, strippedValidatorPayload)) {
             throw new V1ProtocolError(
                 ResultCode.PROOF_PAYLOAD_MISMATCH,
-                'Decoded transaction payload mismatch after removing validator metadata fields.',
-                false
+                'Decoded transaction payload mismatch after removing validator metadata fields.'
             );
         }
         return {validatorDecodedTx: stateTxDecodedFromResponse, manifest};
@@ -145,8 +157,7 @@ class V1BroadcastTransactionResponse extends V1BaseOperation {
         if (!b4a.isBuffer(validatorAddressBuffer) || validatorAddressBuffer.length === 0) {
             throw new V1ProtocolError(
                 ResultCode.VALIDATOR_WRITER_KEY_NOT_REGISTERED,
-                `Validator with writer key ${writerKeyFromManifestHex} is not registered.`,
-                false
+                `Validator with writer key ${writerKeyFromManifestHex} is not registered.`
             );
         }
 
@@ -166,24 +177,21 @@ class V1BroadcastTransactionResponse extends V1BaseOperation {
         if (!b4a.equals(validatorAddressFromTx, validatorAddressFromConnectionPublicKey)) {
             throw new V1ProtocolError(
                 ResultCode.VALIDATOR_ADDRESS_MISMATCH,
-                `Validator address from transaction (${bufferToAddress(validatorAddressFromTx, this.#config.addressPrefix)}) does not match address derived from connection public key (${bufferToAddress(validatorAddressFromConnectionPublicKey, this.#config.addressPrefix)}).`,
-                false
+                `Validator address from transaction (${bufferToAddress(validatorAddressFromTx, this.#config.addressPrefix)}) does not match address derived from connection public key (${bufferToAddress(validatorAddressFromConnectionPublicKey, this.#config.addressPrefix)}).`
             );
         }
 
         if (!b4a.equals(validatorAddressFromTx, validatorAddressCorrelatedWithManifest)) {
             throw new V1ProtocolError(
                 ResultCode.VALIDATOR_ADDRESS_MISMATCH,
-                `Validator address from transaction (${bufferToAddress(validatorAddressFromTx, this.#config.addressPrefix)}) does not match address correlated with manifest writer key (${bufferToAddress(validatorAddressCorrelatedWithManifest, this.#config.addressPrefix)}).`,
-                false
+                `Validator address from transaction (${bufferToAddress(validatorAddressFromTx, this.#config.addressPrefix)}) does not match address correlated with manifest writer key (${bufferToAddress(validatorAddressCorrelatedWithManifest, this.#config.addressPrefix)}).`
             );
         }
 
         if (!b4a.equals(validatorAddressCorrelatedWithManifest, validatorAddressFromConnectionPublicKey)) {
             throw new V1ProtocolError(
                 ResultCode.VALIDATOR_ADDRESS_MISMATCH,
-                `Validator address correlated with manifest writer key (${bufferToAddress(validatorAddressCorrelatedWithManifest, this.#config.addressPrefix)}) does not match address derived from connection public key (${bufferToAddress(validatorAddressFromConnectionPublicKey, this.#config.addressPrefix)}).`,
-                false
+                `Validator address correlated with manifest writer key (${bufferToAddress(validatorAddressCorrelatedWithManifest, this.#config.addressPrefix)}) does not match address derived from connection public key (${bufferToAddress(validatorAddressFromConnectionPublicKey, this.#config.addressPrefix)}).`
             );
         }
 
@@ -193,24 +201,21 @@ class V1BroadcastTransactionResponse extends V1BaseOperation {
         if (!account) {
             throw new V1ProtocolError(
                 ResultCode.VALIDATOR_NODE_ENTRY_NOT_FOUND,
-                `No node entry found in state for validator address derived from connection public key (${validatorAddressFromConnection}).`,
-                false
+                `No node entry found in state for validator address derived from connection public key (${validatorAddressFromConnection}).`
             );
         }
 
         if (!account.isWriter) {
             throw new V1ProtocolError(
                 ResultCode.VALIDATOR_NODE_NOT_WRITER,
-                `Node entry found for validator address derived from connection public key (${validatorAddressFromConnection}), but it is not registered as a writer.`,
-                false
+                `Node entry found for validator address derived from connection public key (${validatorAddressFromConnection}), but it is not registered as a writer.`
             );
         }
 
         if (!b4a.isBuffer(account.wk) || !b4a.equals(account.wk, writerKeyFromManifest)) {
             throw new V1ProtocolError(
                 ResultCode.VALIDATOR_WRITER_KEY_MISMATCH,
-                `Writer key from manifest (${b4a.toString(writerKeyFromManifest, "hex")}) does not match writer key in state for validator address derived from connection public key (${validatorAddressFromConnection}).`,
-                false
+                `Writer key from manifest (${b4a.toString(writerKeyFromManifest, "hex")}) does not match writer key in state for validator address derived from connection public key (${validatorAddressFromConnection}).`
             );
         }
     }
@@ -219,37 +224,17 @@ class V1BroadcastTransactionResponse extends V1BaseOperation {
         if (resultCode === ResultCode.TX_COMMITTED_RECEIPT_MISSING) {
             throw new V1ProtocolError(
                 resultCode,
-                `Validator response indicates an error with result code ${resultCode}, which is an internal error code.`,
-                true
+                `Validator response indicates an error with result code ${resultCode}, which is an internal error code.`
             )
         }
     }
 }
 
-const stripValidatorMetadata = (value) => {
-
-    if (value === null || value === undefined) return value;
-    if (b4a.isBuffer(value)) return value;
-    if (Array.isArray(value)) return value.map(stripValidatorMetadata);
-    if (typeof value !== "object") return value;
-
-    const result = {};
-    for (const [key, nestedValue] of Object.entries(value)) {
-        if (VALIDATOR_METADATA_FIELDS.has(key)) {
-            result[key] = null;
-            continue;
-        }
-        result[key] = stripValidatorMetadata(nestedValue);
-    }
-    return result;
-};
-
 export function extractRequiredVaFromDecodedTx(validatorDecodedTx) {
     if (!validatorDecodedTx || typeof validatorDecodedTx !== 'object') {
         throw new V1ProtocolError(
             ResultCode.VALIDATOR_TX_OBJECT_INVALID,
-            'Invalid decoded transaction: expected object',
-            false
+            'Invalid decoded transaction: expected object'
         );
     }
 
@@ -266,8 +251,7 @@ export function extractRequiredVaFromDecodedTx(validatorDecodedTx) {
     if (!b4a.isBuffer(va)) {
         throw new V1ProtocolError(
             ResultCode.VALIDATOR_VA_MISSING,
-            'Missing validator address (va) in decoded transaction',
-            false
+            'Missing validator address (va) in decoded transaction'
         );
     }
     return va;

package/src/core/network/protocols/v1/validators/V1ValidationSchema.js

@@ -30,7 +30,7 @@ class V1ValidationSchema {
             },
         });
         const isBuffer = b4a.isBuffer;
-        this.#validator.add("buffer", function ({schema, messages}, path, context) {
+        this.#validator.add("buffer", function ({schema, messages}, _path, _context) {
             const allowZero = schema.allowZero === true;
             const allowEmpty = schema.allowEmpty === true;
             const exactLength = Number.isInteger(schema.length) ? schema.length : null;

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

@@ -6,6 +6,13 @@ import {Logger} from "../../../utils/logger.js";
  * @typedef {import('hyperswarm').Connection} Connection
  */
 
+export class ConnectionManagerError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = this.constructor.name;
+    }
+}
+
 class ConnectionManager {
     #validators
     #maxValidators
@@ -180,15 +187,16 @@ class ConnectionManager {
     /**
      * Removes a validator from the pool.
      * @param {String | Buffer} publicKey - The public key hex string of the validator to remove
+     * @param {object} [options]
+     * @param {boolean} [options.endConnection=true] - Whether to close the underlying socket.
      */
-    remove(publicKey) {
+    remove(publicKey, { endConnection = true } = {}) {
         this.#logger.debug(`remove: removing validator ${publicKeyToAddress(publicKey, this.#config)}`);
         const publicKeyHex = this.#toHexString(publicKey);
         this.#stopHealthCheck(publicKeyHex);
         if (this.exists(publicKeyHex)) {
-            // Close the connection socket
             const entry = this.#validators.get(publicKeyHex);
-            if (entry && entry.connection && typeof entry.connection.end === 'function') {
+            if (endConnection && entry && entry.connection && typeof entry.connection.end === 'function') {
                 try {
                     entry.connection.end();
                 } catch (e) {
@@ -349,11 +357,4 @@ class ConnectionManager {
     }
 }
 
-export class ConnectionManagerError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = this.constructor.name;
-    }
-}
-
 export default ConnectionManager;