trac-msb 0.2.7 → 0.2.9

package/src/index.js

@@ -1,4 +1,3 @@
-
 /** @typedef {import('pear-interface')} */ /* global Pear */
 import ReadyResource from "ready-resource";
 import Corestore from "corestore";
@@ -6,36 +5,23 @@ import PeerWallet from "trac-wallet";
 import b4a from "b4a";
 import readline from "readline";
 import tty from "tty";
-
-import { sleep, getFormattedIndexersWithAddresses, isHexString, convertAdminCoreOperationPayloadToHex } from "./utils/helpers.js";
-import { verifyDag, printHelp, printWalletInfo, get_confirmed_tx_info, printBalance, get_unconfirmed_tx_info } from "./utils/cli.js";
-import CompleteStateMessageOperations from "./messages/completeStateMessages/CompleteStateMessageOperations.js";
-import { safeDecodeApplyOperation } from "./utils/protobuf/operationHelpers.js";
-import { bufferToAddress, isAddressValid } from "./core/state/utils/address.js";
+import { sleep, isHexString } from "./utils/helpers.js";
+import { verifyDag, printHelp, printWalletInfo, printBalance } from "./utils/cli.js";
+import { applyStateMessageFactory } from "./messages/state/applyStateMessageFactory.js";
+import { isAddressValid } from "./core/state/utils/address.js";
 import Network from "./core/network/Network.js";
 import Check from "./utils/check.js";
 import State from "./core/state/State.js";
-import PartialStateMessageOperations from "./messages/partialStateMessages/PartialStateMessageOperations.js";
 import {
     EventType,
     WHITELIST_SLEEP_INTERVAL,
     BOOTSTRAP_HEXSTRING_LENGTH,
-    EntryType,
-    OperationType,
-    MAX_MESSAGE_SEND_ATTEMPTS,
     CustomEventType,
     BALANCE_MIGRATION_SLEEP_INTERVAL,
     WHITELIST_MIGRATION_DIR
 } from "./utils/constants.js";
-import partialStateMessageOperations from "./messages/partialStateMessages/PartialStateMessageOperations.js";
 import { randomBytes } from "hypercore-crypto";
-import { decimalStringToBigInt, bigIntTo16ByteBuffer, bufferToBigInt, bigIntToDecimalString, licenseBufferToBigInt } from "./utils/amountSerialization.js"
-import { ZERO_WK } from "./utils/buffer.js";
-import { normalizeDecodedPayloadForJson, normalizeTransferOperation, normalizeTransactionOperation } from "./utils/normalizers.js"
-import PartialTransfer from "./core/network/messaging/validators/PartialTransfer.js";
-import { blake3Hash } from "./utils/crypto.js";
-import deploymentEntryUtils from "./core/state/utils/deploymentEntry.js";
-import PartialTransaction from "./core/network/messaging/validators/PartialTransaction.js";
+import { decimalStringToBigInt, bigIntTo16ByteBuffer, bufferToBigInt, bigIntToDecimalString } from "./utils/amountSerialization.js"
 import fileUtils from './utils/fileUtils.js';
 import migrationUtils from './utils/migrationUtils.js';
 import {
@@ -57,131 +43,76 @@ import {
     getLicenseAddressCommand,
     getLicenseCountCommand
 } from "./utils/cliCommands.js";
+import {safeEncodeApplyOperation} from "./utils/protobuf/operationHelpers.js";
+
 export class MainSettlementBus extends ReadyResource {
-    // internal attributes
-    #options;
-    #stores_directory;
-    #key_pair_path;
-    #bootstrap;
-    #channel;
     #store;
-    #enable_wallet;
     #wallet;
     #network;
     #readline_instance;
-    #enable_validator_observer;
-    #enable_role_requester;
     #state;
     #isClosing = false;
-    #is_admin_mode;
-    #partialTransferValidator;
-    #partialTransactionValidator;
-    #maxRetries
+    #config
 
-    constructor(options = {}) {
+    /**
+     * @param {object} config
+     **/
+    constructor(config) {
         super();
-        this.#options = options;
-        this.#stores_directory = options.stores_directory;
-        this.#key_pair_path = `${this.#stores_directory}${options.store_name}/db/keypair.json`;
-        this.#enable_wallet = options.enable_wallet !== false;
-        this.enable_interactive_mode = options.enable_interactive_mode !== false;
-        this.#is_admin_mode = options.store_name === 'admin';
-        this.#enable_role_requester =
-            options.enable_role_requester !== undefined
-                ? options.enable_role_requester
-                : false;
-        this.#enable_validator_observer =
-            options.enable_validator_observer !== undefined
-                ? options.enable_validator_observer
-                : true;
-        this.#bootstrap = options.bootstrap
-            ? b4a.from(options.bootstrap, "hex")
-            : null;
-
-        if (!options.channel) {
-            throw new Error(
-                "MainSettlementBus: Channel is required. Application cannot start without channel."
-            );
-        }
-
-        this.#channel = b4a.alloc(32).fill(options.channel);
-        this.#store = new Corestore(this.#stores_directory + options.store_name);
-        this.#wallet = new PeerWallet(options);
+        this.#config = config
+        this.#store = new Corestore(this.#config.storesFullPath);
+        this.#wallet = new PeerWallet({ networkPrefix: this.#config.addressPrefix });
         this.#readline_instance = null;
-        this.#maxRetries = Number(options.max_retries) ? options.max_retries : MAX_MESSAGE_SEND_ATTEMPTS
 
-        if (this.enable_interactive_mode !== false) {
+        if (this.#config.enableInteractiveMode) {
             try {
                 this.#readline_instance = readline.createInterface({
                     input: new tty.ReadStream(0),
                     output: new tty.WriteStream(1),
                 });
-            } catch (e) {
-            }
+            } catch (_ignored) {}
         }
 
-        this.check = new Check();
-    }
-
-    get options() {
-        return this.#options;
-    }
-
-    get stores_directory() {
-        return this.#stores_directory;
-    }
-
-    get key_pair_path() {
-        return this.#key_pair_path;
+        this.check = new Check(this.#config);
     }
 
-    get bootstrap() {
-        return this.#bootstrap;
+    get config() {
+        return this.#config
     }
 
     get state() {
         return this.#state;
     }
 
-    get channel() {
-        return this.#channel;
-    }
-
     get network() {
         return this.#network;
     }
 
-    // This can be null if enable_wallet is false
     get wallet() {
+        if (!this.#config.enableWallet) {
+            return undefined;
+        }
         return this.#wallet;
     }
 
-    get tracPublicKey() {
-        if (!this.#wallet) return null;
-        return this.#wallet.publicKey;
-    }
-
     async _open() {
-        if (this.#enable_wallet) {
+        if (this.#config.enableWallet) {
             await this.#wallet.initKeyPair(
-                this.key_pair_path,
+                this.#config.keyPairPath,
                 this.#readline_instance
             );
         }
-        this.#state = new State(this.#store, this.bootstrap, this.#wallet, this.options);
-        this.#network = new Network(this.#state, this.#channel, this.#wallet.address, this.options);
+        this.#state = new State(this.#store, this.#wallet, this.#config);
+        this.#network = new Network(this.#state, this.#config, this.#wallet.address);
 
         await this.#state.ready();
         await this.#network.ready();
-        this.#stateEventsListener();
+        await this.#stateEventsListener();
 
-        if (this.#enable_wallet) {
-            printWalletInfo(this.#wallet.address, this.#state.writingKey, this.#state, this.#enable_wallet);
+        if (this.#config.enableWallet) {
+            printWalletInfo(this.#wallet.address, this.#state.writingKey, this.#state, this.#config.enableWallet);
         }
 
-        this.#partialTransferValidator = new PartialTransfer(this.state);
-        this.#partialTransactionValidator = new PartialTransaction(this.state);
-
         await this.#network.replicate(
             this.#state,
             this.#store,
@@ -191,12 +122,14 @@ export class MainSettlementBus extends ReadyResource {
         const adminEntry = await this.#state.getAdminEntry();
         await this.#setUpRoleAutomatically(adminEntry);
 
+
+
         console.log(`isIndexer: ${this.#state.isIndexer()}`);
         console.log(`isWriter: ${this.#state.isWritable()}`);
         console.log("MSB Unsigned Length:", this.#state.getUnsignedLength());
         console.log("MSB Signed Length:", this.#state.getSignedLength());
 
-        await printBalance(this.#wallet.address, this.#state, this.#enable_wallet);
+        await printBalance(this.#wallet.address, this.#state, this.#config.enableWallet);
     }
 
     async _close() {
@@ -239,56 +172,11 @@ export class MainSettlementBus extends ReadyResource {
     }
 
     async broadcastPartialTransaction(partialTransactionPayload) {
-        await this.#network.validatorMessageOrchestrator.send(partialTransactionPayload);
-    }
-
-    async broadcastTransactionCommand(payload) {
-        if (!payload) {
-            throw new Error("Transaction payload is required for broadcast_transaction command.");
-        }
-
-        let normalizedPayload;
-        let isValid = false;
-        let hash;
-
-        if (payload.type === OperationType.TRANSFER) {
-            normalizedPayload = normalizeTransferOperation(payload);
-            isValid = await this.#partialTransferValidator.validate(normalizedPayload);
-            hash = b4a.toString(normalizedPayload.tro.tx, "hex");
-        } else if (payload.type === OperationType.TX) {
-            normalizedPayload = normalizeTransactionOperation(payload);
-            isValid = await this.#partialTransactionValidator.validate(normalizedPayload);
-            hash = b4a.toString(normalizedPayload.txo.tx, "hex");
-        }
-
-        if (!isValid) {
-            throw new Error("Invalid transaction payload.");
-        }
-
-        const signedLength = this.#state.getSignedLength();
-        const unsignedLength = this.#state.getUnsignedLength();
-
-        for (let attempt = 0; attempt <= this.#maxRetries; attempt++) { // should iterate once if maxRetries === 0
-            await this.broadcastPartialTransaction(payload);
-            await sleep(1000 * (attempt + 1)); // linear backoff wait time
-            const tx = await this.#state.get(hash);
-
-            if (tx !== null) {
-                break;
-            }
-
-            this.network.validatorConnectionManager.rotate(); // force change connection rotation for the next retry
-        }
-
-        if (await this.#state.get(hash) === null) {
-            throw new Error("Failed to broadcast transaction after multiple attempts.");
-        }
-
-        return { message: "Transaction broadcasted successfully.", signedLength, unsignedLength, tx: hash };
+        return await this.#network.validatorMessageOrchestrator.send(partialTransactionPayload);
     }
 
     async #setUpRoleAutomatically() {
-        if (!this.#state.isWritable() && this.#enable_role_requester) {
+        if (!this.#state.isWritable() && this.#config.enableRoleRequester) {
             console.log("Requesting writer role... This may take a moment.");
             await this.#requestWriterRole(false);
             setTimeout(async () => {
@@ -299,15 +187,12 @@ export class MainSettlementBus extends ReadyResource {
     }
 
     #isAdmin(adminEntry) {
-        if (!adminEntry || this.#enable_wallet === false) return false;
-        return !!(
-            this.#wallet.address === adminEntry.address &&
-            b4a.equals(adminEntry.wk, this.#state.writingKey)
-        );
+        if (!adminEntry || !this.#config.enableWallet) return false;
+        return this.#wallet.address === adminEntry.address && b4a.equals(adminEntry.wk, this.#state.writingKey)
     }
 
     async #isAllowedToRequestRole(adminEntry, nodeEntry) {
-        return nodeEntry && nodeEntry.isWhitelisted && !this.#isAdmin(adminEntry);
+        return nodeEntry?.isWhitelisted && !this.#isAdmin(adminEntry);
     }
 
     async #stateEventsListener() {
@@ -338,18 +223,15 @@ export class MainSettlementBus extends ReadyResource {
         });
 
         this.#state.base.on(EventType.UNWRITABLE, async () => {
-            if (this.#enable_wallet === false) {
-                console.log("Current node is unwritable");
-                return;
-            }
             console.log("Current node is unwritable");
         });
     }
 
     async #handleAdminCreation() {
-        if (this.#enable_wallet === false) {
+        if (!this.#config.enableWallet) {
             throw new Error("Can not initialize an admin - wallet is not enabled.");
         }
+
         const adminEntry = await this.#state.getAdminEntry();
 
         if (adminEntry) {
@@ -365,25 +247,29 @@ export class MainSettlementBus extends ReadyResource {
                 "Can not initialize an admin - writing key is not initialized."
             );
         }
-        if (!b4a.equals(this.#state.writingKey, this.#bootstrap)) {
+        if (!b4a.equals(this.#state.writingKey, this.#config.bootstrap)) {
             throw new Error(
                 "Can not initialize an admin - bootstrap is not equal to writing key."
             );
         }
 
-        const txValidity = await blake3Hash(this.bootstrap);
-        const addAdminMessage = await CompleteStateMessageOperations.assembleAddAdminMessage(
-            this.#wallet,
-            this.#state.writingKey,
-            txValidity
-        );
+        const txValidity = await PeerWallet.blake3(this.#config.bootstrap);
+        const addAdminMessage = await applyStateMessageFactory(this.#wallet, this.#config)
+            .buildCompleteAddAdminMessage(
+                this.#wallet.address,
+                this.#state.writingKey,
+                txValidity,
+            )
+        const encodedPayload = safeEncodeApplyOperation(addAdminMessage);
 
-        await this.#state.append(addAdminMessage);
+        await this.#state.append(encodedPayload);
     }
+
     async #handleAdminRecovery() {
-        if (this.#enable_wallet === false) {
+        if (!this.#config.enableWallet) {
             throw new Error("Can not initialize an admin - wallet is not enabled.");
         }
+
         const adminEntry = await this.#state.getAdminEntry();
 
         if (!adminEntry) {
@@ -404,22 +290,28 @@ export class MainSettlementBus extends ReadyResource {
         }
 
         const txValidity = await this.#state.getIndexerSequenceState();
-        const adminRecoveryMessage = await partialStateMessageOperations.assembleAdminRecoveryMessage(
-            this.#wallet,
-            this.#state.writingKey.toString('hex'),
-            txValidity.toString('hex')
-        );
+        const adminRecoveryMessage = await applyStateMessageFactory(this.#wallet, this.#config)
+            .buildPartialAdminRecoveryMessage(
+                this.#wallet.address,
+                this.#state.writingKey,
+                txValidity,
+                "json"
+            )
+
+        const success = await this.broadcastPartialTransaction(adminRecoveryMessage);
+
+        if (!success) {
+            throw new Error("Failed to broadcast transaction after multiple attempts.");
+        }
 
-        await this.broadcastPartialTransaction(adminRecoveryMessage);
         console.info(`Transaction hash: ${adminRecoveryMessage.rao.tx}`);
     }
 
     async #handleWhitelistOperations() {
-        if (this.#enable_wallet === false) {
+        if (!this.#config.enableWallet) {
             throw new Error("Cannot perform whitelisting - wallet is not enabled.");
         }
 
-        if (this.#enable_wallet === false) return;
         const adminEntry = await this.#state.getAdminEntry();
 
         if (!this.#isAdmin(adminEntry)) {
@@ -430,7 +322,7 @@ export class MainSettlementBus extends ReadyResource {
         const addresses = await fileUtils.readAddressesFromWhitelistFile();
 
         for (const address of addresses) {
-            await migrationUtils.validateAddressFromIncomingFile(this.#state, address, adminEntry);
+            await migrationUtils.validateAddressFromIncomingFile(this.#state, this.#config, address, adminEntry);
         }
         await fileUtils.validateWhitelistMigrationData(addresses, WHITELIST_MIGRATION_DIR);
         const migrationNumber = await fileUtils.getNextMigrationNumber(WHITELIST_MIGRATION_DIR);
@@ -438,11 +330,13 @@ export class MainSettlementBus extends ReadyResource {
 
         for (const addressToWhitelist of addresses) {
             const txValidity = await this.#state.getIndexerSequenceState();
-            const encodedPayload = await CompleteStateMessageOperations.assembleAppendWhitelistMessages(
-                this.#wallet,
-                txValidity,
-                addressToWhitelist
-            );
+            const appendWhitelistMessage = await applyStateMessageFactory(this.#wallet, this.#config)
+                .buildCompleteAppendWhitelistMessage(
+                    this.#wallet.address,
+                    addressToWhitelist,
+                    txValidity,
+                )
+            const encodedPayload = safeEncodeApplyOperation(appendWhitelistMessage)
             messages.set(addressToWhitelist, encodedPayload);
         }
 
@@ -476,12 +370,13 @@ export class MainSettlementBus extends ReadyResource {
     }
 
     async #requestWriterRole(toAdd) {
-        if (this.#enable_wallet === false) {
+        if (!this.#config.enableWallet) {
             throw new Error("Cannot request writer role - wallet is not enabled");
         }
+
         const adminEntry = await this.#state.getAdminEntry();
         const nodeEntry = await this.#state.getNodeEntry(this.#wallet.address);
-        const isAlreadyWriter = !!(nodeEntry && nodeEntry.isWriter === true);
+        const isAlreadyWriter = !!nodeEntry?.isWriter;
 
         if (toAdd) {
             if (isAlreadyWriter) {
@@ -515,13 +410,21 @@ export class MainSettlementBus extends ReadyResource {
             }
 
             const txValidity = await this.#state.getIndexerSequenceState();
-            const assembledMessage = await PartialStateMessageOperations.assembleAddWriterMessage(
-                this.#wallet,
-                this.#state.writingKey.toString('hex'),
-                txValidity.toString('hex')
-            )
 
-            await this.broadcastPartialTransaction(assembledMessage);
+            const assembledMessage = await applyStateMessageFactory(this.#wallet, this.#config)
+                .buildPartialAddWriterMessage(
+                    this.#wallet.address,
+                    this.#state.writingKey,
+                    txValidity,
+                    'json'
+                )
+
+            const success = await this.broadcastPartialTransaction(assembledMessage);
+
+            if (!success) {
+                throw new Error("Failed to broadcast transaction after multiple attempts.");
+            }
+
             console.info(`Transaction hash: ${assembledMessage.rao.tx}`);
             return;
         }
@@ -542,21 +445,27 @@ export class MainSettlementBus extends ReadyResource {
         }
 
         const txValidity = await this.#state.getIndexerSequenceState();
-        const assembledMessage = await PartialStateMessageOperations.assembleRemoveWriterMessage(
-            this.#wallet,
-            nodeEntry.wk.toString('hex'),
-            txValidity.toString('hex')
-        )
+        const assembledMessage = await applyStateMessageFactory(this.#wallet, this.#config)
+            .buildPartialRemoveWriterMessage(
+                this.#wallet.address,
+                nodeEntry.wk,
+                txValidity,
+                "json"
+            )
+
+        const success = await this.broadcastPartialTransaction(assembledMessage);
+
+        if (!success) {
+            throw new Error("Failed to broadcast transaction after multiple attempts.");
+        }
 
-        await this.broadcastPartialTransaction(assembledMessage);
         console.info(`Transaction hash: ${assembledMessage.rao.tx}`);
-        return;
     }
 
-    async #updateIndexerRole(address, toAdd) {
-        if (this.#enable_wallet === false) {
+    async #updateWriterToIndexerRole(addressToUpdate, toAdd) {
+        if (!this.#config.enableWallet) {
             throw new Error(
-                `Can not request indexer role for: ${address} - wallet is not enabled.`
+                `Can not request indexer role for: ${addressToUpdate} - wallet is not enabled.`
             );
         }
 
@@ -564,29 +473,29 @@ export class MainSettlementBus extends ReadyResource {
 
         if (!adminEntry) {
             throw new Error(
-                `Can not request indexer role for: ${address} - admin entry has not been initialized.`
+                `Can not request indexer role for: ${addressToUpdate} - admin entry has not been initialized.`
             );
         }
 
-        if (!isAddressValid(address)) {
+        if (!isAddressValid(addressToUpdate, this.#config.addressPrefix)) {
             throw new Error(
-                `Can not request indexer role for: ${address} - invalid address.`
+                `Can not request indexer role for: ${addressToUpdate} - invalid address.`
             );
         }
 
         if (!this.#isAdmin(adminEntry) && !this.#state.isWritable()) {
             throw new Error(
-                `Can not request indexer role for: ${address} - You are not an admin or writer.`
+                `Can not request indexer role for: ${addressToUpdate} - You are not an admin or writer.`
             );
         }
-        const nodeEntry = await this.#state.getNodeEntry(address);
+        const nodeEntry = await this.#state.getNodeEntry(addressToUpdate);
         if (!nodeEntry) {
             throw new Error(
-                `Can not request indexer role for: ${address} - node entry has not been not initialized.`
+                `Can not request indexer role for: ${addressToUpdate} - node entry has not been not initialized.`
             );
         }
 
-        const indexerNodeEntry = await this.#state.getNodeEntry(address);
+        const indexerNodeEntry = await this.#state.getNodeEntry(addressToUpdate);
         const indexerListHasAddress = await this.#state.isWkInIndexersEntry(
             indexerNodeEntry.wk,
         );
@@ -594,7 +503,7 @@ export class MainSettlementBus extends ReadyResource {
         if (toAdd) {
             if (indexerListHasAddress) {
                 throw new Error(
-                    `Cannot update indexer role for: ${address} - address is already in indexers list.`
+                    `Cannot update indexer role for: ${addressToUpdate} - address is already in indexers list.`
                 );
             }
 
@@ -606,72 +515,90 @@ export class MainSettlementBus extends ReadyResource {
 
             if (!canAddIndexer) {
                 throw new Error(
-                    `Can not request indexer role for: ${address} - node is not whitelisted, not a writer or already an indexer.`
+                    `Can not request indexer role for: ${addressToUpdate} - node is not whitelisted, not a writer or already an indexer.`
                 );
             }
             const txValidity = await this.#state.getIndexerSequenceState();
-            const assembledAddIndexerMessage = await CompleteStateMessageOperations.assembleAddIndexerMessage(this.#wallet, address, txValidity);
-            await this.#state.append(assembledAddIndexerMessage);
+
+            const assembledAddIndexerMessage = await applyStateMessageFactory(this.#wallet, this.#config)
+                .buildCompleteAddIndexerMessage(
+                    this.#wallet.address,
+                    addressToUpdate,
+                    txValidity,
+                )
+
+            const encodedPayload = safeEncodeApplyOperation(assembledAddIndexerMessage);
+
+            await this.#state.append(encodedPayload);
         } else {
             const canRemoveIndexer =
                 !toAdd && nodeEntry.isIndexer && indexerListHasAddress;
 
             if (!canRemoveIndexer) {
                 throw new Error(
-                    `Can not remove indexer role for: ${address} - node is not an indexer or address is not in indexers list.`
+                    `Can not remove indexer role for: ${addressToUpdate} - node is not an indexer or address is not in indexers list.`
                 );
             }
             const txValidity = await this.#state.getIndexerSequenceState();
-            const assembledRemoveIndexer = await CompleteStateMessageOperations.assembleRemoveIndexerMessage(this.#wallet, address, txValidity);
-            await this.#state.append(assembledRemoveIndexer);
+            const assembledRemoveIndexerMessage = await applyStateMessageFactory(this.#wallet, this.#config)
+                .buildCompleteRemoveIndexerMessage(
+                    this.#wallet.address,
+                    addressToUpdate,
+                    txValidity,
+                )
+            const encodedPayload = safeEncodeApplyOperation(assembledRemoveIndexerMessage);
+
+            await this.#state.append(encodedPayload);
         }
     }
 
-    async #banValidator(address) {
-        if (this.#enable_wallet === false) {
+    async #banValidator(addresstToBan) {
+        if (!this.#config.enableWallet) {
             throw new Error(
-                `Can not ban writer with address: ${address} - wallet is not enabled.`
+                `Can not ban writer with address: ${addresstToBan} - wallet is not enabled.`
             );
         }
         const adminEntry = await this.#state.getAdminEntry();
 
         if (!adminEntry) {
             throw new Error(
-                `Can not ban writer with address: ${address} - admin entry has not been initialized.`
+                `Can not ban writer with address: ${addresstToBan} - admin entry has not been initialized.`
             );
         }
 
-        if (!isAddressValid(address)) {
+        if (!isAddressValid(addresstToBan, this.#config.addressPrefix)) {
             throw new Error(
-                `Can not ban writer with address:  ${address} - invalid address.`
+                `Can not ban writer with address:  ${addresstToBan} - invalid address.`
             );
         }
 
         if (!this.#isAdmin(adminEntry)) {
             throw new Error(
-                `Can not ban writer with address: ${address} - You are not an admin.`
+                `Can not ban writer with address: ${addresstToBan} - You are not an admin.`
             );
         }
 
-        const isWhitelisted = await this.#state.isAddressWhitelisted(address);
-        const nodeEntry = await this.#state.getNodeEntry(address);
+        const isWhitelisted = await this.#state.isAddressWhitelisted(addresstToBan);
+        const nodeEntry = await this.#state.getNodeEntry(addresstToBan);
 
         if (!isWhitelisted || null === nodeEntry || nodeEntry.isIndexer === true) {
             throw new Error(
-                `Can not ban writer with address: ${address} - node is not whitelisted or is an indexer.`
+                `Can not ban writer with address: ${addresstToBan} - node is not whitelisted or is an indexer.`
             );
         }
         const txValidity = await this.#state.getIndexerSequenceState();
-        const assembledBanValidatorMessage = await CompleteStateMessageOperations.assembleBanWriterMessage(
-            this.#wallet,
-            address,
-            txValidity
-        );
-        await this.#state.append(assembledBanValidatorMessage);
+        const assembledBanValidatorMessage = await applyStateMessageFactory(this.#wallet, this.#config)
+            .buildCompleteBanWriterMessage(
+                this.#wallet.address,
+                addresstToBan,
+                txValidity,
+            )
+        const encodedPayload = safeEncodeApplyOperation(assembledBanValidatorMessage)
+        await this.#state.append(encodedPayload);
     }
 
     async #deployBootstrap(externalBootstrap, channel) {
-        if (this.#enable_wallet === false) {
+        if (!this.#config.enableWallet) {
             throw new Error(
                 "Can not perform bootstrap deployment - wallet is not enabled."
             );
@@ -719,7 +646,7 @@ export class MainSettlementBus extends ReadyResource {
             );
         }
 
-        if (externalBootstrap === this.bootstrap.toString("hex")) {
+        if (externalBootstrap === this.#config.bootstrap.toString("hex")) {
             throw new Error(
                 `Can not perform bootstrap deployment - bootstrap ${externalBootstrap} is equal to MSB bootstrap!`
             );
@@ -740,14 +667,22 @@ export class MainSettlementBus extends ReadyResource {
         }
 
         const txValidity = await this.#state.getIndexerSequenceState();
-        const payload = await PartialStateMessageOperations.assembleBootstrapDeploymentMessage(
-            this.#wallet,
-            externalBootstrap,
-            channel,
-            txValidity.toString('hex')
-        );
 
-        await this.broadcastPartialTransaction(payload);
+        const payload = await applyStateMessageFactory(this.#wallet, this.#config)
+            .buildPartialBootstrapDeploymentMessage(
+                this.#wallet.address,
+                externalBootstrap,
+                channel,
+                txValidity,
+                "json"
+            )
+
+        const success = await this.broadcastPartialTransaction(payload);
+
+        if (!success) {
+            throw new Error("Failed to broadcast transaction after multiple attempts.");
+        }
+
         console.info(`Transaction hash: ${payload.bdo.tx}`);
         console.log(`Bootstrap ${externalBootstrap} deployment requested on channel ${channel}`);
         console.log('Bootstrap Deployment Fee Details:');
@@ -756,32 +691,8 @@ export class MainSettlementBus extends ReadyResource {
 
     }
 
-    async #handleAddIndexerOperation(address) {
-        await this.#updateIndexerRole(address, true);
-    }
-
-    async #handleRemoveIndexerOperation(address) {
-        await this.#updateIndexerRole(address, false);
-    }
-
-    async #handleAddWriterOperation() {
-        await this.#requestWriterRole(true);
-    }
-
-    async #handleRemoveWriterOperation() {
-        await this.#requestWriterRole(false);
-    }
-
-    async #handleBanValidatorOperation(address) {
-        await this.#banValidator(address);
-    }
-
-    async #handleBootstrapDeploymentOperation(bootstrapHex, channel) {
-        await this.#deployBootstrap(bootstrapHex, channel);
-    }
-
-    async #handleTransferOperation(address, amount) {
-        if (this.#enable_wallet === false) {
+    async #handleTransferOperation(recipientAddress, amount) {
+        if (!this.#config.enableWallet) {
             throw new Error(
                 "Can not perform transfer - wallet is not enabled."
             );
@@ -793,7 +704,7 @@ export class MainSettlementBus extends ReadyResource {
             );
         }
 
-        if (!isAddressValid(address)) {
+        if (!isAddressValid(recipientAddress, this.#config.addressPrefix)) {
             throw new Error("Invalid recipient address");
         }
 
@@ -818,7 +729,7 @@ export class MainSettlementBus extends ReadyResource {
         const fee = this.#state.getFee();
         const feeBigInt = bufferToBigInt(fee);
         const senderBalance = bufferToBigInt(senderEntry.balance);
-        const isSelfTransfer = address === this.#wallet.address;
+        const isSelfTransfer = recipientAddress === this.#wallet.address;
         const totalDeductedAmount = isSelfTransfer ? feeBigInt : amountBigInt + feeBigInt;
 
         if (!(senderBalance >= totalDeductedAmount)) {
@@ -826,15 +737,15 @@ export class MainSettlementBus extends ReadyResource {
         }
 
         const txValidity = await this.#state.getIndexerSequenceState();
-        const payload = await PartialStateMessageOperations.assembleTransferOperationMessage(
-            this.#wallet,
-            address,
-            amountBuffer.toString('hex'),
-            txValidity.toString('hex'),
+        const payload = await applyStateMessageFactory(this.#wallet, this.#config)
+            .buildPartialTransferOperationMessage(
+            this.#wallet.address,
+            recipientAddress,
+            amountBuffer,
+            txValidity,
+            "json"
         )
 
-        await this.broadcastPartialTransaction(payload);
-
         const expectedNewBalance = senderBalance - totalDeductedAmount;
         console.info('Transfer Details:');
         console.info(`Transaction hash ${payload.tro.tx}`)
@@ -848,9 +759,16 @@ export class MainSettlementBus extends ReadyResource {
             console.info(`Total: ${bigIntToDecimalString(totalDeductedAmount)}`);
         }
         console.log(`Expected Balance After Transfer: ${bigIntToDecimalString(expectedNewBalance)}`);
+        const success = await this.broadcastPartialTransaction(payload);
+        if (!success) {
+            throw new Error("Failed to broadcast transfer transaction after multiple attempts.");
+        } else {
+            console.log(`Transfer transaction broadcasted successfully. Tx hash: ${payload.tro.tx}`);
+        }
+
     }
 
-    async #handleBalanceMigrationOperation() {
+    async #balanceMigrationOperation() {
 
         const isInitDisabled = await this.#state.isInitalizationDisabled()
 
@@ -858,7 +776,7 @@ export class MainSettlementBus extends ReadyResource {
             throw new Error("Can not initialize balance - balance initialization is disabled.");
         }
 
-        if (this.#enable_wallet === false) {
+        if (!this.#config.enableWallet) {
             throw new Error("Can not initialize an admin - wallet is not enabled.");
         }
 
@@ -880,14 +798,14 @@ export class MainSettlementBus extends ReadyResource {
             throw new Error("Can not initialize an admin - writing key is not initialized.");
         }
 
-        if (!b4a.equals(this.#state.writingKey, this.#bootstrap)) {
+        if (!b4a.equals(this.#state.writingKey, this.#config.bootstrap)) {
             throw new Error("Can not initialize an admin - bootstrap is not equal to writing key.");
         }
 
         const { addressBalancePair, totalBalance, totalAddresses, addresses } = await fileUtils.readBalanceMigrationFile();
 
         for (let i = 0; i < addresses.length; i++) {
-            await migrationUtils.validateAddressFromIncomingFile(this.#state, addresses[i].address, adminEntry);
+            await migrationUtils.validateAddressFromIncomingFile(this.#state, this.#config, addresses[i].address, adminEntry);
         }
 
         await fileUtils.validateBalanceMigrationData(addresses);
@@ -895,11 +813,18 @@ export class MainSettlementBus extends ReadyResource {
         await fileUtils.createMigrationEntryFile(addressBalancePair, migrationNumber);
 
         const txValidity = await this.#state.getIndexerSequenceState();
-        const messages = await CompleteStateMessageOperations.assembleBalanceInitializationMessages(
-            this.#wallet,
-            txValidity,
-            addressBalancePair,
-        );
+
+        let messages = [];
+
+        for (const [recipientAddress, amountBuffer] of addressBalancePair) {
+            const payload = await applyStateMessageFactory(this.#wallet, this.#config).buildCompleteBalanceInitializationMessage(
+                this.#wallet.address,
+                recipientAddress,
+                amountBuffer,
+                txValidity,
+            )
+            messages.push(safeEncodeApplyOperation(payload));
+        }
 
         console.log(`Total balance to migrate: ${bigIntToDecimalString(totalBalance)} across ${totalAddresses} addresses.`);
 
@@ -946,9 +871,13 @@ export class MainSettlementBus extends ReadyResource {
     }
 
     async #disableInitialization() {
-        if (this.#enable_wallet === false) {
+        if (!this.#config.enableWallet) {
             throw new Error("Can not initialize an admin - wallet is not enabled.");
         }
+        const isInitDisabled = await this.#state.isInitalizationDisabled();
+        if (isInitDisabled) {
+            throw new Error("Can not disable initialization - it is already disabled.");
+        }
         const adminEntry = await this.#state.getAdminEntry();
 
         if (!adminEntry) {
@@ -958,22 +887,31 @@ export class MainSettlementBus extends ReadyResource {
         if (!this.#isAdmin(adminEntry)) {
             throw new Error('Cannot perform whitelisting - you are not the admin!.');
         }
-        // add more checks
+        if (!this.#wallet) {
+            throw new Error("Can not initialize an admin - wallet is not initialized.");
+        }
+        if (!this.#state.writingKey) {
+            throw new Error("Can not initialize an admin - writing key is not initialized.");
+        }
         const txValidity = await this.#state.getIndexerSequenceState();
-        const payload = await CompleteStateMessageOperations.assembleDisableInitializationMessage(
-            this.#wallet,
-            this.#state.writingKey,
-            txValidity,
-        )
+
+
+        const payload = await applyStateMessageFactory(this.#wallet, this.#config)
+            .buildCompleteDisableInitializationMessage(
+                this.#wallet.address,
+                this.#state.writingKey,
+                txValidity,
+            )
         console.log('Disabling initialization...');
-        await this.#state.append(payload);
+        const encodedPayload = safeEncodeApplyOperation(payload);
+        await this.#state.append(encodedPayload);
     }
 
     async interactiveMode() {
         if (this.#readline_instance === null) return;
         const rl = this.#readline_instance;
 
-        printHelp(this.#is_admin_mode);
+        printHelp(this.#config.isAdminMode);
 
         rl.on("line", async (input) => {
             try {
@@ -989,35 +927,30 @@ export class MainSettlementBus extends ReadyResource {
 
     async handleCommand(input, rl = null, payload = null) {
         const [command, ...parts] = input.split(" ");
-
         const exactHandlers = {
             "/help": async () => {
-                printHelp(this.#is_admin_mode);
+                printHelp(this.#config.isAdminMode);
             },
             "/exit": async () => {
                 if (rl) rl.close();
                 await this.close();
             },
-            "/add_admin": () => this.#handleAdminCreation(),
-            "/add_admin --recovery": () => this.#handleAdminRecovery(),
-            "/add_whitelist": () => this.#handleWhitelistOperations(),
-            "/add_writer": () => this.#handleAddWriterOperation(),
-            "/remove_writer": () => this.#handleRemoveWriterOperation(),
-            "/core": () => coreInfoCommand(this.#state),
-            "/indexers_list": async () => {
-                console.log(await this.#state.getIndexersEntry());
-            },
-            "/validator_pool": () => {
-                this.network.validatorConnectionManager.prettyPrint();
-            },
-            "/stats": () => verifyDag(
+            "/add_admin": async () => await this.#handleAdminCreation(),
+            "/add_admin --recovery": async () => await this.#handleAdminRecovery(),
+            "/add_whitelist": async () => await this.#handleWhitelistOperations(),
+            "/add_writer": async () => await this.#requestWriterRole(true),
+            "/remove_writer": async () => await this.#requestWriterRole(false),
+            "/core": async () => await coreInfoCommand(this.#state),
+            "/indexers_list": async () => console.log(await this.#state.getIndexersEntry()),
+            "/validator_pool": () => this.#network.validatorConnectionManager.prettyPrint(),
+            "/stats": async () => await verifyDag(
                 this.#state,
                 this.#network,
                 this.#wallet,
                 this.#state.writingKey
             ),
-            "/balance_migration": () => this.#handleBalanceMigrationOperation(),
-            "/disable_initialization": () => this.#disableInitialization()
+            "/balance_migration": async () => await this.#balanceMigrationOperation(),
+            "/disable_initialization": async () => await this.#disableInitialization()
         };
 
         if (exactHandlers[command]) {
@@ -1035,26 +968,26 @@ export class MainSettlementBus extends ReadyResource {
 
         if (input.startsWith("/add_indexer")) {
             const address = parts[0];
-            await this.#handleAddIndexerOperation(address);
+            await this.#updateWriterToIndexerRole(address, true);
         } else if (input.startsWith("/remove_indexer")) {
             const address = parts[0];
-            await this.#handleRemoveIndexerOperation(address);
+            await this.#updateWriterToIndexerRole(address, false);
         } else if (input.startsWith("/ban_writer")) {
             const address = parts[0];
-            await this.#handleBanValidatorOperation(address);
+            await this.#banValidator(address);
         } else if (input.startsWith("/deployment")) {
             const bootstrapToDeploy = parts[0];
             const channel = parts[1] || randomBytes(32).toString("hex");
             if (channel.length !== 64 || !isHexString(channel)) {
                 throw new Error("Channel must be a 32-byte hex string");
             }
-            await this.#handleBootstrapDeploymentOperation(bootstrapToDeploy, channel);
+            await this.#deployBootstrap(bootstrapToDeploy, channel);
         } else if (input.startsWith("/get_validator_addr")) {
             const wkHexString = parts[0];
-            await getValidatorAddressCommand(this.#state, wkHexString);
+            await getValidatorAddressCommand(this.#state, wkHexString, this.#config.addressPrefix);
         } else if (input.startsWith("/get_deployment")) {
             const bootstrapHex = parts[0];
-            await getDeploymentCommand(this.#state, bootstrapHex);
+            await getDeploymentCommand(this.#state, bootstrapHex, this.#config.addressLength);
         } else if (input.startsWith("/get_tx_info")) {
             const txHash = parts[0];
             await getTxInfoCommand(this.#state, txHash);
@@ -1092,19 +1025,11 @@ export class MainSettlementBus extends ReadyResource {
             const result = getUnconfirmedLengthCommand(this.#state);
             if (rl) rl.prompt();
             return result;
-        } else if (input.startsWith("/broadcast_transaction")) {
-            if (!payload) {
-                throw new Error("Transaction payload is required for broadcast_transaction command.");
-            }
-            const result = await this.broadcastTransactionCommand(payload);
-            if (rl) rl.prompt();
-            return result;
         } else if (input.startsWith("/get_tx_payloads_bulk")) {
             if (!payload) {
                 throw new Error("Missing payload for fetching tx payloads.");
             }
-            const hashes = payload;
-            const result = await getTxPayloadsBulkCommand(this.#state, hashes);
+            const result = await getTxPayloadsBulkCommand(this.#state, payload, this.#config);
             if (rl) rl.prompt();
             return result;
         } else if (input.startsWith("/get_txs_hashes")) {
@@ -1115,13 +1040,13 @@ export class MainSettlementBus extends ReadyResource {
             return result;
         } else if (input.startsWith("/get_tx_details")) {
             const hash = parts[0];
-            const result = await getTxDetailsCommand(this.#state, hash);
+            const result = await getTxDetailsCommand(this.#state, hash, this.#config);
             if (rl) rl.prompt();
             return result;
         } else if (input.startsWith("/get_extended_tx_details")) {
             const hash = parts[0];
             const confirmed = parts[1] === "true";
-            const result = await getExtendedTxDetailsCommand(this.#state, hash, confirmed);
+            const result = await getExtendedTxDetailsCommand(this.#state, hash, confirmed, this.#config);
             if (rl) rl.prompt();
             return result;
         }