trac-msb 0.2.17 → 0.2.19

package/src/core/network/protocols/legacy/handlers/{GetRequestHandler.js → LegacyGetRequestHandler.js}

@@ -1,8 +1,8 @@
 import { NETWORK_MESSAGE_TYPES } from '../../../../../utils/constants.js';
-import PeerWallet from 'trac-wallet';
+import tracCryptoApi from 'trac-crypto-api';
 import b4a from 'b4a';
 
-class GetRequestHandler {
+class LegacyGetRequestHandler {
     #wallet;
     #state;
 
@@ -15,18 +15,18 @@ class GetRequestHandler {
         return this.#state;
     }
 
-    async handle(message, messageProtomux, connection, channelString) {
+    async handle(message, connection, channelString) {
         switch (message) {
             case NETWORK_MESSAGE_TYPES.GET.VALIDATOR:
-                await this.handleGetValidatorResponse(messageProtomux, connection, channelString);
+                await this.handleGetValidatorResponse(connection, channelString);
                 break;
             default:
                 throw new Error(`Unhandled GET type: ${message}`);
         }
     }
 
-    async handleGetValidatorResponse(messageProtomux, connection, channelString) {
-        const nonce = PeerWallet.generateNonce().toString('hex');
+    async handleGetValidatorResponse(connection, channelString) {
+        const nonce = b4a.toString(tracCryptoApi.nonce.generate(), 'hex');
         const payload = {
             op: 'validatorResponse',
             wk: this.state.writingKey.toString('hex'),
@@ -39,15 +39,15 @@ class GetRequestHandler {
 
 
         const hashInput = b4a.from(JSON.stringify(payload), 'utf8');
-        const hash = await PeerWallet.blake3(hashInput);
+        const hash = await tracCryptoApi.hash.blake3(hashInput);
         const sig = this.#wallet.sign(hash);
 
         const responseMessage = {
             ...payload,
             sig: sig.toString('hex'),
         };
-        messageProtomux.send(responseMessage);
+        connection.protocolSession.sendAndForget(responseMessage)
     }
 }
 
-export default GetRequestHandler;
+export default LegacyGetRequestHandler;

package/src/core/network/protocols/legacy/handlers/LegacyResponseHandler.js

@@ -0,0 +1,23 @@
+import ValidatorResponse from '../validators/ValidatorResponse.js';
+
+class LegacyResponseHandler {
+    #responseValidator;
+
+    constructor(state, wallet, config) {
+        this.#responseValidator = new ValidatorResponse(state, wallet, config);
+
+    }
+
+    async handle(message, channelString) {
+        await this.#handleValidatorResponse(message, channelString);
+    }
+
+    async #handleValidatorResponse(message, channelString) {
+        const isValid = await this.#responseValidator.validate(message, channelString);
+        if (!isValid) {
+            throw new Error("Validator response verification failed");
+        }
+    }
+}
+
+export default LegacyResponseHandler;

package/src/core/network/protocols/{shared/handlers/RoleOperationHandler.js → legacy/handlers/LegacyRoleOperationHandler.js}

@@ -1,19 +1,20 @@
 import {OperationType} from '../../../../../utils/constants.js';
-import PartialRoleAccess from "../validators/PartialRoleAccess.js";
-import BaseOperationHandler from './base/BaseOperationHandler.js';
+import PartialRoleAccessValidator from "../../shared/validators/PartialRoleAccessValidator.js";
+import BaseStateOperationHandler from './BaseStateOperationHandler.js';
 import {applyStateMessageFactory} from "../../../../../messages/state/applyStateMessageFactory.js";
 import {safeEncodeApplyOperation} from "../../../../../utils/protobuf/operationHelpers.js";
 import {normalizeRoleAccessOperation} from "../../../../../utils/normalizers.js";
+import { publicKeyToAddress } from "../../../../../utils/helpers.js"
+import b4a from "b4a";
 
-class RoleOperationHandler extends BaseOperationHandler {
+class LegacyRoleOperationHandler extends BaseStateOperationHandler {
     #partialRoleAccessValidator;
     #wallet;
     #config;
-    #txPoolService;
 
     /**
      * @param {State} state
-     * @param {PeerWallet} wallet
+     * @param {IWallet} wallet
      * @param {TransactionRateLimiterService} rateLimiter
      * @param {TransactionPoolService} txPoolService
      * @param {Config} config
@@ -22,8 +23,7 @@ class RoleOperationHandler extends BaseOperationHandler {
         super(state, wallet, rateLimiter, txPoolService, config);
         this.#wallet = wallet;
         this.#config = config;
-        this.#partialRoleAccessValidator = new PartialRoleAccess(state, this.#wallet.address ,this.#config)
-        this.#txPoolService = txPoolService;
+        this.#partialRoleAccessValidator = new PartialRoleAccessValidator(state, this.#wallet.address ,this.#config)
     }
 
     get partialRoleAccessValidator() {
@@ -35,7 +35,8 @@ class RoleOperationHandler extends BaseOperationHandler {
         const isValid = await this.partialRoleAccessValidator.validate(normalizedPartialRoleAccessPayload)
         let completePayload = null
         if (!isValid) {
-            throw new Error("OperationHandler: partial role access payload validation failed.");
+            throw new Error(
+                `OperationHandler: partial role access payload validation failed. Requested by ${publicKeyToAddress(connection.remotePublicKey, this.#config)}`);
         }
         
         switch (normalizedPartialRoleAccessPayload.type) {
@@ -74,15 +75,21 @@ class RoleOperationHandler extends BaseOperationHandler {
                     )
                 break;
             default:
-                throw new Error("OperationHandler: Assembling complete role access operation failed due to unsupported operation type.");
+                throw new Error(
+                    `OperationHandler: Assembling complete role access operation failed due to unsupported operation type. Requested by ${publicKeyToAddress(connection.remotePublicKey, this.#config)}`
+                );
         }
 
         if (!completePayload) {
-            throw new Error("OperationHandler: Assembling complete role access operation failed.");
+            throw new Error(
+                `OperationHandler: Assembling complete role access operation failed. Requested by ${publicKeyToAddress(connection.remotePublicKey, this.#config)}`
+            );
         }
 
-        this.#txPoolService.addTransaction(safeEncodeApplyOperation(completePayload))
+        const encodedOperation = safeEncodeApplyOperation(completePayload);
+        const txHash =  b4a.toString(completePayload.rao.tx, 'hex');
+        this.enqueueTransaction(txHash, encodedOperation);
     }
 }
 
-export default RoleOperationHandler;
+export default LegacyRoleOperationHandler;

package/src/core/network/protocols/{shared/handlers/SubnetworkOperationHandler.js → legacy/handlers/LegacySubnetworkOperationHandler.js}

@@ -1,47 +1,49 @@
-import BaseOperationHandler from './base/BaseOperationHandler.js';
+import BaseStateOperationHandler from './BaseStateOperationHandler.js';
 import {
     OperationType
 } from '../../../../../utils/constants.js';
-import PartialBootstrapDeployment from "../validators/PartialBootstrapDeployment.js";
-import PartialTransaction from "../validators/PartialTransaction.js";
+import PartialBootstrapDeploymentValidator from "../../shared/validators/PartialBootstrapDeploymentValidator.js";
+import PartialTransactionValidator from "../../shared/validators/PartialTransactionValidator.js";
 import {applyStateMessageFactory} from "../../../../../messages/state/applyStateMessageFactory.js";
 import {safeEncodeApplyOperation} from "../../../../../utils/protobuf/operationHelpers.js";
 import {
     normalizeBootstrapDeploymentOperation,
     normalizeTransactionOperation
 } from "../../../../../utils/normalizers.js";
+import b4a from "b4a";
+import {publicKeyToAddress} from "../../../../../utils/helpers.js";
 
 
-class SubnetworkOperationHandler extends BaseOperationHandler {
+class LegacySubnetworkOperationHandler extends BaseStateOperationHandler {
     #partialBootstrapDeploymentValidator;
     #partialTransactionValidator;
     #config;
     #wallet;
-    #txPoolService;
 
     /**
      * @param {State} state
-     * @param {PeerWallet} wallet
+     * @param {IWallet} wallet
      * @param {TransactionRateLimiterService} rateLimiter
      * @param {TransactionPoolService} txPoolService
      * @param {Config} config
      **/
-    constructor( state, wallet, rateLimiter, txPoolService, config) {
+    constructor(state, wallet, rateLimiter, txPoolService, config) {
         super(state, wallet, rateLimiter, txPoolService, config);
         this.#config = config;
         this.#wallet = wallet
-        this.#partialBootstrapDeploymentValidator = new PartialBootstrapDeployment(state, this.#wallet.address, config);
-        this.#partialTransactionValidator = new PartialTransaction(state, this.#wallet.address, config);
-        this.#txPoolService = txPoolService;
+        this.#partialBootstrapDeploymentValidator = new PartialBootstrapDeploymentValidator(state, this.#wallet.address, config);
+        this.#partialTransactionValidator = new PartialTransactionValidator(state, this.#wallet.address, config);
     }
 
-    async handleOperation(payload, connection)  {
+    async handleOperation(payload, connection) {
         if (payload.type === OperationType.TX) {
             await this.#partialTransactionSubHandler(payload, connection);
         } else if (payload.type === OperationType.BOOTSTRAP_DEPLOYMENT) {
             await this.#partialBootstrapDeploymentSubHandler(payload, connection);
         } else {
-            throw new Error('Unsupported operation type for SubnetworkOperationHandler');
+            throw new Error(
+                `Unsupported operation type for LegacySubnetworkOperationHandler. Requested by ${publicKeyToAddress(connection.remotePublicKey, this.#config)} `
+            );
         }
     }
 
@@ -49,10 +51,12 @@ class SubnetworkOperationHandler extends BaseOperationHandler {
         const normalizedPayload = normalizeTransactionOperation(payload, this.#config);
         const isValid = await this.#partialTransactionValidator.validate(normalizedPayload);
         if (!isValid) {
-            throw new Error("SubnetworkHandler: Transaction validation failed.");
+            throw new Error(`
+                SubnetworkHandler: Transaction validation failed. Requested by ${publicKeyToAddress(connection.remotePublicKey, this.#config)}`
+            );
         }
 
-        const completeTransactionOperation = await applyStateMessageFactory(this.#wallet,this.#config)
+        const completeTransactionOperation = await applyStateMessageFactory(this.#wallet, this.#config)
             .buildCompleteTransactionOperationMessage(
                 normalizedPayload.address,
                 normalizedPayload.txo.tx,
@@ -64,14 +68,19 @@ class SubnetworkOperationHandler extends BaseOperationHandler {
                 normalizedPayload.txo.bs,
                 normalizedPayload.txo.mbs
             )
-        this.#txPoolService.addTransaction(safeEncodeApplyOperation(completeTransactionOperation));
+        const encodedOperation = safeEncodeApplyOperation(completeTransactionOperation);
+        const txHash = b4a.toString(normalizedPayload.txo.tx, 'hex');
+        this.enqueueTransaction(txHash, encodedOperation);
+
     }
 
     async #partialBootstrapDeploymentSubHandler(payload, connection) {
         const normalizedPayload = normalizeBootstrapDeploymentOperation(payload, this.#config);
         const isValid = await this.#partialBootstrapDeploymentValidator.validate(normalizedPayload);
         if (!isValid) {
-            throw new Error("SubnetworkHandler: Bootstrap deployment validation failed.");
+            throw new Error(
+                `SubnetworkHandler: Bootstrap deployment validation failed. Requested by ${publicKeyToAddress(connection.remotePublicKey, this.#config)}`
+            );
         }
 
 
@@ -85,9 +94,11 @@ class SubnetworkOperationHandler extends BaseOperationHandler {
                 normalizedPayload.bdo.in,
                 normalizedPayload.bdo.is
             )
-        this.#txPoolService.addTransaction(safeEncodeApplyOperation(completeBootstrapDeploymentOperation));
+        const encodedOperation = safeEncodeApplyOperation(completeBootstrapDeploymentOperation);
+        const txHash = b4a.toString(normalizedPayload.bdo.tx, 'hex');
+        this.enqueueTransaction(txHash, encodedOperation);
 
     }
 }
 
-export default SubnetworkOperationHandler;
+export default LegacySubnetworkOperationHandler;

package/src/core/network/protocols/{shared/handlers/TransferOperationHandler.js → legacy/handlers/LegacyTransferOperationHandler.js}

@@ -1,33 +1,36 @@
-import BaseOperationHandler from './base/BaseOperationHandler.js';
+import BaseStateOperationHandler from './BaseStateOperationHandler.js';
 import {OperationType} from '../../../../../utils/constants.js';
-import PartialTransfer from "../validators/PartialTransfer.js";
+import PartialTransferValidator from "../../shared/validators/PartialTransferValidator.js";
 import {normalizeTransferOperation} from "../../../../../utils/normalizers.js"
 import {applyStateMessageFactory} from "../../../../../messages/state/applyStateMessageFactory.js";
 import {safeEncodeApplyOperation} from "../../../../../utils/protobuf/operationHelpers.js";
+import b4a from "b4a";
+import {publicKeyToAddress} from "../../../../../utils/helpers.js";
 
-class TransferOperationHandler extends BaseOperationHandler {
+class LegacyTransferOperationHandler extends BaseStateOperationHandler {
     #partialTransferValidator;
     #config;
     #wallet;
-    #txPoolService;
 
     /**
      * @param {State} state
-     * @param {PeerWallet} wallet
+     * @param {IWallet} wallet
      * @param {TransactionRateLimiterService} rateLimiter
+     * @param {TransactionPoolService} txPoolService
      * @param {Config} config
      **/
     constructor(state, wallet, rateLimiter, txPoolService, config) {
         super(state, wallet, rateLimiter, txPoolService, config);
         this.#config = config;
         this.#wallet = wallet;
-        this.#partialTransferValidator = new PartialTransfer(state, this.#wallet.address, this.#config);
-        this.#txPoolService = txPoolService;
+        this.#partialTransferValidator = new PartialTransferValidator(state, this.#wallet.address, this.#config);
     }
 
     async handleOperation(payload, connection) {
         if (payload.type !== OperationType.TRANSFER) {
-            throw new Error('Unsupported operation type for TransferOperationHandler');
+            throw new Error(
+                `Unsupported operation type for LegacyTransferOperationHandler. Requested by ${publicKeyToAddress(connection.remotePublicKey, this.#config)}`
+            );
         }
         await this.#handleTransfer(payload, connection);
     }
@@ -36,7 +39,9 @@ class TransferOperationHandler extends BaseOperationHandler {
         const normalizedPayload = normalizeTransferOperation(payload, this.#config);
         const isValid = await this.#partialTransferValidator.validate(normalizedPayload);
         if (!isValid) {
-            throw new Error("TransferHandler: Transfer validation failed.");
+            throw new Error(
+                `TransferHandler: Transfer validation failed. Requested by ${publicKeyToAddress(connection.remotePublicKey, this.#config)}`
+            );
         }
 
         const completeTransferOperation = await applyStateMessageFactory(this.#wallet, this.#config)
@@ -49,9 +54,10 @@ class TransferOperationHandler extends BaseOperationHandler {
                 normalizedPayload.tro.am,
                 normalizedPayload.tro.is
             )
-
-        this.#txPoolService.addTransaction(safeEncodeApplyOperation(completeTransferOperation));
+        const encodedOperation = safeEncodeApplyOperation(completeTransferOperation);
+        const txHash =  b4a.toString(normalizedPayload.tro.tx, 'hex');
+        this.enqueueTransaction(txHash, encodedOperation);
     }
 }
 
-export default TransferOperationHandler;
+export default LegacyTransferOperationHandler;

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/{PartialBootstrapDeployment.js → PartialBootstrapDeploymentValidator.js}

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

package/src/core/network/protocols/shared/validators/{base/PartialOperation.js → PartialOperationValidator.js}

@@ -1,18 +1,19 @@
 import b4a from 'b4a';
-import PeerWallet from 'trac-wallet';
-import Check from '../../../../../../utils/check.js';
-import {bufferToAddress} from "../../../../../state/utils/address.js";
-import {createMessage} from "../../../../../../utils/buffer.js";
-import {OperationType} 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 tracCryptoApi from 'trac-crypto-api';
+import Check from '../../../../../utils/check.js';
+import {bufferToAddress} from "../../../../state/utils/address.js";
+import {createMessage} from "../../../../../utils/buffer.js";
+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 {V1ProtocolError} from '../../v1/V1ProtocolError.js';
 
 const MAX_AMOUNT = BigInt('0xffffffffffffffffffffffffffffffff');
 const FEE_BIGINT = bufferToBigInt(FEE);
 const PUBLIC_KEY_LENGTH = 32;
 
-class PartialOperation {
+class PartialOperationValidator {
     #state;
     #check;
     #config
@@ -35,19 +36,19 @@ class PartialOperation {
         return this.#check;
     }
 
-    async validate(payload) {
-        throw new 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 Error('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 Error(`Payload is invalid.`);
+            throw new V1ProtocolError(ResultCode.SCHEMA_VALIDATION_FAILED, 'Payload is invalid.');
         }
     }
 
@@ -64,21 +65,24 @@ class PartialOperation {
             case OperationType.TRANSFER:
                 return this.check.validateTransferOperation.bind(this.check);
             default:
-                throw new Error(`Unknown operation type: ${type}`);
+                throw new V1ProtocolError(
+                    ResultCode.OPERATION_TYPE_UNKNOWN,
+                    `Unknown operation type: ${type}`
+                );
         }
     }
 
     validateRequesterAddress(payload) {
         const incomingAddress = bufferToAddress(payload.address, this.#config.addressPrefix);
         if (!incomingAddress) {
-            throw new Error('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 Error('Invalid requesting public key in payload.');
+            throw new V1ProtocolError(ResultCode.REQUESTER_PUBLIC_KEY_INVALID, 'Invalid requesting public key in payload.');
         }
     }
 
@@ -127,7 +131,10 @@ class PartialOperation {
                     OperationType.TRANSFER
                 ];
             default:
-                throw new Error(`Unknown operation type: ${payload.type}`);
+                throw new V1ProtocolError(
+                    ResultCode.OPERATION_TYPE_UNKNOWN,
+                    `Unknown operation type: ${payload.type}`
+                );
         }
     }
 
@@ -135,19 +142,22 @@ class PartialOperation {
         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 Error('Regenerated transaction does not match incoming transaction in payload.');
+            throw new V1ProtocolError(
+                ResultCode.TX_HASH_MISMATCH,
+                'Regenerated transaction does not match incoming transaction in payload.'
+            );
         }
 
-        if (!PeerWallet.verify(incomingSignature, messageHash, incomingPublicKey)) {
-            throw new Error('Invalid signature in payload.');
+        if (!tracCryptoApi.signature.verify(incomingSignature, messageHash, incomingPublicKey)) {
+            throw new V1ProtocolError(ResultCode.TX_SIGNATURE_INVALID, 'Invalid signature in payload.');
         }
     }
 
@@ -158,7 +168,7 @@ class PartialOperation {
         const incomingTxv = operation.txv
 
         if (!b4a.equals(currentTxv, incomingTxv)) {
-            throw new Error(`Transaction has expired.`);
+            throw new V1ProtocolError(ResultCode.TX_EXPIRED, 'Transaction has expired.');
         }
     }
 
@@ -169,7 +179,10 @@ class PartialOperation {
         const txHex = tx.toString('hex');
 
         if (await this.state.get(txHex) !== null) {
-            throw new Error(`Transaction with hash ${txHex} already exists in the state.`);
+            throw new V1ProtocolError(
+                ResultCode.TX_ALREADY_EXISTS,
+                `Transaction with hash ${txHex} already exists in the state.`
+            );
         }
     }
 
@@ -180,7 +193,10 @@ class PartialOperation {
 
         const condition = va === undefined && vn === undefined && vs === undefined
         if (!condition) {
-            throw new Error('Transfer operation must not be completed already (va, vn, vs must be undefined).');
+            throw new V1ProtocolError(
+                ResultCode.OPERATION_ALREADY_COMPLETED,
+                'Transfer operation must not be completed already (va, vn, vs must be undefined).'
+            );
         }
     }
 
@@ -194,12 +210,12 @@ class PartialOperation {
         }
 
         if (!requesterEntry) {
-            throw new Error('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 Error('Insufficient balance to cover transaction fee.');
+            throw new V1ProtocolError(ResultCode.INSUFFICIENT_FEE_BALANCE, 'Insufficient balance to cover transaction fee.');
         }
     }
 
@@ -209,7 +225,10 @@ class PartialOperation {
         const operation = payload[operationKey];
         const bs = operation.bs;
         if (b4a.equals(this.#config.bootstrap, bs)) {
-            throw new Error(`External bootstrap is the same as MSB bootstrap: ${bs.toString('hex')}`);
+            throw new V1ProtocolError(
+                ResultCode.EXTERNAL_BOOTSTRAP_EQUALS_MSB_BOOTSTRAP,
+                `External bootstrap is the same as MSB bootstrap: ${bs.toString('hex')}`
+            );
         }
     }
 
@@ -223,10 +242,13 @@ class PartialOperation {
 
         const requesterAddress = bufferToAddress(payload.address, this.#config.addressPrefix);
         if (this.#selfAddress === requesterAddress) {
-            throw new Error('Requester address cannot be the same as the validator wallet address.');
+            throw new V1ProtocolError(
+                ResultCode.SELF_VALIDATION_FORBIDDEN,
+                'Requester address cannot be the same as the validator wallet address.'
+            );
         }
     }
 
 }
 
-export default PartialOperation;
+export default PartialOperationValidator;