trac-msb 0.2.13 → 0.2.15

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

@@ -19,8 +19,6 @@ class NetworkMessageBuilder {
     #issuerAddress;
     #resultCode;
     #data;
-    #proof;
-    #timestamp_ledger;
     #header;
     #payloadKey;
     #body;
@@ -87,9 +85,6 @@ 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.`);
         }
@@ -97,30 +92,6 @@ 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');
@@ -136,6 +107,76 @@ 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);
@@ -217,50 +258,21 @@ 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
         };
     }
@@ -269,6 +281,14 @@ 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,6 +13,47 @@ 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
@@ -20,11 +61,12 @@ class NetworkMessageDirector {
      * @param {string[]} capabilities
      * @returns {Promise<object>}
      */
-    async buildLivenessRequest(id, capabilities) {
+    async buildLivenessRequest(id, data, capabilities) {
         await this.#builder
             .setType(NetworkOperationType.LIVENESS_REQUEST)
             .setId(id)
             .setTimestamp()
+            .setData(data)
             .setCapabilities(capabilities)
             .buildPayload();
 
@@ -34,15 +76,17 @@ 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, capabilities, statusCode) {
+    async buildLivenessResponse(id, data, capabilities, statusCode) {
         await this.#builder
             .setType(NetworkOperationType.LIVENESS_RESPONSE)
             .setId(id)
             .setTimestamp()
+            .setData(data)
             .setCapabilities(capabilities)
             .setResultCode(statusCode)
             .buildPayload();
@@ -71,28 +115,18 @@ 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} resultCode
-     * @param {Buffer|null|undefined} proof
-     * @param {number|Date|null|undefined} timestamp - When transaction has been appended by the validator
+     * @param {number} statusCode
      * @returns {Promise<object>}
      */
-    async buildBroadcastTransactionResponse(id, capabilities, resultCode, proof = null, timestamp = null) {
+    async buildBroadcastTransactionResponse(id, capabilities, statusCode) {
         await this.#builder
             .setType(NetworkOperationType.BROADCAST_TRANSACTION_RESPONSE)
             .setId(id)
             .setTimestamp()
             .setCapabilities(capabilities)
-            .setProof(proof)
-            .setTimestampLedger(timestamp)
-            .setResultCode(resultCode)
+            .setResultCode(statusCode)
             .buildPayload();
 
         return this.#builder.getResult();

package/src/utils/Scheduler.js

@@ -42,6 +42,14 @@ 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,10 +1,8 @@
 import { OperationType as ApplyOperationType } from './protobuf/applyOperations.cjs';
-import networkV1Generated from './protobuf/networkV1.generated.cjs';
+import { MessageType as NetworkMessageType, ResultCode as NetworkResultCode } from './protobuf/network.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',
@@ -36,6 +34,8 @@ 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,68 +43,12 @@ 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,
-    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
+    SIGNATURE_INVALID: NetworkResultCode.RESULT_CODE_SIGNATURE_INVALID,
 });
 
 // Role managment constants
@@ -117,7 +61,6 @@ 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
@@ -166,13 +109,6 @@ 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: {
@@ -187,5 +123,3 @@ export const NETWORK_MESSAGE_TYPES = Object.freeze({
         NODE: 'nodeResponse'
     },
 });
-
-export const NETWORK_CAPABILITIES = Object.freeze(["protocols:v1:legacy"]);

package/src/utils/helpers.js

@@ -1,8 +1,7 @@
 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) {
@@ -96,11 +95,3 @@ 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/normalizers.js

@@ -3,7 +3,6 @@ import { normalizeHex } from './helpers.js';
 import { addressToBuffer, bufferToAddress } from '../core/state/utils/address.js';
 import b4a from 'b4a';
 import { bufferToBigInt } from './amountSerialization.js'
-import {isBootstrapDeployment, isRoleAccess, isTransaction, isTransfer} from './applyOperations.js';
 
 /**
  * Normalizes the payload for a transfer operation.
@@ -200,40 +199,3 @@ export function normalizeBootstrapDeploymentOperation(payload, config) {
         bdo: normalizedBdo
     };
 }
-
-/**
- * Normalizes an incoming partial operation message based on its operation type.
- *
- * @param {Object} message The raw incoming message.
- * @param {object} config The environment configuration object.
- * @returns {Object} Normalized payload.
- * @throws {Error} If message is invalid or operation type is unsupported.
- */
-export function normalizeMessageByOperationType(message, config) {
-    if (!message || typeof message !== 'object') {
-        throw new Error('Invalid message for normalization.');
-    }
-
-    const { type } = message;
-    if (!Number.isInteger(type) || type <= 0) {
-        throw new Error('Message type is missing or invalid.');
-    }
-
-    if (isRoleAccess(type)) {
-        return normalizeRoleAccessOperation(message, config);
-    }
-
-    if (isTransaction(type)) {
-        return normalizeTransactionOperation(message, config);
-    }
-
-    if (isBootstrapDeployment(type)) {
-        return normalizeBootstrapDeploymentOperation(message, config);
-    }
-
-    if (isTransfer(type)) {
-        return normalizeTransferOperation(message, config);
-    }
-
-    throw new Error(`Unsupported operation type for normalization: ${type}`);
-}