trac-msb 0.2.24 → 0.3.0-beta.1

package/src/core/network/{services/PendingRequestService.js → protocols/validators/v1/ValidatorPendingRequestService.js}

@@ -1,33 +1,27 @@
-import {NetworkOperationType, ResultCode} from '../../../utils/constants.js';
-import {isHexString, publicKeyToAddress} from '../../../utils/helpers.js';
-import {V1ProtocolError} from "../protocols/v1/V1ProtocolError.js";
+import {NetworkOperationType, PEER_PUBLIC_KEY_HEX_LENGTH, ResultCode} from '../../../../../utils/constants.js';
+import {isHexString, publicKeyToAddress} from '../../../../../utils/helpers.js';
+import {V1ProtocolError} from "./V1ProtocolError.js";
 import b4a from 'b4a';
+import BasePendingRequestService from '../../../shared/BasePendingRequestService.js';
 
-const PEER_PUBLIC_KEY_HEX_LENGTH = 64;
-
-export class PendingRequestServiceTimeoutError extends Error {
+export class ValidatorPendingRequestServiceTimeoutError extends Error {
     constructor(requestId, peerAddress, timeoutMs) {
         super(`Pending request ${requestId} to peer ${peerAddress} timed out after ${timeoutMs} ms.`);
         this.name = this.constructor.name;
     }
 }
 
-export default class PendingRequestService {
-    #pendingRequests;
+export default class ValidatorPendingRequestService extends BasePendingRequestService {
     #requestMessageTypes = [NetworkOperationType.LIVENESS_REQUEST, NetworkOperationType.BROADCAST_TRANSACTION_REQUEST];
     #config;
 
     constructor(config) {
-        this.#pendingRequests = new Map(); // Map<id, pendingRequestEntry>
+        super();
         this.#config = config;
     }
 
-    has(id) {
-        return this.#pendingRequests.has(id);
-    }
-
     isProbePending(peerPubKeyHex) {
-        for (const [, entry] of this.#pendingRequests) {
+        for (const [, entry] of this._pendingRequests) {
             if (entry.requestedTo === peerPubKeyHex && entry.requestType === NetworkOperationType.LIVENESS_REQUEST) {
                 return true;
             }
@@ -40,15 +34,11 @@ export default class PendingRequestService {
             throw new Error('Invalid peer public key. Expected 32-byte hex string.');
         }
 
-        if (!message || typeof message !== 'object') {
-            throw new Error('Pending request message must be an object.');
-        }
-
-        if (typeof message.id !== 'string' || message.id.length === 0) {
+        if (typeof message?.id !== 'string' || message?.id.length === 0) {
             throw new Error('Pending request ID must be a non-empty string.');
         }
 
-        if (!this.#requestMessageTypes.includes(message.type)) {
+        if (!this.#requestMessageTypes.includes(message?.type)) {
             throw new Error('Unsupported pending request type.');
         }
     }
@@ -60,11 +50,11 @@ export default class PendingRequestService {
         this.#validateRegisterInput(peerPubKeyHex, message);
         const id = message.id;
         const peerAddress = publicKeyToAddress(peerPubKeyHex, this.#config);
-        if (this.#pendingRequests.size >= this.#config.maxPendingRequestsInPendingRequestsService) {
+        if (this._pendingRequests.size >= this.#config.maxPendingRequestsInPendingRequestsService) {
             throw new Error('Maximum number of pending requests reached.');
         }
 
-        if (this.#pendingRequests.has(id)) {
+        if (this._pendingRequests.has(id)) {
             throw new Error(`Pending request with ID ${id} from peer ${peerPubKeyHex} already exists.`);
         }
 
@@ -86,7 +76,7 @@ export default class PendingRequestService {
         entry.timeoutId = setTimeout(() => {
             this.rejectPendingRequest(
                 id,
-                new PendingRequestServiceTimeoutError(
+                new ValidatorPendingRequestServiceTimeoutError(
                     id,
                     peerAddress,
                     this.#config.pendingRequestTimeout
@@ -95,7 +85,7 @@ export default class PendingRequestService {
 
         }, this.#config.pendingRequestTimeout);
 
-        this.#pendingRequests.set(id, entry);
+        this._pendingRequests.set(id, entry);
         return promise;
     }
 
@@ -105,21 +95,6 @@ export default class PendingRequestService {
         return b4a.isBuffer(txData) ? txData : null;
     }
 
-    getAndDeletePendingRequest(id) {
-        const entry = this.#pendingRequests.get(id);
-        if (!entry) return null;
-
-        clearTimeout(entry.timeoutId);
-        this.#pendingRequests.delete(id);
-        return entry;
-    }
-
-    getPendingRequest(id) {
-        const entry = this.#pendingRequests.get(id);
-        if (!entry) return null;
-        return entry;
-    }
-
     // for now, we are resolving only resultCode, but we can extend it in the future if needed...
     resolvePendingRequest(id, resultCode = ResultCode.OK) {
         const entry = this.getAndDeletePendingRequest(id);
@@ -128,48 +103,10 @@ export default class PendingRequestService {
         return true;
     }
 
-    rejectPendingRequest(id, error) {
-        const entry = this.getAndDeletePendingRequest(id);
-        if (!entry) return false;
-        entry.reject(error instanceof Error ? error : new Error(error?.message ?? 'Unexpected error'));
-        return true;
-    }
-
-    rejectPendingRequestsForPeer(peerPubKeyHex, error) {
-        const idsToReject = [];
-        for (const [id, entry] of this.#pendingRequests) {
-            if (entry.requestedTo === peerPubKeyHex) idsToReject.push(id);
-        }
-
-        for (const id of idsToReject) {
-            this.rejectPendingRequest(id, error);
-        }
-
-        return idsToReject.length;
-    }
-
-    stopPendingRequestTimeout(id) {
-        const entry = this.#pendingRequests.get(id);
-        if (!entry) return false;
-
-        clearTimeout(entry.timeoutId);
-        entry.timeoutId = null;
-        return true;
-    }
-
-    close() {
-        for (const [id, entry] of this.#pendingRequests) {
-            clearTimeout(entry.timeoutId);
-            try {
-                entry.reject(
-                    new V1ProtocolError(
-                        ResultCode.UNEXPECTED_ERROR,
-                        `Pending request ${id} cancelled (shutdown).`)
-                );
-            } catch (error) {
-                console.error(`PendingRequestService.close: failed to reject pending request ${id}:`, error);
-            }
-        }
-        this.#pendingRequests.clear();
+    _createShutdownError(id) {
+        return new V1ProtocolError(
+            ResultCode.UNEXPECTED_ERROR,
+            `Pending request ${id} cancelled (shutdown).`
+        );
     }
 }

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

@@ -1,11 +1,11 @@
-import { decodeV1networkOperation } from '../../../../utils/protobuf/operationHelpers.js'
+import { decodeV1networkOperation } from '../../../../../codecs/network/v1/networkV1OperationCodec.js'
 import b4a from 'b4a'
-import { NetworkOperationType, V1_PROTOCOL_PAYLOAD_MAX_SIZE } from '../../../../utils/constants.js'
-import { publicKeyToAddress } from '../../../../utils/helpers.js'
+import { NetworkOperationType, V1_PROTOCOL_PAYLOAD_MAX_SIZE } from '../../../../../utils/constants.js'
+import { publicKeyToAddress } from '../../../../../utils/helpers.js'
 import V1LivenessOperationHandler from './handlers/V1LivenessOperationHandler.js'
 import V1BroadcastTransactionOperationHandler from './handlers/V1BroadcastTransactionOperationHandler.js'
 
-class NetworkMessageRouterV1 {
+class ValidatorV1MessageRouter {
     #config
     #livenessRequestHandler
     #broadcastTransactionHandler
@@ -59,19 +59,19 @@ class NetworkMessageRouterV1 {
         }
 
         // We received a v1 message, so we set the connection protocol accordingly
-        connection.protocolSession.setV1AsPreferredProtocol()
+        connection.protocolSessions.validator.setV1AsPreferredProtocol()
 
         try {
             switch (decodedMessage.type) {
                 case NetworkOperationType.LIVENESS_REQUEST:
-                    await this.#livenessRequestHandler.handleRequest(decodedMessage, connection);
+                    await this.#livenessRequestHandler.handleRequest(decodedMessage, connection, connection.protocolSessions.validator);
                     break;
                 case NetworkOperationType.LIVENESS_RESPONSE:
                     await this.#livenessRequestHandler.handleResponse(decodedMessage, connection);
                     break;
 
                 case NetworkOperationType.BROADCAST_TRANSACTION_REQUEST:
-                    await this.#broadcastTransactionHandler.handleRequest(decodedMessage, connection);
+                    await this.#broadcastTransactionHandler.handleRequest(decodedMessage, connection, connection.protocolSessions.validator);
                     break;
 
                 case NetworkOperationType.BROADCAST_TRANSACTION_RESPONSE:
@@ -91,9 +91,9 @@ class NetworkMessageRouterV1 {
 
     #disconnect(connection, reason) {
         const sender = publicKeyToAddress(connection.remotePublicKey, this.#config)
-        console.error(`NetworkMessageRouterV1: ${reason}, sender: ${sender}`)
+        console.error(`ValidatorV1MessageRouter: ${reason}, sender: ${sender}`)
         connection.end();
     }
 }
 
-export default NetworkMessageRouterV1
+export default ValidatorV1MessageRouter

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

@@ -1,9 +1,9 @@
 import Protomux from 'protomux';
-import ProtocolInterface from './ProtocolInterface.js';
+import ValidatorProtocolInterface from '../shared/ValidatorProtocolInterface.js';
 import c from 'compact-encoding';
-import {encodeV1networkOperation, decodeV1networkOperation} from '../../../utils/protobuf/operationHelpers.js';
+import { encodeV1networkOperation, decodeV1networkOperation } from '../../../../../codecs/network/v1/networkV1OperationCodec.js';
 
-class V1Protocol extends ProtocolInterface {
+class ValidatorV1Protocol extends ValidatorProtocolInterface {
     #channel;
     #session;
     #router;
@@ -38,13 +38,15 @@ class V1Protocol extends ProtocolInterface {
             }
         });
 
+        if (!this.#channel) return; // connection already destroyed before protocol setup completed
+
         this.#channel.open();
 
         this.#session = this.#channel.addMessage({
             encoding: c.raw,
             onmessage: (incomingMessage) => {
                 this.#router.route(incomingMessage, connection).catch((err) => {
-                    console.error(`V1Protocol: unhandled router error: ${err.message}`);
+                    console.error(`ValidatorV1Protocol: unhandled router error: ${err.message}`);
                     try {
                         connection.end();
                     } catch {
@@ -55,7 +57,7 @@ class V1Protocol extends ProtocolInterface {
     }
 
     // TODO: Consider making this method private/internal-only, just like 'encode'
-    // NOTE: This method might be moved to v1/NetworkMessageRouter.js as it is only used there
+    // NOTE: This method might be moved to v1/ValidatorLegacyMessageRouter.js as it is only used there
     decode(message) {
         return decodeV1networkOperation(message);
     }
@@ -72,12 +74,12 @@ class V1Protocol extends ProtocolInterface {
     }
 
     sendAndForget(message) {
-        this.#session.send(encodeV1networkOperation(message));
+        this.#session?.send(encodeV1networkOperation(message));
     }
 
     close() {
-        this.#channel.close();
+        this.#channel?.close();
     }
 }
 
-export default V1Protocol;
+export default ValidatorV1Protocol;

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

@@ -1,4 +1,4 @@
-import { ResultCode } from '../../../utils/constants.js';
+import { ResultCode } from '../../../../../utils/constants.js';
 
 // TODO: Consider how to behave with ResultCode.UNSPECIFIED
 

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

@@ -1,30 +1,26 @@
-import {ResultCode} from "../../../../../utils/constants.js";
-import {publicKeyToAddress} from "../../../../../utils/helpers.js";
+import {ResultCode} from "../../../../../../utils/constants.js";
 import {V1ProtocolError} from "../V1ProtocolError.js";
+import ConnectionOperationHandler from "../../../shared/ConnectionOperationHandler.js";
 
-class V1BaseOperationHandler {
+class V1BaseOperationHandler extends ConnectionOperationHandler{
     #rateLimiterService;
     #pendingRequestService;
-    #config;
-
     constructor(rateLimiterService, pendingRequestService, config) {
+        super(config);
         this.#rateLimiterService = rateLimiterService;
         this.#pendingRequestService = pendingRequestService;
-        this.#config = config;
     }
 
-    get config() {
-        return this.#config;
-    }
 
     applyRateLimit(connection) {
-        if (!this.#config.disableRateLimit) {
+        if (!this.config.disableRateLimit) {
             this.#rateLimiterService.v1HandleRateLimit(connection);
         }
     }
 
     async resolvePendingResponse(message, connection, validator, extractResultCode) {
         const pendingRequestServiceEntry = this.#pendingRequestService.getPendingRequest(message.id);
+        //TODO: Investigate if this return false shouldn't be a throw.
         if (!pendingRequestServiceEntry) return false;
 
         this.#pendingRequestService.stopPendingRequestTimeout(message.id);
@@ -42,19 +38,6 @@ class V1BaseOperationHandler {
         this.displayError(step, connection.remotePublicKey, protocolError);
     }
 
-    async sendResponseAndMaybeClose(connection, response, endConnection) {
-        connection.protocolSession.sendAndForget(response);
-        if (!endConnection) return;
-
-        await connection.flush();
-        connection.end();
-    }
-
-    displayError(step = "undefined step", senderPublicKey, error) {
-        const errorMessage = error?.message ?? 'Unexpected error';
-        console.error(`${this.constructor.name}: ${step} ${publicKeyToAddress(senderPublicKey, this.#config)}: ${errorMessage}`);
-    }
-
     #toProtocolError(error) {
         if (error instanceof V1ProtocolError) {
             return error;

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

@@ -1,8 +1,8 @@
-import {networkMessageFactory} from "../../../../../messages/network/v1/networkMessageFactory.js";
+import {networkMessageFactory} from "../../../../../../messages/network/v1/networkMessageFactory.js";
 import {
     NETWORK_CAPABILITIES,
     ResultCode
-} from "../../../../../utils/constants.js";
+} from "../../../../../../utils/constants.js";
 import {
     getResultCode,
     V1ProtocolError
@@ -11,12 +11,13 @@ import V1BroadcastTransactionRequest from "../validators/V1BroadcastTransactionR
 import {
     unsafeDecodeApplyOperation,
     unsafeEncodeApplyOperation
-} from "../../../../../utils/protobuf/operationHelpers.js";
+} from "../../../../../../codecs/apply/applyOperationCodec.js";
 import PartialRoleAccessValidator from "../../shared/validators/PartialRoleAccessValidator.js";
 import PartialBootstrapDeploymentValidator from "../../shared/validators/PartialBootstrapDeploymentValidator.js";
 import PartialTransactionValidator from "../../shared/validators/PartialTransactionValidator.js";
 import PartialTransferValidator from "../../shared/validators/PartialTransferValidator.js";
-import {applyStateMessageFactory} from "../../../../../messages/state/applyStateMessageFactory.js";
+import PartialHtlcValidator from '../../shared/validators/PartialHtlcValidator.js';
+import {applyStateMessageFactory} from "../../../../../../messages/state/applyStateMessageFactory.js";
 import V1BroadcastTransactionResponse from "../validators/V1BroadcastTransactionResponse.js";
 import V1BaseOperationHandler from "./V1BaseOperationHandler.js";
 import {
@@ -33,7 +34,7 @@ import {
     mapTransactionEnqueueError,
     mapTxPoolAvailabilityError
 } from "./broadcastTransaction/BroadcastTransactionErrorMapper.js";
-import {shouldEndConnection} from "../../connectionPolicies.js";
+import {shouldEndConnection} from "../connectionPolicies.js";
 
 class V1BroadcastTransactionOperationHandler extends V1BaseOperationHandler {
     #state;
@@ -47,6 +48,7 @@ class V1BroadcastTransactionOperationHandler extends V1BaseOperationHandler {
     #partialTransferValidator;
     #transactionCommitService;
     #operationStrategies;
+    #partialHtlcValidator;
 
     constructor(state, wallet, rateLimiterService, txPoolService, pendingRequestService, transactionCommitService, config) {
         super(rateLimiterService, pendingRequestService, config);
@@ -58,6 +60,7 @@ class V1BroadcastTransactionOperationHandler extends V1BaseOperationHandler {
         this.#partialBootstrapDeploymentValidator = new PartialBootstrapDeploymentValidator(state, this.#wallet.address, config);
         this.#partialTransactionValidator = new PartialTransactionValidator(state, this.#wallet.address, config);
         this.#partialTransferValidator = new PartialTransferValidator(state, this.#wallet.address, config);
+        this.#partialHtlcValidator = new PartialHtlcValidator(state, this.#wallet.address, config);
         this.#broadcastTransactionResponseValidator = new V1BroadcastTransactionResponse(state, config);
         this.#transactionCommitService = transactionCommitService;
         this.#operationStrategies = createBroadcastTransactionOperationStrategies({
@@ -65,13 +68,14 @@ class V1BroadcastTransactionOperationHandler extends V1BaseOperationHandler {
             partialBootstrapDeploymentValidator: this.#partialBootstrapDeploymentValidator,
             partialTransactionValidator: this.#partialTransactionValidator,
             partialTransferValidator: this.#partialTransferValidator,
+            partialHtlcValidator: this.#partialHtlcValidator,
             createApplyStateMessageFactory: () => applyStateMessageFactory(this.#wallet, this.config)
         });
     }
 
-    async handleRequest(message, connection) {
+    async handleRequest(message, connection, protocolSession) {
         const outcome = await this.#processBroadcastTransactionRequest(message, connection);
-        await this.#sendBroadcastTransactionResponse(message.id, connection, outcome);
+        await this.#sendBroadcastTransactionResponse(message.id, connection, protocolSession, outcome);
     }
 
     async handleResponse(message, connection) {
@@ -111,7 +115,7 @@ class V1BroadcastTransactionOperationHandler extends V1BaseOperationHandler {
         try {
             return unsafeDecodeApplyOperation(message);
         } catch (error) {
-            throw new V1ProtocolError(ResultCode.UNEXPECTED_ERROR, `Failed to decode apply operation from message: ${error.message}`);
+            throw new V1ProtocolError(ResultCode.TX_INVALID_PAYLOAD, `Failed to decode apply operation from message: ${error.message}`);
         }
     }
 
@@ -170,7 +174,7 @@ class V1BroadcastTransactionOperationHandler extends V1BaseOperationHandler {
         };
     }
 
-    async #sendBroadcastTransactionResponse(messageId, connection, {proof, timestamp, resultCode, endConnection}) {
+    async #sendBroadcastTransactionResponse(messageId, connection, protocolSession, {proof, timestamp, resultCode, endConnection}) {
         try {
             const response = await this.#buildBroadcastTransactionResponse(
                 messageId,
@@ -181,6 +185,7 @@ class V1BroadcastTransactionOperationHandler extends V1BaseOperationHandler {
             );
 
             await this.sendResponseAndMaybeClose(
+                protocolSession,
                 connection,
                 response,
                 endConnection

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

@@ -1,10 +1,10 @@
-import {networkMessageFactory} from "../../../../../messages/network/v1/networkMessageFactory.js";
-import {NETWORK_CAPABILITIES, ResultCode} from "../../../../../utils/constants.js";
+import {networkMessageFactory} from "../../../../../../messages/network/v1/networkMessageFactory.js";
+import {NETWORK_CAPABILITIES, ResultCode} from "../../../../../../utils/constants.js";
 import V1LivenessRequest from "../validators/V1LivenessRequest.js";
 import {getResultCode, V1ProtocolError} from "../V1ProtocolError.js";
 import V1LivenessResponse from "../validators/V1LivenessResponse.js";
 import V1BaseOperationHandler from "./V1BaseOperationHandler.js";
-import {shouldEndConnection} from "../../connectionPolicies.js"
+import {shouldEndConnection} from "../connectionPolicies.js"
 
 class V1LivenessOperationHandler extends V1BaseOperationHandler {
     #wallet;
@@ -18,7 +18,7 @@ class V1LivenessOperationHandler extends V1BaseOperationHandler {
         this.#v1LivenessResponseValidator = new V1LivenessResponse(config);
     }
 
-    async handleRequest(message, connection) {
+    async handleRequest(message, connection, protocolSession) {
         let resultCode = ResultCode.OK;
         let endConnection = false;
         try {
@@ -36,6 +36,7 @@ class V1LivenessOperationHandler extends V1BaseOperationHandler {
         try {
             const response = await this.#buildLivenessResponsePayload(message.id, NETWORK_CAPABILITIES, resultCode);
             await this.sendResponseAndMaybeClose(
+                protocolSession,
                 connection,
                 response,
                 endConnection

package/src/core/network/protocols/{v1 → validators/v1}/handlers/broadcastTransaction/BroadcastTransactionErrorMapper.js

@@ -1,4 +1,4 @@
-import {ResultCode} from "../../../../../../utils/constants.js";
+import {ResultCode} from "../../../../../../../utils/constants.js";
 import {V1ProtocolError} from "../../V1ProtocolError.js";
 import {
     TransactionPoolAlreadyQueuedError,
@@ -6,13 +6,13 @@ import {
     TransactionPoolInvalidIncomingDataError,
     TransactionPoolMissingCommitReceiptError,
     TransactionPoolProofUnavailableError
-} from "../../../../services/TransactionPoolService.js";
+} from "../../../../../services/TransactionPoolService.js";
 import {
     PendingCommitAlreadyExistsError,
     PendingCommitBufferFullError,
     PendingCommitInvalidTxHashError,
     PendingCommitTimeoutError
-} from "../../../../services/TransactionCommitService.js";
+} from "../../../../../services/TransactionCommitService.js";
 
 export function mapTxPoolAvailabilityError(error) {
     if (error instanceof TransactionPoolFullError) {

package/src/core/network/protocols/{v1 → validators/v1}/handlers/broadcastTransaction/BroadcastTransactionOperationStrategies.js

@@ -1,4 +1,4 @@
-import {OperationType, ResultCode} from "../../../../../../utils/constants.js";
+import {OperationType, ResultCode} from "../../../../../../../utils/constants.js";
 import {V1ProtocolError} from "../../V1ProtocolError.js";
 
 function createOperationStrategy(payloadKey, validator, buildCompleteOperation) {
@@ -16,6 +16,7 @@ export function createBroadcastTransactionOperationStrategies({
     partialBootstrapDeploymentValidator,
     partialTransactionValidator,
     partialTransferValidator,
+    partialHtlcValidator,
     createApplyStateMessageFactory
 }) {
     return new Map([
@@ -113,6 +114,48 @@ export function createBroadcastTransactionOperationStrategies({
                     decodedTransaction.tro.is
                 )
             )
+        ],
+        [
+            OperationType.HTLC_LOCK,
+            createOperationStrategy(
+                'hlo',
+                partialHtlcValidator,
+                decodedOperation => createApplyStateMessageFactory().buildCompleteHtlcLockOperationMessage(
+                    decodedOperation.address,
+                    decodedOperation.hlo
+                )
+            )
+        ],
+        [
+            OperationType.HTLC_CLAIM,
+            createOperationStrategy(
+                'hco',
+                partialHtlcValidator,
+                decodedOperation => createApplyStateMessageFactory().buildCompleteHtlcClaimOperationMessage(
+                    decodedOperation.address,
+                    decodedOperation.hco.tx,
+                    decodedOperation.hco.txv,
+                    decodedOperation.hco.li,
+                    decodedOperation.hco.pi,
+                    decodedOperation.hco.in,
+                    decodedOperation.hco.is
+                )
+            )
+        ],
+        [
+            OperationType.HTLC_REFUND,
+            createOperationStrategy(
+                'hro',
+                partialHtlcValidator,
+                decodedOperation => createApplyStateMessageFactory().buildCompleteHtlcRefundOperationMessage(
+                    decodedOperation.address,
+                    decodedOperation.hro.tx,
+                    decodedOperation.hro.txv,
+                    decodedOperation.hro.li,
+                    decodedOperation.hro.in,
+                    decodedOperation.hro.is
+                )
+            )
         ]
     ]);
 }

package/src/core/network/protocols/{v1 → validators/v1}/handlers/broadcastTransaction/BroadcastTransactionPayloadUtils.js

@@ -1,6 +1,6 @@
 import b4a from "b4a";
 
-import { operationToPayload } from "../../../../../../utils/applyOperations.js";
+import { operationToPayload } from "../../../../../../../utils/applyOperations.js";
 
 const COMPLETION_FIELDS = ['va', 'vn', 'vs'];
 

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

@@ -1,14 +1,14 @@
 import V1ValidationSchema from "./V1ValidationSchema.js";
-import {NetworkOperationType, ResultCode} from "../../../../../utils/constants.js";
+import {NetworkOperationType, ResultCode} from "../../../../../../utils/constants.js";
 import tracCryptoApi from "trac-crypto-api";
 import b4a from "b4a";
 import {
     createMessage,
     encodeCapabilities,
     idToBuffer,
-    safeWriteUInt32BE,
-    timestampToBuffer
-} from "../../../../../utils/buffer.js";
+    timestampToBuffer,
+    uint32ToBuffer
+} from "../../../../../../utils/buffer.js";
 import {
     V1ProtocolError,
 } from "../V1ProtocolError.js";
@@ -33,7 +33,7 @@ class V1BaseOperation {
         const selectedValidator = this.#selectCheckSchemaValidator(payload.type);
         const isPayloadValid = selectedValidator(payload);
         if (!isPayloadValid) {
-            throw new V1ProtocolError(ResultCode.INVALID_PAYLOAD, 'Payload is invalid.');
+            throw new V1ProtocolError(ResultCode.SCHEMA_VALIDATION_FAILED, 'Payload is invalid.');
         }
     }
 
@@ -48,14 +48,18 @@ class V1BaseOperation {
             if (error instanceof V1ProtocolError) {
                 throw error;
             }
-            throw new V1ProtocolError(ResultCode.INVALID_PAYLOAD, `Failed to build signature message: ${error.message}`);
+            throw new V1ProtocolError(ResultCode.UNEXPECTED_ERROR, `Failed to build signature message: ${error.message}`);
+        }
+
+        if (!remotePublicKey) {
+            throw new V1ProtocolError(ResultCode.UNEXPECTED_ERROR, 'Remote public key is missing.');
         }
 
         let hash;
         try {
             hash = await tracCryptoApi.hash.blake3(message);
         } catch {
-            throw new V1ProtocolError(ResultCode.INVALID_PAYLOAD, 'Failed to hash signature message.');
+            throw new V1ProtocolError(ResultCode.UNEXPECTED_ERROR, 'Failed to hash signature message.');
         }
 
         let verified = false;
@@ -71,10 +75,10 @@ class V1BaseOperation {
 
     #buildSignatureMessage(payload) {
         if (!Number.isInteger(payload.type)) {
-            throw new V1ProtocolError(ResultCode.INVALID_PAYLOAD, 'Operation type must be an integer.');
+            throw new V1ProtocolError(ResultCode.OPERATION_TYPE_UNKNOWN, 'Operation type must be an integer.');
         }
         if (payload.type === 0) {
-            throw new V1ProtocolError(ResultCode.INVALID_PAYLOAD, 'Operation type is unspecified.');
+            throw new V1ProtocolError(ResultCode.OPERATION_TYPE_UNKNOWN, 'Operation type is unspecified.');
         }
 
         const idBuf = idToBuffer(payload.id);
@@ -92,7 +96,7 @@ class V1BaseOperation {
                 const nonce = payload.liveness_response.nonce;
                 const signature = payload.liveness_response.signature;
                 const result = payload.liveness_response.result;
-                const message = createMessage(payload.type, idBuf, tsBuf, nonce, safeWriteUInt32BE(result, 0), capsBuf);
+                const message = createMessage(payload.type, idBuf, tsBuf, nonce, uint32ToBuffer(result), capsBuf);
                 return {signature, message};
             }
             case NetworkOperationType.BROADCAST_TRANSACTION_REQUEST: {
@@ -140,23 +144,23 @@ class V1BaseOperation {
                     nonce,
                     proof,
                     timestampToBuffer(timestamp),
-                    safeWriteUInt32BE(result, 0),
+                    uint32ToBuffer(result),
                     capsBuf
                 );
 
                 return {signature, message};
             }
             default:
-                throw new V1ProtocolError(ResultCode.UNEXPECTED_ERROR, `Unknown operation type: ${payload.type}`);
+                throw new V1ProtocolError(ResultCode.OPERATION_TYPE_UNKNOWN, `Unknown operation type: ${payload.type}`);
         }
     }
 
     #selectCheckSchemaValidator(type) {
         if (!Number.isInteger(type)) {
-            throw new V1ProtocolError(ResultCode.INVALID_PAYLOAD, 'Operation type must be an integer.');
+            throw new V1ProtocolError(ResultCode.OPERATION_TYPE_UNKNOWN, 'Operation type must be an integer.');
         }
         if (type === 0) {
-            throw new V1ProtocolError(ResultCode.INVALID_PAYLOAD, 'Operation type is unspecified.');
+            throw new V1ProtocolError(ResultCode.OPERATION_TYPE_UNKNOWN, 'Operation type is unspecified.');
         }
 
         switch (type) {
@@ -169,7 +173,7 @@ class V1BaseOperation {
             case NetworkOperationType.BROADCAST_TRANSACTION_RESPONSE:
                 return this.#v1ValidationSchema.validateV1BroadcastTransactionResponse.bind(this.#v1ValidationSchema);
             default:
-                throw new V1ProtocolError(ResultCode.UNEXPECTED_ERROR, `Unknown operation type: ${type}`);
+                throw new V1ProtocolError(ResultCode.OPERATION_TYPE_UNKNOWN, `Unknown operation type: ${type}`);
         }
     }