trac-msb 0.2.17 → 0.2.19

package/src/messages/network/v1/NetworkMessageBuilder.js

@@ -1,13 +1,13 @@
-import PeerWallet from 'trac-wallet';
+import tracCryptoApi from 'trac-crypto-api';
 import b4a from 'b4a';
 import {createMessage, safeWriteUInt32BE, idToBuffer, timestampToBuffer} from "../../../utils/buffer.js";
 import {NetworkOperationType, ResultCode} from '../../../utils/constants.js';
-import {addressToBuffer, isAddressValid} from "../../../core/state/utils/address.js";
+import {isAddressValid} from "../../../core/state/utils/address.js";
 import {encodeCapabilities} from "../../../utils/buffer.js";
 
 /**
  * Builder for v1 internal network protocol messages.
- * @param {PeerWallet} wallet
+ * @param {IWallet} wallet
  * @param {Config} config
  */
 class NetworkMessageBuilder {
@@ -16,16 +16,17 @@ class NetworkMessageBuilder {
     #capabilities;
     #id;
     #timestamp;
-    #issuerAddress;
     #resultCode;
     #data;
+    #proof;
+    #timestamp_ledger;
     #header;
     #payloadKey;
     #body;
     #config;
 
     /**
-     * @param {PeerWallet} wallet
+     * @param {IWallet} wallet
      * @param {Config} config
      */
     constructor(wallet, config) {
@@ -50,14 +51,6 @@ class NetworkMessageBuilder {
         return this;
     }
 
-    setIssuerAddress(issuerAddress) {
-        if (!isAddressValid(issuerAddress, this.#config.addressPrefix)) {
-            throw new Error('Issuer TRAC address must be valid.');
-        }
-        this.#issuerAddress = issuerAddress;
-        return this;
-    }
-
     setCapabilities(capabilities = []) {
         if (!Array.isArray(capabilities) || !capabilities.every(capability => typeof capability === 'string')) {
             throw new Error('Capabilities must be a string array.');
@@ -85,6 +78,9 @@ class NetworkMessageBuilder {
     }
 
     setData(data) {
+        // case when response have to be empty.
+        if (data === undefined || data === null) data = b4a.alloc(0);
+
         if (!b4a.isBuffer(data)) {
             throw new Error(`Data must be a buffer.`);
         }
@@ -92,6 +88,30 @@ class NetworkMessageBuilder {
         return this;
     }
 
+    setProof(proof) {
+        if (proof === undefined || proof === null) proof = b4a.alloc(0);
+        if (!b4a.isBuffer(proof)) {
+            throw new Error(`Proof must be a buffer.`);
+        }
+        this.#proof = proof;
+        return this;
+    }
+
+    setTimestampLedger(timestamp) {
+        if (timestamp === undefined || timestamp === null) {
+            this.#timestamp_ledger = null;
+            return this;
+        }
+
+        const value = timestamp instanceof Date ? timestamp.getTime() : timestamp;
+        if (!Number.isSafeInteger(value) || value < 0) {
+            throw new Error('timestamp must be a non-negative safe integer or Date.');
+        }
+
+        this.#timestamp_ledger = value;
+        return this;
+    }
+
     #setHeader() {
         if (!this.#type) throw new Error('Header requires type to be set');
         if (!this.#id) throw new Error('Header requires id to be set');
@@ -107,78 +127,8 @@ class NetworkMessageBuilder {
         return this;
     }
 
-    async #buildValidatorConnectionRequestPayload() {
-        const issuer = this.#issuerAddress
-        if (!isAddressValid(issuer, this.#config.addressPrefix)) {
-            throw new Error('Issuer address must be a valid TRAC address');
-        }
-
-        if (this.#issuerAddress !== this.#wallet.address) {
-            throw new Error('Issuer address must be the signer address');
-        }
-
-        const nonce = PeerWallet.generateNonce();
-        const tsBuf = timestampToBuffer(this.#timestamp);
-        const idBuf = idToBuffer(this.#id);
-        const message = createMessage(
-            this.#type,
-            idBuf,
-            tsBuf,
-            addressToBuffer(issuer, this.#config.addressPrefix),
-            nonce,
-            encodeCapabilities(this.#capabilities),
-        );
-        const hash = await PeerWallet.blake3(message);
-        const signature = this.#wallet.sign(hash);
-
-        this.#payloadKey = 'validator_connection_request';
-        this.#body = {
-            issuer_address: issuer,
-            nonce,
-            signature
-        };
-    }
-
-    async #buildValidatorConnectionResponsePayload() {
-        const issuer = this.#issuerAddress
-        if (!isAddressValid(issuer, this.#config.addressPrefix)) {
-            throw new Error('Issuer address must be a valid TRAC address');
-        }
-
-        if (this.#issuerAddress === this.#wallet.address) {
-            throw new Error('Issuer address must be the different than the signer address');
-        }
-
-        if (this.#resultCode === null || this.#resultCode === undefined) {
-            throw new Error('Result code must be set before building validator connection response');
-        }
-
-        const nonce = PeerWallet.generateNonce();
-        const tsBuf = timestampToBuffer(this.#timestamp);
-        const idBuf = idToBuffer(this.#id);
-        const message = createMessage(
-            this.#type,
-            idBuf,
-            tsBuf,
-            addressToBuffer(issuer, this.#config.addressPrefix),
-            nonce,
-            safeWriteUInt32BE(this.#resultCode, 0),
-            encodeCapabilities(this.#capabilities),
-        );
-        const hash = await PeerWallet.blake3(message);
-        const signature = this.#wallet.sign(hash);
-
-        this.#payloadKey = 'validator_connection_response';
-        this.#body = {
-            issuer_address: issuer,
-            nonce,
-            signature,
-            result: this.#resultCode
-        };
-    }
-
     async #buildLivenessRequestPayload() {
-        const nonce = PeerWallet.generateNonce();
+        const nonce = tracCryptoApi.nonce.generate();
         const tsBuf = timestampToBuffer(this.#timestamp);
         const idBuf = idToBuffer(this.#id);
         const message = createMessage(
@@ -188,7 +138,7 @@ class NetworkMessageBuilder {
             nonce,
             encodeCapabilities(this.#capabilities),
         );
-        const hash = await PeerWallet.blake3(message);
+        const hash = await tracCryptoApi.hash.blake3(message);
         const signature = this.#wallet.sign(hash);
 
         this.#payloadKey = 'liveness_request';
@@ -203,7 +153,7 @@ class NetworkMessageBuilder {
             throw new Error('Result code must be set before building liveness response');
         }
 
-        const nonce = PeerWallet.generateNonce();
+        const nonce = tracCryptoApi.nonce.generate();
         const tsBuf = timestampToBuffer(this.#timestamp);
         const idBuf = idToBuffer(this.#id);
         const message = createMessage(
@@ -214,7 +164,7 @@ class NetworkMessageBuilder {
             safeWriteUInt32BE(this.#resultCode, 0),
             encodeCapabilities(this.#capabilities),
         );
-        const hash = await PeerWallet.blake3(message);
+        const hash = await tracCryptoApi.hash.blake3(message);
         const signature = this.#wallet.sign(hash);
 
         this.#payloadKey = 'liveness_response';
@@ -229,7 +179,7 @@ class NetworkMessageBuilder {
         if (!b4a.isBuffer(this.#data)) {
             throw new Error('Data must be set before building broadcast transaction request');
         }
-        const nonce = PeerWallet.generateNonce();
+        const nonce = tracCryptoApi.nonce.generate();
         const tsBuf = timestampToBuffer(this.#timestamp);
         const idBuf = idToBuffer(this.#id);
         const message = createMessage(
@@ -240,7 +190,7 @@ class NetworkMessageBuilder {
             nonce,
             encodeCapabilities(this.#capabilities),
         );
-        const hash = await PeerWallet.blake3(message);
+        const hash = await tracCryptoApi.hash.blake3(message);
         const signature = this.#wallet.sign(hash);
 
         this.#payloadKey = 'broadcast_transaction_request';
@@ -255,24 +205,53 @@ class NetworkMessageBuilder {
         if (this.#resultCode === null || this.#resultCode === undefined) {
             throw new Error('Result code must be set before building broadcast transaction response');
         }
-        const nonce = PeerWallet.generateNonce();
+        const nonce = tracCryptoApi.nonce.generate();
         const tsBuf = timestampToBuffer(this.#timestamp);
         const idBuf = idToBuffer(this.#id);
+        const proof = b4a.isBuffer(this.#proof) ? this.#proof : b4a.alloc(0);
+        const hasProof = proof.length > 0;
+        const timestamp = Number.isSafeInteger(this.#timestamp_ledger) ? this.#timestamp_ledger : 0;
+        const hasTimestamp = timestamp > 0;
+
+        if (this.#resultCode === ResultCode.OK) {
+            if (!hasProof || !hasTimestamp) {
+                throw new Error('Result code OK requires non-empty proof and timestamp > 0.');
+            }
+        } else if (this.#resultCode === ResultCode.TX_ACCEPTED_PROOF_UNAVAILABLE) {
+            if (hasProof) {
+                throw new Error('Result code TX_ACCEPTED_PROOF_UNAVAILABLE requires empty proof.');
+            }
+            if (!hasTimestamp) {
+                throw new Error('Result code TX_ACCEPTED_PROOF_UNAVAILABLE requires timestamp > 0.');
+            }
+        } else {
+            if (hasProof) {
+                throw new Error('Non-OK result code requires empty proof.');
+            }
+            if (timestamp !== 0) {
+                throw new Error('Non-OK result code requires timestamp to be 0, except TX_ACCEPTED_PROOF_UNAVAILABLE.');
+            }
+        }
+
         const message = createMessage(
             this.#type,
             idBuf,
             tsBuf,
             nonce,
+            proof,
+            timestampToBuffer(timestamp),
             safeWriteUInt32BE(this.#resultCode, 0),
             encodeCapabilities(this.#capabilities),
         );
-        const hash = await PeerWallet.blake3(message);
-        const signature = this.#wallet.sign(hash);
 
+        const hash = await tracCryptoApi.hash.blake3(message);
+        const signature = this.#wallet.sign(hash);
         this.#payloadKey = 'broadcast_transaction_response';
         this.#body = {
             nonce,
             signature,
+            proof,
+            timestamp: timestamp,
             result: this.#resultCode
         };
     }
@@ -281,14 +260,6 @@ class NetworkMessageBuilder {
         this.#setHeader();
 
         switch (this.#type) {
-            case NetworkOperationType.VALIDATOR_CONNECTION_REQUEST: {
-                await this.#buildValidatorConnectionRequestPayload();
-                break;
-            }
-            case NetworkOperationType.VALIDATOR_CONNECTION_RESPONSE: {
-                await this.#buildValidatorConnectionResponsePayload();
-                break;
-            }
             case NetworkOperationType.LIVENESS_REQUEST: {
                 await this.#buildLivenessRequestPayload();
                 break;

package/src/messages/network/v1/NetworkMessageDirector.js

@@ -1,4 +1,4 @@
-import { NetworkOperationType } from '../../../utils/constants.js';
+import {NetworkOperationType} from '../../../utils/constants.js';
 
 /**
  * Director for v1 internal network protocol messages.
@@ -13,47 +13,6 @@ class NetworkMessageDirector {
         this.#builder = builderInstance;
     }
 
-    /**
-     * Build a validator connection request message.
-     * @param {string} id
-     * @param {string} issuerAddress
-     * @param {string[]} capabilities
-     * @returns {Promise<object>}
-     */
-    async buildValidatorConnectionRequest(id, issuerAddress, capabilities) {
-        await this.#builder
-            .setType(NetworkOperationType.VALIDATOR_CONNECTION_REQUEST)
-            .setId(id)
-            .setTimestamp()
-            .setIssuerAddress(issuerAddress)
-            .setCapabilities(capabilities)
-            .buildPayload()
-
-
-        return this.#builder.getResult();
-    }
-
-    /**
-     * Build a validator connection response message.
-     * @param {string} id
-     * @param {string} issuerAddress
-     * @param {string[]} capabilities
-     * @param {number} statusCode
-     * @returns {Promise<object>}
-     */
-    async buildValidatorConnectionResponse(id, issuerAddress, capabilities, statusCode) {
-        await this.#builder
-        .setType(NetworkOperationType.VALIDATOR_CONNECTION_RESPONSE)
-        .setId(id)
-        .setTimestamp()
-        .setIssuerAddress(issuerAddress)
-        .setCapabilities(capabilities)
-        .setResultCode(statusCode)
-        .buildPayload()
-
-        return this.#builder.getResult();
-    }
-
     /**
      * Build a liveness request message.
      * @param {string} id
@@ -61,12 +20,11 @@ class NetworkMessageDirector {
      * @param {string[]} capabilities
      * @returns {Promise<object>}
      */
-    async buildLivenessRequest(id, data, capabilities) {
+    async buildLivenessRequest(id, capabilities) {
         await this.#builder
             .setType(NetworkOperationType.LIVENESS_REQUEST)
             .setId(id)
             .setTimestamp()
-            .setData(data)
             .setCapabilities(capabilities)
             .buildPayload();
 
@@ -76,17 +34,15 @@ class NetworkMessageDirector {
     /**
      * Build a liveness response message.
      * @param {string} id
-     * @param {Buffer} data
      * @param {string[]} capabilities
      * @param {number} statusCode
      * @returns {Promise<object>}
      */
-    async buildLivenessResponse(id, data, capabilities, statusCode) {
+    async buildLivenessResponse(id, capabilities, statusCode) {
         await this.#builder
             .setType(NetworkOperationType.LIVENESS_RESPONSE)
             .setId(id)
             .setTimestamp()
-            .setData(data)
             .setCapabilities(capabilities)
             .setResultCode(statusCode)
             .buildPayload();
@@ -115,18 +71,28 @@ class NetworkMessageDirector {
 
     /**
      * Build a broadcast transaction response message.
+     *
+     * Allowed payload variants:
+     * 1) resultCode === OK - proof must be non-empty and timestamp must be > 0.
+     * 2) resultCode === TX_ACCEPTED_PROOF_UNAVAILABLE - proof must be empty and timestamp must be > 0.
+     * 3) resultCode !== OK and resultCode !== TX_ACCEPTED_PROOF_UNAVAILABLE - proof must be empty and timestamp must be 0.
+     *
      * @param {string} id
      * @param {string[]} capabilities
-     * @param {number} statusCode
+     * @param {number} resultCode
+     * @param {Buffer|null|undefined} proof
+     * @param {number|Date|null|undefined} timestamp - When transaction has been appended by the validator
      * @returns {Promise<object>}
      */
-    async buildBroadcastTransactionResponse(id, capabilities, statusCode) {
+    async buildBroadcastTransactionResponse(id, capabilities, resultCode, proof = null, timestamp = null) {
         await this.#builder
             .setType(NetworkOperationType.BROADCAST_TRANSACTION_RESPONSE)
             .setId(id)
             .setTimestamp()
             .setCapabilities(capabilities)
-            .setResultCode(statusCode)
+            .setProof(proof)
+            .setTimestampLedger(timestamp)
+            .setResultCode(resultCode)
             .buildPayload();
 
         return this.#builder.getResult();

package/src/messages/network/v1/networkMessageFactory.js

@@ -3,7 +3,7 @@ import NetworkMessageBuilder from "./NetworkMessageBuilder.js";
 
 /**
  * Factory helper to create a director with a fresh builder instance.
- * @param {PeerWallet} wallet
+ * @param {IWallet} wallet
  * @param {object} config
  * @returns {NetworkMessageDirector}
  */

package/src/messages/state/ApplyStateMessageBuilder.js

@@ -1,5 +1,5 @@
 import b4a from 'b4a';
-import PeerWallet from 'trac-wallet';
+import tracCryptoApi from 'trac-crypto-api';
 
 import { createMessage } from '../../utils/buffer.js';
 import { OperationType } from '../../utils/constants.js';
@@ -22,7 +22,7 @@ import { isHexString } from '../../utils/helpers.js';
 
 /**
  * Builder for partial/complete ApplyState messages.
- * @param {PeerWallet} wallet
+ * @param {IWallet} wallet
  * @param {Config} config
  */
 class ApplyStateMessageBuilder {
@@ -257,7 +257,7 @@ class ApplyStateMessageBuilder {
             throw new Error(`Operation type ${this.#operationType} is not supported for partial build.`);
         }
 
-        const nonce = PeerWallet.generateNonce();
+        const nonce = tracCryptoApi.nonce.generate();
         let msg;
 
         switch (this.#operationType) {
@@ -329,7 +329,7 @@ class ApplyStateMessageBuilder {
                 throw new Error(`Unsupported operation type: ${this.#operationType}`);
         }
 
-        const tx = await PeerWallet.blake3(msg);
+        const tx = await tracCryptoApi.hash.blake3(msg);
         const signature = this.#wallet.sign(tx);
 
         if (isBootstrapDeployment(this.#operationType)) {
@@ -378,7 +378,7 @@ class ApplyStateMessageBuilder {
     }
 
     async #buildCompleteBody() {
-        const nonce = PeerWallet.generateNonce();
+        const nonce = tracCryptoApi.nonce.generate();
         let msg;
 
         switch (this.#operationType) {
@@ -503,7 +503,7 @@ class ApplyStateMessageBuilder {
                 throw new Error(`Unsupported operation type: ${this.#operationType}`);
         }
 
-        const tx = await PeerWallet.blake3(msg);
+        const tx = await tracCryptoApi.hash.blake3(msg);
         const signature = this.#wallet.sign(tx);
         const validatorAddress = addressToBuffer(this.#wallet.address, this.#config.addressPrefix);
 

package/src/messages/state/applyStateMessageFactory.js

@@ -3,7 +3,7 @@ import ApplyStateMessageBuilder from "./ApplyStateMessageBuilder.js";
 
 /**
  * Factory helper to create a director with a builder instance.
- * @param {PeerWallet} wallet
+ * @param {IWallet} wallet
  * @param {object} config
  * @returns {ApplyStateMessageDirector}
  */

package/src/utils/Scheduler.js

@@ -42,14 +42,6 @@ class Scheduler {
         return this.#defaultInterval;
     }
 
-    get timer() {
-        return this.#timer;
-    }
-
-    get currentWorkerRun() {
-        return this.#currentWorkerRun;
-    }
-
     static #validateDelay(delayMs, scope = 'delayMs') {
         const ms = Number(delayMs);
         if (!Number.isFinite(ms) || ms < 0) {

package/src/utils/buffer.js

@@ -15,7 +15,7 @@ export const safeWriteUInt32BE = (value, offset) => {
         const buf = b4a.alloc(4);
         buf.writeUInt32BE(value, offset);
         return buf;
-    } catch (error) {
+    } catch {
         return b4a.alloc(4);
     }
 }

package/src/utils/check.js

@@ -41,7 +41,7 @@ class Check {
             },
         });
         const isBuffer = b4a.isBuffer;
-        this.#validator.add("buffer", function ({ schema, messages }, path, context) {
+        this.#validator.add("buffer", function ({ schema, messages }, _path, _context) {
             return {
                 source:
                     `
@@ -50,11 +50,11 @@ class Check {
                         }
                         if (value.length !== ${schema.length}) {
                             ${this.makeError({
-                        type: "bufferLength",
-                        expected: schema.length,
-                        actual: "value.length",
-                        messages
-                    })}
+        type: "bufferLength",
+        expected: schema.length,
+        actual: "value.length",
+        messages
+    })}
                         }
                         let isEmpty = true;
                             for (let i = 0; i < value.length; i++) {
@@ -71,7 +71,7 @@ class Check {
             };
         });
 
-        this.#validator.add("buffer_amount", function ({ schema, messages }, path, context) {
+        this.#validator.add("buffer_amount", function ({ schema, messages }, _path, _context) {
             return {
                 source:
                     `
@@ -80,11 +80,11 @@ class Check {
                         }
                         if (value.length !== ${schema.length}) {
                             ${this.makeError({
-                        type: "bufferLength",
-                        expected: schema.length,
-                        actual: "value.length",
-                        messages
-                    })}
+        type: "bufferLength",
+        expected: schema.length,
+        actual: "value.length",
+        messages
+    })}
                         }
                         return value;
                     `
@@ -523,4 +523,3 @@ class Check {
 }
 
 export default Check;
-

package/src/utils/constants.js

@@ -1,8 +1,10 @@
 import { OperationType as ApplyOperationType } from './protobuf/applyOperations.cjs';
-import { MessageType as NetworkMessageType, ResultCode as NetworkResultCode } from './protobuf/network.cjs';
+import networkV1Generated from './protobuf/networkV1.generated.cjs';
 import b4a from 'b4a'
 // TODO: We are going to have a lot of contstants. It would be good, to separate them into different files.
 
+const { MessageType: NetworkMessageType, ResultCode: NetworkResultCode } = networkV1Generated.network.v1;
+
 //ATTENTION - THIS IS USED IN THE APPLY FUNCTION!
 export const EntryType = Object.freeze({
     ADMIN: 'admin',
@@ -34,8 +36,6 @@ export const OperationType = Object.freeze({
 });
 
 export const NetworkOperationType = Object.freeze({
-    VALIDATOR_CONNECTION_REQUEST: NetworkMessageType.MESSAGE_TYPE_VALIDATOR_CONNECTION_REQUEST,
-    VALIDATOR_CONNECTION_RESPONSE: NetworkMessageType.MESSAGE_TYPE_VALIDATOR_CONNECTION_RESPONSE,
     LIVENESS_REQUEST: NetworkMessageType.MESSAGE_TYPE_LIVENESS_REQUEST,
     LIVENESS_RESPONSE: NetworkMessageType.MESSAGE_TYPE_LIVENESS_RESPONSE,
     BROADCAST_TRANSACTION_REQUEST: NetworkMessageType.MESSAGE_TYPE_BROADCAST_TRANSACTION_REQUEST,
@@ -43,12 +43,68 @@ export const NetworkOperationType = Object.freeze({
 });
 
 export const ResultCode = Object.freeze({
+    UNSPECIFIED: NetworkResultCode.RESULT_CODE_UNSPECIFIED,
     OK: NetworkResultCode.RESULT_CODE_OK,
     INVALID_PAYLOAD: NetworkResultCode.RESULT_CODE_INVALID_PAYLOAD,
-    UNSUPPORTED_VERSION: NetworkResultCode.RESULT_CODE_UNSUPPORTED_VERSION,
     RATE_LIMITED: NetworkResultCode.RESULT_CODE_RATE_LIMITED,
-    TIMEOUT: NetworkResultCode.RESULT_CODE_TIMEOUT,
     SIGNATURE_INVALID: NetworkResultCode.RESULT_CODE_SIGNATURE_INVALID,
+    UNEXPECTED_ERROR: NetworkResultCode.RESULT_CODE_UNEXPECTED_ERROR,
+    TIMEOUT: NetworkResultCode.RESULT_CODE_TIMEOUT,
+    NODE_HAS_NO_WRITE_ACCESS: NetworkResultCode.RESULT_CODE_NODE_HAS_NO_WRITE_ACCESS,
+    TX_ACCEPTED_PROOF_UNAVAILABLE: NetworkResultCode.RESULT_CODE_TX_ACCEPTED_PROOF_UNAVAILABLE,
+    NODE_OVERLOADED: NetworkResultCode.RESULT_CODE_NODE_OVERLOADED,
+    TX_ALREADY_PENDING: NetworkResultCode.RESULT_CODE_TX_ALREADY_PENDING,
+    OPERATION_TYPE_UNKNOWN: NetworkResultCode.RESULT_CODE_OPERATION_TYPE_UNKNOWN,
+    SCHEMA_VALIDATION_FAILED: NetworkResultCode.RESULT_CODE_SCHEMA_VALIDATION_FAILED,
+    REQUESTER_ADDRESS_INVALID: NetworkResultCode.RESULT_CODE_REQUESTER_ADDRESS_INVALID,
+    REQUESTER_PUBLIC_KEY_INVALID: NetworkResultCode.RESULT_CODE_REQUESTER_PUBLIC_KEY_INVALID,
+    TX_HASH_MISMATCH: NetworkResultCode.RESULT_CODE_TX_HASH_MISMATCH,
+    TX_SIGNATURE_INVALID: NetworkResultCode.RESULT_CODE_TX_SIGNATURE_INVALID,
+    TX_EXPIRED: NetworkResultCode.RESULT_CODE_TX_EXPIRED,
+    TX_ALREADY_EXISTS: NetworkResultCode.RESULT_CODE_TX_ALREADY_EXISTS,
+    OPERATION_ALREADY_COMPLETED: NetworkResultCode.RESULT_CODE_OPERATION_ALREADY_COMPLETED,
+    REQUESTER_NOT_FOUND: NetworkResultCode.RESULT_CODE_REQUESTER_NOT_FOUND,
+    INSUFFICIENT_FEE_BALANCE: NetworkResultCode.RESULT_CODE_INSUFFICIENT_FEE_BALANCE,
+    EXTERNAL_BOOTSTRAP_EQUALS_MSB_BOOTSTRAP: NetworkResultCode.RESULT_CODE_EXTERNAL_BOOTSTRAP_EQUALS_MSB_BOOTSTRAP,
+    SELF_VALIDATION_FORBIDDEN: NetworkResultCode.RESULT_CODE_SELF_VALIDATION_FORBIDDEN,
+    ROLE_NODE_ENTRY_NOT_FOUND: NetworkResultCode.RESULT_CODE_ROLE_NODE_ENTRY_NOT_FOUND,
+    ROLE_NODE_ALREADY_WRITER: NetworkResultCode.RESULT_CODE_ROLE_NODE_ALREADY_WRITER,
+    ROLE_NODE_NOT_WHITELISTED: NetworkResultCode.RESULT_CODE_ROLE_NODE_NOT_WHITELISTED,
+    ROLE_NODE_NOT_WRITER: NetworkResultCode.RESULT_CODE_ROLE_NODE_NOT_WRITER,
+    ROLE_NODE_IS_INDEXER: NetworkResultCode.RESULT_CODE_ROLE_NODE_IS_INDEXER,
+    ROLE_ADMIN_ENTRY_MISSING: NetworkResultCode.RESULT_CODE_ROLE_ADMIN_ENTRY_MISSING,
+    ROLE_INVALID_RECOVERY_CASE: NetworkResultCode.RESULT_CODE_ROLE_INVALID_RECOVERY_CASE,
+    ROLE_UNKNOWN_OPERATION: NetworkResultCode.RESULT_CODE_ROLE_UNKNOWN_OPERATION,
+    ROLE_INVALID_WRITER_KEY: NetworkResultCode.RESULT_CODE_ROLE_INVALID_WRITER_KEY,
+    ROLE_INSUFFICIENT_FEE_BALANCE: NetworkResultCode.RESULT_CODE_ROLE_INSUFFICIENT_FEE_BALANCE,
+    MSB_BOOTSTRAP_MISMATCH: NetworkResultCode.RESULT_CODE_MSB_BOOTSTRAP_MISMATCH,
+    EXTERNAL_BOOTSTRAP_NOT_DEPLOYED: NetworkResultCode.RESULT_CODE_EXTERNAL_BOOTSTRAP_NOT_DEPLOYED,
+    EXTERNAL_BOOTSTRAP_TX_MISSING: NetworkResultCode.RESULT_CODE_EXTERNAL_BOOTSTRAP_TX_MISSING,
+    EXTERNAL_BOOTSTRAP_MISMATCH: NetworkResultCode.RESULT_CODE_EXTERNAL_BOOTSTRAP_MISMATCH,
+    BOOTSTRAP_ALREADY_EXISTS: NetworkResultCode.RESULT_CODE_BOOTSTRAP_ALREADY_EXISTS,
+    TRANSFER_RECIPIENT_ADDRESS_INVALID: NetworkResultCode.RESULT_CODE_TRANSFER_RECIPIENT_ADDRESS_INVALID,
+    TRANSFER_RECIPIENT_PUBLIC_KEY_INVALID: NetworkResultCode.RESULT_CODE_TRANSFER_RECIPIENT_PUBLIC_KEY_INVALID,
+    TRANSFER_AMOUNT_TOO_LARGE: NetworkResultCode.RESULT_CODE_TRANSFER_AMOUNT_TOO_LARGE,
+    TRANSFER_SENDER_NOT_FOUND: NetworkResultCode.RESULT_CODE_TRANSFER_SENDER_NOT_FOUND,
+    TRANSFER_INSUFFICIENT_BALANCE: NetworkResultCode.RESULT_CODE_TRANSFER_INSUFFICIENT_BALANCE,
+    TRANSFER_RECIPIENT_BALANCE_OVERFLOW: NetworkResultCode.RESULT_CODE_TRANSFER_RECIPIENT_BALANCE_OVERFLOW,
+    TX_HASH_INVALID_FORMAT: NetworkResultCode.RESULT_CODE_TX_HASH_INVALID_FORMAT,
+    INTERNAL_ENQUEUE_VALIDATION_FAILED: NetworkResultCode.RESULT_CODE_INTERNAL_ENQUEUE_VALIDATION_FAILED,
+    TX_COMMITTED_RECEIPT_MISSING: NetworkResultCode.RESULT_CODE_TX_COMMITTED_RECEIPT_MISSING,
+    VALIDATOR_RESPONSE_TX_TYPE_INVALID: NetworkResultCode.RESULT_CODE_VALIDATOR_RESPONSE_TX_TYPE_INVALID,
+    VALIDATOR_RESPONSE_TX_TYPE_UNKNOWN: NetworkResultCode.RESULT_CODE_VALIDATOR_RESPONSE_TX_TYPE_UNKNOWN,
+    VALIDATOR_RESPONSE_TX_TYPE_UNSUPPORTED: NetworkResultCode.RESULT_CODE_VALIDATOR_RESPONSE_TX_TYPE_UNSUPPORTED,
+    VALIDATOR_RESPONSE_SCHEMA_INVALID: NetworkResultCode.RESULT_CODE_VALIDATOR_RESPONSE_SCHEMA_INVALID,
+    PENDING_REQUEST_MISSING_TX_DATA: NetworkResultCode.RESULT_CODE_PENDING_REQUEST_MISSING_TX_DATA,
+    PROOF_PAYLOAD_MISMATCH: NetworkResultCode.RESULT_CODE_PROOF_PAYLOAD_MISMATCH,
+    VALIDATOR_WRITER_KEY_NOT_REGISTERED: NetworkResultCode.RESULT_CODE_VALIDATOR_WRITER_KEY_NOT_REGISTERED,
+    VALIDATOR_ADDRESS_MISMATCH: NetworkResultCode.RESULT_CODE_VALIDATOR_ADDRESS_MISMATCH,
+    VALIDATOR_NODE_ENTRY_NOT_FOUND: NetworkResultCode.RESULT_CODE_VALIDATOR_NODE_ENTRY_NOT_FOUND,
+    VALIDATOR_NODE_NOT_WRITER: NetworkResultCode.RESULT_CODE_VALIDATOR_NODE_NOT_WRITER,
+    VALIDATOR_WRITER_KEY_MISMATCH: NetworkResultCode.RESULT_CODE_VALIDATOR_WRITER_KEY_MISMATCH,
+    VALIDATOR_TX_OBJECT_INVALID: NetworkResultCode.RESULT_CODE_VALIDATOR_TX_OBJECT_INVALID,
+    VALIDATOR_VA_MISSING: NetworkResultCode.RESULT_CODE_VALIDATOR_VA_MISSING,
+    TX_INVALID_PAYLOAD: NetworkResultCode.RESULT_CODE_TX_INVALID_PAYLOAD
 });
 
 // Role managment constants
@@ -61,6 +117,7 @@ export const EventType = Object.freeze({
     WARNING: 'warning',
     VALIDATOR_CONNECTION_READY: 'validator-connection-ready',
     VALIDATOR_CONNECTION_TIMEOUT: 'validator-connection-timeout',
+    VALIDATOR_HEALTH_CHECK: 'validator-health-check',
 });
 
 // Role managment constants
@@ -109,6 +166,13 @@ export const BOOTSTRAP_HEXSTRING_LENGTH = 64;
 // Pool constants
 export const BATCH_SIZE = 10;
 
+// Operation handler constants
+export const MAX_PARTIAL_TX_PAYLOAD_BYTE_SIZE = 3072;
+export const V1_PROTOCOL_PAYLOAD_MAX_SIZE = 4096;
+
+// Transaction Commit Service
+export const TRANSACTION_COMMIT_SERVICE_BUFFER_SIZE = 1500;
+
 // Network message constants
 export const NETWORK_MESSAGE_TYPES = Object.freeze({
     GET: {
@@ -123,3 +187,12 @@ export const NETWORK_MESSAGE_TYPES = Object.freeze({
         NODE: 'nodeResponse'
     },
 });
+
+export const NETWORK_CAPABILITIES = Object.freeze(["protocols:v1:legacy"]);
+
+// Network tryConnect status constants
+export const CONNECTION_STATUS = Object.freeze({
+    CONNECTED: 0,
+    PENDING: 1,
+    IGNORED: 2
+});