trac-msb 0.2.18 → 0.2.20

package/src/core/network/protocols/legacy/validators/base/BaseResponse.js

@@ -1,6 +1,5 @@
 import b4a from 'b4a';
-import PeerWallet from 'trac-wallet';
-import State from '../../../../../state/State.js';
+import tracCryptoApi from 'trac-crypto-api';
 
 /*
     BaseResponse class for handling common validation logic for network responses.
@@ -9,18 +8,16 @@ import State from '../../../../../state/State.js';
 class BaseResponse {
     #wallet;
     #state;
-    #config
 
     /**
      * 
      * @param {State} state 
-     * @param {PeerWallet} wallet 
+     * @param {IWallet} wallet
      * @param {Config} config
      */
-    constructor(state, wallet, config) {
+    constructor(state, wallet, _config) {
         this.#state = state;
         this.#wallet = wallet;
-        this.#config = config;
     }
 
     get state() {
@@ -66,11 +63,11 @@ class BaseResponse {
         switch (type) {
             case 'admin':
                 const adminEntry = await this.state.getAdminEntry();
-                publicKey = PeerWallet.decodeBech32m(adminEntry.address);
+                publicKey = tracCryptoApi.address.decode(adminEntry.address);
 
                 break;
             default:
-                publicKey = PeerWallet.decodeBech32m(message.address);
+                publicKey = tracCryptoApi.address.decode(message.address);
         }
 
         if (!publicKey) {
@@ -80,7 +77,7 @@ class BaseResponse {
         const messageWithoutSig = { ...message };
         delete messageWithoutSig.sig;
         const hashInput = b4a.from(JSON.stringify(messageWithoutSig), 'utf8');
-        const hash = await PeerWallet.blake3(hashInput);
+        const hash = await tracCryptoApi.hash.blake3(hashInput);
         const signature = b4a.from(message.sig, 'hex');
         const verified = this.#wallet.verify(signature, hash, publicKey);
 
@@ -91,4 +88,4 @@ class BaseResponse {
     }
 }
 
-export default BaseResponse;
+export default BaseResponse;

package/src/core/network/protocols/shared/validators/PartialBootstrapDeploymentValidator.js

@@ -1,6 +1,6 @@
 import PartialOperationValidator from './PartialOperationValidator.js';
 import {ResultCode} from "../../../../../utils/constants.js";
-import SharedValidatorRejectionError from '../errors/SharedValidatorRejectionError.js';
+import {V1ProtocolError} from '../../v1/V1ProtocolError.js';
 
 class PartialBootstrapDeploymentValidator extends PartialOperationValidator {
     constructor(state, selfAddress , config) {
@@ -28,7 +28,7 @@ class PartialBootstrapDeploymentValidator extends PartialOperationValidator {
     async validateBootstrapRegistration(payload) {
         const bootstrapString = payload.bdo.bs.toString('hex');
         if (null !== await this.state.getRegisteredBootstrapEntryUnsigned(bootstrapString)) {
-            throw new SharedValidatorRejectionError(
+            throw new V1ProtocolError(
                 ResultCode.BOOTSTRAP_ALREADY_EXISTS,
                 `Bootstrap with hash ${bootstrapString} already exists in the state. Bootstrap must be unique.`
             );

package/src/core/network/protocols/shared/validators/PartialOperationValidator.js

@@ -1,5 +1,5 @@
 import b4a from 'b4a';
-import PeerWallet from 'trac-wallet';
+import tracCryptoApi from 'trac-crypto-api';
 import Check from '../../../../../utils/check.js';
 import {bufferToAddress} from "../../../../state/utils/address.js";
 import {createMessage} from "../../../../../utils/buffer.js";
@@ -7,7 +7,7 @@ import {OperationType, ResultCode} from "../../../../../utils/constants.js";
 import {bufferToBigInt} from "../../../../../utils/amountSerialization.js";
 import {FEE} from "../../../../state/utils/transaction.js";
 import * as operationsUtils from '../../../../../utils/applyOperations.js';
-import SharedValidatorRejectionError from '../errors/SharedValidatorRejectionError.js';
+import {V1ProtocolError} from '../../v1/V1ProtocolError.js';
 
 const MAX_AMOUNT = BigInt('0xffffffffffffffffffffffffffffffff');
 const FEE_BIGINT = bufferToBigInt(FEE);
@@ -36,19 +36,19 @@ class PartialOperationValidator {
         return this.#check;
     }
 
-    async validate(payload) {
-        throw new SharedValidatorRejectionError(ResultCode.UNEXPECTED_ERROR, "Method 'validate()' must be implemented.");
+    async validate() {
+        throw new V1ProtocolError(ResultCode.UNEXPECTED_ERROR, "Method 'validate()' must be implemented.");
     }
 
     isPayloadSchemaValid(payload) {
         if (!payload || !payload.type) {
-            throw new SharedValidatorRejectionError(ResultCode.TX_INVALID_PAYLOAD, 'Payload or payload type is missing.');
+            throw new V1ProtocolError(ResultCode.TX_INVALID_PAYLOAD, 'Payload or payload type is missing.');
         }
 
         const selectedValidator = this.#selectCheckSchemaValidator(payload.type);
         const isPayloadValid = selectedValidator(payload);
         if (!isPayloadValid) {
-            throw new SharedValidatorRejectionError(ResultCode.SCHEMA_VALIDATION_FAILED, 'Payload is invalid.');
+            throw new V1ProtocolError(ResultCode.SCHEMA_VALIDATION_FAILED, 'Payload is invalid.');
         }
     }
 
@@ -65,7 +65,7 @@ class PartialOperationValidator {
             case OperationType.TRANSFER:
                 return this.check.validateTransferOperation.bind(this.check);
             default:
-                throw new SharedValidatorRejectionError(
+                throw new V1ProtocolError(
                     ResultCode.OPERATION_TYPE_UNKNOWN,
                     `Unknown operation type: ${type}`
                 );
@@ -75,14 +75,14 @@ class PartialOperationValidator {
     validateRequesterAddress(payload) {
         const incomingAddress = bufferToAddress(payload.address, this.#config.addressPrefix);
         if (!incomingAddress) {
-            throw new SharedValidatorRejectionError(ResultCode.REQUESTER_ADDRESS_INVALID, 'Invalid requesting address in payload.');
+            throw new V1ProtocolError(ResultCode.REQUESTER_ADDRESS_INVALID, 'Invalid requesting address in payload.');
         }
 
-        const incomingPublicKey = PeerWallet.decodeBech32mSafe(incomingAddress);
+        const incomingPublicKey = tracCryptoApi.address.decodeSafe(incomingAddress);
 
         // TODO: We can add check if public key belongs to the Ed25519 curve. Validate signature already checks that but it would be amazing to catch it earlier.
         if (!incomingPublicKey || incomingPublicKey.length !== PUBLIC_KEY_LENGTH) {
-            throw new SharedValidatorRejectionError(ResultCode.REQUESTER_PUBLIC_KEY_INVALID, 'Invalid requesting public key in payload.');
+            throw new V1ProtocolError(ResultCode.REQUESTER_PUBLIC_KEY_INVALID, 'Invalid requesting public key in payload.');
         }
     }
 
@@ -131,7 +131,7 @@ class PartialOperationValidator {
                     OperationType.TRANSFER
                 ];
             default:
-                throw new SharedValidatorRejectionError(
+                throw new V1ProtocolError(
                     ResultCode.OPERATION_TYPE_UNKNOWN,
                     `Unknown operation type: ${payload.type}`
                 );
@@ -142,22 +142,22 @@ class PartialOperationValidator {
         const operationKey = operationsUtils.operationToPayload(payload.type);
         const operation = payload[operationKey];
 
-        const incomingPublicKey = PeerWallet.decodeBech32mSafe(bufferToAddress(payload.address, this.#config.addressPrefix));
+        const incomingPublicKey = tracCryptoApi.address.decodeSafe(bufferToAddress(payload.address, this.#config.addressPrefix));
         const incomingSignature = operation.is;
         const messageComponents = this.#getMessageComponents(payload);
 
         const message = createMessage(...messageComponents);
-        const messageHash = await PeerWallet.blake3(message);
+        const messageHash = await tracCryptoApi.hash.blake3(message);
         const payloadHash = operation.tx;
         if (!b4a.equals(payloadHash, messageHash)) {
-            throw new SharedValidatorRejectionError(
+            throw new V1ProtocolError(
                 ResultCode.TX_HASH_MISMATCH,
                 'Regenerated transaction does not match incoming transaction in payload.'
             );
         }
 
-        if (!PeerWallet.verify(incomingSignature, messageHash, incomingPublicKey)) {
-            throw new SharedValidatorRejectionError(ResultCode.TX_SIGNATURE_INVALID, 'Invalid signature in payload.');
+        if (!tracCryptoApi.signature.verify(incomingSignature, messageHash, incomingPublicKey)) {
+            throw new V1ProtocolError(ResultCode.TX_SIGNATURE_INVALID, 'Invalid signature in payload.');
         }
     }
 
@@ -168,7 +168,7 @@ class PartialOperationValidator {
         const incomingTxv = operation.txv
 
         if (!b4a.equals(currentTxv, incomingTxv)) {
-            throw new SharedValidatorRejectionError(ResultCode.TX_EXPIRED, 'Transaction has expired.');
+            throw new V1ProtocolError(ResultCode.TX_EXPIRED, 'Transaction has expired.');
         }
     }
 
@@ -179,7 +179,7 @@ class PartialOperationValidator {
         const txHex = tx.toString('hex');
 
         if (await this.state.get(txHex) !== null) {
-            throw new SharedValidatorRejectionError(
+            throw new V1ProtocolError(
                 ResultCode.TX_ALREADY_EXISTS,
                 `Transaction with hash ${txHex} already exists in the state.`
             );
@@ -193,7 +193,7 @@ class PartialOperationValidator {
 
         const condition = va === undefined && vn === undefined && vs === undefined
         if (!condition) {
-            throw new SharedValidatorRejectionError(
+            throw new V1ProtocolError(
                 ResultCode.OPERATION_ALREADY_COMPLETED,
                 'Transfer operation must not be completed already (va, vn, vs must be undefined).'
             );
@@ -210,12 +210,12 @@ class PartialOperationValidator {
         }
 
         if (!requesterEntry) {
-            throw new SharedValidatorRejectionError(ResultCode.REQUESTER_NOT_FOUND, 'Requester address not found in state');
+            throw new V1ProtocolError(ResultCode.REQUESTER_NOT_FOUND, 'Requester address not found in state');
         }
 
         const requesterBalance = bufferToBigInt(requesterEntry.balance);
         if (requesterBalance < FEE_BIGINT) {
-            throw new SharedValidatorRejectionError(ResultCode.INSUFFICIENT_FEE_BALANCE, 'Insufficient balance to cover transaction fee.');
+            throw new V1ProtocolError(ResultCode.INSUFFICIENT_FEE_BALANCE, 'Insufficient balance to cover transaction fee.');
         }
     }
 
@@ -225,7 +225,7 @@ class PartialOperationValidator {
         const operation = payload[operationKey];
         const bs = operation.bs;
         if (b4a.equals(this.#config.bootstrap, bs)) {
-            throw new SharedValidatorRejectionError(
+            throw new V1ProtocolError(
                 ResultCode.EXTERNAL_BOOTSTRAP_EQUALS_MSB_BOOTSTRAP,
                 `External bootstrap is the same as MSB bootstrap: ${bs.toString('hex')}`
             );
@@ -242,7 +242,7 @@ class PartialOperationValidator {
 
         const requesterAddress = bufferToAddress(payload.address, this.#config.addressPrefix);
         if (this.#selfAddress === requesterAddress) {
-            throw new SharedValidatorRejectionError(
+            throw new V1ProtocolError(
                 ResultCode.SELF_VALIDATION_FORBIDDEN,
                 'Requester address cannot be the same as the validator wallet address.'
             );

package/src/core/network/protocols/shared/validators/PartialRoleAccessValidator.js

@@ -3,7 +3,7 @@ import {OperationType, ResultCode} from "../../../../../utils/constants.js";
 import {bufferToAddress} from "../../../../state/utils/address.js";
 import PartialOperationValidator from './PartialOperationValidator.js';
 import {bufferToBigInt} from "../../../../../utils/amountSerialization.js";
-import SharedValidatorRejectionError from '../errors/SharedValidatorRejectionError.js';
+import {V1ProtocolError} from '../../v1/V1ProtocolError.js';
 
 class PartialRoleAccessValidator extends PartialOperationValidator {
     #config;
@@ -43,7 +43,7 @@ class PartialRoleAccessValidator extends PartialOperationValidator {
             const nodeAddress = bufferToAddress(payload.address, this.#config.addressPrefix);
             const nodeEntry = await this.state.getNodeEntry(nodeAddress);
             if (!nodeEntry) {
-                throw new SharedValidatorRejectionError(
+                throw new V1ProtocolError(
                     ResultCode.ROLE_NODE_ENTRY_NOT_FOUND,
                     `Node with address ${nodeAddress} entry does not exist.`
                 );
@@ -51,7 +51,7 @@ class PartialRoleAccessValidator extends PartialOperationValidator {
 
             const isNodeAlreadyWriter = nodeEntry.isWriter;
             if (isNodeAlreadyWriter) {
-                throw new SharedValidatorRejectionError(
+                throw new V1ProtocolError(
                     ResultCode.ROLE_NODE_ALREADY_WRITER,
                     `Node with address ${nodeAddress} is already a writer.`
                 );
@@ -59,7 +59,7 @@ class PartialRoleAccessValidator extends PartialOperationValidator {
 
             const isNodeWhitelisted = nodeEntry.isWhitelisted;
             if (!isNodeWhitelisted) {
-                throw new SharedValidatorRejectionError(
+                throw new V1ProtocolError(
                     ResultCode.ROLE_NODE_NOT_WHITELISTED,
                     `Node with address ${nodeAddress} is not whitelisted.`
                 );
@@ -70,7 +70,7 @@ class PartialRoleAccessValidator extends PartialOperationValidator {
             const nodeAddress = bufferToAddress(payload.address, this.#config.addressPrefix);
             const nodeEntry = await this.state.getNodeEntry(nodeAddress);
             if (!nodeEntry) {
-                throw new SharedValidatorRejectionError(
+                throw new V1ProtocolError(
                     ResultCode.ROLE_NODE_ENTRY_NOT_FOUND,
                     `Node with address ${nodeAddress} entry does not exist.`
                 );
@@ -78,7 +78,7 @@ class PartialRoleAccessValidator extends PartialOperationValidator {
 
             const isAlreadyWriter = nodeEntry.isWriter;
             if (!isAlreadyWriter) {
-                throw new SharedValidatorRejectionError(
+                throw new V1ProtocolError(
                     ResultCode.ROLE_NODE_NOT_WRITER,
                     `Node with address ${nodeAddress} is not a writer.`
                 );
@@ -86,7 +86,7 @@ class PartialRoleAccessValidator extends PartialOperationValidator {
 
             const isAlreadyIndexer = nodeEntry.isIndexer;
             if (isAlreadyIndexer) {
-                throw new SharedValidatorRejectionError(
+                throw new V1ProtocolError(
                     ResultCode.ROLE_NODE_IS_INDEXER,
                     `Node with address ${nodeAddress} is an indexer.`
                 );
@@ -96,7 +96,7 @@ class PartialRoleAccessValidator extends PartialOperationValidator {
         } else if (type === OperationType.ADMIN_RECOVERY) {
             const adminEntry = await this.state.getAdminEntry();
             if (!adminEntry) {
-                throw new SharedValidatorRejectionError(ResultCode.ROLE_ADMIN_ENTRY_MISSING, 'Admin entry does not exist.');
+                throw new V1ProtocolError(ResultCode.ROLE_ADMIN_ENTRY_MISSING, 'Admin entry does not exist.');
             }
 
             const adminAddressBuffer = payload.address;
@@ -106,7 +106,7 @@ class PartialRoleAccessValidator extends PartialOperationValidator {
                 !b4a.equals(payload.rao.iw, adminEntry.wk)
             );
             if (!isRecoveryCase) {
-                throw new SharedValidatorRejectionError(
+                throw new V1ProtocolError(
                     ResultCode.ROLE_INVALID_RECOVERY_CASE,
                     `Node with address ${adminAddress} is not a valid recovery case.`
                 );
@@ -115,7 +115,7 @@ class PartialRoleAccessValidator extends PartialOperationValidator {
             return;
         }
 
-        throw new SharedValidatorRejectionError(
+        throw new V1ProtocolError(
             ResultCode.ROLE_UNKNOWN_OPERATION,
             `Unknown role access operation type: ${type}`
         );
@@ -125,7 +125,7 @@ class PartialRoleAccessValidator extends PartialOperationValidator {
         const requesterAddress = bufferToAddress(payload.address, this.#config.addressPrefix);
         const nodeEntry = await this.state.getNodeEntry(requesterAddress);
         if (!nodeEntry) {
-            throw new SharedValidatorRejectionError(
+            throw new V1ProtocolError(
                 ResultCode.REQUESTER_NOT_FOUND,
                 `Node entry not found for address ${requesterAddress}`
             );
@@ -139,7 +139,7 @@ class PartialRoleAccessValidator extends PartialOperationValidator {
             const isOwner = b4a.equals(addressFromRegisteredWritingKey, payload.address);
 
             if (!isCurrentWk || !isOwner) {
-                throw new SharedValidatorRejectionError(
+                throw new V1ProtocolError(
                     ResultCode.ROLE_INVALID_WRITER_KEY,
                     'Invalid writer key: either not owned by requester or different from assigned key'
                 );
@@ -157,13 +157,13 @@ class PartialRoleAccessValidator extends PartialOperationValidator {
         }
 
         if (!requesterEntry) {
-            throw new SharedValidatorRejectionError(ResultCode.REQUESTER_NOT_FOUND, 'Requester address not found in state');
+            throw new V1ProtocolError(ResultCode.REQUESTER_NOT_FOUND, 'Requester address not found in state');
         }
         const requesterBalance = bufferToBigInt(requesterEntry.balance);
 
         const requiredBalance = this.fee * 11n;
         if (requesterBalance < requiredBalance) {
-            throw new SharedValidatorRejectionError(
+            throw new V1ProtocolError(
                 ResultCode.ROLE_INSUFFICIENT_FEE_BALANCE,
                 'Insufficient requester balance to cover role access operation FEE.'
             );

package/src/core/network/protocols/shared/validators/PartialTransactionValidator.js

@@ -3,7 +3,7 @@ import {safeDecodeApplyOperation} from "../../../../../utils/protobuf/operationH
 import deploymentEntryUtils from "../../../../state/utils/deploymentEntry.js";
 import PartialOperationValidator from './PartialOperationValidator.js';
 import {ResultCode} from "../../../../../utils/constants.js";
-import SharedValidatorRejectionError from '../errors/SharedValidatorRejectionError.js';
+import {V1ProtocolError} from '../../v1/V1ProtocolError.js';
 
 class PartialTransactionValidator extends PartialOperationValidator {
     #config
@@ -34,7 +34,7 @@ class PartialTransactionValidator extends PartialOperationValidator {
 
     validateMsbBootstrap(payload) {
         if (!b4a.equals(this.#config.bootstrap, payload.txo.mbs)) {
-            throw new SharedValidatorRejectionError(
+            throw new V1ProtocolError(
                 ResultCode.MSB_BOOTSTRAP_MISMATCH,
                 `Declared MSB bootstrap is different than network bootstrap in transaction operation: ${payload.txo.mbs.toString('hex')}`
             );
@@ -44,7 +44,7 @@ class PartialTransactionValidator extends PartialOperationValidator {
     async validateIfExternalBootstrapHasBeenDeployed(payload) {
         const externalBootstrapResult = await this.state.getRegisteredBootstrapEntry(payload.txo.bs.toString('hex'));
         if (externalBootstrapResult === null) {
-            throw new SharedValidatorRejectionError(
+            throw new V1ProtocolError(
                 ResultCode.EXTERNAL_BOOTSTRAP_NOT_DEPLOYED,
                 `External bootstrap with hash ${payload.txo.bs.toString('hex')} is not registered as deployment entry.`
             );
@@ -55,7 +55,7 @@ class PartialTransactionValidator extends PartialOperationValidator {
         const getBootstrapTransactionTxPayload = await this.state.get(txHash.toString('hex'));
 
         if (getBootstrapTransactionTxPayload === null) {
-            throw new SharedValidatorRejectionError(
+            throw new V1ProtocolError(
                 ResultCode.EXTERNAL_BOOTSTRAP_TX_MISSING,
                 `External bootstrap is not registered as usual tx ${externalBootstrapResult.toString('hex')}: ${payload}`
             );
@@ -65,7 +65,7 @@ class PartialTransactionValidator extends PartialOperationValidator {
 
         // edge case
         if (!b4a.equals(decodedBootstrapDeployment.bdo.bs, payload.txo.bs)) {
-            throw new SharedValidatorRejectionError(
+            throw new V1ProtocolError(
                 ResultCode.EXTERNAL_BOOTSTRAP_MISMATCH,
                 `External bootstrap does not match the one in the transaction payload: ${decodedBootstrapDeployment.bdo.bs.toString('hex')} !== ${payload.txo.bs.toString('hex')}`
             );

package/src/core/network/protocols/shared/validators/PartialTransferValidator.js

@@ -1,10 +1,11 @@
-import PeerWallet from 'trac-wallet';
-
 import {bufferToAddress} from "../../../../state/utils/address.js";
 import {bufferToBigInt} from "../../../../../utils/amountSerialization.js";
 import {ResultCode} from "../../../../../utils/constants.js";
+import { NULL_BUFFER } from '../../../../../utils/buffer.js';
 import PartialOperationValidator from './PartialOperationValidator.js';
-import SharedValidatorRejectionError from '../errors/SharedValidatorRejectionError.js';
+import {V1ProtocolError} from '../../v1/V1ProtocolError.js';
+import tracCryptoApi from "trac-crypto-api";
+import b4a from 'b4a';
 
 class PartialTransferValidator extends PartialOperationValidator {
     #config
@@ -33,15 +34,15 @@ class PartialTransferValidator extends PartialOperationValidator {
     #validateRecipientAddress(payload) {
         const incomingAddress = bufferToAddress(payload.tro.to, this.#config.addressPrefix);
         if (!incomingAddress) {
-            throw new SharedValidatorRejectionError(
+            throw new V1ProtocolError(
                 ResultCode.TRANSFER_RECIPIENT_ADDRESS_INVALID,
                 'Invalid recipient address in transfer payload.'
             );
         }
 
-        const incomingPublicKey = PeerWallet.decodeBech32mSafe(incomingAddress);
-        if (incomingPublicKey === null) {
-            throw new SharedValidatorRejectionError(
+        const incomingPublicKey = tracCryptoApi.address.decodeSafe(incomingAddress);
+        if (b4a.equals(incomingPublicKey, NULL_BUFFER)) {
+            throw new V1ProtocolError(
                 ResultCode.TRANSFER_RECIPIENT_PUBLIC_KEY_INVALID,
                 'Invalid recipient public key in transfer payload.'
             );
@@ -55,7 +56,7 @@ class PartialTransferValidator extends PartialOperationValidator {
 
         const transferAmount = bufferToBigInt(payload.tro.am);
         if (transferAmount > this.max_amount) {
-            throw new SharedValidatorRejectionError(
+            throw new V1ProtocolError(
                 ResultCode.TRANSFER_AMOUNT_TOO_LARGE,
                 'Transfer amount exceeds maximum allowed value'
             );
@@ -66,12 +67,12 @@ class PartialTransferValidator extends PartialOperationValidator {
 
         const senderEntry = await this.state.getNodeEntryUnsigned(senderAddress);
         if (!senderEntry) {
-            throw new SharedValidatorRejectionError(ResultCode.TRANSFER_SENDER_NOT_FOUND, 'Sender account not found');
+            throw new V1ProtocolError(ResultCode.TRANSFER_SENDER_NOT_FOUND, 'Sender account not found');
         }
 
         const senderBalance = bufferToBigInt(senderEntry.balance);
         if (!(senderBalance >= totalDeductedAmount)) {
-            throw new SharedValidatorRejectionError(
+            throw new V1ProtocolError(
                 ResultCode.TRANSFER_INSUFFICIENT_BALANCE,
                 'Insufficient balance for transfer' + (isSelfTransfer ? ' fee' : ' + fee')
             );
@@ -83,7 +84,7 @@ class PartialTransferValidator extends PartialOperationValidator {
                 const recipientBalance = bufferToBigInt(recipientEntry.balance);
                 const newRecipientBalance = recipientBalance + transferAmount;
                 if (newRecipientBalance > this.max_amount) {
-                    throw new SharedValidatorRejectionError(
+                    throw new V1ProtocolError(
                         ResultCode.TRANSFER_RECIPIENT_BALANCE_OVERFLOW,
                         'Transfer would cause recipient balance to exceed maximum allowed value'
                     );

package/src/core/network/protocols/v1/V1ProtocolError.js

@@ -1,91 +1,27 @@
 import {ResultCode} from '../../../../utils/constants.js';
 
-export function getResultCode(err) {
-    return err instanceof V1ProtocolError ? err.resultCode : ResultCode.UNEXPECTED_ERROR;
-}
-
-export function shouldEndConnection(err) {
-    return err instanceof V1ProtocolError ? Boolean(err.endConnection) : false;
-}
-
 /** 
  * V1 protocol error type.
  *
  * `V1ProtocolError` is the v1 base class used by handlers/validators to attach:
  * - `resultCode`: a stable `ResultCode` enum value for programmatic handling
- * - `endConnection`: a transport hint (close peer connection after responding)
  */
 export class V1ProtocolError extends Error {
     /**
      * @param {number} resultCode Stable rejection reason (a `ResultCode` enum value).
      * @param {string} message Human-readable error message.
-     * @param {boolean} [endConnection=false] Whether the transport should end the connection after responding.
      */
-    constructor(resultCode, message, endConnection = false) {
+    constructor(resultCode, message) {
         super(message);
         this.name = this.constructor.name;
         this.resultCode = resultCode;
-        this.endConnection = Boolean(endConnection);
-    }
-}
-
-export class V1InvalidPayloadError extends V1ProtocolError {
-    constructor(message = 'Invalid payload', endConnection = false) {
-        super(ResultCode.INVALID_PAYLOAD, message, endConnection);
-    }
-}
-
-export class V1TxInvalidPayloadError extends V1ProtocolError {
-    constructor(message = 'Invalid tx payload', endConnection = false) {
-        super(ResultCode.TX_INVALID_PAYLOAD, message, endConnection);
-    }
-}
-
-export class V1SignatureInvalidError extends V1ProtocolError {
-    constructor(message = 'Signature invalid', endConnection = true) {
-        super(ResultCode.SIGNATURE_INVALID, message, endConnection);
-    }
-}
-
-export class V1RateLimitedError extends V1ProtocolError {
-    constructor(message = 'Rate limited', endConnection = true) {
-        super(ResultCode.RATE_LIMITED, message, endConnection);
-    }
-}
-
-export class V1UnexpectedError extends V1ProtocolError {
-    constructor(message = 'Unexpected error', endConnection = true) {
-        super(ResultCode.UNEXPECTED_ERROR, message, endConnection);
-    }
-}
-
-export class V1TimeoutError extends V1ProtocolError {
-    constructor(message = 'Request timed out', endConnection = false) {
-        super(ResultCode.TIMEOUT, message, endConnection);
-    }
-}
-
-export class V1NodeHasNoWriteAccess extends V1ProtocolError {
-    constructor(message = 'Node has no write access', endConnection = true) {
-        super(ResultCode.NODE_HAS_NO_WRITE_ACCESS, message, endConnection);
     }
 }
 
-export class V1TxAcceptedProofUnavailable extends V1ProtocolError {
-    constructor(message = 'Transaction accepted but proof is unavailable', endConnection = false, timestamp = 0) {
-        super(ResultCode.TX_ACCEPTED_PROOF_UNAVAILABLE, message, endConnection);
-        this.timestamp = Number.isSafeInteger(timestamp) && timestamp > 0 ? timestamp : 0;
-    }
-}
-
-export class V1NodeOverloadedError extends V1ProtocolError {
-    constructor(message = 'Commit queue is full', endConnection = true) {
-        super(ResultCode.NODE_OVERLOADED, message, endConnection);
-    }
+export function getResultCode(err) {
+    return err instanceof V1ProtocolError ? err.resultCode : ResultCode.UNEXPECTED_ERROR;
 }
 
-export class V1TxAlreadyPendingError extends V1ProtocolError {
-    constructor(message = 'Transaction is already pending', endConnection = false) {
-        super(ResultCode.TX_ALREADY_PENDING, message, endConnection);
-    }
+export function shouldEndConnection(err) {
+    return err instanceof V1ProtocolError ? Boolean(err.endConnection) : false;
 }

package/src/core/network/protocols/v1/handlers/V1BaseOperationHandler.js

@@ -1,5 +1,6 @@
+import {ResultCode} from "../../../../../utils/constants.js";
 import {publicKeyToAddress} from "../../../../../utils/helpers.js";
-import {V1ProtocolError, V1UnexpectedError} from "../V1ProtocolError.js";
+import {V1ProtocolError} from "../V1ProtocolError.js";
 
 class V1BaseOperationHandler {
     #rateLimiterService;
@@ -58,7 +59,7 @@ class V1BaseOperationHandler {
         if (error instanceof V1ProtocolError) {
             return error;
         }
-        return new V1UnexpectedError(error?.message ?? 'Unexpected error');
+        return new V1ProtocolError(ResultCode.UNEXPECTED_ERROR, error?.message ?? 'Unexpected error');
     }
 }