trac-msb 0.2.24 → 0.3.0-beta.1

package/src/utils/constants.js

@@ -1,10 +1,13 @@
-import { OperationType as ApplyOperationType } from './protobuf/applyOperations.cjs';
-import networkV1Generated from './protobuf/networkV1.generated.cjs';
+import applyOperationsGenerated from '../codecs/apply/applyOperations.generated.cjs';
+import networkV1Generated from '../codecs/network/v1/networkV1.generated.cjs';
+import consensusV1Generated from '../codecs/consensus/v1/consensusV1.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;
-
+const { OperationType: ApplyOperationType } = applyOperationsGenerated.apply.operations;
+const { MessageType: NetworkMessageType } = networkV1Generated.network.v1;
+const { MessageType: ConsensusMessageType } = consensusV1Generated.consensus.v1;
+const { ResultCode: SharedResultCode } = networkV1Generated.common.v1;
 //ATTENTION - THIS IS USED IN THE APPLY FUNCTION!
 export const EntryType = Object.freeze({
     ADMIN: 'admin',
@@ -16,6 +19,13 @@ export const EntryType = Object.freeze({
     INITIALIZATION: 'init',
     LICENSE_COUNT: 'lc',
     LICENSE_INDEX: 'li/',
+    EPOCH_CURRENT: '/epoch/current',
+    EPOCH: `/epoch/`,              // Epoch hashes are stored under `/epoch/<n>`
+    EPOCH_HASH: `/epochHash/`,     // Versioned epoch records are stored under `/epochHash/<epochHashHex>`
+    CONSENSUS_CONFIG_CURRENT: '/consensus/config/current',
+    CONSENSUS_CONFIG_RECORD: '/consensus/config/record/',
+    HTLC_ESCROW: '/htlc/escrow/',
+
 });
 
 //ATTENTION - THIS IS USED IN THE APPLY FUNCTION!
@@ -33,6 +43,12 @@ export const OperationType = Object.freeze({
     BOOTSTRAP_DEPLOYMENT: ApplyOperationType.BOOTSTRAP_DEPLOYMENT,
     TX: ApplyOperationType.TX,
     TRANSFER: ApplyOperationType.TRANSFER,
+    SET_EPOCH: ApplyOperationType.SET_EPOCH,
+    SET_GENESIS_EPOCH: ApplyOperationType.SET_GENESIS_EPOCH,
+    SET_CONSENSUS_CONFIG: ApplyOperationType.SET_CONSENSUS_CONFIG,
+    HTLC_LOCK: ApplyOperationType.HTLC_LOCK,
+    HTLC_CLAIM: ApplyOperationType.HTLC_CLAIM,
+    HTLC_REFUND: ApplyOperationType.HTLC_REFUND,
 });
 
 export const NetworkOperationType = Object.freeze({
@@ -42,71 +58,105 @@ export const NetworkOperationType = Object.freeze({
     BROADCAST_TRANSACTION_RESPONSE: NetworkMessageType.MESSAGE_TYPE_BROADCAST_TRANSACTION_RESPONSE,
 });
 
-export const ResultCode = Object.freeze({
-    UNSPECIFIED: NetworkResultCode.RESULT_CODE_UNSPECIFIED,
-    OK: NetworkResultCode.RESULT_CODE_OK,
-    INVALID_PAYLOAD: NetworkResultCode.RESULT_CODE_INVALID_PAYLOAD,
-    RATE_LIMITED: NetworkResultCode.RESULT_CODE_RATE_LIMITED,
-    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
+export const ConsensusOperationType = Object.freeze({
+    UNSPECIFIED: ConsensusMessageType.MESSAGE_TYPE_UNSPECIFIED,
+    PROOF_PROPOSAL: ConsensusMessageType.MESSAGE_TYPE_PROOF_PROPOSAL,
+    PROOF_PROPOSAL_APPROVAL: ConsensusMessageType.MESSAGE_TYPE_PROOF_PROPOSAL_APPROVAL,
+    REQUEST: ConsensusMessageType.MESSAGE_TYPE_REQUEST,
+    REPLY: ConsensusMessageType.MESSAGE_TYPE_REPLY,
+});
+
+export const ConsensusResultCode = Object.freeze({
+    UNSPECIFIED: SharedResultCode.RESULT_CODE_UNSPECIFIED,
+    OK: SharedResultCode.RESULT_CODE_OK,
+    INVALID_PAYLOAD: SharedResultCode.RESULT_CODE_INVALID_PAYLOAD,
+    UNEXPECTED_ERROR: SharedResultCode.RESULT_CODE_UNEXPECTED_ERROR,
+    SCHEMA_VALIDATION_FAILED: SharedResultCode.RESULT_CODE_CONSENSUS_SCHEMA_VALIDATION_FAILED,
+    BAD_PROTOCOL_VERSION: SharedResultCode.RESULT_CODE_CONSENSUS_BAD_PROTOCOL_VERSION,
+    WRONG_NETWORK_ID: SharedResultCode.RESULT_CODE_CONSENSUS_WRONG_NETWORK_ID,
+    CONSENSUS_CONFIG_MISMATCH: SharedResultCode.RESULT_CODE_CONSENSUS_CONFIG_MISMATCH,
+    VDF_PROOF_INVALID: SharedResultCode.RESULT_CODE_CONSENSUS_VDF_PROOF_INVALID,
+    ADDRESS_INVALID: SharedResultCode.RESULT_CODE_CONSENSUS_ADDRESS_INVALID,
+    PUBLIC_KEY_MISMATCH: SharedResultCode.RESULT_CODE_CONSENSUS_PUBLIC_KEY_MISMATCH,
+    PROPOSAL_SIGNATURE_INVALID: SharedResultCode.RESULT_CODE_CONSENSUS_PROPOSAL_SIGNATURE_INVALID,
+    RESPONSE_SIGNATURE_INVALID: SharedResultCode.RESULT_CODE_CONSENSUS_RESPONSE_SIGNATURE_INVALID,
+    APPROVAL_SIGNATURE_INVALID: SharedResultCode.RESULT_CODE_CONSENSUS_APPROVAL_SIGNATURE_INVALID,
+    OPERATION_TYPE_INVALID: SharedResultCode.RESULT_CODE_CONSENSUS_OPERATION_TYPE_INVALID,
+    RESPONSE_APPROVAL_INVALID: SharedResultCode.RESULT_CODE_CONSENSUS_RESPONSE_APPROVAL_INVALID,
+    EPOCH_INVALID: SharedResultCode.RESULT_CODE_CONSENSUS_EPOCH_INVALID,
+    PREVIOUS_EPOCH_RECORD_HASH_INVALID: SharedResultCode.RESULT_CODE_CONSENSUS_PREVIOUS_EPOCH_RECORD_HASH_INVALID,
+    INDEXER_ROLE_INVALID: SharedResultCode.RESULT_CODE_CONSENSUS_INDEXER_ROLE_INVALID,
+});
+
+export const NetworkResultCode = Object.freeze({
+    UNSPECIFIED: SharedResultCode.RESULT_CODE_UNSPECIFIED,
+    OK: SharedResultCode.RESULT_CODE_OK,
+    INVALID_PAYLOAD: SharedResultCode.RESULT_CODE_INVALID_PAYLOAD,
+    RATE_LIMITED: SharedResultCode.RESULT_CODE_RATE_LIMITED,
+    SIGNATURE_INVALID: SharedResultCode.RESULT_CODE_SIGNATURE_INVALID,
+    UNEXPECTED_ERROR: SharedResultCode.RESULT_CODE_UNEXPECTED_ERROR,
+    TIMEOUT: SharedResultCode.RESULT_CODE_TIMEOUT,
+    NODE_HAS_NO_WRITE_ACCESS: SharedResultCode.RESULT_CODE_NODE_HAS_NO_WRITE_ACCESS,
+    TX_ACCEPTED_PROOF_UNAVAILABLE: SharedResultCode.RESULT_CODE_TX_ACCEPTED_PROOF_UNAVAILABLE,
+    NODE_OVERLOADED: SharedResultCode.RESULT_CODE_NODE_OVERLOADED,
+    TX_ALREADY_PENDING: SharedResultCode.RESULT_CODE_TX_ALREADY_PENDING,
+    OPERATION_TYPE_UNKNOWN: SharedResultCode.RESULT_CODE_OPERATION_TYPE_UNKNOWN,
+    SCHEMA_VALIDATION_FAILED: SharedResultCode.RESULT_CODE_SCHEMA_VALIDATION_FAILED,
+    REQUESTER_ADDRESS_INVALID: SharedResultCode.RESULT_CODE_REQUESTER_ADDRESS_INVALID,
+    REQUESTER_PUBLIC_KEY_INVALID: SharedResultCode.RESULT_CODE_REQUESTER_PUBLIC_KEY_INVALID,
+    TX_HASH_MISMATCH: SharedResultCode.RESULT_CODE_TX_HASH_MISMATCH,
+    TX_SIGNATURE_INVALID: SharedResultCode.RESULT_CODE_TX_SIGNATURE_INVALID,
+    TX_EXPIRED: SharedResultCode.RESULT_CODE_TX_EXPIRED,
+    TX_ALREADY_EXISTS: SharedResultCode.RESULT_CODE_TX_ALREADY_EXISTS,
+    OPERATION_ALREADY_COMPLETED: SharedResultCode.RESULT_CODE_OPERATION_ALREADY_COMPLETED,
+    REQUESTER_NOT_FOUND: SharedResultCode.RESULT_CODE_REQUESTER_NOT_FOUND,
+    INSUFFICIENT_FEE_BALANCE: SharedResultCode.RESULT_CODE_INSUFFICIENT_FEE_BALANCE,
+    EXTERNAL_BOOTSTRAP_EQUALS_MSB_BOOTSTRAP: SharedResultCode.RESULT_CODE_EXTERNAL_BOOTSTRAP_EQUALS_MSB_BOOTSTRAP,
+    SELF_VALIDATION_FORBIDDEN: SharedResultCode.RESULT_CODE_SELF_VALIDATION_FORBIDDEN,
+    ROLE_NODE_ENTRY_NOT_FOUND: SharedResultCode.RESULT_CODE_ROLE_NODE_ENTRY_NOT_FOUND,
+    ROLE_NODE_ALREADY_WRITER: SharedResultCode.RESULT_CODE_ROLE_NODE_ALREADY_WRITER,
+    ROLE_NODE_NOT_WHITELISTED: SharedResultCode.RESULT_CODE_ROLE_NODE_NOT_WHITELISTED,
+    ROLE_NODE_NOT_WRITER: SharedResultCode.RESULT_CODE_ROLE_NODE_NOT_WRITER,
+    ROLE_NODE_IS_INDEXER: SharedResultCode.RESULT_CODE_ROLE_NODE_IS_INDEXER,
+    ROLE_ADMIN_ENTRY_MISSING: SharedResultCode.RESULT_CODE_ROLE_ADMIN_ENTRY_MISSING,
+    ROLE_INVALID_RECOVERY_CASE: SharedResultCode.RESULT_CODE_ROLE_INVALID_RECOVERY_CASE,
+    ROLE_UNKNOWN_OPERATION: SharedResultCode.RESULT_CODE_ROLE_UNKNOWN_OPERATION,
+    ROLE_INVALID_WRITER_KEY: SharedResultCode.RESULT_CODE_ROLE_INVALID_WRITER_KEY,
+    ROLE_INSUFFICIENT_FEE_BALANCE: SharedResultCode.RESULT_CODE_ROLE_INSUFFICIENT_FEE_BALANCE,
+    MSB_BOOTSTRAP_MISMATCH: SharedResultCode.RESULT_CODE_MSB_BOOTSTRAP_MISMATCH,
+    EXTERNAL_BOOTSTRAP_NOT_DEPLOYED: SharedResultCode.RESULT_CODE_EXTERNAL_BOOTSTRAP_NOT_DEPLOYED,
+    EXTERNAL_BOOTSTRAP_TX_MISSING: SharedResultCode.RESULT_CODE_EXTERNAL_BOOTSTRAP_TX_MISSING,
+    EXTERNAL_BOOTSTRAP_MISMATCH: SharedResultCode.RESULT_CODE_EXTERNAL_BOOTSTRAP_MISMATCH,
+    BOOTSTRAP_ALREADY_EXISTS: SharedResultCode.RESULT_CODE_BOOTSTRAP_ALREADY_EXISTS,
+    TRANSFER_RECIPIENT_ADDRESS_INVALID: SharedResultCode.RESULT_CODE_TRANSFER_RECIPIENT_ADDRESS_INVALID,
+    TRANSFER_RECIPIENT_PUBLIC_KEY_INVALID: SharedResultCode.RESULT_CODE_TRANSFER_RECIPIENT_PUBLIC_KEY_INVALID,
+    TRANSFER_AMOUNT_TOO_LARGE: SharedResultCode.RESULT_CODE_TRANSFER_AMOUNT_TOO_LARGE,
+    TRANSFER_SENDER_NOT_FOUND: SharedResultCode.RESULT_CODE_TRANSFER_SENDER_NOT_FOUND,
+    TRANSFER_INSUFFICIENT_BALANCE: SharedResultCode.RESULT_CODE_TRANSFER_INSUFFICIENT_BALANCE,
+    TRANSFER_RECIPIENT_BALANCE_OVERFLOW: SharedResultCode.RESULT_CODE_TRANSFER_RECIPIENT_BALANCE_OVERFLOW,
+    TX_HASH_INVALID_FORMAT: SharedResultCode.RESULT_CODE_TX_HASH_INVALID_FORMAT,
+    INTERNAL_ENQUEUE_VALIDATION_FAILED: SharedResultCode.RESULT_CODE_INTERNAL_ENQUEUE_VALIDATION_FAILED,
+    TX_COMMITTED_RECEIPT_MISSING: SharedResultCode.RESULT_CODE_TX_COMMITTED_RECEIPT_MISSING,
+    VALIDATOR_RESPONSE_TX_TYPE_INVALID: SharedResultCode.RESULT_CODE_VALIDATOR_RESPONSE_TX_TYPE_INVALID,
+    VALIDATOR_RESPONSE_TX_TYPE_UNKNOWN: SharedResultCode.RESULT_CODE_VALIDATOR_RESPONSE_TX_TYPE_UNKNOWN,
+    VALIDATOR_RESPONSE_TX_TYPE_UNSUPPORTED: SharedResultCode.RESULT_CODE_VALIDATOR_RESPONSE_TX_TYPE_UNSUPPORTED,
+    VALIDATOR_RESPONSE_SCHEMA_INVALID: SharedResultCode.RESULT_CODE_VALIDATOR_RESPONSE_SCHEMA_INVALID,
+    PENDING_REQUEST_MISSING_TX_DATA: SharedResultCode.RESULT_CODE_PENDING_REQUEST_MISSING_TX_DATA,
+    PROOF_PAYLOAD_MISMATCH: SharedResultCode.RESULT_CODE_PROOF_PAYLOAD_MISMATCH,
+    VALIDATOR_WRITER_KEY_NOT_REGISTERED: SharedResultCode.RESULT_CODE_VALIDATOR_WRITER_KEY_NOT_REGISTERED,
+    VALIDATOR_ADDRESS_MISMATCH: SharedResultCode.RESULT_CODE_VALIDATOR_ADDRESS_MISMATCH,
+    VALIDATOR_NODE_ENTRY_NOT_FOUND: SharedResultCode.RESULT_CODE_VALIDATOR_NODE_ENTRY_NOT_FOUND,
+    VALIDATOR_NODE_NOT_WRITER: SharedResultCode.RESULT_CODE_VALIDATOR_NODE_NOT_WRITER,
+    VALIDATOR_WRITER_KEY_MISMATCH: SharedResultCode.RESULT_CODE_VALIDATOR_WRITER_KEY_MISMATCH,
+    VALIDATOR_TX_OBJECT_INVALID: SharedResultCode.RESULT_CODE_VALIDATOR_TX_OBJECT_INVALID,
+    VALIDATOR_VA_MISSING: SharedResultCode.RESULT_CODE_VALIDATOR_VA_MISSING,
+    TX_INVALID_PAYLOAD: SharedResultCode.RESULT_CODE_TX_INVALID_PAYLOAD
 });
 
+// TODO: Refactor network code to use NetworkResultCode instead of "old" ResultCode
+//       Then, remove the line below 
+export const ResultCode = NetworkResultCode; // TO BE DEPRECATED
+
 // Role managment constants
 export const EventType = Object.freeze({
     WRITER_EVENT: 'writer-event',
@@ -115,15 +165,25 @@ export const EventType = Object.freeze({
     WRITABLE: 'writable',
     UNWRITABLE: 'unwritable',
     WARNING: 'warning',
-    VALIDATOR_CONNECTION_READY: 'validator-connection-ready',
-    VALIDATOR_CONNECTION_TIMEOUT: 'validator-connection-timeout',
     VALIDATOR_HEALTH_CHECK: 'validator-health-check',
 });
 
 // Role managment constants
 export const CustomEventType = Object.freeze({
     IS_INDEXER: 'msb:is-indexer',
-    UNWRITABLE: 'msb:unwritable'
+    UNWRITABLE: 'msb:unwritable',
+    IS_NON_INDEXER: 'msb:is-non-indexer',
+    EPOCH_PROPOSAL_SUBMITTED: 'msb:epoch_proposal_submitted',
+    EPOCH_PROPOSAL_RECEIVED: 'msb:epoch_proposal_received',
+    EPOCH_PROPOSAL_VALIDATION_SUCCESS: 'msb:epoch_proposal_validation_success',
+    EPOCH_PROPOSAL_VALIDATION_FAILURE: 'msb:epoch_proposal_validation_failure',
+    EPOCH_PROPOSAL_APPROVAL_RECEIVED: 'msb:epoch_proposal_approval_received',
+    EPOCH_PROPOSAL_APPROVAL_SUCCESS: 'msb:epoch_proposal_approval_success',
+    EPOCH_PROPOSAL_APPROVAL_FAILURE: 'msb:epoch_proposal_approval_failure',
+    CONSENSUS_PEER_BAN_REQUESTED: 'msb:consensus_peer_ban_requested',
+    GENESIS_EPOCH_CREATED: 'msb:genesis_epoch_created',
+    EPOCH_CREATED: 'msb:epoch_created',
+    CONSENSUS_CONFIG_CHANGED: 'msb:consensus_config_changed'
 });
 
 // Token
@@ -144,19 +204,59 @@ export const ACK_INTERVAL = 1_000;
 export const AUTOBASE_VALUE_ENCODING = 'binary';
 export const HYPERBEE_KEY_ENCODING = 'ascii';
 export const HYPERBEE_VALUE_ENCODING = 'binary';
-// check.js
+// StateValidationSchema.js
 
 //ATTENTION - THIS IS USED IN THE APPLY FUNCTION!
+// Apply schema validation
+export const PUBLIC_KEY_LENGTH = 32
 export const WRITER_BYTE_LENGTH = 32;
 export const BOOTSTRAP_BYTE_LENGTH = 32;
 export const CHANNEL_BYTE_LENGTH = 32;
 export const NONCE_BYTE_LENGTH = 32;
 export const HASH_BYTE_LENGTH = 32;
+export const HTLC_LOCK_ID_BYTE_LENGTH = 32;
+export const HTLC_PREIMAGE_BYTE_LENGTH = 32;
+export const HTLC_THRESHOLD_BYTE_LENGTH = 1;
+export const HTLC_METADATA_MAX_BYTE_LENGTH = 1024;
 export const BALANCE_BYTE_LENGTH = 16;
 export const SIGNATURE_BYTE_LENGTH = 64;
+export const PEER_PUBLIC_KEY_HEX_LENGTH = 64;
 export const AMOUNT_BYTE_LENGTH = 16;
-export const MIN_SAFE_VALIDATION_INTEGER = 0x00000001;
-export const MAX_SAFE_VALIDATION_INTEGER = 0xFFFFFFFF;
+export const UINT16_MAX = 0xFFFF;
+export const UINT32_MAX = 0xFFFFFFFF;
+
+// consensus
+export const NETWORK_ID_BYTE_LENGTH = 2; // 2 BYTES - UINT16
+export const EPOCH_BYTE_LENGTH = 8; // 8 BYTES - UINT64
+// Peer hints advance the election clock by at most one step per message.
+export const VDF_DIFFICULTY_SIZE = 4; // 4 BYTES - UINT32
+export const VDF_DISCRIMINANT_SIZE = 2; // 2 BYTES - UINT16
+export const MAX_VDF_DIFFICULTY = UINT32_MAX;
+export const CONSENSUS_CONFIG_INDEX_SIZE = 4 // 4 BYTES - UINT32
+export const CONSENSUS_CONFIG_SCHEMA_VERSION_BYTE_LENGTH = 1;
+export const CONSENSUS_CONFIG_DATA_MAX_SIZE = 3072; // 3 KiB
+export const SET_EPOCH_DATA_MAX_SIZE = 3072; // 3 KiB
+export const VDF_PROOF_BYTE_LENGTHS = Object.freeze({
+    1024: 260,
+    2048: 516,
+    4096: 1028
+});
+export const EPOCH_APPENDER_SELECTION_MAX_COUNTER = (1n << 64n) - 1n;
+export const CONSENSUS_REQUEST_ID_MAX_LENGTH = 64;
+export const CONSENSUS_SESSION_ID_MAX_LENGTH = 64;
+export const HASH_HEX_LENGTH = HASH_BYTE_LENGTH * 2;
+export const EPOCH_APPENDER_SELECTION_COUNTER_STEP = 1024n;
+export const EPOCH_APPENDER_SELECTION_COUNTER_LIMIT = EPOCH_APPENDER_SELECTION_MAX_COUNTER - EPOCH_APPENDER_SELECTION_COUNTER_STEP;
+
+// These permanent consensus IDs select the config, SET_EPOCH and genesis formats.
+// Assign higher IDs to new versions; parameter updates retain the current ID.
+export const ConsensusVersion = Object.freeze({
+    VDF_V1: 1,
+});
+
+// HTLC constants
+export const HTLC_MAX_SIGNERS = 8;
+export const HTLC_MIN_LOCK_DURATION_EPOCHS = 1n;
 
 export const LICENSE_BYTE_LENGTH = 4;
 
@@ -169,6 +269,7 @@ 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;
+export const CONSENSUS_MESSAGE_MAX_BYTE_SIZE = 4096;
 
 // Transaction Commit Service
 export const TRANSACTION_COMMIT_SERVICE_BUFFER_SIZE = 1500;

package/src/utils/helpers.js

@@ -1,7 +1,5 @@
 import b4a from "b4a";
 import tracCryptoApi from "trac-crypto-api";
-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)
 
@@ -49,29 +47,6 @@ export const safeJsonParse = (str) => {
     return undefined;
 }
 
-export async function getFormattedIndexersWithAddresses(state, config) {
-    const indexers = await state.getIndexersEntry();
-    const formatted = indexers.map((entry) => ({
-        writingKey: b4a.toString(entry.key, "hex"),
-    }));
-
-    const results = await Promise.all(
-        formatted.map(async (entry) => {            
-            const address = bufferToAddress(
-                await state.getSigned(EntryType.WRITER_ADDRESS + entry.writingKey),
-                config.addressPrefix
-            );
-
-            return {
-                ...entry,
-                address,
-            };
-        })
-    );
-
-    return results;
-}
-
 export function formatIndexersEntry(indexersEntry, addressLength) {
 
     const count = indexersEntry[0];

package/src/utils/htlcLock.js

@@ -0,0 +1,122 @@
+import b4a from 'b4a';
+import tracCryptoApi from 'trac-crypto-api';
+
+import {createMessage, isZeroBuffer, uint8ToBuffer, uint32ToBuffer} from './buffer.js';
+import {
+    AMOUNT_BYTE_LENGTH,
+    EPOCH_BYTE_LENGTH,
+    HASH_BYTE_LENGTH,
+    HTLC_MAX_SIGNERS,
+    HTLC_METADATA_MAX_BYTE_LENGTH,
+    HTLC_THRESHOLD_BYTE_LENGTH,
+    NONCE_BYTE_LENGTH,
+    OperationType,
+    PUBLIC_KEY_LENGTH,
+    UINT32_MAX,
+} from './constants.js';
+
+const EMPTY_METADATA = b4a.alloc(0);
+
+function requireBuffer(value, length, field, allowZero = false) {
+    if (!b4a.isBuffer(value) || value.length !== length || (!allowZero && isZeroBuffer(value))) {
+        throw new Error(`${field} must be a${allowZero ? '' : ' non-zero'} ${length}-byte buffer.`);
+    }
+}
+
+/**
+ * Creates the canonical message committed by every HTLC lock authorizer.
+ * Signatures and validator completion fields are intentionally excluded.
+ */
+export function createHtlcLockSigningMessage(networkId, locker, operation) {
+    if (!Number.isInteger(networkId) || networkId < 1 || networkId > UINT32_MAX) {
+        throw new Error('HTLC network id must be an unsigned non-zero 32-bit integer.');
+    }
+    if (!operation || !Array.isArray(operation.ss)) {
+        throw new Error('HTLC lock operation and signer set are required.');
+    }
+    if (!b4a.isBuffer(locker) || locker.length === 0) {
+        throw new Error('HTLC locker must be a non-empty address buffer.');
+    }
+    if (operation.ss.length < 1 || operation.ss.length > HTLC_MAX_SIGNERS) {
+        throw new Error(`HTLC signer set must contain between 1 and ${HTLC_MAX_SIGNERS} public keys.`);
+    }
+
+    requireBuffer(operation.txv, HASH_BYTE_LENGTH, 'HTLC transaction validity');
+    requireBuffer(operation.ca, locker.length, 'HTLC claim address');
+    requireBuffer(operation.ra, locker.length, 'HTLC refund address');
+    requireBuffer(operation.am, AMOUNT_BYTE_LENGTH, 'HTLC amount');
+    requireBuffer(operation.fa, AMOUNT_BYTE_LENGTH, 'HTLC fee amount', true);
+    requireBuffer(operation.hl, HASH_BYTE_LENGTH, 'HTLC hashlock');
+    requireBuffer(operation.re, EPOCH_BYTE_LENGTH, 'HTLC refund epoch');
+    requireBuffer(operation.th, HTLC_THRESHOLD_BYTE_LENGTH, 'HTLC threshold');
+    requireBuffer(operation.in, NONCE_BYTE_LENGTH, 'HTLC nonce');
+    if (operation.fr !== undefined) requireBuffer(operation.fr, locker.length, 'HTLC fee recipient');
+    if (operation.md !== undefined && (
+        !b4a.isBuffer(operation.md) || operation.md.length === 0 || operation.md.length > HTLC_METADATA_MAX_BYTE_LENGTH
+    )) {
+        throw new Error(`HTLC metadata must be a buffer containing 1 to ${HTLC_METADATA_MAX_BYTE_LENGTH} bytes.`);
+    }
+
+    const feeIsZero = isZeroBuffer(operation.fa);
+    if (feeIsZero === (operation.fr !== undefined)) {
+        throw new Error('HTLC fee recipient must be present exactly when the fee amount is non-zero.');
+    }
+
+    const signerKeys = new Set();
+    for (let index = 0; index < operation.ss.length; index++) {
+        const signer = operation.ss[index];
+        requireBuffer(signer, PUBLIC_KEY_LENGTH, `HTLC signer ${index}`);
+        const signerHex = b4a.toString(signer, 'hex');
+        if (signerKeys.has(signerHex)) throw new Error('HTLC signer set must not contain duplicates.');
+        signerKeys.add(signerHex);
+        if (index > 1 && b4a.compare(operation.ss[index - 1], signer) >= 0) {
+            throw new Error('HTLC cosigner public keys must be sorted by raw bytes.');
+        }
+    }
+
+    const threshold = operation.th[0];
+    if (threshold < 1 || threshold > operation.ss.length) {
+        throw new Error('HTLC threshold must be between one and the signer-set size.');
+    }
+
+    return createMessage(
+        networkId,
+        locker,
+        operation.txv,
+        operation.ca,
+        operation.ra,
+        operation.am,
+        operation.fa,
+        operation.fr ?? b4a.alloc(locker.length),
+        operation.hl,
+        operation.re,
+        uint32ToBuffer(operation.md?.length ?? 0),
+        operation.md ?? EMPTY_METADATA,
+        uint8ToBuffer(operation.ss.length),
+        ...operation.ss,
+        operation.th,
+        operation.in,
+        OperationType.HTLC_LOCK
+    );
+}
+
+/**
+ * Match signatures to cosigner keys using Bitcoin-style forward-only scanning.
+ * Both arrays must be in signer-set order; omitted cosigners need no placeholder.
+ */
+export function verifyOrderedHtlcCosignerSignatures(signatures, transactionHash, signerSet) {
+    if (!Array.isArray(signatures) || !Array.isArray(signerSet)) return false;
+
+    let signerIndex = 1;
+    for (const signature of signatures) {
+        let matched = false;
+        while (signerIndex < signerSet.length) {
+            matched = tracCryptoApi.signature.verify(signature, transactionHash, signerSet[signerIndex]);
+            signerIndex++;
+            if (matched) break;
+        }
+        if (!matched) return false;
+    }
+
+    return true;
+}

package/src/utils/logger.js

@@ -1,25 +1,31 @@
 export class Logger {
     #config
+
     constructor(config) {
         this.#config = config;
     }
 
+    #format(message) {
+        const timestamp = this.#config.enableLogTimestamp ? `[${new Date().toISOString()}] ` : '';
+        return `${timestamp}${message}`;
+    }
+
     info(message) {
-        console.log("i: " + message);
+        console.log(this.#format("i: " + message));
     }
 
     debug(message) {
         if (this.#config.debug) {
-            console.debug("d: " + message);
+            console.debug(this.#format("d: " + message));
         }
     }
 
     error(message) {
-        console.error("e: " + message);
+        console.error(this.#format("e: " + message));
     }
 
     warn(message) {
-        console.warn("w: " + message);
+        console.warn(this.#format("w: " + message));
     }
 
 }

package/src/utils/migrationUtils.js

@@ -3,6 +3,7 @@ import { isAddressValid } from '../core/state/utils/address.js';
 import tracCryptoApi from 'trac-crypto-api';
 import b4a from 'b4a';
 import { ZERO_LICENSE } from '../core/state/utils/nodeEntry.js';
+import { PUBLIC_KEY_LENGTH } from './constants.js';
 
 export async function validateAddressFromIncomingFile(stateInstance, config, address, adminEntry) {
     if (!isAddressValid(address, config.addressPrefix)) {
@@ -11,7 +12,7 @@ export async function validateAddressFromIncomingFile(stateInstance, config, add
 
     const publicKey = tracCryptoApi.address.decode(address);
 
-    if (!publicKey || publicKey.length !== 32) {
+    if (!publicKey || publicKey.length !== PUBLIC_KEY_LENGTH) {
         throw new Error(`Invalid public key: '${address}'. Please ensure all addresses are valid.`);
     }
 

package/src/utils/normalizers.js

@@ -201,6 +201,107 @@ export function normalizeBootstrapDeploymentOperation(payload, config) {
     };
 }
 
+/**
+ * Normalizes the payload for an HTLC lock operation.
+ *
+ * @param {Object} payload The raw payload for the HTLC lock operation.
+ * @param {object} config The environment configuration object.
+ * @returns {Object} A normalized payload with address converted to buffer and hex values normalized.
+ */
+export function normalizeHtlcLockOperation(payload, config) {
+    if (!payload || typeof payload !== 'object' || !payload.hlo) {
+        throw new Error('Invalid payload for HTLC lock operation normalization.');
+    }
+    const { type, address, hlo } = payload;
+    if (
+        type !== OperationType.HTLC_LOCK ||
+        !address ||
+        !hlo.tx || !hlo.txv || !hlo.ca || !hlo.ra ||
+        !hlo.am || !hlo.fa || !hlo.hl || !hlo.re ||
+        !Array.isArray(hlo.ss) || !hlo.th || !Array.isArray(hlo.cs) ||
+        !hlo.in || !hlo.is
+    ) {
+        throw new Error('Missing required fields in HTLC lock operation payload.');
+    }
+
+    const normalizedHlo = {
+        tx: normalizeHex(hlo.tx),
+        txv: normalizeHex(hlo.txv),
+        ca: addressToBuffer(hlo.ca, config.addressPrefix),
+        ra: addressToBuffer(hlo.ra, config.addressPrefix),
+        am: normalizeHex(hlo.am),
+        fa: normalizeHex(hlo.fa),
+        hl: normalizeHex(hlo.hl),
+        re: normalizeHex(hlo.re),
+        ss: hlo.ss.map(normalizeHex),
+        th: normalizeHex(hlo.th),
+        cs: hlo.cs.map(normalizeHex),
+        in: normalizeHex(hlo.in),
+        is: normalizeHex(hlo.is)
+    };
+    if (hlo.fr !== undefined) normalizedHlo.fr = addressToBuffer(hlo.fr, config.addressPrefix);
+    if (hlo.md !== undefined) normalizedHlo.md = normalizeHex(hlo.md);
+
+    return {
+        type,
+        address: addressToBuffer(address, config.addressPrefix),
+        hlo: normalizedHlo
+    };
+}
+
+export function normalizeHtlcClaimOperation(payload, config) {
+    if (!payload || typeof payload !== 'object' || !payload.hco) {
+        throw new Error('Invalid payload for HTLC claim operation normalization.');
+    }
+    const {type, address, hco} = payload;
+    if (
+        type !== OperationType.HTLC_CLAIM ||
+        !address || !hco.tx || !hco.txv || !hco.li ||
+        !hco.pi || !hco.in || !hco.is
+    ) {
+        throw new Error('Missing required fields in HTLC claim operation payload.');
+    }
+
+    return {
+        type,
+        address: addressToBuffer(address, config.addressPrefix),
+        hco: {
+            tx: normalizeHex(hco.tx),
+            txv: normalizeHex(hco.txv),
+            li: normalizeHex(hco.li),
+            pi: normalizeHex(hco.pi),
+            in: normalizeHex(hco.in),
+            is: normalizeHex(hco.is)
+        }
+    };
+}
+
+export function normalizeHtlcRefundOperation(payload, config) {
+    if (!payload || typeof payload !== 'object' || !payload.hro) {
+        throw new Error('Invalid payload for HTLC refund operation normalization.');
+    }
+    const {type, address, hro} = payload;
+    if (
+        type !== OperationType.HTLC_REFUND ||
+        !address || !hro.tx || !hro.txv || !hro.li ||
+        !hro.in || !hro.is
+    ) {
+        throw new Error('Missing required fields in HTLC refund operation payload.');
+    }
+
+    return {
+        type,
+        address: addressToBuffer(address, config.addressPrefix),
+        hro: {
+            tx: normalizeHex(hro.tx),
+            txv: normalizeHex(hro.txv),
+            li: normalizeHex(hro.li),
+            in: normalizeHex(hro.in),
+            is: normalizeHex(hro.is)
+        }
+    };
+}
+
 /**
  * Normalizes an incoming partial operation message based on its operation type.
  *
@@ -235,5 +336,17 @@ export function normalizeMessageByOperationType(message, config) {
         return normalizeTransferOperation(message, config);
     }
 
+    if (type === OperationType.HTLC_LOCK) {
+        return normalizeHtlcLockOperation(message, config);
+    }
+
+    if (type === OperationType.HTLC_CLAIM) {
+        return normalizeHtlcClaimOperation(message, config);
+    }
+
+    if (type === OperationType.HTLC_REFUND) {
+        return normalizeHtlcRefundOperation(message, config);
+    }
+
     throw new Error(`Unsupported operation type for normalization: ${type}`);
 }