trac-msb 0.2.9 → 0.2.11

package/src/index.js

@@ -44,6 +44,7 @@ import {
     getLicenseCountCommand
 } from "./utils/cliCommands.js";
 import {safeEncodeApplyOperation} from "./utils/protobuf/operationHelpers.js";
+import {Config} from "./config/config.js";
 
 export class MainSettlementBus extends ReadyResource {
     #store;
@@ -55,7 +56,7 @@ export class MainSettlementBus extends ReadyResource {
     #config
 
     /**
-     * @param {object} config
+     * @param {Config} config
      **/
     constructor(config) {
         super();
@@ -96,6 +97,8 @@ export class MainSettlementBus extends ReadyResource {
     }
 
     async _open() {
+        await fileUtils.ensureCoresStoreDir(this.#config);
+
         if (this.#config.enableWallet) {
             await this.#wallet.initKeyPair(
                 this.#config.keyPairPath,
@@ -301,7 +304,7 @@ export class MainSettlementBus extends ReadyResource {
         const success = await this.broadcastPartialTransaction(adminRecoveryMessage);
 
         if (!success) {
-            throw new Error("Failed to broadcast transaction after multiple attempts.");
+            throw new Error("Failed to broadcast transaction. Try again later.");
         }
 
         console.info(`Transaction hash: ${adminRecoveryMessage.rao.tx}`);
@@ -422,7 +425,7 @@ export class MainSettlementBus extends ReadyResource {
             const success = await this.broadcastPartialTransaction(assembledMessage);
 
             if (!success) {
-                throw new Error("Failed to broadcast transaction after multiple attempts.");
+                throw new Error("Failed to broadcast transaction. Try again later.");
             }
 
             console.info(`Transaction hash: ${assembledMessage.rao.tx}`);
@@ -456,7 +459,7 @@ export class MainSettlementBus extends ReadyResource {
         const success = await this.broadcastPartialTransaction(assembledMessage);
 
         if (!success) {
-            throw new Error("Failed to broadcast transaction after multiple attempts.");
+            throw new Error("Failed to broadcast transaction. Try again later.");
         }
 
         console.info(`Transaction hash: ${assembledMessage.rao.tx}`);
@@ -680,7 +683,7 @@ export class MainSettlementBus extends ReadyResource {
         const success = await this.broadcastPartialTransaction(payload);
 
         if (!success) {
-            throw new Error("Failed to broadcast transaction after multiple attempts.");
+            throw new Error("Failed to broadcast transaction. Try again later.");
         }
 
         console.info(`Transaction hash: ${payload.bdo.tx}`);

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

@@ -8,7 +8,7 @@ import {encodeCapabilities} from "../../../utils/buffer.js";
 /**
  * Builder for v1 internal network protocol messages.
  * @param {PeerWallet} wallet
- * @param {object} config
+ * @param {Config} config
  */
 class NetworkMessageBuilder {
     #wallet;
@@ -19,6 +19,8 @@ class NetworkMessageBuilder {
     #issuerAddress;
     #resultCode;
     #data;
+    #proof;
+    #timestamp_ledger;
     #header;
     #payloadKey;
     #body;
@@ -26,7 +28,7 @@ class NetworkMessageBuilder {
 
     /**
      * @param {PeerWallet} wallet
-     * @param {object} config
+     * @param {Config} config
      */
     constructor(wallet, config) {
         this.#config = config;
@@ -85,6 +87,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 +97,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,76 +136,6 @@ 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 tsBuf = timestampToBuffer(this.#timestamp);
@@ -258,21 +217,50 @@ class NetworkMessageBuilder {
         const nonce = PeerWallet.generateNonce();
         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);
-
         this.#payloadKey = 'broadcast_transaction_response';
         this.#body = {
             nonce,
             signature,
+            proof,
+            timestamp: timestamp,
             result: this.#resultCode
         };
     }
@@ -281,14 +269,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/state/ApplyStateMessageBuilder.js

@@ -23,7 +23,7 @@ import { isHexString } from '../../utils/helpers.js';
 /**
  * Builder for partial/complete ApplyState messages.
  * @param {PeerWallet} wallet
- * @param {object} config
+ * @param {Config} config
  */
 class ApplyStateMessageBuilder {
     #address;

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/check.js

@@ -26,7 +26,7 @@ class Check {
     #config
 
     /**
-     * @param {object} config
+     * @param {Config} config
      **/
     constructor(config) {
         this.#config = config

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
@@ -82,13 +139,6 @@ export const TRAC_NAMESPACE = 'TracNetwork';
 export const WHITELIST_SLEEP_INTERVAL = 1_000;
 export const BALANCE_MIGRATION_SLEEP_INTERVAL = 500;
 
-// Connectivity constants
-export const MAX_PEERS = 64;
-export const MAX_PARALLEL = 64;
-export const MAX_SERVER_CONNECTIONS = Infinity;
-export const MAX_CLIENT_CONNECTIONS = Infinity;
-export const MAX_WRITERS_FOR_ADMIN_INDEXER_CONNECTION = 10;
-
 // State
 export const ACK_INTERVAL = 1_000;
 export const AUTOBASE_VALUE_ENCODING = 'binary';
@@ -115,16 +165,13 @@ export const BOOTSTRAP_HEXSTRING_LENGTH = 64;
 
 // Pool constants
 export const BATCH_SIZE = 10;
-export const PROCESS_INTERVAL_MS = 50;
-
-// Rate limiting constants
-export const CLEANUP_INTERVAL_MS = 120_000;
-export const CONNECTION_TIMEOUT_MS = 60_000;
-export const MAX_TRANSACTIONS_PER_SECOND = 50;
 
 // Operation handler constants
 export const MAX_PARTIAL_TX_PAYLOAD_BYTE_SIZE = 3072;
-export const TRANSACTION_POOL_SIZE = 1000;
+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({
@@ -140,3 +187,5 @@ export const NETWORK_MESSAGE_TYPES = Object.freeze({
         NODE: 'nodeResponse'
     },
 });
+
+export const NETWORK_CAPABILITIES = Object.freeze(["protocols:v1:legacy"]);

package/src/utils/deepEqualApplyPayload.js

@@ -0,0 +1,40 @@
+import b4a from 'b4a';
+import _ from 'lodash';
+
+export const isDeepEqualApplyPayload = (left, right) => {
+    if (left === right) return true;
+
+    const leftIsBuffer = b4a.isBuffer(left);
+    const rightIsBuffer = b4a.isBuffer(right);
+
+    if (leftIsBuffer || rightIsBuffer) {
+        return leftIsBuffer && rightIsBuffer && b4a.equals(left, right);
+    }
+
+    const leftIsArray = Array.isArray(left);
+    const rightIsArray = Array.isArray(right);
+
+    if (leftIsArray || rightIsArray) {
+        if (!leftIsArray || !rightIsArray) return false;
+        if (left.length !== right.length) return false;
+
+        for (let i = 0; i < left.length; i++) {
+            if (!isDeepEqualApplyPayload(left[i], right[i])) return false;
+        }
+        return true;
+    }
+
+    if (!_.isObject(left) || !_.isObject(right)) return false;
+
+    const leftKeys = Object.keys(left);
+    const rightKeys = Object.keys(right);
+
+    if (leftKeys.length !== rightKeys.length) return false;
+
+    for (const key of leftKeys) {
+        if (!Object.prototype.hasOwnProperty.call(right, key)) return false;
+        if (!isDeepEqualApplyPayload(left[key], right[key])) return false;
+    }
+
+    return true;
+};

package/src/utils/fileUtils.js

@@ -123,6 +123,18 @@ export async function getAllMigrationFiles(migrationDirectory = BALANCE_MIGRATED
     }
 }
 
+export async function ensureCoresStoreDir(config) {
+    try {
+        // const storesDirectoryStats = await fs.promises.stat(config.storesDirectory);
+        // if (!storesDirectoryStats.isDirectory()) {
+        //     throw new Error(`Stores directory path is not a directory: ${config.storesDirectory}`);
+        // }
+        await fs.promises.mkdir(config.storesFullPath, { recursive: true });
+    } catch (err) {
+        throw new Error(`Failed to ensure corestore directory: ${err.message}`);
+    }
+}
+
 export async function validateBalanceMigrationData(addresses) {
     const migrationFiles = await getAllMigrationFiles(BALANCE_MIGRATED_DIR);
     const addressSet = new Set(addresses.map(a => a.address));
@@ -197,6 +209,7 @@ export default {
     readAddressesFromWhitelistFile,
     readBalanceMigrationFile,
     getAllMigrationFiles,
+    ensureCoresStoreDir,
     validateBalanceMigrationData,
     validateWhitelistMigrationData,
     getNextMigrationNumber,

package/src/utils/helpers.js

@@ -1,7 +1,8 @@
 import b4a from "b4a";
+import PeerWallet from "trac-wallet";
 import {bufferToAddress} from "../core/state/utils/address.js";
 import { EntryType } from "./constants.js";
-
+import { v7 as uuidv7 } from 'uuid';
 //TODO: change file name or split functions below into multiple files (Remember to update imports and tests accordingly)
 
 export function isHexString(string) {
@@ -95,3 +96,11 @@ export function isTransactionRecordPut(entry) {
     const is64 = entry.key.length === 64;
     return isPut && isHex && is64;
 }
+
+export function generateUUID() {
+    return uuidv7();
+}
+
+export function publicKeyToAddress(publicKey, config) {
+    return PeerWallet.encodeBech32m(config.addressPrefix, b4a.isBuffer(publicKey) ? publicKey : b4a.from(publicKey, typeof publicKey === 'string' ? 'hex' : undefined));
+}

package/src/utils/logger.js

@@ -0,0 +1,25 @@
+export class Logger {
+    #config
+    constructor(config) {
+        this.#config = config;
+    }
+
+    info(message) {
+        console.log("i: " + message);
+    }
+
+    debug(message) {
+        if (this.#config.debug) {
+            console.debug("d: " + message);
+        }
+    }
+
+    error(message) {
+        console.error("e: " + message);
+    }
+
+    warn(message) {
+        console.warn("w: " + message);
+    }
+
+}