trac-msb 0.2.17 → 0.2.19

package/src/core/network/protocols/v1/validators/V1ValidationSchema.js

@@ -0,0 +1,210 @@
+import Validator from 'fastest-validator';
+import b4a from 'b4a';
+import {
+    NetworkOperationType,
+    NONCE_BYTE_LENGTH,
+    SIGNATURE_BYTE_LENGTH,
+    MAX_PARTIAL_TX_PAYLOAD_BYTE_SIZE,
+    ResultCode
+} from '../../../../../utils/constants.js';
+
+const ALLOWED_RESULT_CODES = Object.values(ResultCode);
+
+class V1ValidationSchema {
+    #validator;
+    #validateV1LivenessRequest;
+    #validateV1LivenessResponse;
+    #validateV1BroadcastTransactionRequest;
+    #validateV1BroadcastTransactionResponse;
+
+    constructor() {
+        this.#validator = new Validator({
+            useNewCustomCheckerFunction: true,
+            messages: {
+                buffer: "The '{field}' field must be a Buffer! Actual: {actual}",
+                bufferLength: "The '{field}' field must be a Buffer with length {expected}! Actual: {actual}",
+                bufferMinLength: "The '{field}' field must be a Buffer with min length {expected}! Actual: {actual}",
+                bufferMaxLength: "The '{field}' field must be a Buffer with max length {expected}! Actual: {actual}",
+                nonZeroBuffer: "The '{field}' field must not be an empty or zero-filled Buffer!",
+                emptyBuffer: "The '{field}' field must not be an empty Buffer! Actual: {actual}",
+            },
+        });
+        const isBuffer = b4a.isBuffer;
+        this.#validator.add("buffer", function ({schema, messages}, _path, _context) {
+            const allowZero = schema.allowZero === true;
+            const allowEmpty = schema.allowEmpty === true;
+            const exactLength = Number.isInteger(schema.length) ? schema.length : null;
+            const minLength = Number.isInteger(schema.min) ? schema.min : null;
+            const maxLength = Number.isInteger(schema.max) ? schema.max : null;
+            return {
+                source:
+                    `
+                        if (!${isBuffer}(value)) {
+                            ${this.makeError({type: "buffer", actual: "value", messages})}
+                            return value;
+                        }
+                        const len = value.length;
+                        ${exactLength === null ? '' : `
+                        if (len !== ${exactLength}) {
+                            ${this.makeError({type: "bufferLength", expected: exactLength, actual: "len", messages})}
+                        }`}
+                        ${minLength === null ? '' : `
+                        if (len < ${minLength}) {
+                            ${this.makeError({type: "bufferMinLength", expected: minLength, actual: "len", messages})}
+                        }`}
+                        ${maxLength === null ? '' : `
+                        if (len > ${maxLength}) {
+                            ${this.makeError({type: "bufferMaxLength", expected: maxLength, actual: "len", messages})}
+                        }`}
+                        if (len === 0 && !${allowEmpty}) {
+                            ${this.makeError({type: "emptyBuffer", actual: "len", messages})}
+                            return value;
+                        }
+                        if (!${allowZero}) {
+                            let isZeroFilled = true;
+                            for (let i = 0; i < len; i++) {
+                                if (value[i] !== 0) {
+                                    isZeroFilled = false;
+                                    break;
+                                }
+                            }
+                            if (isZeroFilled) {
+                                ${this.makeError({type: "nonZeroBuffer", actual: "value", messages})}
+                            }
+                        }
+                            return value;
+                    `
+            };
+        });
+
+        this.#validateV1LivenessRequest = this.#compileV1LivenessRequestSchema();
+        this.#validateV1LivenessResponse = this.#compileV1LivenessResponseSchema();
+        this.#validateV1BroadcastTransactionRequest = this.#compileV1BroadcastTransactionRequestSchema();
+        this.#validateV1BroadcastTransactionResponse = this.#compileV1BroadcastTransactionResponseSchema();
+    }
+
+    #compileV1LivenessRequestSchema() {
+        const schema = {
+            $$strict: true,
+            type: {type: 'number', integer: true, equal: NetworkOperationType.LIVENESS_REQUEST, required: true},
+            id: {type: 'string', min: 1, max: 64, required: true},
+            timestamp: {type: 'number', integer: true, min: 1, max: Number.MAX_SAFE_INTEGER, required: true},
+            liveness_request: {
+                strict: true,
+                type: 'object',
+                props: {
+                    nonce: {type: 'buffer', length: NONCE_BYTE_LENGTH, required: true},
+                    signature: {type: 'buffer', length: SIGNATURE_BYTE_LENGTH, required: true},
+                }
+            },
+            capabilities: {type: 'array', items: 'string', required: true},
+
+        };
+        return this.#validator.compile(schema);
+    }
+
+    validateV1LivenessRequest(operation) {
+        return this.#validateV1LivenessRequest(operation) === true;
+    }
+
+    #compileV1LivenessResponseSchema() {
+        const schema = {
+            $$strict: true,
+            type: {type: 'number', integer: true, equal: NetworkOperationType.LIVENESS_RESPONSE, required: true},
+            id: {type: 'string', min: 1, max: 64, required: true},
+            timestamp: {type: 'number', integer: true, min: 1, max: Number.MAX_SAFE_INTEGER, required: true},
+            liveness_response: {
+                strict: true,
+                type: 'object',
+                props: {
+                    nonce: {type: 'buffer', length: NONCE_BYTE_LENGTH, required: true},
+                    signature: {type: 'buffer', length: SIGNATURE_BYTE_LENGTH, required: true},
+                    result: {type: 'enum', values: ALLOWED_RESULT_CODES, required: true},
+                }
+            },
+            capabilities: {type: 'array', items: 'string', required: true},
+
+        };
+        return this.#validator.compile(schema);
+    }
+
+    validateV1LivenessResponse(operation) {
+        return this.#validateV1LivenessResponse(operation) === true;
+    }
+
+    #compileV1BroadcastTransactionRequestSchema() {
+        const schema = {
+            $$strict: true,
+            type: {
+                type: 'number',
+                integer: true,
+                equal: NetworkOperationType.BROADCAST_TRANSACTION_REQUEST,
+                required: true
+            },
+            id: {type: 'string', min: 1, max: 64, required: true},
+            timestamp: {type: 'number', integer: true, min: 1, max: Number.MAX_SAFE_INTEGER, required: true},
+            broadcast_transaction_request: {
+                strict: true,
+                type: 'object',
+                props: {
+                    data: {
+                        type: 'buffer',
+                        min: 1,
+                        max: MAX_PARTIAL_TX_PAYLOAD_BYTE_SIZE,
+                        allowZero: true,
+                        required: true
+                    },
+                    nonce: {type: 'buffer', length: NONCE_BYTE_LENGTH, required: true},
+                    signature: {type: 'buffer', length: SIGNATURE_BYTE_LENGTH, required: true},
+                }
+            },
+            capabilities: {type: 'array', items: 'string', required: true},
+
+        };
+        return this.#validator.compile(schema);
+    }
+
+    validateV1BroadcastTransactionRequest(operation) {
+        return this.#validateV1BroadcastTransactionRequest(operation) === true;
+    }
+
+    #compileV1BroadcastTransactionResponseSchema() {
+        const schema = {
+            $$strict: true,
+            type: {
+                type: 'number',
+                integer: true,
+                equal: NetworkOperationType.BROADCAST_TRANSACTION_RESPONSE,
+                required: true
+            },
+            id: {type: 'string', min: 1, max: 64, required: true},
+            timestamp: {type: 'number', integer: true, min: 1, max: Number.MAX_SAFE_INTEGER, required: true},
+            broadcast_transaction_response: {
+                strict: true,
+                type: 'object',
+                props: {
+                    nonce: {type: 'buffer', length: NONCE_BYTE_LENGTH, required: true},
+                    signature: {type: 'buffer', length: SIGNATURE_BYTE_LENGTH, required: true},
+                    proof: {type: 'buffer', allowEmpty: true, allowZero: true, required: true},
+                    timestamp: {
+                        type: 'number',
+                        integer: true,
+                        min: 0,
+                        max: Number.MAX_SAFE_INTEGER,
+                        optional: true
+                    },
+                    result: {type: 'enum', values: ALLOWED_RESULT_CODES, required: true},
+                }
+            },
+            capabilities: {type: 'array', items: 'string', required: true},
+
+        };
+        return this.#validator.compile(schema);
+    }
+
+    validateV1BroadcastTransactionResponse(operation) {
+        return this.#validateV1BroadcastTransactionResponse(operation) === true;
+    }
+}
+
+export default V1ValidationSchema;

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

@@ -1,89 +1,161 @@
 import b4a from 'b4a'
-import PeerWallet from "trac-wallet"
-
-
-// -- 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 [ConnectionManager] ==> ', ...args);
+import {EventType, ResultCode} from '../../../utils/constants.js';
+import {publicKeyToAddress} from "../../../utils/helpers.js";
+import {Logger} from "../../../utils/logger.js";
+/**
+ * @typedef {import('hyperswarm').Connection} Connection
+ */
+
+export class ConnectionManagerError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = this.constructor.name;
     }
-};
+}
 
 class ConnectionManager {
     #validators
     #maxValidators
     #config
-
+    #healthCheckService
+    #boundedHealthCheckHandler
+    #logger
     // Note: #validators is using publicKey (Buffer) as key
     // As Buffers are objects, we will rely on internal conversions done by JS to compare them.
     // It would be better to handle these conversions manually by using hex strings as keys to avoid issues
     /**
      * @param {Config} config
      **/
-    constructor(config)  {
+    constructor(config) {
         this.#validators = new Map();
         this.#config = config
         this.#maxValidators = config.maxValidators
+        this.#boundedHealthCheckHandler = this.#healthCheckHandler.bind(this);
+        this.#logger = new Logger(config)
     }
 
     /**
-     * Sends a message to a single randomly selected connected validator.
-     * Returns the public key (buffer) of the validator used, or throws
-     * if the specified validator is unavailable.
-     * @param {Object} message - The message to send to the validator
-     * @returns {String} - The public key of the validator used
+     * Subscribes to periodic validator health checks.
+     * @param {ReadyResource} healthCheckService
      */
-    send(message) {
-        const connectedValidators = this.connectedValidators();
+    // TODO: We should consider moving this to ValidatorObserver instead.
+    // Keep here only if we forsee having health checks for non-validator connections in the future. 
+    // For now, it seems that it would be better to keep this logic here.
+    subscribeToHealthChecks(healthCheckService) {
+        this.#logger.debug('subscribeToHealthChecks: subscribing to health check events');
+        if (!healthCheckService || typeof healthCheckService.on !== 'function' || typeof healthCheckService.off !== 'function') {
+            throw new Error('ConnectionManager: health check service must implement on/off');
+        }
 
-        if (connectedValidators.length === 0) {
-            throw new Error('ConnectionManager: no connected validators available to send message');
+        if (this.#healthCheckService && this.#boundedHealthCheckHandler) {
+            this.#logger.debug('subscribeToHealthChecks: removing previous health check handler');
+            // Unsubscribe from previous health check service if already subscribed
+            // TODO: Maybe we should not allow switching to a new health check service
+            this.#healthCheckService.off(EventType.VALIDATOR_HEALTH_CHECK, this.#boundedHealthCheckHandler);
         }
 
-        const target = this.pickRandomValidator(connectedValidators);
-        const entry = this.#validators.get(target);
-        if (!entry || !entry.connection || !entry.connection.protocolSession?.has('legacy')) return null;
+        this.#healthCheckService = healthCheckService; // TODO: Maybe this should be handled in the constructor directly?
+        // TODO: declare this method outside this function to avoid redeclaring it every time we subscribe to health checks. We can just bind it to 'this' in the constructor.
+
+        this.#healthCheckService.on(EventType.VALIDATOR_HEALTH_CHECK, this.#boundedHealthCheckHandler);
+        this.#logger.debug('subscribeToHealthChecks: subscribed to health check events');
+    }
 
+    async #healthCheckHandler(publicKey, requestId) {
+        if (typeof publicKey !== 'string' || typeof requestId !== 'string') {
+            // We can't throw here because this is an event handler, but we should at least log the error and return early to avoid further issues.
+            this.#logger.error(`healthCheck: malformed event payload. Typeof publicKey = ${typeof publicKey}. Typeof requestId = ${typeof requestId}`);
+            return;
+        }
+
+        const targetAddress = publicKeyToAddress(publicKey, this.#config);
+
+        if (!this.exists(publicKey) || !this.connected(publicKey)) {
+            this.#logger.debug(`healthCheck: validator not connected, stopping checks. Address = ${targetAddress}; Request ID = ${requestId}`);
+            this.#stopHealthCheck(publicKey);
+            return;
+        }
+
+        const connection = this.getConnection(publicKey);
+        if (!connection || !connection.protocolSession || typeof connection.protocolSession.sendHealthCheck !== 'function') {
+            this.#logger.debug(`healthCheck: missing protocol session, removing validator. Address = ${targetAddress}; Request ID = ${requestId}`);
+            this.#stopHealthCheck(publicKey);
+            this.remove(publicKey);
+            return;
+        }
+
+        let success = false;
         try {
-            entry.connection.protocolSession.send(message);
-            entry.sent = (entry.sent || 0) + 1;
-        } catch (e) {
-            // Swallow individual send errors.
+            this.#logger.debug(`healthCheck: sending liveness request. Address = ${targetAddress}; Request ID = ${requestId}`);
+
+            const resultCode = await connection.protocolSession.sendHealthCheck();
+            success = resultCode === ResultCode.OK;
+            if (!success) {
+                this.#logger.debug(`healthCheck: non-OK result code. Address = ${targetAddress}; Request ID = ${requestId}`);
+            }
+        } catch {
+            success = false;
         }
 
-        return target;
-    }
+        if (!success) {
+            this.#logger.debug(`healthCheck: liveness request failed, removing validator. Address = ${targetAddress}; Request ID = ${requestId}`);
+            this.remove(publicKey);
+            this.#stopHealthCheck(publicKey);
+        } else {
+            this.#logger.debug(`healthCheck: success. Address = ${targetAddress}; Request ID = ${requestId}`);
+        }
+    };
 
-    /**
-     * Sends a message through a specific validator without increasing sent messages count.
-     * @param {Object} message - The message to send to the validator
-     * @param {String | Buffer} publicKey - A validator public key hex string to be fetched from the pool.
-     * @returns {Boolean} True if the message was sent, false otherwise.
-     */
-    sendSingleMessage(message, publicKey) {
-        let publicKeyHex = this.#toHexString(publicKey);
-        if (!this.exists(publicKeyHex) || !this.connected(publicKeyHex)) return false; // Fail silently
+    #stopHealthCheck(publicKeyHex) {
+        const targetAddress = publicKeyToAddress(publicKeyHex, this.#config);
 
-        const validator = this.#validators.get(publicKeyHex);
-        if (!validator || !validator.connection || !validator.connection.protocolSession) return false;
+        if (!this.#healthCheckService) {
+            this.#logger.debug(`stopHealthCheck: no health check service, cannot stop checks for ${targetAddress}`);
+            return;
+        }
         try {
-            validator.connection.protocolSession.send(message);
-        } catch (e) {
-            // Swallow individual send errors.
+            if (this.#healthCheckService.has(publicKeyHex)) {
+                this.#logger.debug(`stopHealthCheck: stopping scheduled checks for ${targetAddress}`);
+                this.#healthCheckService.stop(publicKeyHex);
+            }
+        } catch (error) {
+            this.#logger.debug(`stopHealthCheck: failed to stop health check for validator ${targetAddress}. Error: ${error.message}`);
         }
-        return true; // TODO: Implement better success/failure reporting
     }
 
     /**
-     * Creates a blank entry for a validator in the pool without a connection.
-     * @param {String | Buffer} publicKey - The public key hex string of the validator to whitelist
+     * Retrieves the Hyperswarm connection object for a given validator public key.
+     * @param {String | Buffer} publicKey - The public key (Buffer or hex string) of the validator.
+     * @returns {Connection|undefined} - The connection object if found, otherwise undefined.
+     */
+    getConnection(publicKey) {
+        const publicKeyHex = this.#toHexString(publicKey);
+        const entry = this.#validators.get(publicKeyHex);
+        return entry ? entry.connection : undefined;
+    }
+
+    /**
+     * Sends a message through a specific validator without increasing sent messages count.
+     * @param {Object} message - The message to send to the validator.
+     * @param {String | Buffer} publicKey - A validator public key hex string to be fetched from the pool.
+     * @returns {Promise<*>} A promise returned by `validator.connection.protocolSession.send(message)`.
+     * @throws {ConnectionManagerError} If the validator is not connected.
+     * @throws {ConnectionManagerError} If the validator has no valid connection or protocol session.
      */
-    // TODO: Deprecated/Unused - remove if not needed
-    whiteList(publicKey) {
+    async sendSingleMessage(message, publicKey) {
         let publicKeyHex = this.#toHexString(publicKey);
-        this.#validators.set(publicKeyHex, { connection: null, sent: 0 });
+        if (!this.connected(publicKeyHex)) {
+            throw new ConnectionManagerError(
+                `Cannot send message: validator ${publicKeyToAddress(publicKey, this.#config)} is not connected.`
+            );
+        }
+        const validator = this.#validators.get(publicKeyHex);
+        if (!validator || !validator.connection || !validator.connection.protocolSession) {
+            throw new ConnectionManagerError(
+                `Cannot send message: no valid connection found for validator ${publicKeyToAddress(publicKey, this.#config)}.`
+            );
+        }
+        return validator.connection.protocolSession.send(message)
     }
 
     /**
@@ -95,44 +167,47 @@ class ConnectionManager {
     addValidator(publicKey, connection) {
         let publicKeyHex = this.#toHexString(publicKey);
         if (this.maxConnectionsReached()) {
-            debugLog(`addValidator: max connections reached.`);
+            this.#logger.debug('addValidator: max connections reached.');
             return false;
         }
-        debugLog(`addValidator: adding validator ${this.#toAddress(publicKeyHex)}`);
+        this.#logger.debug(`addValidator: adding validator ${publicKeyToAddress(publicKeyHex, this.#config)}`);
         if (!this.exists(publicKeyHex)) {
-            debugLog(`addValidator: appending validator ${this.#toAddress(publicKeyHex)}`);
+            this.#logger.debug(`addValidator: appending validator ${publicKeyToAddress(publicKeyHex, this.#config)}`);
             this.#append(publicKeyHex, connection);
             return true;
         } else if (!this.connected(publicKeyHex)) {
-            debugLog(`addValidator: updating validator ${this.#toAddress(publicKeyHex)}`);
+            this.#logger.debug(`addValidator: updating validator ${publicKeyToAddress(publicKeyHex, this.#config)}`);
             this.#update(publicKeyHex, connection);
             return true;
         }
-        debugLog(`addValidator: didn't add validator ${this.#toAddress(publicKeyHex)}`);
+        this.#logger.debug(`addValidator: didn't add validator ${publicKeyToAddress(publicKeyHex, this.#config)}`);
         return false; // TODO: Implement better success/failure reporting
     }
 
     /**
      * Removes a validator from the pool.
      * @param {String | Buffer} publicKey - The public key hex string of the validator to remove
+     * @param {object} [options]
+     * @param {boolean} [options.endConnection=true] - Whether to close the underlying socket.
      */
-    remove(publicKey) {
-        debugLog(`remove: removing validator ${this.#toAddress(publicKey)}`);
+    remove(publicKey, { endConnection = true } = {}) {
+        this.#logger.debug(`remove: removing validator ${publicKeyToAddress(publicKey, this.#config)}`);
         const publicKeyHex = this.#toHexString(publicKey);
+        this.#stopHealthCheck(publicKeyHex);
         if (this.exists(publicKeyHex)) {
-            // Close the connection socket
             const entry = this.#validators.get(publicKeyHex);
-            if (entry && entry.connection && typeof entry.connection.end === 'function') {
+            if (endConnection && entry && entry.connection && typeof entry.connection.end === 'function') {
                 try {
                     entry.connection.end();
                 } catch (e) {
                     // Ignore errors on connection end
+                    this.#logger.debug(`remove: failed to end connection: ${e.message}`);
                     // TODO: Consider logging these errors here in verbose mode
                 }
             }
-            debugLog(`remove: removing validator from map: ${this.#toAddress(publicKeyHex)}. Map size before removal: ${this.#validators.size}.`);
+            this.#logger.debug(`remove: removing validator from map: ${publicKeyToAddress(publicKeyHex, this.#config)}. Map size before removal: ${this.#validators.size}.`);
             this.#validators.delete(publicKeyHex);
-            debugLog(`remove: validator removed successfully. Map size is now ${this.#validators.size}.`);
+            this.#logger.debug(`remove: validator removed successfully. Map size is now ${this.#validators.size}.`);
         }
     }
 
@@ -206,26 +281,12 @@ class ConnectionManager {
     }
 
     prettyPrint() {
-        console.log('Connection count: ', this.connectionCount())
-        console.log('Validator map keys count: ', this.#validators.size)
-        console.log('Validator map keys: ', Array.from(this.#validators.keys()).map(val => this.#toAddress(val)).join(', '))
-    }
-
-    // Note 1: This method shuffles the whole array (in practice, probably around 50 elements)
-    //      just to fetch a small subset of it (most times, 1 element).
-    //      There are more efficient ways to pick a small subset of validators. Consider optimizing.
-    // Note 2: This method is unused now, but will be kept here for future reference
-    // TODO: Deprecated/Unused - remove if not needed
-    pickRandomSubset(validators, maxTargets) {
-        const copy = validators.slice();
-        const count = Math.min(maxTargets, copy.length);
-
-        for (let i = copy.length - 1; i > 0; i--) {
-            const j = Math.floor(Math.random() * (i + 1));
-            [copy[i], copy[j]] = [copy[j], copy[i]];
-        }
-
-        return copy.slice(0, count);
+        this.#logger.info(`Connection count: ${this.connectionCount()}`);
+        this.#logger.info(`Validator map keys count: ${this.#validators.size}`);
+        this.#logger.info(`Validator map keys:\n${Array.from(this.#validators.entries()).map(([publicKey, val]) => {
+            const protocols = val.connection?.protocolSession?.preferredProtocol || 'none';
+            return `${publicKeyToAddress(publicKey, this.#config)}: ${protocols}`;
+        }).join('\n')}`);
     }
 
     /**
@@ -257,18 +318,18 @@ class ConnectionManager {
      * @param {Object} connection - The connection object
      */
     #append(publicKey, connection) {
-        debugLog(`#append: appending validator ${this.#toAddress(publicKey)}`);
+        this.#logger.debug(`#append: appending validator ${publicKeyToAddress(publicKey, this.#config)}`);
         const publicKeyHex = this.#toHexString(publicKey);
         if (this.#validators.has(publicKeyHex)) {
             // This should never happen, but just in case, we log it
-            debugLog(`#append: tried to append existing validator: ${this.#toAddress(publicKey)}`);
+            this.#logger.debug(`#append: tried to append existing validator: ${publicKeyToAddress(publicKey, this.#config)}`);
             return;
         }
-        this.#validators.set(publicKeyHex, { connection, sent: 0 });
+        this.#validators.set(publicKeyHex, {connection, sent: 0});
         connection.on('close', () => {
-            debugLog(`#append: connection closing for validator ${this.#toAddress(publicKey)}`);
+            this.#logger.debug(`#append: connection closing for validator ${publicKeyToAddress(publicKey, this.#config)}`);
             this.remove(publicKeyHex);
-            debugLog(`#append: connection closed for validator ${this.#toAddress(publicKey)}`);
+            this.#logger.debug(`#append: connection closed for validator ${publicKeyToAddress(publicKey, this.#config)}`);
         });
     }
 
@@ -283,22 +344,14 @@ class ConnectionManager {
         // It would be preferable to keep them separated though, but we would need to review all usages to ensure correctness.
         // Also, we should remove the 'else' branch below if we decide to keep 'update' and 'append' separated.
         const publicKeyHex = this.#toHexString(publicKey);
-        debugLog(`#update: updating validator ${this.#toAddress(publicKey)}`);
+        this.#logger.debug(`#update: updating validator ${publicKeyToAddress(publicKey, this.#config)}`);
         if (this.#validators.has(publicKeyHex)) {
             this.#validators.get(publicKeyHex).connection = connection;
         } else {
-            this.#validators.set(publicKeyHex, { connection, sent: 0 });
+            this.#validators.set(publicKeyHex, {connection, sent: 0});
         }
     }
 
-    #toAddress(publicKey) {
-        const keyHex = b4a.isBuffer(publicKey) ? publicKey : b4a.from(publicKey, 'hex');
-        return PeerWallet.encodeBech32m(
-            this.#config.addressPrefix,
-            keyHex
-        );
-    }
-
     #toHexString(publicKey) {
         return b4a.isBuffer(publicKey) ? publicKey.toString('hex') : publicKey;
     }