trac-msb 0.2.18 → 0.2.19

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;
@@ -126,7 +126,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}`);
                 }
@@ -168,8 +168,8 @@ class Network extends ReadyResource {
         wallet,
     ) {
         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.#wallet = wrappedWallet
             this.#validatorMessageOrchestrator.setWallet(this.#wallet);
 
             this.#swarm = new Hyperswarm({
@@ -255,14 +255,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 +292,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 +312,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 +328,22 @@ 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
-            });
-        }
-        return this.#identityProvider;
+    #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;
+    }
 }
 
 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

package/src/core/network/protocols/legacy/validators/base/BaseResponse.js

@@ -1,6 +1,5 @@
 import b4a from 'b4a';
-import PeerWallet from 'trac-wallet';
-import State from '../../../../../state/State.js';
+import tracCryptoApi from 'trac-crypto-api';
 
 /*
     BaseResponse class for handling common validation logic for network responses.
@@ -9,18 +8,16 @@ import State from '../../../../../state/State.js';
 class BaseResponse {
     #wallet;
     #state;
-    #config
 
     /**
      * 
      * @param {State} state 
-     * @param {PeerWallet} wallet 
+     * @param {IWallet} wallet
      * @param {Config} config
      */
-    constructor(state, wallet, config) {
+    constructor(state, wallet, _config) {
         this.#state = state;
         this.#wallet = wallet;
-        this.#config = config;
     }
 
     get state() {
@@ -66,11 +63,11 @@ class BaseResponse {
         switch (type) {
             case 'admin':
                 const adminEntry = await this.state.getAdminEntry();
-                publicKey = PeerWallet.decodeBech32m(adminEntry.address);
+                publicKey = tracCryptoApi.address.decode(adminEntry.address);
 
                 break;
             default:
-                publicKey = PeerWallet.decodeBech32m(message.address);
+                publicKey = tracCryptoApi.address.decode(message.address);
         }
 
         if (!publicKey) {
@@ -80,7 +77,7 @@ class BaseResponse {
         const messageWithoutSig = { ...message };
         delete messageWithoutSig.sig;
         const hashInput = b4a.from(JSON.stringify(messageWithoutSig), 'utf8');
-        const hash = await PeerWallet.blake3(hashInput);
+        const hash = await tracCryptoApi.hash.blake3(hashInput);
         const signature = b4a.from(message.sig, 'hex');
         const verified = this.#wallet.verify(signature, hash, publicKey);
 
@@ -91,4 +88,4 @@ class BaseResponse {
     }
 }
 
-export default BaseResponse;
+export default BaseResponse;

package/src/core/network/protocols/shared/validators/PartialBootstrapDeploymentValidator.js

@@ -1,6 +1,6 @@
 import PartialOperationValidator from './PartialOperationValidator.js';
 import {ResultCode} from "../../../../../utils/constants.js";
-import SharedValidatorRejectionError from '../errors/SharedValidatorRejectionError.js';
+import {V1ProtocolError} from '../../v1/V1ProtocolError.js';
 
 class PartialBootstrapDeploymentValidator extends PartialOperationValidator {
     constructor(state, selfAddress , config) {
@@ -28,7 +28,7 @@ class PartialBootstrapDeploymentValidator extends PartialOperationValidator {
     async validateBootstrapRegistration(payload) {
         const bootstrapString = payload.bdo.bs.toString('hex');
         if (null !== await this.state.getRegisteredBootstrapEntryUnsigned(bootstrapString)) {
-            throw new SharedValidatorRejectionError(
+            throw new V1ProtocolError(
                 ResultCode.BOOTSTRAP_ALREADY_EXISTS,
                 `Bootstrap with hash ${bootstrapString} already exists in the state. Bootstrap must be unique.`
             );