trac-msb 0.2.9 → 0.2.11

package/src/core/network/services/TransactionRateLimiterService.js

@@ -1,59 +1,57 @@
 import b4a from 'b4a';
-import {
-    CLEANUP_INTERVAL_MS,
-    CONNECTION_TIMEOUT_MS,
-    MAX_TRANSACTIONS_PER_SECOND
-} from '../../../utils/constants.js';
+import {V1RateLimitedError} from "../protocols/v1/V1ProtocolError.js";
+import {publicKeyToAddress} from "../../../utils/helpers.js";
 
 class TransactionRateLimiterService {
     #lastCleanup;
     #connectionsStatistics;
     #swarm;
+    #config;
 
-    constructor(swarm) {
+    constructor(swarm, config) {
         this.#lastCleanup = Date.now();
         this.#connectionsStatistics = new Map();
         this.#swarm = swarm
+        this.#config = config
     }
 
     /*
-        Checks if the peer has exceeded the rate limit.
+        Checks if the peer has exceeded the rate limit for the current 1-second window.
         A peer is considered to have exceeded the rate limit if:
-        - The time since the last activity is greater than or equal to 1000 ms (1 second)
-        - The number of transactions in the current session is greater than or equal to MAX_TRANSACTIONS_PER_SECOND
-        If the rate limit is exceeded, the peer is disconnected.
+        - The request belongs to the same 1-second window as previous requests (tracked per peer)
+        - The number of transactions already seen in this window is >= rateLimitMaxTransactionsPerSecond
+
+        Important:
+        - This method assumes the caller increments transactionCount AFTER calling this method.
+          (So exactly rateLimitMaxTransactionsPerSecond are allowed; the next one is blocked.)
     */
-    #hasExceededRateLimit(peer) {
+    #hasExceededRateLimit(peer, currentTime) {
         const peerData = this.#connectionsStatistics.get(peer);
-        const currentSecond = Math.floor((peerData.lastActivityTime - peerData.sessionStartTime) / 1000);
-        
-        if (currentSecond > Math.floor((peerData.lastCounterReset - peerData.sessionStartTime) / 1000)) {
+        const currentSecond = Math.floor((currentTime - peerData.sessionStartTime) / 1000);
+        const lastResetSecond = Math.floor((peerData.lastCounterReset - peerData.sessionStartTime) / 1000);
+
+        if (currentSecond > lastResetSecond) {
             peerData.transactionCount = 0;
-            peerData.lastCounterReset = peerData.lastActivityTime;
+            peerData.lastCounterReset = currentTime;
             this.#connectionsStatistics.set(peer, peerData);
         }
         
-        return peerData.transactionCount >= MAX_TRANSACTIONS_PER_SECOND;
+        return peerData.transactionCount >= this.#config.rateLimitMaxTransactionsPerSecond;
     }
 
     /*
-        Handles the rate limiting for a peer connection.
-        If the peer has exceeded the rate limit, it disconnects the peer.
-        Otherwise, it updates the connection info with the current timestamp.
+        Handles rate limiting for a peer connection (legacy protocol).
+        If the peer has exceeded the rate limit, it disconnects the peer and returns true.
+        Otherwise, it updates the connection info with the current timestamp and returns false.
     */
-    handleRateLimit(connection) {
+    legacyHandleRateLimit(connection) {
         const peer = b4a.toString(connection.remotePublicKey, 'hex');
         const currentTime = Date.now();
 
         this.#cleanUpOldConnections(currentTime);
         this.#initializePeerConnectionInfoEntry(peer, currentTime);
 
-        if (this.#isConnectionExpired(peer)) {
-            this.#connectionsStatistics.delete(peer);
-            return false;
-        }
-
-        if (this.#hasExceededRateLimit(peer)) {
+        if (this.#hasExceededRateLimit(peer, currentTime)) {
             console.warn(`Rate limit exceeded for peer ${peer}. Disconnecting...`);
             this.#swarm.leavePeer(connection.remotePublicKey);
             connection.end();
@@ -64,14 +62,31 @@ class TransactionRateLimiterService {
         return false;
     }
 
+    /*
+        Handles rate limiting for a peer connection (v1 protocol).
+        If the peer has exceeded the rate limit, it throws RateLimitedError.
+        Otherwise, it updates the connection info with the current timestamp.
+    */
+    v1HandleRateLimit(connection) {
+        const peer = b4a.toString(connection.remotePublicKey, 'hex');
+        const currentTime = Date.now();
+
+        this.#cleanUpOldConnections(currentTime);
+        this.#initializePeerConnectionInfoEntry(peer, currentTime);
+
+        if (this.#hasExceededRateLimit(peer, currentTime)) {
+            throw new V1RateLimitedError(`Rate limit exceeded for peer ${publicKeyToAddress(connection.remotePublicKey, this.#config)}`);
+        }
+        this.#updatePeerConnectionInfo(peer, currentTime);
+    }
+
     #shouldCleanupConnections(currentTime) {
-        return currentTime - this.#lastCleanup >= CLEANUP_INTERVAL_MS;
+        return currentTime - this.#lastCleanup >= this.#config.rateLimitCleanupIntervalMs;
     }
 
     /**
-        Cleans up old connections that have timed out.
-        Condition for cleanup based on #shouldCleanupConnections:
-        - If the last cleanup was more than CLEANUP_INTERVAL_MS ago
+        Cleans up per-peer statistics that have been inactive for more than rateLimitCleanupIntervalMs.
+        Runs at most once every rateLimitCleanupIntervalMs.
     */
     #cleanUpOldConnections(currentTime) {
         if (!this.#shouldCleanupConnections(currentTime)) {
@@ -79,8 +94,7 @@ class TransactionRateLimiterService {
         }
 
         for (const [peer, _] of this.#connectionsStatistics.entries()) {
-            if (this.#isConnectionExpired(peer)) {
-                //console.log(`Connection for peer ${peer} has expired. Removing...`);
+            if (this.#isConnectionExpired(peer, currentTime)) {
                 this.#connectionsStatistics.delete(peer);
             }
         }
@@ -90,19 +104,19 @@ class TransactionRateLimiterService {
 
     /*
         Initializes the connection statistics for a peer.
-        Connection is a HashMap with the following structure:
-            peerPublicKey: {
-                sessionStartTime: timestamp,     // When the external peer started their session
-                lastActivityTime: timestamp,     // Timestamp of peer's most recent activity (default: 0)
-                transactionCount: number         // Number of transactions in the current session (default: 0)
+        Stored as a HashMap with the following structure:
+            peerPublicKeyHex: {
+                sessionStartTime: timestamp,  // When we first saw this peer (start of local tracking session)
+                lastActivityTime: timestamp,  // Timestamp of peer's most recent activity
+                lastCounterReset: timestamp,  // Timestamp when the per-second counter was last reset
+                transactionCount: number      // Transactions seen in the current 1-second window
             }
-        
     */
     #initializePeerConnectionInfoEntry(peer, timestamp) {
         if (!this.#connectionsStatistics.has(peer)) {
             this.#connectionsStatistics.set(peer, {
                 sessionStartTime: timestamp,
-                lastActivityTime: 0,
+                lastActivityTime: timestamp,
                 lastCounterReset: timestamp,
                 transactionCount: 0
             });
@@ -121,11 +135,12 @@ class TransactionRateLimiterService {
     }
 
     /*
-        Checks if the connection for a peer has expired.
+        Checks if the stored statistics for a peer have expired due to inactivity.
+        Note: this is NOT a network-level connection timeout; it's only used to evict old Map entries.
     */
-    #isConnectionExpired(peer) {
+    #isConnectionExpired(peer, currentTime) {
         const peerData = this.#connectionsStatistics.get(peer);
-        return peerData.lastActivityTime - peerData.sessionStartTime >= CONNECTION_TIMEOUT_MS;
+        return currentTime - peerData.lastActivityTime >= this.#config.rateLimitConnectionTimeoutMs;
     }
 }
 

package/src/core/network/services/ValidatorHealthCheckService.js

@@ -0,0 +1,127 @@
+import ReadyResource from 'ready-resource';
+import b4a from 'b4a';
+import { generateUUID } from '../../../utils/helpers.js';
+import { EventType } from '../../../utils/constants.js';
+import { Logger } from '../../../utils/logger.js';
+
+const DEFAULT_HEALTH_CHECK_INTERVAL_MS = 300000; // 5 minutes
+class ValidatorHealthCheckService extends ReadyResource {
+    #config;
+    #intervalMs;
+    #timers;
+    #logger;
+
+    /**
+     * @param {object} config
+     */
+    constructor(config = {}) {
+        super();
+        this.#config = config;
+        this.#timers = new Map();
+        this.#logger = new Logger(config);
+
+        const interval = this.#config.validatorHealthCheckInterval;
+        this.#intervalMs = interval ? this.#checkInterval(interval) : DEFAULT_HEALTH_CHECK_INTERVAL_MS;
+
+        this.#logger.debug(`initialized with intervalMs ${this.#intervalMs}`);
+    }
+
+    get size() {
+        return this.#timers.size;
+    }
+
+    async _open() {
+        this.#logger.debug('open: health check service ready');
+    }
+
+    async _close() {
+        this.#logger.debug('close: stopping all health checks');
+        this.#stopAll();
+        this.#timers.clear();
+    }
+
+    /**
+     * Start periodic health checks for a validator.
+     * @param {String} publicKey
+     */
+    start(publicKey) {
+        if (!this.opened) {
+            throw new Error('start: service not ready. Call ready() before start().');
+        }
+        const publicKeyHex = this.#normalizePublicKey(publicKey);
+        if (this.#timers.has(publicKeyHex)) {
+            this.#logger.debug(`start: already scheduled for ${publicKey}`);
+            return false; // TODO: Implement better error handling
+        }
+
+        const timerId = setInterval(() => {
+            this.#emitHealthCheck(publicKeyHex);
+        }, this.#intervalMs);
+
+        this.#timers.set(publicKeyHex, { timerId, intervalMs: this.#intervalMs });
+        this.#logger.debug(`start: scheduled health checks for ${publicKeyHex} every ${this.#intervalMs} ms`);
+
+        return true;
+    }
+
+    /**
+     * Stop periodic health checks for a validator.
+     * @param {String} publicKey
+     * @returns {boolean} true if stopped, false if not scheduled
+     */
+    stop(publicKey) {
+        const publicKeyHex = this.#normalizePublicKey(publicKey);
+        const entry = this.#timers.get(publicKeyHex);
+        if (!entry) {
+            this.#logger.debug(`stop: did not find scheduled health check for public key ${publicKey}. Aborting`);
+            return false;
+        }
+        clearInterval(entry.timerId);
+        this.#timers.delete(publicKeyHex);
+        this.#logger.debug(`stop: cancelled health checks for ${publicKeyHex}`);
+        return true;
+    }
+
+    /**
+     * Check if a validator is scheduled.
+     * @param {String} publicKey
+     * @returns {boolean}
+     */
+    has(publicKey) {
+        return this.#timers.has(this.#normalizePublicKey(publicKey));
+    }
+
+    async #emitHealthCheck(publicKey) {
+        try {
+            const requestId = generateUUID();
+            this.emit(EventType.VALIDATOR_HEALTH_CHECK, publicKey, requestId);
+            this.#logger.debug(`Emitted health check event for ${publicKey} with requestId ${requestId}`);
+        } catch (error) {
+            this.#logger.error(`ValidatorHealthCheckService: Failed to emit health check for ${publicKey}: ${error?.message || error}`);
+        }
+    }
+
+    #stopAll() {
+        this.#logger.debug(`stopAll: cancelling health checks for ${this.#timers.size} validators`);
+        for (const publicKey of this.#timers.keys()) {
+            this.stop(publicKey);
+        }
+    }
+
+    #checkInterval(intervalMs) {
+        const ms = Number(intervalMs);
+        if (!Number.isFinite(ms) || ms <= 0) {
+            throw new RangeError(`ValidatorHealthCheckService: invalid intervalMs value: ${intervalMs}`);
+        }
+        return ms;
+    }
+
+    // TODO: This method is used in multiple places. Consider moving it to a utility file or exposing it from PeerWallet.
+    #normalizePublicKey(publicKey) {
+        if (b4a.isBuffer(publicKey)) return publicKey.toString('hex');
+        if (typeof publicKey === 'string') return publicKey.toLowerCase();
+        throw new TypeError('ValidatorHealthCheckService: publicKey must be a Buffer or hex string');
+    }
+}
+
+export default ValidatorHealthCheckService;

package/src/core/network/services/ValidatorObserverService.js

@@ -1,24 +1,15 @@
 import PeerWallet from "trac-wallet";
 import b4a from "b4a";
-import { MAX_WRITERS_FOR_ADMIN_INDEXER_CONNECTION } from '../../../utils/constants.js';
 import { bufferToAddress } from '../../state/utils/address.js';
 import { sleep } from '../../../utils/helpers.js';
 import Scheduler from "../../../utils/Scheduler.js";
 import Network from "../Network.js";
+import { Logger } from '../../../utils/logger.js';
 
 const DELAY_INTERVAL = 50
 const VALIDATOR_CANDIDATES_PER_CYCLE = 10
 const POLL_INTERVAL = (VALIDATOR_CANDIDATES_PER_CYCLE + 1) * DELAY_INTERVAL // This is to avoid more than one instance of the worker running at the same time
 
-// -- Debug Mode --
-// TODO: Implement a better debug system in the future. This is just temporary.
-const DEBUG = false;
-const debugLog = (...args) => {
-    if (DEBUG) {
-        console.log('DEBUG [ValidatorObserverService] ==> ', ...args);
-    }
-};
-
 class ValidatorObserverService {
     #config;
     #state;
@@ -26,12 +17,13 @@ class ValidatorObserverService {
     #scheduler;
     #address;
     #isInterrupted
+    #logger;
 
     /**
      * @param {Network} network
      * @param {State} state
      * @param {string} address
-     * @param {object} config
+     * @param {Config} config
      **/
     constructor(network, state, address, config) {
         this.#config = config
@@ -39,12 +31,11 @@ class ValidatorObserverService {
         this.#state = state;
         this.#address = address;
         this.#isInterrupted = false;
-        if (DEBUG) {
-            this.initTimestamp = Date.now();
-            this.reachedMax = false;
-            this.end = 0;
-            this.begin = 0;
-        }
+        this.#logger = new Logger(config);
+        this.initTimestamp = Date.now();
+        this.reachedMax = false;
+        this.end = 0;
+        this.begin = 0;
     }
 
     get state() {
@@ -56,11 +47,11 @@ class ValidatorObserverService {
     // OS CALLS, ACCUMULATORS, MAYBE THIS IS POSSIBLE TO CHECK I/O QUEUE IF IT COINTAIN IT. FOR NOW WE ARE USING SLEEP.
     async start() {
         if (!this.#shouldRun()) {
-            console.info('ValidatorObserverService can not start. Disabled by configuration.');
+            this.#logger.info('ValidatorObserverService can not start. Disabled by configuration.');
             return;
         }
         if (this.#scheduler && this.#scheduler.isRunning) {
-            console.info('ValidatorObserverService is already started');
+            this.#logger.info('ValidatorObserverService is already started');
             return;
         }
 
@@ -74,12 +65,12 @@ class ValidatorObserverService {
         this.#isInterrupted = true;
         await this.#scheduler.stop(waitForCurrent);
         this.#scheduler = null;
-        console.info('ValidatorObserverService: closing gracefully...');
+        this.#logger.info('ValidatorObserverService: closing gracefully...');
     }
 
     async #worker(next) {
         if (!this.#network.validatorConnectionManager.maxConnectionsReached()) {
-            if (DEBUG) this.begin = Date.now();
+            this.begin = Date.now();
             const length = await this.#lengthEntry()
 
             const promises = [];
@@ -89,16 +80,16 @@ class ValidatorObserverService {
             }
             await Promise.all(promises);
 
-            if (DEBUG) this.end = Date.now();
-            debugLog('Worker cycle completed in (ms):', this.end - this.begin, '| Validator Connections:', this.#network.validatorConnectionManager.connectionCount(), " | Pending: ", this.#network.pendingConnectionsCount());
+            this.end = Date.now();
+            this.#logger.debug(`Worker cycle completed in (ms): ${this.end - this.begin} | Validator Connections: ${this.#network.validatorConnectionManager.connectionCount()} | Pending: ${this.#network.pendingConnectionsCount()}`);
         }
-        else if (DEBUG) {
+        else {
             if (!this.reachedMax) {
                 this.reachedMax = true;
-                debugLog('Max validator connections reached. Skipping this cycle.');
+                this.#logger.debug('Max validator connections reached. Skipping this cycle.');
                 const now = Date.now();
                 const elapsed = now - this.initTimestamp;
-                debugLog('>>> Time elapsed since start (ms):', elapsed);
+                this.#logger.debug(`>>> Time elapsed since start (ms): ${elapsed}`);
             }
         }
         next(POLL_INTERVAL);
@@ -119,10 +110,10 @@ class ValidatorObserverService {
         }
 
         if (attempts >= maxAttempts) {
-            debugLog('Max attempts reached without finding a valid validator.');
+            this.#logger.debug('Max attempts reached without finding a valid validator.');
         }
         else {
-            debugLog(`Found valid validator to connect after ${attempts} attempts.`);
+            this.#logger.debug(`Found valid validator to connect after ${attempts} attempts.`);
         }
 
         if (!isValidatorValid) return;
@@ -132,7 +123,7 @@ class ValidatorObserverService {
         const validatorPubKeyHex = validatorPubKeyBuffer.toString('hex');
         const adminEntry = await this.state.getAdminEntry();
 
-        if (validatorAddress !== adminEntry?.address || validatorListLength < MAX_WRITERS_FOR_ADMIN_INDEXER_CONNECTION) {
+        if (validatorAddress !== adminEntry?.address || validatorListLength < this.#config.maxWritersForAdminIndexerConnection) {
             this.#network.tryConnect(validatorPubKeyHex, 'validator');
         }
     };
@@ -151,7 +142,7 @@ class ValidatorObserverService {
             return false;
         }
 
-        if (validatorAddress === adminEntry?.address && validatorListLength >= MAX_WRITERS_FOR_ADMIN_INDEXER_CONNECTION) {
+        if (validatorAddress === adminEntry?.address && validatorListLength >= this.#config.maxWritersForAdminIndexerConnection) {
             if (this.#network.validatorConnectionManager.exists(validatorPubKeyBuffer)) {
                 this.#network.validatorConnectionManager.remove(validatorPubKeyBuffer)
             }
@@ -161,12 +152,12 @@ class ValidatorObserverService {
         // - Cannot connect if already connected to a validator
         // - Validator must exist and be a writer
         // - Cannot connect to indexers, except for admin-indexer
-        // - Admin-indexer connection is allowed only when writers length has less than 10 writers
+        // - Admin-indexer connection is allowed only when writers length is below maxWritersForAdminIndexerConnection
         if (this.#network.validatorConnectionManager.connected(validatorPubKeyBuffer) ||
             this.#network.validatorConnectionManager.maxConnectionsReached() ||
             validatorEntry === null ||
             !validatorEntry.isWriter ||
-            (validatorEntry.isIndexer && (validatorAddress !== adminEntry?.address || validatorListLength >= MAX_WRITERS_FOR_ADMIN_INDEXER_CONNECTION))
+            (validatorEntry.isIndexer && (validatorAddress !== adminEntry?.address || validatorListLength >= this.#config.maxWritersForAdminIndexerConnection))
         ) {
             return false;
         }

package/src/core/state/State.js

@@ -12,7 +12,6 @@ import {
     HYPERBEE_VALUE_ENCODING,
     BATCH_SIZE,
     ADMIN_INITIAL_STAKED_BALANCE,
-    MAX_WRITERS_FOR_ADMIN_INDEXER_CONNECTION,
     TRAC_NAMESPACE,
     CustomEventType
 } from '../../utils/constants.js';
@@ -41,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;
@@ -58,7 +59,7 @@ class State extends ReadyResource {
     /**
      * @param {Corestore} store
      * @param {PeerWallet} wallet
-     * @param {object} config
+     * @param {Config} config
      **/
     constructor(store, wallet, config) {
         super();
@@ -178,7 +179,7 @@ class State extends ReadyResource {
     async isAdminAllowedToValidate() {
         const isAdmin = this.writingKey.toString('hex') === this.#config.bootstrap.toString('hex');
         const isIndexer = this.isIndexer();
-        const lengthCondition = await this.getWriterLength() <= MAX_WRITERS_FOR_ADMIN_INDEXER_CONNECTION;
+        const lengthCondition = await this.getWriterLength() <= this.#config.maxWritersForAdminIndexerConnection;
         return !!(isAdmin && isIndexer && lengthCondition);
     }
 
@@ -188,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);
     }
@@ -244,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() {
@@ -265,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");
@@ -1794,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'))
@@ -2931,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);
@@ -3389,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.