trac-msb 0.2.18 → 0.2.20

package/src/config/env.js

@@ -1,7 +1,7 @@
-import { TRAC_NETWORK_MSB_MAINNET_PREFIX, TRAC_NETWORK_MSB_TESTNET1_PREFIX } from 'trac-wallet/constants.js';
+import { TRAC_NETWORK_MSB_MAINNET_PREFIX, TRAC_NETWORK_MSB_TESTNET1_PREFIX } from 'trac-wallet';
 import { TRAC_NETWORK_TESTNET_ID, TRAC_NETWORK_MAINNET_ID } from 'trac-crypto-api/constants.js';
-import { address } from 'trac-crypto-api';
 import { Config } from './config.js';
+import { address } from 'trac-crypto-api';
 
 export const ENV = {
     MAINNET: 'mainnet',
@@ -18,16 +18,23 @@ const configData = {
         bech32mHrpLength: TRAC_NETWORK_MSB_TESTNET1_PREFIX.length + 1, // len(addressPrefix + separator)
         bootstrap: 'c184f4ad8e9cf5e911f9415b60e7dcfb30aed73ebd8a402ef68e1b154624f5ef',
         channel: '1111trac1network1msb1testnet1111',
-        dhtBootstrap: ['116.202.214.149:10001', '157.180.12.214:10001', 'node1.hyperdht.org:49737', 'node2.hyperdht.org:49737', 'node3.hyperdht.org:49737'], // these are used to peer discovery
+        dhtBootstrap: ['116.202.214.149:10001','157.180.12.214:10001','node1.hyperdht.org:49737','node2.hyperdht.org:49737','node3.hyperdht.org:49737'], // these are used to peer discovery
         derivationPath: address.TESNET_DERIVATION_PATH,
+        enableValidatorObserver: true,
+        pollInterval: 500, // Validator observer poll interval
+        adminCacheTTL: 10_000, // Admin cache TTL ms
+        validatorConnectionAttemptDelay: 5, // Delay between validator connection attempts (ms)
+        bootstrapTimeout: 60_000, // time used (ms) to connect to new validators at bootstrap
+        writersShortCacheTTL: 10_000, // short TTL during bootstrap
+        writersLongCacheTTL: 120_000, // long TTL after bootstrap
+        maxValidators: 50,
+        maxWritersForAdminIndexerConnection: 10, // Connectivity constants
         disableRateLimit: false,
         enableErrorApplyLogs: true,
         enableInteractiveMode: true,
         enableRoleRequester: false,
         enableTxApplyLogs: true,
-        enableValidatorObserver: true,
         enableWallet: true,
-        maxValidators: 50,
         maxRetries: 3,
         messageThreshold: 3,
         messageValidatorRetryDelay: 1000, //How long to wait before retrying (ms) MESSAGE_VALIDATOR_RETRY_DELAY_MS
@@ -39,7 +46,6 @@ const configData = {
         maxParallel: 64, // Connectivity constants
         maxServerConnections: Infinity, // Connectivity constants
         maxClientConnections: Infinity, // Connectivity constants
-        maxWritersForAdminIndexerConnection: 10, // Connectivity constants
         processIntervalMs: 50, // Pool constants
         transactionPoolSize: 1000, // Operation handler constants
         rateLimitCleanupIntervalMs: 120_000, // Rate limiting constants
@@ -61,16 +67,23 @@ const configData = {
         bech32mHrpLength: TRAC_NETWORK_MSB_MAINNET_PREFIX.length + 1, // len(addressPrefix + separator)
         bootstrap: 'acbc3a4344d3a804101d40e53db1dda82b767646425af73599d4cd6577d69685',
         channel: '0000trac0network0msb0mainnet0000',
-        dhtBootstrap: ['116.202.214.149:10001', '157.180.12.214:10001', 'node1.hyperdht.org:49737', 'node2.hyperdht.org:49737', 'node3.hyperdht.org:49737'],
+        dhtBootstrap: ['116.202.214.149:10001','157.180.12.214:10001','node1.hyperdht.org:49737','node2.hyperdht.org:49737','node3.hyperdht.org:49737'],
         derivationPath: address.MAINNET_DERIVATION_PATH,
+        enableValidatorObserver: true,
+        pollInterval: 500, // Validator observer poll interval
+        adminCacheTTL: 3_600_000, // Admin cache TTL ms
+        validatorConnectionAttemptDelay: 5, // Delay between validator connection attempts (ms)
+        bootstrapTimeout: 120_000, // time used (ms) to connect to new validators at bootstrap
+        writersShortCacheTTL: 2_000, // short TTL during bootstrap
+        writersLongCacheTTL: 120_000, // long TTL after bootstrap
+        maxValidators: 50,
+        maxWritersForAdminIndexerConnection: 10, // Connectivity constants
         disableRateLimit: false,
         enableErrorApplyLogs: false,
         enableInteractiveMode: true,
         enableRoleRequester: false,
         enableTxApplyLogs: false,
-        enableValidatorObserver: true,
         enableWallet: true,
-        maxValidators: 50,
         maxRetries: 3,
         messageThreshold: 3,
         messageValidatorRetryDelay: 1000, //How long to wait before retrying (ms) MESSAGE_VALIDATOR_RETRY_DELAY_MS
@@ -82,7 +95,6 @@ const configData = {
         maxParallel: 64, // Connectivity constants
         maxServerConnections: Infinity, // Connectivity constants
         maxClientConnections: Infinity, // Connectivity constants
-        maxWritersForAdminIndexerConnection: 10, // Connectivity constants
         processIntervalMs: 50, // Pool constants
         transactionPoolSize: 1000, // Operation handler constants
         rateLimitCleanupIntervalMs: 120_000, // Rate limiting constants
@@ -97,23 +109,30 @@ const configData = {
         storeName: 'mainnet',
     },
     [ENV.DEVELOPMENT]: {
-        debug: true,
+        debug: false,
         addressLength: 63,
         addressPrefix: TRAC_NETWORK_MSB_MAINNET_PREFIX,
         addressPrefixLength: TRAC_NETWORK_MSB_MAINNET_PREFIX.length,
         bech32mHrpLength: TRAC_NETWORK_MSB_MAINNET_PREFIX.length + 1, // len(addressPrefix + separator)
-        bootstrap: 'e90cca53847a12a82f3bf0f67401e45e2ccc1698ee163e61414c2894eb3c6b12',
+        bootstrap: '12f7f1668eac2e691e17cbc6a53e509c5cee78cdcac562313091c64e5fd077d6',
         channel: '12312313123123',
-        dhtBootstrap: ['116.202.214.149:10001', '157.180.12.214:10001', 'node1.hyperdht.org:49737', 'node2.hyperdht.org:49737', 'node3.hyperdht.org:49737'],
+        dhtBootstrap: ['116.202.214.149:10001','157.180.12.214:10001','node1.hyperdht.org:49737','node2.hyperdht.org:49737','node3.hyperdht.org:49737'],
         derivationPath: address.MAINNET_DERIVATION_PATH,
+        enableValidatorObserver: true,
+        pollInterval: 500, // Validator observer poll interval
+        adminCacheTTL: 60_000, // Admin cache TTL ms
+        validatorConnectionAttemptDelay: 5, // Delay between validator connection attempts (ms)
+        bootstrapTimeout: 30_000,  // time used (ms) to connect to new validators at bootstrap
+        writersShortCacheTTL: 1_000, // short TTL during bootstrap
+        writersLongCacheTTL: 2_000, // long TTL after bootstrap
+        maxValidators: 10,
+        maxWritersForAdminIndexerConnection: 10, // Connectivity constants
         disableRateLimit: false,
         enableErrorApplyLogs: true,
         enableInteractiveMode: true,
         enableRoleRequester: false,
         enableTxApplyLogs: true,
-        enableValidatorObserver: true,
         enableWallet: true,
-        maxValidators: 6,
         maxRetries: 3,
         messageThreshold: 1000,
         messageValidatorRetryDelay: 1000, //How long to wait before retrying (ms) MESSAGE_VALIDATOR_RETRY_DELAY_MS
@@ -125,7 +144,6 @@ const configData = {
         maxParallel: 64, // Connectivity constants
         maxServerConnections: Infinity, // Connectivity constants
         maxClientConnections: Infinity, // Connectivity constants
-        maxWritersForAdminIndexerConnection: 10, // Connectivity constants
         processIntervalMs: 50, // Pool constants
         transactionPoolSize: 1000, // Operation handler constants
         rateLimitCleanupIntervalMs: 120_000, // Rate limiting constants
@@ -135,7 +153,7 @@ const configData = {
         pendingRequestTimeout: 3000, // constant after which time the transaction will be considered invalid
         txCommitTimeout: 2200,
         txPoolSize: 1000, // size of transaction pool
-        validatorHealthCheckInterval: 5 * 60 * 1000, // How often to check validator health (ms)
+        validatorHealthCheckInterval: 1_000, // How often to check validator health (ms)
         storesDirectory: 'stores/',
         storeName: 'development',
     }
@@ -143,4 +161,4 @@ const configData = {
 
 export const createConfig = (environment, options) => {
     return new Config(options, configData[environment])
-}
+}

package/src/core/network/Network.js

@@ -8,16 +8,17 @@ import NetworkMessages from './protocols/NetworkMessages.js';
 import { sleep } from '../../utils/helpers.js';
 import {
     TRAC_NAMESPACE,
-    EventType
+    EventType,
+    CONNECTION_STATUS
 } from '../../utils/constants.js';
 import ConnectionManager from './services/ConnectionManager.js';
 import MessageOrchestrator from './services/MessageOrchestrator.js';
-import NetworkWalletFactory from './identity/NetworkWalletFactory.js';
 import TransactionRateLimiterService from './services/TransactionRateLimiterService.js';
 import PendingRequestService from './services/PendingRequestService.js';
 import TransactionCommitService from "./services/TransactionCommitService.js";
 import ValidatorHealthCheckService from './services/ValidatorHealthCheckService.js';
 import { Logger } from '../../utils/logger.js';
+import { WalletProvider } from 'trac-wallet';
 
 const wakeup = new w();
 
@@ -29,7 +30,6 @@ class Network extends ReadyResource {
     #validatorConnectionManager;
     #validatorMessageOrchestrator;
     #config;
-    #identityProvider = null;
     #pendingConnections;
     #connectTimeoutMs;
     #maxPendingConnections;
@@ -39,6 +39,7 @@ class Network extends ReadyResource {
     #wallet;
     #validatorHealthCheckService;
     #logger;
+    #closing = false;
 
     /**
      * @param {State} state
@@ -82,6 +83,7 @@ class Network extends ReadyResource {
 
     async _open() {
         this.#logger.info('Network initialization...');
+        this.#closing = false;
 
         this.setupNetworkListeners();
 
@@ -91,6 +93,7 @@ class Network extends ReadyResource {
 
     async _close() {
         this.#logger.info('Network: closing gracefully...');
+        this.#closing = true;
         await this.transactionPoolService.stopPool();
         await sleep(100);
         await this.#validatorObserverService.stopValidatorObserver();
@@ -104,8 +107,15 @@ class Network extends ReadyResource {
         this.#pendingRequestsService.close();
         this.#transactionCommitService.close();
 
-        if (this.#swarm !== null) {
-            this.#swarm.destroy();
+        const swarm = this.#swarm;
+        if (swarm !== null) {
+            if (typeof swarm.removeAllListeners === 'function') {
+                swarm.removeAllListeners('connection');
+            }
+            await swarm.destroy();
+            if (this.#swarm === swarm) {
+                this.#swarm = null;
+            }
         }
     }
 
@@ -126,7 +136,7 @@ class Network extends ReadyResource {
 
             if (type === 'validator') {
                 try {
-                    await connection.protocolSession.probe();
+                    if (!connection.protocolSession.isProbed()) await connection.protocolSession.probe();
                 } catch (err) {
                     this.#logger.debug(`failed to probe peer with publicKey ${publicKey}: ${err?.message ?? err}`);
                 }
@@ -167,9 +177,13 @@ class Network extends ReadyResource {
         store,
         wallet,
     ) {
+        this.#assertCanReplicate();
+
         if (!this.#swarm) {
-            const keyPair = await this.initializeNetworkingKeyPair(store, wallet);
-            this.#wallet = this.#getNetworkWalletWrapper(wallet, keyPair);
+            const { wallet: wrappedWallet, keyPair } = await this.#getOrGenerateWallet(store, wallet);
+            this.#assertCanReplicate();
+
+            this.#wallet = wrappedWallet
             this.#validatorMessageOrchestrator.setWallet(this.#wallet);
 
             this.#swarm = new Hyperswarm({
@@ -193,19 +207,49 @@ class Network extends ReadyResource {
             );
             this.#validatorHealthCheckService = new ValidatorHealthCheckService(this.#config);
             await this.#validatorHealthCheckService.ready();
+            this.#assertCanReplicate();
+
             this.#validatorConnectionManager.subscribeToHealthChecks(this.#validatorHealthCheckService);
 
             this.#logger.info(`Channel: ${b4a.toString(this.#config.channel)}`);
 
             this.#swarm.on('connection', async (connection) => {
-                // Per-peer connection initialization:
-                // - attach Protomux (legacy + v1 channels/messages)
-                // - attach connection.protocolSession (used later by tryConnect / orchestrators to send messages)
-                await this.#networkMessages.setupProtomuxMessages(connection);
+                if (this.#closing) {
+                    this.#destroyConnection(connection);
+                    return;
+                }
+
+                try {
+                    // Per-peer connection initialization:
+                    // - attach Protomux (legacy + v1 channels/messages)
+                    // - attach connection.protocolSession (used later by tryConnect / orchestrators to send messages)
+                    await this.#networkMessages.setupProtomuxMessages(connection);
+
+                    // Pear v3 can deliver a late swarm connection while shutdown is
+                    // already closing the Corestore. Do not replicate a connection
+                    // after close has begun; store.replicate would otherwise throw.
+                    if (this.#closing || this.#swarm === null) {
+                        this.#destroyConnection(connection);
+                        return;
+                    }
 
-                // ATTENTION: Must be called AFTER the protomux init above
-                const stream = store.replicate(connection);
-                wakeup.addStream(stream);
+                    // ATTENTION: Must be called AFTER the protomux init above
+                    const stream = store.replicate(connection);
+                    wakeup.addStream(stream);
+                } catch (error) {
+                    const publicKey = connection.remotePublicKey
+                        ? b4a.toString(connection.remotePublicKey, 'hex')
+                        : 'unknown';
+                    this.#pendingRequestsService.rejectPendingRequestsForPeer(
+                        publicKey,
+                        error ?? new Error('Connection setup failed')
+                    );
+                    this.#destroyConnection(connection);
+                    if (!this.#closing) {
+                        this.#logger.error(error?.message ?? 'Unknown network connection setup error');
+                    }
+                    return;
+                }
 
                 const publicKey = b4a.toString(connection.remotePublicKey, 'hex');
                 if (this.#pendingConnections.has(publicKey)) {
@@ -218,9 +262,13 @@ class Network extends ReadyResource {
                         publicKey,
                         new Error('Connection closed before response')
                     );
-                    this.#swarm.leavePeer(connection.remotePublicKey);
+                    this.#swarm?.leavePeer(connection.remotePublicKey);
                     this.#validatorConnectionManager.remove(publicKey);
-                    connection.protocolSession.close();
+                    if (connection.protocolSession) {
+                        try {
+                            connection.protocolSession.close();
+                        } catch {}
+                    }
                 });
 
                 connection.on('error', (error) => {
@@ -255,14 +303,36 @@ class Network extends ReadyResource {
         return this.#pendingConnections.size;
     }
 
-    async initializeNetworkingKeyPair(store, wallet) {
+    disconnectValidatorPeer(publicKey, reason = 'validator peer invalidated') {
+        const publicKeyHex = this.#normalizePublicKey(publicKey);
+        if (!publicKeyHex) return false;
+
+        const hadPendingValidatorConnection = this.#clearPendingValidatorConnection(publicKeyHex);
+        const isTrackedValidator = this.#validatorConnectionManager.exists(publicKeyHex);
+
+        const shouldLeavePeer = hadPendingValidatorConnection || isTrackedValidator;
+
+        if (shouldLeavePeer && this.#swarm?.peers?.has(publicKeyHex)) {
+            this.#logger.debug(`Network.disconnectValidatorPeer: leaving peer ${publicKeyHex}. Reason: ${reason}`);
+            this.#swarm.leavePeer(b4a.from(publicKeyHex, 'hex'));
+        }
+
+        if (isTrackedValidator) {
+            this.#logger.debug(`Network.disconnectValidatorPeer: detaching tracked validator ${publicKeyHex}. Reason: ${reason}`);
+            this.#validatorConnectionManager.remove(publicKeyHex, { endConnection: false });
+        }
+
+        return hadPendingValidatorConnection || isTrackedValidator;
+    }
+
+    async #getOrGenerateWallet(store, wallet) {
         if (!this.#config.enableWallet) {
-            return await store.createKeyPair(TRAC_NAMESPACE);
+            const keyPair = await store.createKeyPair(TRAC_NAMESPACE);
+            const wallet = await new WalletProvider(this.#config).fromSecretKey(keyPair.secretKey)
+            return { keyPair, wallet }
         } else {
-            return {
-                publicKey: wallet.publicKey,
-                secretKey: wallet.secretKey
-            };
+            const keyPair = { publicKey: wallet.publicKey, secretKey: wallet.secretKey }
+            return { keyPair, wallet }
         }
     }
 
@@ -270,7 +340,7 @@ class Network extends ReadyResource {
         if (this.#swarm === null) throw new Error('Network swarm is not initialized');
         if (this.#pendingConnections.has(publicKey) || this.#pendingConnections.size >= this.#maxPendingConnections) {
             this.#logger.debug(`Network.tryConnect: Connection to peer: ${publicKey} as type: ${type} is already pending or max pending connections reached.`);
-            return;
+            return CONNECTION_STATUS.IGNORED;
         }
 
         const timeoutId = setTimeout(() => {
@@ -290,12 +360,14 @@ class Network extends ReadyResource {
 
             if (connection &&
                 connection.protocolSession &&
-                !connection.protocolSession.isProbed() &&
                 !this.#pendingRequestsService.isProbePending(connection.remotePublicKey.toString('hex'))
             ) {
                 await this.#finalizeConnection(publicKey, type, connection);
+                return CONNECTION_STATUS.CONNECTED;
             }
         }
+        
+        return CONNECTION_STATUS.PENDING;
     }
 
     async #finalizeConnection(publicKey, type, connection) {
@@ -304,18 +376,42 @@ class Network extends ReadyResource {
         this.#logger.debug(`Network.finalizeConnection: Connected to peer: ${publicKey} as type: ${type}`);
     }
 
-    #getNetworkWalletWrapper(wallet, keyPair) {
-        if (!this.#identityProvider) {
-            this.#identityProvider = NetworkWalletFactory.provide({
-                enableWallet: this.#config.enableWallet,
-                wallet,
-                keyPair,
-                networkPrefix: this.#config.addressPrefix
-            });
+    #normalizePublicKey(publicKey) {
+        if (typeof publicKey === 'string') return publicKey;
+        if (b4a.isBuffer(publicKey)) return b4a.toString(publicKey, 'hex');
+        return null;
+    }
+
+    #clearPendingValidatorConnection(publicKeyHex) {
+        if (!this.#pendingConnections.has(publicKeyHex)) return false;
+
+        const { timeoutId, type } = this.#pendingConnections.get(publicKeyHex);
+        if (type !== 'validator') return false;
+
+        clearTimeout(timeoutId);
+        this.#pendingConnections.delete(publicKeyHex);
+        return true;
+    }
+
+    #assertCanReplicate() {
+        if (this.#closing || this.closed) {
+            throw new Error('Network is closing or already closed');
         }
-        return this.#identityProvider;
     }
 
+    #destroyConnection(connection) {
+        if (!connection) return;
+        if (connection.protocolSession) {
+            try {
+                connection.protocolSession.close();
+            } catch {}
+        }
+        if (typeof connection.destroy === 'function') {
+            connection.destroy();
+        } else if (typeof connection.end === 'function') {
+            connection.end();
+        }
+    }
 }
 
 export default Network;

package/src/core/network/protocols/ProtocolInterface.js

@@ -6,30 +6,30 @@
 class ProtocolInterface {
     
     // TODO: Refactor this so we don't need to pass a reference for the whole network instance
-    constructor(router, connection, pendingRequestService, config) {
+    constructor(_router, _connection, _pendingRequestService, _config) {
         if (new.target === ProtocolInterface) {
             throw new Error('ProtocolInterface cannot be instantiated directly');
         }
     }
 
-    init(connection) {
+    init(_connection) {
         // Abstract method. Need to be implemented by subclasses.
         throw new Error('init() method must be implemented by subclass');
     }
 
     // TODO: This method is only kept here because of v1, but it should be probably removed from the interface
     // Remove it after we finish refactoring v1 protocol
-    decode(message) {
+    decode(_message) {
         // Abstract method. Need to be implemented by subclasses.
         throw new Error('decode() method must be implemented by subclass');
     }
 
-    async send(message) {
+    async send(_message) {
         // Abstract method. Need to be implemented by subclasses.
         throw new Error('send() method must be implemented by subclass');
     }
 
-    sendAndForget(message) {
+    sendAndForget(_message) {
         // Abstract method. Need to be implemented by subclasses.
         throw new Error('sendAndForget() method must be implemented by subclass');
     }

package/src/core/network/protocols/connectionPolicies.js

@@ -2,6 +2,11 @@ import { ResultCode } from '../../../utils/constants.js';
 
 // TODO: Consider how to behave with ResultCode.UNSPECIFIED
 
+/**
+ * Sender actions are consumed by the message orchestrator after a validator responds.
+ * They define whether the validator should be treated as successful, rotated out, or kept
+ * in the pool without rotation for the current result code.
+ */
 export const SENDER_ACTION = Object.freeze({
     UNDEFINED: 'UNDEFINED',
     SUCCESS: 'SUCCESS',
@@ -9,10 +14,14 @@ export const SENDER_ACTION = Object.freeze({
     NO_ROTATE: 'NO_ROTATE',
 });
 
+// Result codes that mean the validator completed the request successfully.
 const SUCCESS_CODES = new Set([
     ResultCode.OK,
 ]);
 
+// Result codes that should rotate the validator out of the sender pool after the response.
+// In practice these are transport, protocol, validation, or validator-side failures that make
+// the current peer unsuitable to keep as the next sender candidate.
 const ROTATE_CODES = new Set([
     ResultCode.UNSPECIFIED,
     ResultCode.INVALID_PAYLOAD,
@@ -86,3 +95,80 @@ export function resultToValidatorAction(resultCode) {
     if (NO_ROTATE_CODES.has(resultCode)) return SENDER_ACTION.NO_ROTATE;
     return SENDER_ACTION.UNDEFINED;
 }
+
+/**
+ * Keep connection result codes:
+ * - ResultCode.OK
+ * - ResultCode.TIMEOUT
+ * - ResultCode.TX_ACCEPTED_PROOF_UNAVAILABLE
+ * - ResultCode.TX_ALREADY_PENDING
+ * - ResultCode.TX_HASH_INVALID_FORMAT
+ * - ResultCode.INTERNAL_ENQUEUE_VALIDATION_FAILED
+ * - ResultCode.TX_COMMITTED_RECEIPT_MISSING
+ * - ResultCode.VALIDATOR_RESPONSE_TX_TYPE_INVALID
+ * - ResultCode.VALIDATOR_RESPONSE_TX_TYPE_UNKNOWN
+ * - ResultCode.VALIDATOR_RESPONSE_TX_TYPE_UNSUPPORTED
+ * - ResultCode.VALIDATOR_RESPONSE_SCHEMA_INVALID
+ * - ResultCode.PENDING_REQUEST_MISSING_TX_DATA
+ * - ResultCode.PROOF_PAYLOAD_MISMATCH
+ * - ResultCode.VALIDATOR_WRITER_KEY_NOT_REGISTERED
+ * - ResultCode.VALIDATOR_ADDRESS_MISMATCH
+ * - ResultCode.VALIDATOR_NODE_ENTRY_NOT_FOUND
+ * - ResultCode.VALIDATOR_NODE_NOT_WRITER
+ * - ResultCode.VALIDATOR_WRITER_KEY_MISMATCH
+ * - ResultCode.VALIDATOR_TX_OBJECT_INVALID
+ * - ResultCode.VALIDATOR_VA_MISSING
+ */
+const VALIDATOR_SIDE_END_CONNECTION_CODES = new Set([
+    // BASE_TRANSPORT_AND_VALIDATOR_STATUS
+    ResultCode.UNSPECIFIED,
+    ResultCode.INVALID_PAYLOAD,
+    ResultCode.RATE_LIMITED,
+    ResultCode.SIGNATURE_INVALID,
+    ResultCode.UNEXPECTED_ERROR,
+    ResultCode.NODE_HAS_NO_WRITE_ACCESS,
+    ResultCode.NODE_OVERLOADED,
+
+    // SHARED_VALIDATORS_REQUEST_PAYLOAD
+    ResultCode.OPERATION_TYPE_UNKNOWN,
+    ResultCode.SCHEMA_VALIDATION_FAILED,
+    ResultCode.REQUESTER_ADDRESS_INVALID,
+    ResultCode.REQUESTER_PUBLIC_KEY_INVALID,
+    ResultCode.TX_HASH_MISMATCH,
+    ResultCode.TX_SIGNATURE_INVALID,
+    ResultCode.TX_EXPIRED,
+    ResultCode.TX_ALREADY_EXISTS,
+    ResultCode.OPERATION_ALREADY_COMPLETED,
+    ResultCode.REQUESTER_NOT_FOUND,
+    ResultCode.INSUFFICIENT_FEE_BALANCE,
+    ResultCode.EXTERNAL_BOOTSTRAP_EQUALS_MSB_BOOTSTRAP,
+    ResultCode.SELF_VALIDATION_FORBIDDEN,
+    ResultCode.ROLE_NODE_ENTRY_NOT_FOUND,
+    ResultCode.ROLE_NODE_ALREADY_WRITER,
+    ResultCode.ROLE_NODE_NOT_WHITELISTED,
+    ResultCode.ROLE_NODE_NOT_WRITER,
+    ResultCode.ROLE_NODE_IS_INDEXER,
+    ResultCode.ROLE_ADMIN_ENTRY_MISSING,
+    ResultCode.ROLE_INVALID_RECOVERY_CASE,
+    ResultCode.ROLE_UNKNOWN_OPERATION,
+    ResultCode.ROLE_INVALID_WRITER_KEY,
+    ResultCode.ROLE_INSUFFICIENT_FEE_BALANCE,
+    ResultCode.MSB_BOOTSTRAP_MISMATCH,
+    ResultCode.EXTERNAL_BOOTSTRAP_NOT_DEPLOYED,
+    ResultCode.EXTERNAL_BOOTSTRAP_TX_MISSING,
+    ResultCode.EXTERNAL_BOOTSTRAP_MISMATCH,
+    ResultCode.BOOTSTRAP_ALREADY_EXISTS,
+    ResultCode.TRANSFER_RECIPIENT_ADDRESS_INVALID,
+    ResultCode.TRANSFER_RECIPIENT_PUBLIC_KEY_INVALID,
+    ResultCode.TRANSFER_AMOUNT_TOO_LARGE,
+    ResultCode.TRANSFER_SENDER_NOT_FOUND,
+    ResultCode.TRANSFER_INSUFFICIENT_BALANCE,
+    ResultCode.TRANSFER_RECIPIENT_BALANCE_OVERFLOW,
+
+    // VALIDATOR_RESPONSE_PROOF_AND_IDENTITY_VALIDATION
+    ResultCode.TX_INVALID_PAYLOAD,
+]);
+
+export function shouldEndConnection(resultCode) {
+    return VALIDATOR_SIDE_END_CONNECTION_CODES.has(resultCode);
+}

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

@@ -14,7 +14,7 @@ class NetworkMessageRouter {
 
     /**
      * @param {State} state
-     * @param {PeerWallet} wallet
+     * @param {IWallet} wallet
      * @param {TransactionRateLimiterService} rateLimiterService
      * @param {TransactionPoolService} txPoolService
      * @param {Config} config

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

@@ -10,7 +10,7 @@ class BaseStateOperationHandler {
 
     /**
      * @param {State} state
-     * @param {PeerWallet} wallet
+     * @param {IWallet} wallet
      * @param {TransactionRateLimiterService} rateLimiter
      * @param {TransactionPoolService} txPoolService
      * @param {Config} config
@@ -69,7 +69,7 @@ class BaseStateOperationHandler {
         }
     }
 
-    async handleOperation(payload, connection) {
+    async handleOperation(_payload, _connection) {
         throw new Error('handleOperation must be implemented by child class');
     }
 

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

@@ -1,5 +1,5 @@
 import { NETWORK_MESSAGE_TYPES } from '../../../../../utils/constants.js';
-import PeerWallet from 'trac-wallet';
+import tracCryptoApi from 'trac-crypto-api';
 import b4a from 'b4a';
 
 class LegacyGetRequestHandler {
@@ -26,7 +26,7 @@ class LegacyGetRequestHandler {
     }
 
     async handleGetValidatorResponse(connection, channelString) {
-        const nonce = PeerWallet.generateNonce().toString('hex');
+        const nonce = b4a.toString(tracCryptoApi.nonce.generate(), 'hex');
         const payload = {
             op: 'validatorResponse',
             wk: this.state.writingKey.toString('hex'),
@@ -39,7 +39,7 @@ class LegacyGetRequestHandler {
 
 
         const hashInput = b4a.from(JSON.stringify(payload), 'utf8');
-        const hash = await PeerWallet.blake3(hashInput);
+        const hash = await tracCryptoApi.hash.blake3(hashInput);
         const sig = this.#wallet.sign(hash);
 
         const responseMessage = {

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

@@ -14,7 +14,7 @@ class LegacyRoleOperationHandler extends BaseStateOperationHandler {
 
     /**
      * @param {State} state
-     * @param {PeerWallet} wallet
+     * @param {IWallet} wallet
      * @param {TransactionRateLimiterService} rateLimiter
      * @param {TransactionPoolService} txPoolService
      * @param {Config} config

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

@@ -22,7 +22,7 @@ class LegacySubnetworkOperationHandler extends BaseStateOperationHandler {
 
     /**
      * @param {State} state
-     * @param {PeerWallet} wallet
+     * @param {IWallet} wallet
      * @param {TransactionRateLimiterService} rateLimiter
      * @param {TransactionPoolService} txPoolService
      * @param {Config} config

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

@@ -14,7 +14,7 @@ class LegacyTransferOperationHandler extends BaseStateOperationHandler {
 
     /**
      * @param {State} state
-     * @param {PeerWallet} wallet
+     * @param {IWallet} wallet
      * @param {TransactionRateLimiterService} rateLimiter
      * @param {TransactionPoolService} txPoolService
      * @param {Config} config