trac-msb 0.3.0-beta.1 → 0.3.0-beta.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "trac-msb",
   "main": "msb.mjs",
-  "version": "0.3.0-beta.1",
+  "version": "0.3.0-beta.3",
   "pear": {
     "name": "trac-msb",
     "type": "terminal"
@@ -26,7 +26,7 @@
     "lint:fix": "eslint . --fix",
     "protobuf": "node scripts/generate-protobufs.js",
     "docs:check": "node scripts/docs/docs-checker.js",
-    "test:acceptance": "node --experimental-vm-modules node_modules/jest/bin/jest.js --testTimeout=200000 tests/acceptance/v1/rpc.test.mjs tests/acceptance/v1/htlc/htlc-routing.test.mjs --runInBand",
+    "test:acceptance": "node --experimental-vm-modules node_modules/jest/bin/jest.js --testTimeout=200000 tests/acceptance/v1/rpc.test.mjs tests/acceptance/v1/htlc/htlc-routing.test.mjs tests/acceptance/v1/current-epoch/current-epoch-routing.test.mjs tests/acceptance/v1/consensus-config/consensus-config-routing.test.mjs --runInBand",
     "test:integration": "brittle-node -t 1200000 tests/integration/integration.test.js",
     "test:unit:node": "brittle-node -t 60000 tests/unit/unit.test.js",
     "test:unit:bare": "brittle-bare -t 60000 tests/unit/unit.test.js",

package/rpc/handlers.js

@@ -456,3 +456,21 @@ export async function handleAccountDetails({ msbInstance, respond, req }) {
         stakedBalance: bufferToBigInt(nodeEntry.stakedBalance).toString(),
     });
 }
+
+export async function handleCurrentEpoch({ req, msbInstance, respond }) {
+    const confirmed = getConfirmedParameter(buildRequestUrl(req));
+    if (confirmed === null) {
+        return respond(400, { error: 'Parameter "confirmed" must be exactly "true" or "false"' });
+    }
+    const current_epoch = await msbInstance.getCurrentEpoch(confirmed);
+    respond(200, { current_epoch });
+}
+
+export async function handleConsensusConfig({ req, msbInstance, respond }) {
+    const confirmed = getConfirmedParameter(buildRequestUrl(req));
+    if (confirmed === null) {
+        return respond(400, { error: 'Parameter "confirmed" must be exactly "true" or "false"' });
+    }
+    const consensusConfig = await msbInstance.getConsensusConfig(confirmed);
+    respond(200, consensusConfig);
+}

package/rpc/routes/v1.js

@@ -15,6 +15,8 @@ import {
     handleHtlcClaim,
     handleHtlcRefund,
     handleHtlc,
+    handleCurrentEpoch,
+    handleConsensusConfig,
 } from '../handlers.js';
 
 export const v1Routes = [
@@ -34,4 +36,6 @@ export const v1Routes = [
     { method: 'POST', path: '/tx-payloads-bulk', handler: handleFetchBulkTxPayloads },
     { method: 'GET', path: '/tx/details', handler: handleTransactionExtendedDetails },
     { method: 'GET', path: '/account', handler: handleAccountDetails },
+    { method: 'GET', path: '/current-epoch', exact: true, handler: handleCurrentEpoch },
+    { method: 'GET', path: '/consensus-config', exact: true, handler: handleConsensusConfig },
 ];

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

@@ -42,9 +42,9 @@ class ValidatorMessageOrchestrator {
      *
      * @param {object} [message] Outgoing operation payload.
      * @param {string} [message.address] Requester address (bech32m).
-     * @returns {string|null} Selected validator public key hex, or null when unavailable.
+     * @returns {Promise<string|null>} Selected validator public key hex, or null when unavailable.
      */
-    #pickValidatorForMessage(message) {
+    async #pickValidatorForMessage(message) {
         const requesterAddress = message?.address;
 
         if (!requesterAddress) return null
@@ -58,10 +58,15 @@ class ValidatorMessageOrchestrator {
             return publicKeyToAddress(publicKey, this.#config) !== requesterAddress;
         });
 
-        const pool = eligible.length > 0 ? eligible : connected;
-
-        const index = Math.floor(Math.random() * pool.length);
-        return pool[index] ?? null;
+        const pool = [...(eligible.length > 0 ? eligible : connected)];
+        while (pool.length > 0) {
+            const index = Math.floor(Math.random() * pool.length);
+            const [publicKey] = pool.splice(index, 1);
+            const address = publicKeyToAddress(publicKey, this.#config);
+            if (await this.state.isValidatorAddress(address)) return publicKey;
+            this.validatorConnectionManager.remove(publicKey);
+        }
+        return null;
     }
 
     /**
@@ -76,7 +81,7 @@ class ValidatorMessageOrchestrator {
             return false;
         }
 
-        const validatorPublicKey = this.#pickValidatorForMessage(message);
+        const validatorPublicKey = await this.#pickValidatorForMessage(message);
         if (!validatorPublicKey) return false;
         console.log("Sending message to validator:", publicKeyToAddress(validatorPublicKey, this.#config));
 
@@ -91,6 +96,7 @@ class ValidatorMessageOrchestrator {
 
         // TODO: After Legacy is deprecated, we don't need to check preferred protocol here.
         const validatorConnection = this.validatorConnectionManager.getConnection(validatorPublicKey);
+        if (!validatorConnection) return this.send(message, retries + 1);
         const preferredProtocol = validatorConnection.protocolSessions.validator.preferredProtocol;
         let success = false;
         if (preferredProtocol === validatorConnection.protocolSessions.validator.supportedProtocols.LEGACY) {

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

@@ -4,6 +4,7 @@ import b4a from "b4a";
 import { bufferToAddress } from "../../../core/state/utils/address.js";
 import tracCryptoApi from "trac-crypto-api";
 import { WRITER_BYTE_LENGTH, CONNECTION_STATUS } from "../../../utils/constants.js";
+import { publicKeyToAddress } from "../../../utils/helpers.js";
 
 // Internal constants
 const VALIDATOR_CANDIDATES_PER_CYCLE = 10;
@@ -48,27 +49,19 @@ class ValidatorObserverService extends SchedulableService {
      * - Assumes writers list is already pre-filtered and deduplicated from scan phase.
      * - Excludes self.
      * - Excludes already connected or pending nodes.
-     * - Applies admin connection restriction based on the threshold of ALIVE writers.
+     * - Revalidates roles and the admin threshold before connecting.
      * - Randomizes selection (Fisher-Yates) to avoid bias.
      * @param {Array<Object>} writers - The deduplicated list of active writers.
-     * @param {Object} adminEntry - The current admin node entry.
      * @returns {{candidates: Array<Object>, slots: number}} The selected candidates and the number of available connection slots.
      */
-    #selectCandidates(writers, adminEntry) {
+    #selectCandidates(writers) {
         const manager = this.#network.validatorConnectionManager;
-        const adminThreshold = this.#config.maxWritersForAdminIndexerConnection;
-        
-        // Evaluates the admin blockage policy based on fully connected/alive writers
-        const aliveWritersCount = this.#countAliveWriters(writers, adminEntry);
-        const adminBlocked = adminEntry && aliveWritersCount >= adminThreshold;
-        
         // Target calculation: ensures the observer deducts its own slot from the network size 
         // only if it belongs to the valid writers list.
         const isSelfInWriters = writers.some(w => w.address === this.#address);
         const networkSize = isSelfInWriters ? writers.length - 1 : writers.length;
         const target = Math.min(networkSize, this.#config.maxValidators);
         
-        const isSelfAdmin = this.#address === adminEntry?.address;
         const totalConnected = manager.connectionCount();
 
         const available = writers.filter((w) => {
@@ -82,9 +75,6 @@ class ValidatorObserverService extends SchedulableService {
             // Skips nodes we are already interacting with
             if (isConnected || isPending) return false;
             
-            // The admin is actively filtered out from the pool if the threshold policy is triggered
-            if (adminBlocked && !isSelfAdmin && w.address === adminEntry?.address) return false;
-
             return true;
         });
 
@@ -107,37 +97,6 @@ class ValidatorObserverService extends SchedulableService {
         }
     }
    
-    /**
-     * Enforces admin-specific connection rules.
-     *
-     * If the count of fully connected writers exceeds the threshold:
-     * - The admin node is excluded from the validator pool (handled in selection phase).
-     * - Non-admin nodes detach the admin from the validator pool, preserving replication.
-     *
-     * NOTE:
-     * The admin is not forcibly disconnected from all roles.
-     * It can still maintain connections for tx submission and observation.
-     * @param {Array<Object>} writers - The deduplicated list of active writers.
-     * @param {Object} adminEntry - The current admin node entry.
-     */
-    #enforceAdminPolicy(writers, adminEntry) {
-        // Evaluates against alive network peers rather than dormant database entries
-        const aliveWritersCount = this.#countAliveWriters(writers, adminEntry);
-        
-        if (aliveWritersCount < this.#config.maxWritersForAdminIndexerConnection) return;
-
-        this.#logger.debug("Validator threshold reached → enforcing admin policy");
-
-        const isAdmin = adminEntry && this.#address === adminEntry.address;
-        if (isAdmin) return;
-
-        // Non-admin nodes: ensure the admin is not kept as a validator connection
-        const adminWriter = writers.find((w) => w.address === adminEntry?.address);
-        if (adminWriter?.publicKey) {
-            this.#network.validatorConnectionManager.remove(adminWriter.publicKey);
-        }
-    }
-
     /**
      * Removes active connections to writers that are no longer valid (e.g., removed/soft-deleted).
      * @param {Uint8Array} publicKey - The public key of the stale connection to be removed.
@@ -161,40 +120,6 @@ class ValidatorObserverService extends SchedulableService {
         return !this.isInterrupted;
     }
     
-    /**
-     * Counts the number of physically active and connected writers in the network.
-     * This method bridges the gap between the Autobase state (which may include 
-     * offline/dormant writers due to its append-only/soft-delete nature) and the 
-     * actual physical network layer. It ensures the admin threshold policy is 
-     * evaluated against truly active nodes rather than historical state.
-     *
-     * @param {Array<Object>} writers - The deduplicated list of writers from the Autobase.
-     * @param {Object} adminEntry - The current admin node entry.
-     * @returns {number} The count of alive, fully connected writers (including self).
-     */
-    #countAliveWriters(writers, adminEntry) {
-        let aliveCount = 0;
-        const manager = this.#network.validatorConnectionManager;
-
-        for (const w of writers) {
-            // Ignores the admin in the threshold calculation
-            if (w.address === adminEntry?.address) continue;
-
-            // Always counts the current node as alive if it's in the valid writers list
-            if (w.address === this.#address) {
-                aliveCount++;
-                continue;
-            }
-
-            // Counts only fully connected nodes (ignores pending or offline peers)
-            if (manager.connected(w.publicKey)) {
-                aliveCount++;
-            }
-        }
-
-        return aliveCount;
-    }
-
     /**
      * Starts the validator observer loop.
      * Initializes the scheduler and bootstrap state.
@@ -226,8 +151,8 @@ class ValidatorObserverService extends SchedulableService {
      * Main worker loop (executed periodically).
      *
      * Flow:
-     * 1. Fetch admin + writers (cached).
-     * 2. Enforce admin connection policy.
+     * 1. Revalidate connected peers against current roles and the admin threshold.
+     * 2. Fetch admin + writers (cached).
      * 3. Skip if the connection pool is full.
      * 4. Select candidates.
      * 5. Attempt connections (with pacing).
@@ -245,18 +170,23 @@ class ValidatorObserverService extends SchedulableService {
         }
 
         try {
+            // Recheck bounded connection pools on every cycle, even when discovery
+            // is cached or the pool is full. Removing a role preserves replication.
+            const manager = this.#network.validatorConnectionManager;
+            for (const publicKey of manager.connectedPeers()) {
+                if (!await this.#state.isValidatorAddress(publicKeyToAddress(publicKey, this.#config))) {
+                    manager.remove(publicKey);
+                }
+            }
             const adminEntry = await this.#getAdminEntryCached();
             const writers = await this.#getWritersCached(adminEntry);
             
             if (writers.length === 0) return next(interval);
 
-            this.#enforceAdminPolicy(writers, adminEntry);
-
-            const manager = this.#network.validatorConnectionManager;
             // CEILING: do not exceed the max connections limit
             if (manager.maxConnectionsReached()) return next(interval); 
             
-            const { candidates, slots} = this.#selectCandidates(writers, adminEntry);
+            const { candidates, slots} = this.#selectCandidates(writers);
             if (candidates.length > 0) {
                 await this.#processCandidates(candidates, slots);
             }
@@ -389,7 +319,8 @@ class ValidatorObserverService extends SchedulableService {
                     const addressBuffer = await this.#state.getRegisteredWriterKey(writerKeyHex);
 
                     if (!addressBuffer || b4a.byteLength(addressBuffer) !== this.#config.addressLength) {
-                        this.#keyDecodeCache.set(writerKeyHex, null);
+                        // Autobase membership can arrive before the signed address mapping.
+                        // Retry on the next scan instead of caching a transient absence forever.
                         continue;
                     }
 
@@ -410,9 +341,7 @@ class ValidatorObserverService extends SchedulableService {
 
                 const { addr, publicKey, publicKeyHex } = decodedIdentity;
 
-                if (value.isIndexer && addr !== adminEntry?.address) continue;
-
-                if (value.isRemoved) {
+                if (value.isRemoved || (value.isIndexer && addr !== adminEntry?.address)) {
                     removedMap.set(addr, publicKey);
                     continue;
                 }
@@ -436,7 +365,7 @@ class ValidatorObserverService extends SchedulableService {
     /**
      * Attempts to establish a connection with a validator candidate.
      *
-     * Assumes the candidate was pre-filtered and validated during scan/selection.
+     * Revalidates the role because discovery may predate a promotion or removal.
      *
      * Behavior:
      * - Delegates connection attempt to the network layer.
@@ -445,6 +374,7 @@ class ValidatorObserverService extends SchedulableService {
      */
     async #tryConnect(candidate) {
         try {
+            if (!await this.#state.isValidatorAddress(candidate.address)) return CONNECTION_STATUS.IGNORED;
             return await this.#network.tryConnect(candidate.publicKeyHex, "validator");
         } catch (err) {
             this.#logger.error(`Validator connection attempt failed: ${err.message}`);

package/src/core/state/State.js

@@ -418,13 +418,26 @@ class State extends ReadyResource {
     }
 
     async isAdminAllowedToValidate() {
-        if (!this.writingKey) return false;
-
-        const isAdmin = this.writingKey.toString('hex') === this.#config.bootstrap.toString('hex');
-        const isIndexer = this.isIndexer();
+        if (!this.isWritable() || !this.isIndexer() || !await this.isAdmin()) return false;
         const activeWriters = await this.getActiveWriterCount(true);
-        const lengthCondition = activeWriters < this.#config.maxWritersForAdminIndexerConnection;
-        return !!(isAdmin && isIndexer && lengthCondition);
+        return activeWriters < this.#config.maxWritersForAdminIndexerConnection;
+    }
+
+    /**
+     * Checks a remote validator against the current local view, including pending
+     * role changes. Cached discovery and established transports do not grant a role.
+     */
+    async isValidatorAddress(address) {
+        const entry = await this.getNodeEntryUnsigned(address);
+        if (!entry?.isWriter) return false;
+        if (!entry.isIndexer) {
+            const signedEntry = await this.getNodeEntry(address);
+            return !!signedEntry?.isWriter && !signedEntry.isIndexer;
+        }
+
+        const admin = await this.getAdminEntry();
+        if (address !== admin?.address || !entry.wk || !admin.wk || !b4a.equals(entry.wk, admin.wk)) return false;
+        return await this.getActiveWriterCount(true) < this.#config.maxWritersForAdminIndexerConnection;
     }
 
     async isAddressWhitelisted(address) {
@@ -676,6 +689,12 @@ class State extends ReadyResource {
         for await (const entry of historyStream) {
             if (isTransactionRecordPut(entry)) {
                 hashes.push({ hash: entry.key, confirmed_length: entry.seq });
+            } else if (entry.type === 'put' && entry.key.startsWith(EntryType.EPOCH_HASH)) {
+                // Epoch records share this history, but have their own key namespace.
+                const hash = entry.key.slice(EntryType.EPOCH_HASH.length);
+                if (hash.length === HASH_BYTE_LENGTH * 2 && isHexString(hash)) {
+                    hashes.push({ hash, confirmed_length: entry.seq });
+                }
             }
         }
 
@@ -5561,6 +5580,28 @@ class State extends ReadyResource {
         return Status.SUCCESS;
     }
 
+    async getUnsignedConsensusConfig() {
+        // Keep the pointer and record in the same view while unsigned state can change.
+        const snapshot = this.#base.view.snapshot();
+        try {
+            const currentConfigPointer = (await snapshot.get(EntryType.CONSENSUS_CONFIG_CURRENT))?.value;
+            if (_.isNil(currentConfigPointer)) return null;
+
+            if (!b4a.isBuffer(currentConfigPointer) || currentConfigPointer.length !== CONSENSUS_CONFIG_INDEX_SIZE) {
+                throw new Error('Invalid current consensus config pointer.');
+            }
+
+            const currentConfigIndex = currentConfigPointer.readUInt32BE(0);
+            const encodedConsensusConfig = (await snapshot.get(EntryType.CONSENSUS_CONFIG_RECORD + currentConfigIndex))?.value;
+            if (_.isNil(encodedConsensusConfig)) {
+                throw new Error(`Consensus config record ${currentConfigIndex} does not exist.`);
+            }
+
+            return decodeVersionedConsensusConfig(encodedConsensusConfig);
+        } finally {
+            await snapshot.close();
+        }
+    }
 }
 
 export default State;

package/src/index.js

@@ -37,7 +37,8 @@ import {
     encodeApplyOperation,
     encodeConsensusConfig,
     safeDecodeApplyOperation,
-    safeEncodeApplyOperation
+    safeEncodeApplyOperation,
+    decodeEpochRecord
 } from "./codecs/apply/applyOperationCodec.js";
 import { encodeVdfConfig } from "./codecs/consensus/v1/vdfConfigCodec.js";
 import PartialTransactionValidator from "./core/network/protocols/validators/shared/validators/PartialTransactionValidator.js";
@@ -425,7 +426,16 @@ export class MainSettlementBus extends ReadyResource {
 
     async fetchBulkTxPayloads(hashes) {
         const response = { results: [], missing: [] };
-        const results = await Promise.all(hashes.map((hash) => this.getConfirmedTxInfo(hash)));
+        const results = await Promise.all(hashes.map(async (hash) => {
+            const transaction = await this.getConfirmedTxInfo(hash);
+            if (transaction) return transaction.decoded;
+
+            const epochRecord = await this.#state.getEpochProof(hash);
+            if (epochRecord === null) return null;
+
+            // This hash identifies the stored epoch record, not an original transaction.
+            return { type: OperationType.SET_EPOCH, seo: decodeEpochRecord(epochRecord) };
+        }));
 
         results.forEach((result, index) => {
             const hash = hashes[index];
@@ -434,7 +444,7 @@ export class MainSettlementBus extends ReadyResource {
                 return;
             }
 
-            const decodedResult = normalizeDecodedPayloadForJson(result.decoded, this.#config);
+            const decodedResult = normalizeDecodedPayloadForJson(result, this.#config);
             response.results.push({ hash, payload: decodedResult });
         });
 
@@ -1290,6 +1300,19 @@ export class MainSettlementBus extends ReadyResource {
             expectedKeys.every(key => Object.hasOwn(value, key))
         );
     }
+
+    async getCurrentEpoch(confirmed = true) {
+        const epoch = confirmed
+            ? await this.#state.getCurrentEpoch()
+            : await this.#state.getCurrentEpochUnsigned();
+        return epoch === null ? null : epoch.toString();
+    }
+
+    async getConsensusConfig(confirmed = true) {
+        return confirmed
+            ? this.#state.getSignedConsensusConfig()
+            : this.#state.getUnsignedConsensusConfig();
+    }
 }
 
 export default MainSettlementBus;