trac-msb 0.2.13 → 0.2.15

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

@@ -1,40 +1,37 @@
 // PoolService.js
 import { BATCH_SIZE } from '../../../utils/constants.js';
 import Scheduler from '../../../utils/Scheduler.js';
-import Denque from "denque";
-import b4a from "b4a";
 
 class TransactionPoolService {
     #state;
     #address;
     #config;
-    #txPool = new Denque();
-    #transactionCommitService
+    #tx_pool = [];
     #scheduler = null;
-    #queuedTxHashes
 
     /**
      * @param {State} state
      * @param {string} address
-     * @param {TransactionCommitService} transactionCommitService
      * @param {Config} config
      **/
-    constructor(state, address, transactionCommitService, config) {
+    constructor(state, address, config) {
         this.#state = state;
         this.#address = address;
-        this.#transactionCommitService = transactionCommitService;
-        this.#queuedTxHashes = new Set(); // to improve lookup performance when checking for duplicate transactions
         this.#config = config;
     }
 
-    get txPool() {
-        return this.#txPool;
+    get tx_pool() {
+        return this.#tx_pool;
     }
 
     get state() {
         return this.#state;
     }
 
+    get address() {
+        return this.#address;
+    }
+
     async start() {
         if (!this.#config.enableWallet) {
             console.info('TransactionPoolService can not start. Wallet is not enabled');
@@ -52,7 +49,7 @@ class TransactionPoolService {
     async #worker(next) {
         try {
             await this.#processTransactions();
-            if (this.#txPool.size() > 0) {
+            if (this.#tx_pool.length > 0) {
                 next(0);
             } else {
                 next(this.#config.processIntervalMs);
@@ -68,143 +65,35 @@ class TransactionPoolService {
 
     async #processTransactions() {
         const canValidate = await this.#checkValidationPermissions();
-        if (!canValidate || this.#txPool.size() === 0) return;
-
-        const batchItems = this.#prepareBatch();
-        const encodedBatch = batchItems.map(item => item.encodedTx);
-        const batchTxHashes = batchItems.map(item => item.txHash);
-        try {
-            const receipts = await this.#state.appendWithProofOfPublication(encodedBatch, batchTxHashes);
-
-            const receiptsByHash = new Map();
-            for (const receipt of receipts) {
-                if (receipt.txHash) receiptsByHash.set(receipt.txHash, receipt);
-            }
-
-            for (const item of batchItems) {
-                const receipt = receiptsByHash.get(item.txHash);
-
-                if (!receipt) {
-                    this.#transactionCommitService.rejectPendingCommit(
-                        item.txHash,
-                        new TransactionPoolMissingCommitReceiptError(item.txHash)
-                    );
-                    continue;
-                }
-
-                if (!receipt.proof) {
-                    this.#transactionCommitService.rejectPendingCommit(
-                        item.txHash,
-                        new TransactionPoolProofUnavailableError(
-                            item.txHash,
-                            receipt.blockNumber,
-                            receipt.proofError,
-                            receipt.timestamp
-                        )
-                    );
-                    continue;
-                }
-
-                this.#transactionCommitService.resolvePendingCommit(item.txHash, receipt);
-            }
-        } catch (error) {
-            for (const item of batchItems) {
-                this.#transactionCommitService.rejectPendingCommit(item.txHash, error);
-            }
-            console.error(
-                `TransactionPoolService: failed to process batch (size=${batchItems.length}): ${error?.message ?? 'unknown error'}`
-            );
+        if (canValidate && this.#tx_pool.length > 0) {
+            const batch = this.#prepareBatch();
+            await this.#state.append(batch);
         }
     }
 
     async #checkValidationPermissions() {
         const isAdminAllowedToValidate = await this.state.isAdminAllowedToValidate();
-        const isNodeAllowedToValidate = await this.state.allowedToValidate(this.#address);
+        const isNodeAllowedToValidate = await this.state.allowedToValidate(this.address);
         return isNodeAllowedToValidate || isAdminAllowedToValidate;
     }
 
     #prepareBatch() {
-        const batch = [];
-        const batchSize = Math.min(this.#txPool.size(), BATCH_SIZE);
-
-        for (let i = 0; i < batchSize; i++) {
-            const tx = this.#txPool.shift();
-            this.#queuedTxHashes.delete(tx.txHash);
-            batch.push(tx);
-        }
+        const length = Math.min(this.tx_pool.length, BATCH_SIZE);
+        const batch = this.tx_pool.slice(0, length);
+        this.tx_pool.splice(0, length);
         return batch;
     }
 
-    addTransaction(txHash, encodedTx) {
-        this.validateEnqueue();
-        if (!txHash || !encodedTx || typeof txHash !== 'string' || !b4a.isBuffer(encodedTx)) {
-            throw new TransactionPoolInvalidIncomingDataError()
-        }
-        if (this.hasTransaction(txHash)) {
-            throw new TransactionPoolAlreadyQueuedError(txHash);
-        }
-        this.#queuedTxHashes.add(txHash);
-        const txData = { txHash, encodedTx };
-        this.txPool.push(txData);
+    addTransaction(tx) {
+        this.tx_pool.push(tx);
     }
 
     async stopPool(waitForCurrent = true) {
         if (!this.#scheduler) return;
         await this.#scheduler.stop(waitForCurrent);
         this.#scheduler = null;
-        this.#queuedTxHashes.clear();
-        this.#txPool.clear();
         console.info('TransactionPoolService: closing gracefully...');
     }
-
-    validateEnqueue() {
-        if (this.#txPool.size() >= this.#config.txPoolSize) {
-            throw new TransactionPoolFullError(this.#config.txPoolSize);
-        }
-    }
-
-    hasTransaction(txHash) {
-        return this.#queuedTxHashes.has(txHash);
-    }
-}
-
-export class TransactionPoolProofUnavailableError extends Error {
-    constructor(txHash, blockNumber, reason = 'unknown', timestamp = 0) {
-        const timestampValue = timestamp instanceof Date ? timestamp.getTime() : timestamp;
-        const safeTimestamp = Number.isSafeInteger(timestampValue) ? timestampValue : 0;
-        super(`Proof unavailable for txHash ${txHash} at block ${blockNumber} at ${safeTimestamp}. Reason: ${reason}`);
-        this.txHash = txHash;
-        this.blockNumber = blockNumber;
-        this.timestamp = safeTimestamp;
-        this.reason = reason;
-    }
-}
-
-export class TransactionPoolMissingCommitReceiptError extends Error {
-    constructor(txHash) {
-        super(`Missing commit receipt for txHash ${txHash}`);
-        this.txHash = txHash;
-    }
-}
-
-export class TransactionPoolInvalidIncomingDataError extends Error {
-    constructor(message = 'Invalid transaction pool incoming data') {
-        super(message);
-    }
-}
-
-export class TransactionPoolFullError extends Error {
-    constructor(maxSize) {
-        super(`Transaction pool is full. Maximum size of ${maxSize} reached.`);
-        this.maxSize = maxSize
-    }
-
-}
-
-export class TransactionPoolAlreadyQueuedError extends Error {
-    constructor(txHash) {
-        super(`Transaction with hash ${txHash} is already queued in the transaction pool.`);
-    }
 }
 
 export default TransactionPoolService;

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

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

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

@@ -4,12 +4,20 @@ import { bufferToAddress } from '../../state/utils/address.js';
 import { sleep } from '../../../utils/helpers.js';
 import Scheduler from "../../../utils/Scheduler.js";
 import Network from "../Network.js";
-import { Logger } from '../../../utils/logger.js';
 
 const DELAY_INTERVAL = 50
 const VALIDATOR_CANDIDATES_PER_CYCLE = 10
 const POLL_INTERVAL = (VALIDATOR_CANDIDATES_PER_CYCLE + 1) * DELAY_INTERVAL // This is to avoid more than one instance of the worker running at the same time
 
+// -- Debug Mode --
+// TODO: Implement a better debug system in the future. This is just temporary.
+const DEBUG = false;
+const debugLog = (...args) => {
+    if (DEBUG) {
+        console.log('DEBUG [ValidatorObserverService] ==> ', ...args);
+    }
+};
+
 class ValidatorObserverService {
     #config;
     #state;
@@ -17,7 +25,6 @@ class ValidatorObserverService {
     #scheduler;
     #address;
     #isInterrupted
-    #logger;
 
     /**
      * @param {Network} network
@@ -31,11 +38,12 @@ class ValidatorObserverService {
         this.#state = state;
         this.#address = address;
         this.#isInterrupted = false;
-        this.#logger = new Logger(config);
-        this.initTimestamp = Date.now();
-        this.reachedMax = false;
-        this.end = 0;
-        this.begin = 0;
+        if (DEBUG) {
+            this.initTimestamp = Date.now();
+            this.reachedMax = false;
+            this.end = 0;
+            this.begin = 0;
+        }
     }
 
     get state() {
@@ -47,11 +55,11 @@ class ValidatorObserverService {
     // OS CALLS, ACCUMULATORS, MAYBE THIS IS POSSIBLE TO CHECK I/O QUEUE IF IT COINTAIN IT. FOR NOW WE ARE USING SLEEP.
     async start() {
         if (!this.#shouldRun()) {
-            this.#logger.info('ValidatorObserverService can not start. Disabled by configuration.');
+            console.info('ValidatorObserverService can not start. Disabled by configuration.');
             return;
         }
         if (this.#scheduler && this.#scheduler.isRunning) {
-            this.#logger.info('ValidatorObserverService is already started');
+            console.info('ValidatorObserverService is already started');
             return;
         }
 
@@ -65,12 +73,12 @@ class ValidatorObserverService {
         this.#isInterrupted = true;
         await this.#scheduler.stop(waitForCurrent);
         this.#scheduler = null;
-        this.#logger.info('ValidatorObserverService: closing gracefully...');
+        console.info('ValidatorObserverService: closing gracefully...');
     }
 
     async #worker(next) {
         if (!this.#network.validatorConnectionManager.maxConnectionsReached()) {
-            this.begin = Date.now();
+            if (DEBUG) this.begin = Date.now();
             const length = await this.#lengthEntry()
 
             const promises = [];
@@ -80,16 +88,16 @@ class ValidatorObserverService {
             }
             await Promise.all(promises);
 
-            this.end = Date.now();
-            this.#logger.debug(`Worker cycle completed in (ms): ${this.end - this.begin} | Validator Connections: ${this.#network.validatorConnectionManager.connectionCount()} | Pending: ${this.#network.pendingConnectionsCount()}`);
+            if (DEBUG) this.end = Date.now();
+            debugLog('Worker cycle completed in (ms):', this.end - this.begin, '| Validator Connections:', this.#network.validatorConnectionManager.connectionCount(), " | Pending: ", this.#network.pendingConnectionsCount());
         }
-        else {
+        else if (DEBUG) {
             if (!this.reachedMax) {
                 this.reachedMax = true;
-                this.#logger.debug('Max validator connections reached. Skipping this cycle.');
+                debugLog('Max validator connections reached. Skipping this cycle.');
                 const now = Date.now();
                 const elapsed = now - this.initTimestamp;
-                this.#logger.debug(`>>> Time elapsed since start (ms): ${elapsed}`);
+                debugLog('>>> Time elapsed since start (ms):', elapsed);
             }
         }
         next(POLL_INTERVAL);
@@ -110,10 +118,10 @@ class ValidatorObserverService {
         }
 
         if (attempts >= maxAttempts) {
-            this.#logger.debug('Max attempts reached without finding a valid validator.');
+            debugLog('Max attempts reached without finding a valid validator.');
         }
         else {
-            this.#logger.debug(`Found valid validator to connect after ${attempts} attempts.`);
+            debugLog(`Found valid validator to connect after ${attempts} attempts.`);
         }
 
         if (!isValidatorValid) return;

package/src/core/state/State.js

@@ -40,15 +40,13 @@ import { safeWriteUInt32BE } from '../../utils/buffer.js';
 import deploymentEntryUtils from './utils/deploymentEntry.js';
 import { deepCopyBuffer } from '../../utils/buffer.js';
 import { Status } from './utils/transaction.js';
-import remote from 'hypercore/lib/fully-remote-proof.js'
-import PQueue from 'p-queue';
+import Corestore from 'corestore';
 
 const OVERSIZED_BATCH_PENALTY_MULTIPLIER = BATCH_SIZE;
 
 // TODO: #addWriter, #removeWriter, #transfer, #transferFeeTxOperation need to be refactored to get in arguments actor's nodeEntries in buffer format.
 
 class State extends ReadyResource {
-    #writeQueue = new PQueue({ concurrency: 1 });
     #base;
     #bee;
     #store;
@@ -189,6 +187,18 @@ class State extends ReadyResource {
         return !!nodeEntry.isWhitelisted;
     }
 
+    async isAddressWriter(address) {
+        const nodeEntry = await this.getNodeEntry(address);
+        if (nodeEntry === null) return false;
+        return !!nodeEntry.isWriter;
+    }
+
+    async isAddressIndexer(address) {
+        const nodeEntry = await this.getNodeEntry(address);
+        if (nodeEntry === null) return false;
+        return !!nodeEntry.isIndexer;
+    }
+
     async getIndexersEntry() {
         return Object.values(this.#base.system.indexers);
     }
@@ -233,67 +243,7 @@ class State extends ReadyResource {
     }
 
     async append(payload) {
-        return this.#writeQueue.add(() => this.#base.append(payload));
-    }
-
-    async appendWithProofOfPublication(batch, batchTxHashes) {
-        return this.#writeQueue.add(async () => {
-
-            const core = this.#base.local;
-            const end = await this.#base.append(batch);
-            const start = end - batch.length;
-            const timestamp = new Date();
-            const snapshot = core.snapshot(); // consistent view while generating proofs.
-            await snapshot.ready();
-            // TODO: check state if specific tx has been appened THEN generate a proof.
-            try {
-                const receipts = [];
-                let failedProofs = 0;
-                for (let i = 0; i < batch.length; i++) {
-                    const blockNumber = start + i;
-                    const completeTx = batch[i];
-                    const txHash = batchTxHashes[i];
-
-                    let proof = null;
-                    let proofError = null;
-
-                    // wait:false makes get fail fast (null) instead of waiting for missing data/replication.
-                    const rawBlock = await snapshot.get(blockNumber, { raw: true, wait: false });
-                    if (!rawBlock) {
-                        proofError = `Missing raw block after append (block=${blockNumber}, start=${start}, end=${end})`;
-                        failedProofs++;
-                    } else {
-                        try {
-                            proof = await remote.proof(snapshot, { index: blockNumber, block: rawBlock });
-                        } catch (error) {
-                            proofError = `Proof generation failed (block=${blockNumber}, start=${start}, end=${end}): ${error?.message ?? 'unknown error'}`;
-                            failedProofs++;
-                        }
-                    }
-                    receipts.push({
-                        txHash,
-                        completeTx,
-                        proof,
-                        proofError,
-                        timestamp,
-                        blockNumber
-                    });
-                }
-                if (failedProofs > 0) {
-                    console.error(`appendWithProof completed with ${failedProofs} proof failures (batch=${batch.length})`);
-                }
-                return receipts;
-            } finally {
-                await snapshot.close();
-            }
-        });
-    }
-
-    async verifyProofOfPublication(proof) {
-        // Valid concern. We currently rely on Hypercore’s internal fully-remote-proof helper, which requires low-level storage access
-        const out = await remote.verify(this.#store.storage, proof);
-        if (!out) throw new Error('Proof of publication verification failed');
-        return out;
+        await this.#base.append(payload);
     }
 
     async getIndexerSequenceState() {
@@ -314,7 +264,6 @@ class State extends ReadyResource {
             return b4a.equals(initialization, safeWriteUInt32BE(0, 0))
         }
     }
-
     async getTransactionConfirmedLength(hash) {
         if (!isHexString(hash) || hash.length !== 64) {
             throw new Error("Invalid hash format");
@@ -1844,9 +1793,9 @@ class State extends ReadyResource {
         };
 
         /**
-         * Ensure that:
-         * 1) writer key exists in registry (we can not unregister something that was not registered),
-         * 2) matches the one in node entry ,
+         * Ensure that: 
+         * 1) writer key exists in registry (we can not unregister something that was not registered), 
+         * 2) matches the one in node entry , 
          * 3) belongs to the requester - this prevents unauthorized key removal
          */
         const writerKeyHasBeenRegistered = await this.#getRegisteredWriterKeyApply(batch, op.rao.iw.toString('hex'))
@@ -2981,7 +2930,7 @@ class State extends ReadyResource {
             batch,
             node
         );
-
+        
         // TODO: cover next 4 guards below with tests
         if (transferFeeTxOperationResult === null) {
             this.#safeLogApply(OperationType.TX, "Fee transfer operation failed completely.", node.from.key);
@@ -3439,7 +3388,7 @@ class State extends ReadyResource {
 
     /**
      * Retrieves the address assigned to a given writing key from the registry.
-     *
+     * 
      * @param {Object} batch - The current Hyperbee batch instance used for reading state.
      * @param {string} writingKey - The writing key in hex string format.
      * @returns {Buffer|null} The address buffer assigned to the writing key, or null if not registered.

package/src/index.js

@@ -44,7 +44,6 @@ import {
     getLicenseCountCommand
 } from "./utils/cliCommands.js";
 import {safeEncodeApplyOperation} from "./utils/protobuf/operationHelpers.js";
-import {Config} from "./config/config.js";
 
 export class MainSettlementBus extends ReadyResource {
     #store;
@@ -62,7 +61,10 @@ export class MainSettlementBus extends ReadyResource {
         super();
         this.#config = config
         this.#store = new Corestore(this.#config.storesFullPath);
-        this.#wallet = new PeerWallet({ networkPrefix: this.#config.addressPrefix });
+        this.#wallet = new PeerWallet({
+            networkPrefix: this.#config.addressPrefix,
+            derivationPath: this.#config.derivationPath
+        });
         this.#readline_instance = null;
 
         if (this.#config.enableInteractiveMode) {
@@ -304,7 +306,7 @@ export class MainSettlementBus extends ReadyResource {
         const success = await this.broadcastPartialTransaction(adminRecoveryMessage);
 
         if (!success) {
-            throw new Error("Failed to broadcast transaction. Try again later.");
+            throw new Error("Failed to broadcast transaction after multiple attempts.");
         }
 
         console.info(`Transaction hash: ${adminRecoveryMessage.rao.tx}`);
@@ -425,7 +427,7 @@ export class MainSettlementBus extends ReadyResource {
             const success = await this.broadcastPartialTransaction(assembledMessage);
 
             if (!success) {
-                throw new Error("Failed to broadcast transaction. Try again later.");
+                throw new Error("Failed to broadcast transaction after multiple attempts.");
             }
 
             console.info(`Transaction hash: ${assembledMessage.rao.tx}`);
@@ -459,7 +461,7 @@ export class MainSettlementBus extends ReadyResource {
         const success = await this.broadcastPartialTransaction(assembledMessage);
 
         if (!success) {
-            throw new Error("Failed to broadcast transaction. Try again later.");
+            throw new Error("Failed to broadcast transaction after multiple attempts.");
         }
 
         console.info(`Transaction hash: ${assembledMessage.rao.tx}`);
@@ -683,7 +685,7 @@ export class MainSettlementBus extends ReadyResource {
         const success = await this.broadcastPartialTransaction(payload);
 
         if (!success) {
-            throw new Error("Failed to broadcast transaction. Try again later.");
+            throw new Error("Failed to broadcast transaction after multiple attempts.");
         }
 
         console.info(`Transaction hash: ${payload.bdo.tx}`);