trac-msb 0.2.26 → 0.3.0-beta.1

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

@@ -1,4 +1,4 @@
-import { NETWORK_MESSAGE_TYPES } from '../../../../../utils/constants.js';
+import { NETWORK_MESSAGE_TYPES } from '../../../../../../utils/constants.js';
 import tracCryptoApi from 'trac-crypto-api';
 import b4a from 'b4a';
 
@@ -15,17 +15,17 @@ class LegacyGetRequestHandler {
         return this.#state;
     }
 
-    async handle(message, connection, channelString) {
+    async handle(message, connection, protocolSession, channelString) {
         switch (message) {
             case NETWORK_MESSAGE_TYPES.GET.VALIDATOR:
-                await this.handleGetValidatorResponse(connection, channelString);
+                await this.handleGetValidatorResponse(connection, protocolSession, channelString);
                 break;
             default:
                 throw new Error(`Unhandled GET type: ${message}`);
         }
     }
 
-    async handleGetValidatorResponse(connection, channelString) {
+    async handleGetValidatorResponse(connection, protocolSession, channelString) {
         const nonce = b4a.toString(tracCryptoApi.nonce.generate(), 'hex');
         const payload = {
             op: 'validatorResponse',
@@ -46,7 +46,7 @@ class LegacyGetRequestHandler {
             ...payload,
             sig: sig.toString('hex'),
         };
-        connection.protocolSession.sendAndForget(responseMessage)
+        protocolSession.sendAndForget(responseMessage)
     }
 }
 

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

@@ -1,10 +1,10 @@
-import {OperationType} from '../../../../../utils/constants.js';
+import {OperationType} from '../../../../../../utils/constants.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 {applyStateMessageFactory} from "../../../../../../messages/state/applyStateMessageFactory.js";
+import {safeEncodeApplyOperation} from "../../../../../../codecs/apply/applyOperationCodec.js";
+import {normalizeRoleAccessOperation} from "../../../../../../utils/normalizers.js";
+import { publicKeyToAddress } from "../../../../../../utils/helpers.js"
 import b4a from "b4a";
 
 class LegacyRoleOperationHandler extends BaseStateOperationHandler {

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

@@ -1,17 +1,17 @@
 import BaseStateOperationHandler from './BaseStateOperationHandler.js';
 import {
     OperationType
-} from '../../../../../utils/constants.js';
+} from '../../../../../../utils/constants.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 {applyStateMessageFactory} from "../../../../../../messages/state/applyStateMessageFactory.js";
+import {safeEncodeApplyOperation} from "../../../../../../codecs/apply/applyOperationCodec.js";
 import {
     normalizeBootstrapDeploymentOperation,
     normalizeTransactionOperation
-} from "../../../../../utils/normalizers.js";
+} from "../../../../../../utils/normalizers.js";
 import b4a from "b4a";
-import {publicKeyToAddress} from "../../../../../utils/helpers.js";
+import {publicKeyToAddress} from "../../../../../../utils/helpers.js";
 
 
 class LegacySubnetworkOperationHandler extends BaseStateOperationHandler {

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

@@ -1,11 +1,11 @@
 import BaseStateOperationHandler from './BaseStateOperationHandler.js';
-import {OperationType} from '../../../../../utils/constants.js';
+import {OperationType} from '../../../../../../utils/constants.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 {normalizeTransferOperation} from "../../../../../../utils/normalizers.js"
+import {applyStateMessageFactory} from "../../../../../../messages/state/applyStateMessageFactory.js";
+import {safeEncodeApplyOperation} from "../../../../../../codecs/apply/applyOperationCodec.js";
 import b4a from "b4a";
-import {publicKeyToAddress} from "../../../../../utils/helpers.js";
+import {publicKeyToAddress} from "../../../../../../utils/helpers.js";
 
 class LegacyTransferOperationHandler extends BaseStateOperationHandler {
     #partialTransferValidator;

package/src/core/network/protocols/{ProtocolInterface.js → validators/shared/ValidatorProtocolInterface.js}

@@ -1,14 +1,14 @@
 /**
- * ProtocolInterface serves as a base class for all network protocol implementations.
+ * ValidatorProtocolInterface serves as a base class for validator protocol implementations.
  * @interface
  */
 
-class ProtocolInterface {
+class ValidatorProtocolInterface {
     
     // TODO: Refactor this so we don't need to pass a reference for the whole network instance
     constructor(_router, _connection, _pendingRequestService, _config) {
-        if (new.target === ProtocolInterface) {
-            throw new Error('ProtocolInterface cannot be instantiated directly');
+        if (new.target === ValidatorProtocolInterface) {
+            throw new Error('ValidatorProtocolInterface cannot be instantiated directly');
         }
     }
 
@@ -40,4 +40,4 @@ class ProtocolInterface {
     }
 }
 
-export default ProtocolInterface;
+export default ValidatorProtocolInterface;

package/src/core/network/protocols/{shared → validators/shared}/validators/PartialBootstrapDeploymentValidator.js

@@ -1,5 +1,5 @@
 import PartialOperationValidator from './PartialOperationValidator.js';
-import {ResultCode} from "../../../../../utils/constants.js";
+import {ResultCode} from "../../../../../../utils/constants.js";
 import {V1ProtocolError} from '../../v1/V1ProtocolError.js';
 
 class PartialBootstrapDeploymentValidator extends PartialOperationValidator {

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

@@ -0,0 +1,325 @@
+import b4a from 'b4a';
+import tracCryptoApi from 'trac-crypto-api';
+
+import PartialOperationValidator from './PartialOperationValidator.js';
+import {bufferToAddress} from '../../../../../state/utils/address.js';
+import {BALANCE_FEE, PERCENT_75, toBalance} from '../../../../../state/utils/balance.js';
+import * as escrowEntryUtils from '../../../../../state/utils/escrowEntry.js';
+import nodeEntryUtils from '../../../../../state/utils/nodeEntry.js';
+import {bufferToBigInt} from '../../../../../../utils/amountSerialization.js';
+import {isZeroBuffer, uint64ToBuffer} from '../../../../../../utils/buffer.js';
+import {
+    HTLC_MIN_LOCK_DURATION_EPOCHS,
+    EntryType,
+    OperationType,
+    PUBLIC_KEY_LENGTH,
+    ResultCode
+} from '../../../../../../utils/constants.js';
+import {verifyOrderedHtlcCosignerSignatures} from '../../../../../../utils/htlcLock.js';
+import {V1ProtocolError} from '../../v1/V1ProtocolError.js';
+
+class PartialHtlcValidator extends PartialOperationValidator {
+    #config;
+    #selfAddress;
+
+    constructor(state, selfAddress, config) {
+        super(state, selfAddress, config);
+        this.#config = config;
+        this.#selfAddress = selfAddress;
+    }
+
+    async validate(payload) {
+        if (payload?.type === OperationType.HTLC_CLAIM) {
+            return this.#validateClaim(payload);
+        }
+        if (payload?.type === OperationType.HTLC_REFUND) return this.#validateRefund(payload);
+        if (payload?.type !== OperationType.HTLC_LOCK) {
+            throw new V1ProtocolError(ResultCode.OPERATION_TYPE_UNKNOWN, 'Unsupported HTLC operation type.');
+        }
+        this.isPayloadSchemaValid(payload);
+        this.validateNoSelfValidation(payload);
+        this.validateRequesterAddress(payload);
+        await this.#validateLockUniqueness(payload.hlo.tx);
+        await this.validateSignature(payload);
+        await this.validateTransactionValidity(payload);
+        this.isOperationNotCompleted(payload);
+
+        this.#validateSettlementAddresses(payload.hlo);
+        this.#validateLockAuthorizations(payload);
+        await this.#validateRefundEpoch(payload.hlo);
+        await this.#validateLockerBalance(payload);
+        await this.#validateValidatorRewardBalance();
+
+        return true;
+    }
+
+    async #validateClaim(payload) {
+        this.isPayloadSchemaValid(payload);
+        this.validateNoSelfValidation(payload);
+        this.validateRequesterAddress(payload);
+        await this.validateTransactionUniqueness(payload);
+        await this.validateSignature(payload);
+        await this.validateTransactionValidity(payload);
+        this.isOperationNotCompleted(payload);
+
+        const escrowKey = EntryType.HTLC_ESCROW + b4a.toString(payload.hco.li, 'hex');
+        const signedEscrowBuffer = await this.state.getSigned(escrowKey);
+        const signedEscrow = escrowEntryUtils.decode(signedEscrowBuffer, this.#config.addressPrefix);
+        if (!signedEscrow || !b4a.equals(signedEscrow.lockId, payload.hco.li)) {
+            throw new V1ProtocolError(ResultCode.TX_INVALID_PAYLOAD, 'HTLC lock is not confirmed in signed state.');
+        }
+        if (signedEscrow.status !== escrowEntryUtils.Status.PENDING) {
+            throw new V1ProtocolError(ResultCode.TX_ALREADY_EXISTS, 'HTLC escrow is already settled.');
+        }
+
+        const escrowBuffer = await this.state.get(escrowKey);
+        const escrow = escrowEntryUtils.decode(escrowBuffer, this.#config.addressPrefix);
+        if (!escrow || !b4a.equals(escrow.lockId, payload.hco.li)) {
+            throw new V1ProtocolError(ResultCode.TX_INVALID_PAYLOAD, 'HTLC escrow does not exist or is invalid.');
+        }
+        if (escrow.status !== escrowEntryUtils.Status.PENDING) {
+            throw new V1ProtocolError(ResultCode.TX_ALREADY_EXISTS, 'HTLC escrow is already settled.');
+        }
+
+        const [signedEpoch, unsignedEpoch] = await Promise.all([
+            this.state.getCurrentEpoch(),
+            this.state.getCurrentEpochUnsigned()
+        ]);
+        if (typeof signedEpoch !== 'bigint' || typeof unsignedEpoch !== 'bigint') {
+            throw new V1ProtocolError(ResultCode.TX_INVALID_PAYLOAD, 'HTLC claim requires an initialized network epoch.');
+        }
+        const currentEpoch = signedEpoch > unsignedEpoch ? signedEpoch : unsignedEpoch;
+        if (currentEpoch >= escrow.refundEpoch.readBigUInt64BE(0)) {
+            throw new V1ProtocolError(ResultCode.TX_EXPIRED, 'HTLC claim window has expired.');
+        }
+
+        const settlement = escrowEntryUtils.makeClaim(
+            escrowBuffer,
+            payload.hco.pi,
+            uint64ToBuffer(currentEpoch),
+            this.#config.addressPrefix
+        );
+        if (!settlement) {
+            throw new V1ProtocolError(ResultCode.TX_INVALID_PAYLOAD, 'HTLC claim preimage is invalid.');
+        }
+        await this.#validateClaimRecipientBalances(settlement);
+        return true;
+    }
+
+    async #validateClaimRecipientBalances(settlement) {
+        const credits = new Map();
+        for (const [addressBytes, amount] of [
+            [settlement.address, settlement.amount],
+            [settlement.additionalFeeRecipientAddress, settlement.additionalFeeAmount]
+        ]) {
+            if (addressBytes === null) continue;
+            const address = bufferToAddress(addressBytes, this.#config.addressPrefix);
+            const credit = amount?.asBigInt();
+            if (address === null || typeof credit !== 'bigint') {
+                throw new V1ProtocolError(ResultCode.TX_INVALID_PAYLOAD, 'HTLC settlement recipient or amount is invalid.');
+            }
+            credits.set(address, (credits.get(address) ?? 0n) + credit);
+        }
+
+        for (const [address, credit] of credits) {
+            const recipient = await this.state.getNodeEntryUnsigned(address);
+            if (!recipient) continue;
+            const balance = toBalance(recipient.balance);
+            if (!balance || balance.asBigInt() + credit > this.max_amount) {
+                throw new V1ProtocolError(
+                    ResultCode.TRANSFER_RECIPIENT_BALANCE_OVERFLOW,
+                    'HTLC claim would overflow a settlement recipient balance.'
+                );
+            }
+        }
+    }
+
+    async #validateRefund(payload) {
+        this.isPayloadSchemaValid(payload);
+        this.validateNoSelfValidation(payload);
+        this.validateRequesterAddress(payload);
+        await this.validateTransactionUniqueness(payload);
+        await this.validateSignature(payload);
+        await this.validateTransactionValidity(payload);
+        this.isOperationNotCompleted(payload);
+
+        const escrowKey = EntryType.HTLC_ESCROW + b4a.toString(payload.hro.li, 'hex');
+        const signedEscrow = escrowEntryUtils.decode(
+            await this.state.getSigned(escrowKey), this.#config.addressPrefix
+        );
+        if (!signedEscrow || !b4a.equals(signedEscrow.lockId, payload.hro.li)) {
+            throw new V1ProtocolError(ResultCode.TX_INVALID_PAYLOAD, 'HTLC lock is not confirmed in signed state.');
+        }
+        if (signedEscrow.status !== escrowEntryUtils.Status.PENDING) {
+            throw new V1ProtocolError(ResultCode.TX_ALREADY_EXISTS, 'HTLC escrow is already settled.');
+        }
+
+        const escrowBuffer = await this.state.get(escrowKey);
+        const escrow = escrowEntryUtils.decode(escrowBuffer, this.#config.addressPrefix);
+        if (!escrow || !b4a.equals(escrow.lockId, payload.hro.li)) {
+            throw new V1ProtocolError(ResultCode.TX_INVALID_PAYLOAD, 'HTLC escrow is missing from current state.');
+        }
+        if (escrow.status !== escrowEntryUtils.Status.PENDING) {
+            throw new V1ProtocolError(ResultCode.TX_ALREADY_EXISTS, 'HTLC escrow is already settled.');
+        }
+
+        const [signedEpoch, unsignedEpoch] = await Promise.all([
+            this.state.getCurrentEpoch(),
+            this.state.getCurrentEpochUnsigned()
+        ]);
+        if (typeof signedEpoch !== 'bigint' || typeof unsignedEpoch !== 'bigint') {
+            throw new V1ProtocolError(ResultCode.TX_INVALID_PAYLOAD, 'HTLC refunds require an initialized network epoch.');
+        }
+        const refundEpoch = b4a.from(escrow.refundEpoch).readBigUInt64BE(0);
+        if (signedEpoch < refundEpoch || unsignedEpoch < refundEpoch) {
+            throw new V1ProtocolError(ResultCode.TX_INVALID_PAYLOAD, 'HTLC refund epoch has not been reached.');
+        }
+
+        const settlement = escrowEntryUtils.makeRefund(
+            escrowBuffer, uint64ToBuffer(unsignedEpoch), this.#config.addressPrefix
+        );
+        if (!settlement) {
+            throw new V1ProtocolError(ResultCode.TX_INVALID_PAYLOAD, 'HTLC refund transition is invalid.');
+        }
+        const recipientAddress = bufferToAddress(settlement.address, this.#config.addressPrefix);
+        if (recipientAddress === null) {
+            throw new V1ProtocolError(ResultCode.TX_INVALID_PAYLOAD, 'HTLC refund recipient is invalid.');
+        }
+        const recipientBuffer = await this.state.get(recipientAddress);
+        if (recipientBuffer !== null) {
+            const recipient = nodeEntryUtils.decode(recipientBuffer);
+            if (!recipient) {
+                throw new V1ProtocolError(ResultCode.TX_INVALID_PAYLOAD, 'HTLC refund recipient account is invalid.');
+            }
+            const balance = toBalance(recipient.balance);
+            if (!balance || balance.asBigInt() + settlement.amount.asBigInt() > this.max_amount) {
+                throw new V1ProtocolError(
+                    ResultCode.TRANSFER_RECIPIENT_BALANCE_OVERFLOW,
+                    'HTLC refund would overflow the refund recipient balance.'
+                );
+            }
+        }
+
+        return true;
+    }
+
+    async #validateLockUniqueness(lockId) {
+        const txHex = b4a.toString(lockId, 'hex');
+        const escrowKey = EntryType.HTLC_ESCROW + txHex;
+        const [transaction, signedTransaction, escrow, signedEscrow] = await Promise.all([
+            this.state.get(txHex),
+            this.state.getSigned(txHex),
+            this.state.get(escrowKey),
+            this.state.getSigned(escrowKey)
+        ]);
+        if (transaction !== null || signedTransaction !== null) {
+            throw new V1ProtocolError(ResultCode.TX_ALREADY_EXISTS, 'HTLC lock transaction already exists.');
+        }
+        if (escrow !== null || signedEscrow !== null) {
+            throw new V1ProtocolError(ResultCode.TX_ALREADY_EXISTS, 'HTLC escrow already exists.');
+        }
+    }
+
+    #validateSettlementAddresses(operation) {
+        for (const [field, label] of [
+            [operation.ca, 'claim'],
+            [operation.ra, 'refund'],
+            ...(operation.fr ? [[operation.fr, 'fee recipient']] : [])
+        ]) {
+            const address = bufferToAddress(field, this.#config.addressPrefix);
+            const publicKey = address && tracCryptoApi.address.decodeSafe(address);
+            if (
+                !b4a.isBuffer(publicKey) ||
+                publicKey.length !== PUBLIC_KEY_LENGTH ||
+                isZeroBuffer(publicKey)
+            ) {
+                throw new V1ProtocolError(
+                    ResultCode.TX_INVALID_PAYLOAD,
+                    `Invalid HTLC ${label} address.`
+                );
+            }
+        }
+    }
+
+    #validateLockAuthorizations(payload) {
+        const operation = payload.hlo;
+        const lockerAddress = bufferToAddress(payload.address, this.#config.addressPrefix);
+        const lockerPublicKey = tracCryptoApi.address.decodeSafe(lockerAddress);
+        if (!b4a.equals(lockerPublicKey, operation.ss[0])) {
+            throw new V1ProtocolError(
+                ResultCode.TX_SIGNATURE_INVALID,
+                'HTLC signer zero must be the locker identified by the operation address.'
+            );
+        }
+
+        if (!verifyOrderedHtlcCosignerSignatures(operation.cs, operation.tx, operation.ss)) {
+            throw new V1ProtocolError(
+                ResultCode.TX_SIGNATURE_INVALID,
+                'HTLC cosigner signatures are invalid or not in signer-set order.'
+            );
+        }
+    }
+
+    async #validateRefundEpoch(operation) {
+        const [signedEpoch, unsignedEpoch] = await Promise.all([
+            this.state.getCurrentEpoch(),
+            this.state.getCurrentEpochUnsigned()
+        ]);
+        if (typeof signedEpoch !== 'bigint' || typeof unsignedEpoch !== 'bigint') {
+            throw new V1ProtocolError(
+                ResultCode.TX_INVALID_PAYLOAD,
+                'HTLC locks require an initialized network epoch.'
+            );
+        }
+
+        const currentEpoch = signedEpoch > unsignedEpoch ? signedEpoch : unsignedEpoch;
+        const refundEpoch = b4a.from(operation.re).readBigUInt64BE(0);
+        if (refundEpoch < currentEpoch + HTLC_MIN_LOCK_DURATION_EPOCHS) {
+            throw new V1ProtocolError(
+                ResultCode.TX_INVALID_PAYLOAD,
+                `HTLC refund epoch must be at least ${HTLC_MIN_LOCK_DURATION_EPOCHS} epoch(s) after the current epoch.`
+            );
+        }
+    }
+
+    async #validateLockerBalance(payload) {
+        const lockerAddress = bufferToAddress(payload.address, this.#config.addressPrefix);
+        const lockerEntry = await this.state.getNodeEntryUnsigned(lockerAddress);
+        if (!lockerEntry) {
+            throw new V1ProtocolError(ResultCode.TRANSFER_SENDER_NOT_FOUND, 'HTLC locker account not found.');
+        }
+
+        const principal = bufferToBigInt(payload.hlo.am);
+        const surchargeFee = bufferToBigInt(payload.hlo.fa);
+        const escrowAmount = principal + surchargeFee;
+        if (escrowAmount > this.max_amount || escrowAmount + this.fee > this.max_amount) {
+            throw new V1ProtocolError(
+                ResultCode.TRANSFER_AMOUNT_TOO_LARGE,
+                'HTLC escrow amount exceeds the maximum allowed value.'
+            );
+        }
+
+        if (bufferToBigInt(lockerEntry.balance) < escrowAmount + this.fee) {
+            throw new V1ProtocolError(
+                ResultCode.TRANSFER_INSUFFICIENT_BALANCE,
+                'Insufficient balance for HTLC principal, surcharge fee, and network fee.'
+            );
+        }
+    }
+
+    async #validateValidatorRewardBalance() {
+        if (!this.#selfAddress) return;
+        const validatorEntry = await this.state.getNodeEntryUnsigned(this.#selfAddress);
+        if (!validatorEntry) return;
+
+        const reward = BALANCE_FEE.percentage(PERCENT_75);
+        if (bufferToBigInt(validatorEntry.balance) + bufferToBigInt(reward.value) > this.max_amount) {
+            throw new V1ProtocolError(
+                ResultCode.TRANSFER_RECIPIENT_BALANCE_OVERFLOW,
+                'HTLC validator reward would overflow the validator balance.'
+            );
+        }
+    }
+}
+
+export default PartialHtlcValidator;

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

@@ -1,28 +1,28 @@
 import b4a from 'b4a';
 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 StateValidationSchema from '../../../../../state/validators/StateValidationSchema.js';
+import {bufferToAddress} from "../../../../../state/utils/address.js";
+import {createMessage} from "../../../../../../utils/buffer.js";
+import {OperationType, ResultCode, PUBLIC_KEY_LENGTH} 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';
+import {createHtlcLockSigningMessage} from '../../../../../../utils/htlcLock.js';
 
 const MAX_AMOUNT = BigInt('0xffffffffffffffffffffffffffffffff');
 const FEE_BIGINT = bufferToBigInt(FEE);
-const PUBLIC_KEY_LENGTH = 32;
 
 class PartialOperationValidator {
     #state;
-    #check;
+    #stateValidationSchema;
     #config
     #selfAddress
 
     constructor(state, selfAddress, config) {
         this.#state = state;
         this.#config = config;
-        this.#check = new Check(this.#config);
+        this.#stateValidationSchema = new StateValidationSchema(this.#config);
         this.max_amount = MAX_AMOUNT;
         this.fee = FEE_BIGINT;
         this.#selfAddress = selfAddress;
@@ -32,8 +32,8 @@ class PartialOperationValidator {
         return this.#state;
     }
 
-    get check() {
-        return this.#check;
+    get stateValidationSchema() {
+        return this.#stateValidationSchema;
     }
 
     async validate() {
@@ -45,25 +45,31 @@ class PartialOperationValidator {
             throw new V1ProtocolError(ResultCode.TX_INVALID_PAYLOAD, 'Payload or payload type is missing.');
         }
 
-        const selectedValidator = this.#selectCheckSchemaValidator(payload.type);
+        const selectedValidator = this.#selectStateSchemaValidator(payload.type);
         const isPayloadValid = selectedValidator(payload);
         if (!isPayloadValid) {
             throw new V1ProtocolError(ResultCode.SCHEMA_VALIDATION_FAILED, 'Payload is invalid.');
         }
     }
 
-    #selectCheckSchemaValidator(type) {
+    #selectStateSchemaValidator(type) {
         switch (type) {
             case OperationType.ADD_WRITER:
             case OperationType.REMOVE_WRITER:
             case OperationType.ADMIN_RECOVERY:
-                return this.check.validateRoleAccessOperation.bind(this.check);
+                return this.stateValidationSchema.validateRoleAccessOperation.bind(this.stateValidationSchema);
             case OperationType.BOOTSTRAP_DEPLOYMENT:
-                return this.check.validateBootstrapDeploymentOperation.bind(this.check);
+                return this.stateValidationSchema.validateBootstrapDeploymentOperation.bind(this.stateValidationSchema);
             case OperationType.TX:
-                return this.check.validateTransactionOperation.bind(this.check);
+                return this.stateValidationSchema.validateTransactionOperation.bind(this.stateValidationSchema);
             case OperationType.TRANSFER:
-                return this.check.validateTransferOperation.bind(this.check);
+                return this.stateValidationSchema.validateTransferOperation.bind(this.stateValidationSchema);
+            case OperationType.HTLC_LOCK:
+                return this.stateValidationSchema.validateHtlcLockOperation.bind(this.stateValidationSchema);
+            case OperationType.HTLC_CLAIM:
+                return this.stateValidationSchema.validateHtlcClaimOperation.bind(this.stateValidationSchema);
+            case OperationType.HTLC_REFUND:
+                return this.stateValidationSchema.validateHtlcRefundOperation.bind(this.stateValidationSchema);
             default:
                 throw new V1ProtocolError(
                     ResultCode.OPERATION_TYPE_UNKNOWN,
@@ -130,6 +136,23 @@ class PartialOperationValidator {
                     operation.in,
                     OperationType.TRANSFER
                 ];
+            case OperationType.HTLC_CLAIM:
+                return [
+                    this.#config.networkId,
+                    operation.txv,
+                    operation.li,
+                    operation.pi,
+                    operation.in,
+                    OperationType.HTLC_CLAIM
+                ];
+            case OperationType.HTLC_REFUND:
+                return [
+                    this.#config.networkId,
+                    operation.txv,
+                    operation.li,
+                    operation.in,
+                    OperationType.HTLC_REFUND
+                ];
             default:
                 throw new V1ProtocolError(
                     ResultCode.OPERATION_TYPE_UNKNOWN,
@@ -144,9 +167,9 @@ class PartialOperationValidator {
 
         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 message = payload.type === OperationType.HTLC_LOCK
+            ? createHtlcLockSigningMessage(this.#config.networkId, payload.address, operation)
+            : createMessage(...this.#getMessageComponents(payload));
         const messageHash = await tracCryptoApi.hash.blake3(message);
         const payloadHash = operation.tx;
         if (!b4a.equals(payloadHash, messageHash)) {

package/src/core/network/protocols/{shared → validators/shared}/validators/PartialRoleAccessValidator.js

@@ -1,8 +1,8 @@
 import b4a from 'b4a';
-import {OperationType, ResultCode} from "../../../../../utils/constants.js";
-import {bufferToAddress} from "../../../../state/utils/address.js";
+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 {bufferToBigInt} from "../../../../../../utils/amountSerialization.js";
 import {V1ProtocolError} from '../../v1/V1ProtocolError.js';
 
 class PartialRoleAccessValidator extends PartialOperationValidator {

package/src/core/network/protocols/{shared → validators/shared}/validators/PartialTransactionValidator.js

@@ -1,8 +1,8 @@
 import b4a from 'b4a';
-import {safeDecodeApplyOperation} from "../../../../../utils/protobuf/operationHelpers.js";
-import deploymentEntryUtils from "../../../../state/utils/deploymentEntry.js";
+import {safeDecodeApplyOperation} from "../../../../../../codecs/apply/applyOperationCodec.js";
+import deploymentEntryUtils from "../../../../../state/utils/deploymentEntry.js";
 import PartialOperationValidator from './PartialOperationValidator.js';
-import {ResultCode} from "../../../../../utils/constants.js";
+import {ResultCode} from "../../../../../../utils/constants.js";
 import {V1ProtocolError} from '../../v1/V1ProtocolError.js';
 
 class PartialTransactionValidator extends PartialOperationValidator {

package/src/core/network/protocols/{shared → validators/shared}/validators/PartialTransferValidator.js

@@ -1,7 +1,7 @@
-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 {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 {V1ProtocolError} from '../../v1/V1ProtocolError.js';
 import tracCryptoApi from "trac-crypto-api";

package/src/core/network/protocols/{v1 → validators/v1}/V1ProtocolError.js

@@ -1,4 +1,4 @@
-import {ResultCode} from '../../../../utils/constants.js';
+import {ResultCode} from '../../../../../utils/constants.js';
 
 /** 
  * V1 protocol error type.