trac-msb 0.2.12 → 0.2.13

package/src/core/state/State.js

@@ -40,13 +40,15 @@ import { safeWriteUInt32BE } from '../../utils/buffer.js';
 import deploymentEntryUtils from './utils/deploymentEntry.js';
 import { deepCopyBuffer } from '../../utils/buffer.js';
 import { Status } from './utils/transaction.js';
-import Corestore from 'corestore';
+import remote from 'hypercore/lib/fully-remote-proof.js'
+import PQueue from 'p-queue';
 
 const OVERSIZED_BATCH_PENALTY_MULTIPLIER = BATCH_SIZE;
 
 // TODO: #addWriter, #removeWriter, #transfer, #transferFeeTxOperation need to be refactored to get in arguments actor's nodeEntries in buffer format.
 
 class State extends ReadyResource {
+    #writeQueue = new PQueue({ concurrency: 1 });
     #base;
     #bee;
     #store;
@@ -187,18 +189,6 @@ class State extends ReadyResource {
         return !!nodeEntry.isWhitelisted;
     }
 
-    async isAddressWriter(address) {
-        const nodeEntry = await this.getNodeEntry(address);
-        if (nodeEntry === null) return false;
-        return !!nodeEntry.isWriter;
-    }
-
-    async isAddressIndexer(address) {
-        const nodeEntry = await this.getNodeEntry(address);
-        if (nodeEntry === null) return false;
-        return !!nodeEntry.isIndexer;
-    }
-
     async getIndexersEntry() {
         return Object.values(this.#base.system.indexers);
     }
@@ -243,7 +233,67 @@ class State extends ReadyResource {
     }
 
     async append(payload) {
-        await this.#base.append(payload);
+        return this.#writeQueue.add(() => this.#base.append(payload));
+    }
+
+    async appendWithProofOfPublication(batch, batchTxHashes) {
+        return this.#writeQueue.add(async () => {
+
+            const core = this.#base.local;
+            const end = await this.#base.append(batch);
+            const start = end - batch.length;
+            const timestamp = new Date();
+            const snapshot = core.snapshot(); // consistent view while generating proofs.
+            await snapshot.ready();
+            // TODO: check state if specific tx has been appened THEN generate a proof.
+            try {
+                const receipts = [];
+                let failedProofs = 0;
+                for (let i = 0; i < batch.length; i++) {
+                    const blockNumber = start + i;
+                    const completeTx = batch[i];
+                    const txHash = batchTxHashes[i];
+
+                    let proof = null;
+                    let proofError = null;
+
+                    // wait:false makes get fail fast (null) instead of waiting for missing data/replication.
+                    const rawBlock = await snapshot.get(blockNumber, { raw: true, wait: false });
+                    if (!rawBlock) {
+                        proofError = `Missing raw block after append (block=${blockNumber}, start=${start}, end=${end})`;
+                        failedProofs++;
+                    } else {
+                        try {
+                            proof = await remote.proof(snapshot, { index: blockNumber, block: rawBlock });
+                        } catch (error) {
+                            proofError = `Proof generation failed (block=${blockNumber}, start=${start}, end=${end}): ${error?.message ?? 'unknown error'}`;
+                            failedProofs++;
+                        }
+                    }
+                    receipts.push({
+                        txHash,
+                        completeTx,
+                        proof,
+                        proofError,
+                        timestamp,
+                        blockNumber
+                    });
+                }
+                if (failedProofs > 0) {
+                    console.error(`appendWithProof completed with ${failedProofs} proof failures (batch=${batch.length})`);
+                }
+                return receipts;
+            } finally {
+                await snapshot.close();
+            }
+        });
+    }
+
+    async verifyProofOfPublication(proof) {
+        // Valid concern. We currently rely on Hypercore’s internal fully-remote-proof helper, which requires low-level storage access
+        const out = await remote.verify(this.#store.storage, proof);
+        if (!out) throw new Error('Proof of publication verification failed');
+        return out;
     }
 
     async getIndexerSequenceState() {
@@ -264,6 +314,7 @@ class State extends ReadyResource {
             return b4a.equals(initialization, safeWriteUInt32BE(0, 0))
         }
     }
+
     async getTransactionConfirmedLength(hash) {
         if (!isHexString(hash) || hash.length !== 64) {
             throw new Error("Invalid hash format");
@@ -1793,9 +1844,9 @@ class State extends ReadyResource {
         };
 
         /**
-         * Ensure that: 
-         * 1) writer key exists in registry (we can not unregister something that was not registered), 
-         * 2) matches the one in node entry , 
+         * Ensure that:
+         * 1) writer key exists in registry (we can not unregister something that was not registered),
+         * 2) matches the one in node entry ,
          * 3) belongs to the requester - this prevents unauthorized key removal
          */
         const writerKeyHasBeenRegistered = await this.#getRegisteredWriterKeyApply(batch, op.rao.iw.toString('hex'))
@@ -2930,7 +2981,7 @@ class State extends ReadyResource {
             batch,
             node
         );
-        
+
         // TODO: cover next 4 guards below with tests
         if (transferFeeTxOperationResult === null) {
             this.#safeLogApply(OperationType.TX, "Fee transfer operation failed completely.", node.from.key);
@@ -3388,7 +3439,7 @@ class State extends ReadyResource {
 
     /**
      * Retrieves the address assigned to a given writing key from the registry.
-     * 
+     *
      * @param {Object} batch - The current Hyperbee batch instance used for reading state.
      * @param {string} writingKey - The writing key in hex string format.
      * @returns {Buffer|null} The address buffer assigned to the writing key, or null if not registered.

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;
@@ -303,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}`);
@@ -424,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}`);
@@ -458,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}`);
@@ -682,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

@@ -19,6 +19,8 @@ class NetworkMessageBuilder {
     #issuerAddress;
     #resultCode;
     #data;
+    #proof;
+    #timestamp_ledger;
     #header;
     #payloadKey;
     #body;
@@ -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/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/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,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;
+};