trac-msb 0.2.7 → 0.2.9

package/src/core/network/protocols/legacy/NetworkMessageRouter.js

@@ -0,0 +1,84 @@
+import b4a from "b4a";
+import GetRequestHandler from "./handlers/GetRequestHandler.js";
+import ResponseHandler from "./handlers/ResponseHandler.js";
+import RoleOperationHandler from "../shared/handlers/RoleOperationHandler.js";
+import SubnetworkOperationHandler from "../shared/handlers/SubnetworkOperationHandler.js";
+import TransferOperationHandler from "../shared/handlers/TransferOperationHandler.js";
+import { NETWORK_MESSAGE_TYPES } from '../../../../utils/constants.js';
+import * as operation from '../../../../utils/applyOperations.js';
+import State from "../../../state/State.js";
+import PeerWallet from "trac-wallet";
+
+class NetworkMessageRouter {
+    #handlers;
+    #config;
+
+    /**
+     * @param {State} state
+     * @param {PeerWallet} wallet
+     * @param {TransactionRateLimiterService} rateLimiterService
+     * @param {TransactionPoolService} txPoolService
+     * @param {ConnectionManager} connectionManager
+     * @param {object} config
+     **/
+    constructor(state, wallet, rateLimiterService, txPoolService, connectionManager, config) {
+        this.#config = config;
+
+        this.#handlers = {
+            get: new GetRequestHandler(wallet, state),
+            response: new ResponseHandler(state, wallet, connectionManager, this.#config),
+            roleTransaction: new RoleOperationHandler(state, wallet, rateLimiterService, txPoolService, this.#config),
+            subNetworkTransaction: new SubnetworkOperationHandler(state, wallet, rateLimiterService, txPoolService, this.#config),
+            tracNetworkTransaction: new TransferOperationHandler(state, wallet, rateLimiterService, txPoolService, this.#config),
+        }
+    }
+
+    // NOTE: messageProtomux can be deleted, ad this is a session, and we can extract this from connection
+    async route(incomingMessage, connection, messageProtomux) {
+        const channelString = b4a.toString(this.#config.channel, 'utf8');
+        if (this.#isGetRequest(incomingMessage)) {
+            await this.#handlers.get.handle(incomingMessage, messageProtomux, connection, channelString);
+        }
+        else if (this.#isResponse(incomingMessage)) {
+            await this.#handlers.response.handle(incomingMessage, connection, channelString);
+        }
+        else if (this.#isRoleAccessOperation(incomingMessage)) {
+            await this.#handlers.roleTransaction.handle(incomingMessage, connection);
+        }
+        else if (this.#isSubnetworkOperation(incomingMessage)) {
+            await this.#handlers.subNetworkTransaction.handle(incomingMessage, connection);
+        }
+        else if (this.#isTransferOperation(incomingMessage)) {
+            await this.#handlers.tracNetworkTransaction.handle(incomingMessage, connection);
+        }
+        else {
+            throw new Error(`Failed to route message. Pubkey of requester is ${connection.remotePublicKey ? b4a.toString(connection.remotePublicKey, 'hex') : 'unknown'}`);
+        }
+
+    }
+
+    #isGetRequest(message) {
+        return Object.values(NETWORK_MESSAGE_TYPES.GET).includes(message);
+    }
+
+
+    #isResponse(message) {
+        return Object.values(NETWORK_MESSAGE_TYPES.RESPONSE).includes(message.op);
+    }
+
+    #isRoleAccessOperation(message) {
+        return operation.isRoleAccess(message.type)
+    }
+
+    #isSubnetworkOperation(message) {
+        return operation.isTransaction(message.type) ||
+            operation.isBootstrapDeployment(message.type)
+    }
+
+    #isTransferOperation(message) {
+        return operation.isTransfer(message.type)
+    }
+}
+
+
+export default NetworkMessageRouter;

package/src/core/network/protocols/legacy/handlers/GetRequestHandler.js

@@ -0,0 +1,53 @@
+import { NETWORK_MESSAGE_TYPES } from '../../../../../utils/constants.js';
+import PeerWallet from 'trac-wallet';
+import b4a from 'b4a';
+
+class GetRequestHandler {
+    #wallet;
+    #state;
+
+    constructor(wallet, state) {
+        this.#wallet = wallet;
+        this.#state = state;
+    }
+
+    get state() {
+        return this.#state;
+    }
+
+    async handle(message, messageProtomux, connection, channelString) {
+        switch (message) {
+            case NETWORK_MESSAGE_TYPES.GET.VALIDATOR:
+                await this.handleGetValidatorResponse(messageProtomux, connection, channelString);
+                break;
+            default:
+                throw new Error(`Unhandled GET type: ${message}`);
+        }
+    }
+
+    async handleGetValidatorResponse(messageProtomux, connection, channelString) {
+        const nonce = PeerWallet.generateNonce().toString('hex');
+        const payload = {
+            op: 'validatorResponse',
+            wk: this.state.writingKey.toString('hex'),
+            address: this.#wallet.address,
+            nonce: nonce,
+            channel: channelString,
+            issuer: connection.remotePublicKey.toString('hex'),
+            timestamp: Date.now(),
+        };
+
+
+        const hashInput = b4a.from(JSON.stringify(payload), 'utf8');
+        const hash = await PeerWallet.blake3(hashInput);
+        const sig = this.#wallet.sign(hash);
+
+        const responseMessage = {
+            ...payload,
+            sig: sig.toString('hex'),
+        };
+        messageProtomux.send(responseMessage);
+    }
+}
+
+export default GetRequestHandler;

package/src/core/network/protocols/legacy/handlers/ResponseHandler.js

@@ -0,0 +1,37 @@
+import ValidatorResponse from '../validators/ValidatorResponse.js';
+import PeerWallet from 'trac-wallet';
+
+class ResponseHandler {
+    #responseValidator;
+    #connectionManager;
+
+    
+    constructor(state, wallet, connectionManager ,config) {
+        this.#responseValidator = new ValidatorResponse(state, wallet, config);
+        this.#connectionManager = connectionManager;
+
+    }
+
+    async handle(message, connection, channelString) {
+        await this.#handleValidatorResponse(message, connection, channelString);
+    }
+
+    async #handleValidatorResponse(message, connection, channelString) {
+        const isValid = await this.#responseValidator.validate(message, channelString);
+        if (isValid) {
+            const validatorAddressString = message.address;
+            const validatorPublicKey = PeerWallet.decodeBech32m(validatorAddressString);
+
+            if (this.#connectionManager.connected(validatorPublicKey)) {
+                return;
+                // TODO: What we should return? Or maybe we should throw?
+            }
+
+            this.#connectionManager.addValidator(validatorPublicKey, connection)
+        } else {
+            throw new Error("Validator response verification failed");
+        }
+    }
+}
+
+export default ResponseHandler;

package/src/core/network/{messaging → protocols/legacy}/validators/ValidatorResponse.js

@@ -2,8 +2,8 @@ import b4a from 'b4a';
 import BaseResponse from './base/BaseResponse.js';
 class ValidatorResponse extends BaseResponse {
 
-    constructor(state, wallet) {
-        super(state, wallet);
+    constructor(state, wallet, config) {
+        super(state, wallet, config);
     }
 
     async validate(message, channelString) {

package/src/core/network/{messaging → protocols/legacy}/validators/base/BaseResponse.js

@@ -1,7 +1,6 @@
 import b4a from 'b4a';
 import PeerWallet from 'trac-wallet';
-import { bufferToAddress } from '../../../../state/utils/address.js';
-import { blake3Hash } from '../../../../../utils/crypto.js';
+import State from '../../../../../state/State.js';
 
 /*
     BaseResponse class for handling common validation logic for network responses.
@@ -10,10 +9,18 @@ import { blake3Hash } from '../../../../../utils/crypto.js';
 class BaseResponse {
     #wallet;
     #state;
+    #config
 
-    constructor(state, wallet) {
+    /**
+     * 
+     * @param {State} state 
+     * @param {PeerWallet} wallet 
+     * @param {object} config
+     */
+    constructor(state, wallet, config) {
         this.#state = state;
         this.#wallet = wallet;
+        this.#config = config;
     }
 
     get state() {
@@ -63,8 +70,7 @@ class BaseResponse {
 
                 break;
             default:
-                const addressString = bufferToAddress(message.address);
-                publicKey = PeerWallet.decodeBech32m(addressString);
+                publicKey = PeerWallet.decodeBech32m(message.address);
         }
 
         if (!publicKey) {
@@ -73,7 +79,8 @@ class BaseResponse {
 
         const messageWithoutSig = { ...message };
         delete messageWithoutSig.sig;
-        const hash = await blake3Hash(JSON.stringify(messageWithoutSig));
+        const hashInput = b4a.from(JSON.stringify(messageWithoutSig), 'utf8');
+        const hash = await PeerWallet.blake3(hashInput);
         const signature = b4a.from(message.sig, 'hex');
         const verified = this.#wallet.verify(signature, hash, publicKey);
 

package/src/core/network/protocols/shared/handlers/RoleOperationHandler.js

@@ -0,0 +1,88 @@
+import {OperationType} from '../../../../../utils/constants.js';
+import PartialRoleAccess from "../validators/PartialRoleAccess.js";
+import BaseOperationHandler from './base/BaseOperationHandler.js';
+import {applyStateMessageFactory} from "../../../../../messages/state/applyStateMessageFactory.js";
+import {safeEncodeApplyOperation} from "../../../../../utils/protobuf/operationHelpers.js";
+import {normalizeRoleAccessOperation} from "../../../../../utils/normalizers.js";
+
+class RoleOperationHandler extends BaseOperationHandler {
+    #partialRoleAccessValidator;
+    #wallet;
+    #config;
+    #txPoolService;
+
+    /**
+     * @param {State} state
+     * @param {PeerWallet} wallet
+     * @param {TransactionRateLimiterService} rateLimiter
+     * @param {TransactionPoolService} txPoolService
+     * @param {object} config
+     **/
+    constructor(state, wallet, rateLimiter, txPoolService ,config) {
+        super(state, wallet, rateLimiter, txPoolService, config);
+        this.#wallet = wallet;
+        this.#config = config;
+        this.#partialRoleAccessValidator = new PartialRoleAccess(state, this.#wallet.address ,this.#config)
+        this.#txPoolService = txPoolService;
+    }
+
+    get partialRoleAccessValidator() {
+        return this.#partialRoleAccessValidator;
+    }
+
+    async handleOperation(message, connection) {
+        const normalizedPartialRoleAccessPayload = normalizeRoleAccessOperation(message, this.#config)
+        const isValid = await this.partialRoleAccessValidator.validate(normalizedPartialRoleAccessPayload)
+        let completePayload = null
+        if (!isValid) {
+            throw new Error("OperationHandler: partial role access payload validation failed.");
+        }
+        
+        switch (normalizedPartialRoleAccessPayload.type) {
+            case OperationType.ADD_WRITER:
+                completePayload = await applyStateMessageFactory(this.#wallet, this.#config)
+                    .buildCompleteAddWriterMessage(
+                        normalizedPartialRoleAccessPayload.address,
+                        normalizedPartialRoleAccessPayload.rao.tx,
+                        normalizedPartialRoleAccessPayload.rao.txv,
+                        normalizedPartialRoleAccessPayload.rao.iw,
+                        normalizedPartialRoleAccessPayload.rao.in,
+                        normalizedPartialRoleAccessPayload.rao.is,
+                    )
+                break;
+            case OperationType.REMOVE_WRITER:
+                completePayload = await applyStateMessageFactory(this.#wallet, this.#config)
+                    .buildCompleteRemoveWriterMessage(
+                        normalizedPartialRoleAccessPayload.address,
+                        normalizedPartialRoleAccessPayload.rao.tx,
+                        normalizedPartialRoleAccessPayload.rao.txv,
+                        normalizedPartialRoleAccessPayload.rao.iw,
+                        normalizedPartialRoleAccessPayload.rao.in,
+                        normalizedPartialRoleAccessPayload.rao.is,
+                    )
+                break;
+            case OperationType.ADMIN_RECOVERY:
+
+                completePayload = await applyStateMessageFactory(this.#wallet, this.#config)
+                    .buildCompleteAdminRecoveryMessage(
+                        normalizedPartialRoleAccessPayload.address,
+                        normalizedPartialRoleAccessPayload.rao.tx,
+                        normalizedPartialRoleAccessPayload.rao.txv,
+                        normalizedPartialRoleAccessPayload.rao.iw,
+                        normalizedPartialRoleAccessPayload.rao.in,
+                        normalizedPartialRoleAccessPayload.rao.is,
+                    )
+                break;
+            default:
+                throw new Error("OperationHandler: Assembling complete role access operation failed due to unsupported operation type.");
+        }
+
+        if (!completePayload) {
+            throw new Error("OperationHandler: Assembling complete role access operation failed.");
+        }
+
+        this.#txPoolService.addTransaction(safeEncodeApplyOperation(completePayload))
+    }
+}
+
+export default RoleOperationHandler;

package/src/core/network/protocols/shared/handlers/SubnetworkOperationHandler.js

@@ -0,0 +1,93 @@
+import BaseOperationHandler from './base/BaseOperationHandler.js';
+import {
+    OperationType
+} from '../../../../../utils/constants.js';
+import PartialBootstrapDeployment from "../validators/PartialBootstrapDeployment.js";
+import PartialTransaction from "../validators/PartialTransaction.js";
+import {applyStateMessageFactory} from "../../../../../messages/state/applyStateMessageFactory.js";
+import {safeEncodeApplyOperation} from "../../../../../utils/protobuf/operationHelpers.js";
+import {
+    normalizeBootstrapDeploymentOperation,
+    normalizeTransactionOperation
+} from "../../../../../utils/normalizers.js";
+
+
+class SubnetworkOperationHandler extends BaseOperationHandler {
+    #partialBootstrapDeploymentValidator;
+    #partialTransactionValidator;
+    #config;
+    #wallet;
+    #txPoolService;
+
+    /**
+     * @param {State} state
+     * @param {PeerWallet} wallet
+     * @param {TransactionRateLimiterService} rateLimiter
+     * @param {TransactionPoolService} txPoolService
+     * @param {object} config
+     **/
+    constructor( state, wallet, rateLimiter, txPoolService, config) {
+        super(state, wallet, rateLimiter, txPoolService, config);
+        this.#config = config;
+        this.#wallet = wallet
+        this.#partialBootstrapDeploymentValidator = new PartialBootstrapDeployment(state, this.#wallet.address, config);
+        this.#partialTransactionValidator = new PartialTransaction(state, this.#wallet.address, config);
+        this.#txPoolService = txPoolService;
+    }
+
+    async handleOperation(payload, connection)  {
+        if (payload.type === OperationType.TX) {
+            await this.#partialTransactionSubHandler(payload, connection);
+        } else if (payload.type === OperationType.BOOTSTRAP_DEPLOYMENT) {
+            await this.#partialBootstrapDeploymentSubHandler(payload, connection);
+        } else {
+            throw new Error('Unsupported operation type for SubnetworkOperationHandler');
+        }
+    }
+
+    async #partialTransactionSubHandler(payload, connection) {
+        const normalizedPayload = normalizeTransactionOperation(payload, this.#config);
+        const isValid = await this.#partialTransactionValidator.validate(normalizedPayload);
+        if (!isValid) {
+            throw new Error("SubnetworkHandler: Transaction validation failed.");
+        }
+
+        const completeTransactionOperation = await applyStateMessageFactory(this.#wallet,this.#config)
+            .buildCompleteTransactionOperationMessage(
+                normalizedPayload.address,
+                normalizedPayload.txo.tx,
+                normalizedPayload.txo.txv,
+                normalizedPayload.txo.iw,
+                normalizedPayload.txo.in,
+                normalizedPayload.txo.ch,
+                normalizedPayload.txo.is,
+                normalizedPayload.txo.bs,
+                normalizedPayload.txo.mbs
+            )
+        this.#txPoolService.addTransaction(safeEncodeApplyOperation(completeTransactionOperation));
+    }
+
+    async #partialBootstrapDeploymentSubHandler(payload, connection) {
+        const normalizedPayload = normalizeBootstrapDeploymentOperation(payload, this.#config);
+        const isValid = await this.#partialBootstrapDeploymentValidator.validate(normalizedPayload);
+        if (!isValid) {
+            throw new Error("SubnetworkHandler: Bootstrap deployment validation failed.");
+        }
+
+
+        const completeBootstrapDeploymentOperation = await applyStateMessageFactory(this.#wallet, this.#config)
+            .buildCompleteBootstrapDeploymentMessage(
+                normalizedPayload.address,
+                normalizedPayload.bdo.tx,
+                normalizedPayload.bdo.txv,
+                normalizedPayload.bdo.bs,
+                normalizedPayload.bdo.ic,
+                normalizedPayload.bdo.in,
+                normalizedPayload.bdo.is
+            )
+        this.#txPoolService.addTransaction(safeEncodeApplyOperation(completeBootstrapDeploymentOperation));
+
+    }
+}
+
+export default SubnetworkOperationHandler;

package/src/core/network/protocols/shared/handlers/TransferOperationHandler.js

@@ -0,0 +1,57 @@
+import BaseOperationHandler from './base/BaseOperationHandler.js';
+import {OperationType} from '../../../../../utils/constants.js';
+import PartialTransfer from "../validators/PartialTransfer.js";
+import {normalizeTransferOperation} from "../../../../../utils/normalizers.js"
+import {applyStateMessageFactory} from "../../../../../messages/state/applyStateMessageFactory.js";
+import {safeEncodeApplyOperation} from "../../../../../utils/protobuf/operationHelpers.js";
+
+class TransferOperationHandler extends BaseOperationHandler {
+    #partialTransferValidator;
+    #config;
+    #wallet;
+    #txPoolService;
+
+    /**
+     * @param {State} state
+     * @param {PeerWallet} wallet
+     * @param {TransactionRateLimiterService} rateLimiter
+     * @param {object} config
+     **/
+    constructor(state, wallet, rateLimiter, txPoolService, config) {
+        super(state, wallet, rateLimiter, txPoolService, config);
+        this.#config = config;
+        this.#wallet = wallet;
+        this.#partialTransferValidator = new PartialTransfer(state, this.#wallet.address, this.#config);
+        this.#txPoolService = txPoolService;
+    }
+
+    async handleOperation(payload, connection) {
+        if (payload.type !== OperationType.TRANSFER) {
+            throw new Error('Unsupported operation type for TransferOperationHandler');
+        }
+        await this.#handleTransfer(payload, connection);
+    }
+
+    async #handleTransfer(payload, connection) {
+        const normalizedPayload = normalizeTransferOperation(payload, this.#config);
+        const isValid = await this.#partialTransferValidator.validate(normalizedPayload);
+        if (!isValid) {
+            throw new Error("TransferHandler: Transfer validation failed.");
+        }
+
+        const completeTransferOperation = await applyStateMessageFactory(this.#wallet, this.#config)
+            .buildCompleteTransferOperationMessage(
+                normalizedPayload.address,
+                normalizedPayload.tro.tx,
+                normalizedPayload.tro.txv,
+                normalizedPayload.tro.in,
+                normalizedPayload.tro.to,
+                normalizedPayload.tro.am,
+                normalizedPayload.tro.is
+            )
+
+        this.#txPoolService.addTransaction(safeEncodeApplyOperation(completeTransferOperation));
+    }
+}
+
+export default TransferOperationHandler;

package/src/core/network/{messaging → protocols/shared}/handlers/base/BaseOperationHandler.js

@@ -1,49 +1,44 @@
 import b4a from 'b4a';
-import {MAX_PARTIAL_TX_PAYLOAD_BYTE_SIZE, TRANSACTION_POOL_SIZE, MAX_WRITERS_FOR_ADMIN_INDEXER_CONNECTION} from '../../../../../utils/constants.js';
+import {MAX_PARTIAL_TX_PAYLOAD_BYTE_SIZE, TRANSACTION_POOL_SIZE} from '../../../../../../utils/constants.js';
+
 class BaseOperationHandler {
-    #network;
     #state;
     #wallet;
     #rateLimiter;
-    #disable_rate_limit;
-    #options;
-    constructor(network, state, wallet, rateLimiter, options = {}) {
+    #txPoolService;
+    #config;
+
+    /**
+     * @param {State} state
+     * @param {PeerWallet} wallet
+     * @param {TransactionRateLimiterService} rateLimiter
+     * @param {TransactionPoolService} txPoolService
+     * @param {object} config
+     **/
+    constructor(state, wallet, rateLimiter, txPoolService, config) {
         if (new.target === BaseOperationHandler) {
             throw new Error('BaseOperationHandler is abstract and cannot be instantiated directly');
         }
-        this.#network = network;
         this.#state = state;
         this.#wallet = wallet;
         this.#rateLimiter = rateLimiter;
-        this.#disable_rate_limit = options.disable_rate_limit === true;
-        this.#options = options;
-    }
-    get network() {
-        return this.#network;
-    }
-    get state() {
-        return this.#state;
+        this.#txPoolService = txPoolService;
+        this.#config = config;
     }
-    get wallet() {
-        return this.#wallet;
-    }
-    get options() {
-        return this.#options;
-    }
-    
+
     async validateBasicRequirements(payload, connection) {
         // Validate if operation can be processed:
         // - Non-writable nodes cannot process operations
         // - Regular indexers cannot process operations
         // - Admin-indexer can process operations only when network has less than MAX_WRITERS_FOR_ADMIN_INDEXER_CONNECTION writers
-        const isAllowedToValidate = await this.state.allowedToValidate(this.wallet.address);
-        const isAdminAllowedToValidate = await this.state.isAdminAllowedToValidate();
+        const isAllowedToValidate = await this.#state.allowedToValidate(this.#wallet.address);
+        const isAdminAllowedToValidate = await this.#state.isAdminAllowedToValidate();
         const canValidate = isAllowedToValidate || isAdminAllowedToValidate;
         if (!canValidate) {
             throw new Error('OperationHandler: State is not writable or is an indexer without admin privileges.');
         }
 
-        if (this.network.transactionPoolService.tx_pool.length >= TRANSACTION_POOL_SIZE) {
+        if (this.#txPoolService.tx_pool.length >= TRANSACTION_POOL_SIZE) {
             throw new Error("OperationHandler: Transaction pool is full, ignoring incoming transaction.");
         }
 
@@ -51,8 +46,8 @@ class BaseOperationHandler {
             throw new Error(`OperationHandler: Payload size exceeds maximum limit of ${MAX_PARTIAL_TX_PAYLOAD_BYTE_SIZE} bytes by ${b4a.byteLength(JSON.stringify(payload)) - MAX_PARTIAL_TX_PAYLOAD_BYTE_SIZE} bytes.`);
         }
         
-        if (this.#disable_rate_limit !== true) {
-            const shouldDisconnect = this.#rateLimiter.handleRateLimit(connection, this.network);
+        if (!this.#config.disableRateLimit) {
+            const shouldDisconnect = this.#rateLimiter.handleRateLimit(connection);
             if (shouldDisconnect) {
                 throw new Error(`OperationHandler: Rate limit exceeded for peer ${b4a.toString(connection.remotePublicKey, 'hex')}. Disconnecting...`);
             }

package/src/core/network/{messaging → protocols/shared}/validators/PartialBootstrapDeployment.js

@@ -1,13 +1,13 @@
 import PartialOperation from './base/PartialOperation.js';
 
-
 class PartialBootstrapDeployment extends PartialOperation {
-    constructor(state) {
-        super(state);
+    constructor(state, selfAddress , config) {
+        super(state, selfAddress , config);
     }
 
     async validate(payload) {
         this.isPayloadSchemaValid(payload);
+        this.validateNoSelfValidation(payload);
         this.validateRequesterAddress(payload);
         await this.validateTransactionUniqueness(payload);
         await this.validateSignature(payload);

package/src/core/network/{messaging → protocols/shared}/validators/PartialRoleAccess.js

@@ -1,17 +1,20 @@
 import b4a from 'b4a';
-
-import { OperationType } from "../../../../utils/constants.js";
-import { bufferToAddress } from "../../../state/utils/address.js";
+import {OperationType} from "../../../../../utils/constants.js";
+import {bufferToAddress} from "../../../../state/utils/address.js";
 import PartialOperation from './base/PartialOperation.js';
-import { bufferToBigInt } from "../../../../utils/amountSerialization.js";
+import {bufferToBigInt} from "../../../../../utils/amountSerialization.js";
 
 class PartialRoleAccess extends PartialOperation {
-    constructor(state) {
-        super(state);
+    #config;
+
+    constructor(state, selfAddress, config) {
+        super(state, selfAddress, config);
+        this.#config = config
     }
 
     async validate(payload) {
         this.isPayloadSchemaValid(payload);
+        this.validateNoSelfValidation(payload);
         this.validateRequesterAddress(payload);
         await this.validateTransactionUniqueness(payload);
         await this.validateSignature(payload);
@@ -33,10 +36,10 @@ class PartialRoleAccess extends PartialOperation {
     }
 
     async isRequesterAllowedToChangeRole(payload) {
-        const { type } = payload;
+        const {type} = payload;
 
         if (type === OperationType.ADD_WRITER) {
-            const nodeAddress = bufferToAddress(payload.address);
+            const nodeAddress = bufferToAddress(payload.address, this.#config.addressPrefix);
             const nodeEntry = await this.state.getNodeEntry(nodeAddress);
             if (!nodeEntry) {
                 throw new Error(`Node with address ${nodeAddress} entry does not exist.`);
@@ -54,7 +57,7 @@ class PartialRoleAccess extends PartialOperation {
             return;
 
         } else if (type === OperationType.REMOVE_WRITER) {
-            const nodeAddress = bufferToAddress(payload.address);
+            const nodeAddress = bufferToAddress(payload.address, this.#config.addressPrefix);
             const nodeEntry = await this.state.getNodeEntry(nodeAddress);
             if (!nodeEntry) {
                 throw new Error(`Node with address ${nodeAddress} entry does not exist.`);
@@ -78,7 +81,7 @@ class PartialRoleAccess extends PartialOperation {
             }
 
             const adminAddressBuffer = payload.address;
-            const adminAddress = bufferToAddress(adminAddressBuffer);
+            const adminAddress = bufferToAddress(adminAddressBuffer, this.#config.addressPrefix);
             const isRecoveryCase = !!(
                 adminEntry.address === adminAddress &&
                 !b4a.equals(payload.rao.iw, adminEntry.wk)
@@ -94,7 +97,7 @@ class PartialRoleAccess extends PartialOperation {
     }
 
     async validateWriterKey(payload) {
-        const requesterAddress = bufferToAddress(payload.address);
+        const requesterAddress = bufferToAddress(payload.address, this.#config.addressPrefix);
         const nodeEntry = await this.state.getNodeEntry(requesterAddress);
         if (!nodeEntry) {
             throw new Error(`Node entry not found for address ${requesterAddress}`);
@@ -114,7 +117,7 @@ class PartialRoleAccess extends PartialOperation {
     }
 
     async validateRequesterBalanceForAddWriterOperation(payload, signed = false) {
-        const requesterAddress = bufferToAddress(payload.address);
+        const requesterAddress = bufferToAddress(payload.address, this.#config.addressPrefix);
         let requesterEntry;
         if (signed) {
             requesterEntry = await this.state.getNodeEntry(requesterAddress);