trac-msb 0.2.7 → 0.2.8

package/tests/integration/apply/transfer.test.js

@@ -17,21 +17,23 @@ import {
 import PartialStateMessageOperations from "../../../src/messages/partialStateMessages/PartialStateMessageOperations.js";
 import CompleteStateMessageOperations from '../../../src/messages/completeStateMessages/CompleteStateMessageOperations.js';
 import { $TNK } from '../../../src/core/state/utils/balance.js';
+import { config } from '../../helpers/config.js';
 
 const buildTransfer = async (admin, from, to, amount) => {
     const txValidity = await from.msb.state.getIndexerSequenceState()
-    const tx = await PartialStateMessageOperations.assembleTransferOperationMessage(from.wallet, to.wallet.address, b4a.toString(amount, 'hex'), b4a.toString(txValidity, 'hex'))
+    const tx = await new PartialStateMessageOperations(from.wallet, config)
+        .assembleTransferOperationMessage(to.wallet.address, b4a.toString(amount, 'hex'), b4a.toString(txValidity, 'hex'))
     return { 
-        raw: await CompleteStateMessageOperations.assembleCompleteTransferOperationMessage(
-            admin.wallet,
-            tx.address,
-            b4a.from(tx.tro.tx, 'hex'),
-            b4a.from(tx.tro.txv, 'hex'),
-            b4a.from(tx.tro.in, 'hex'),
-            tx.tro.to,
-            b4a.from(tx.tro.am, 'hex'),
-            b4a.from(tx.tro.is, 'hex'),
-        ),
+        raw: await new CompleteStateMessageOperations(admin.wallet, config)
+            .assembleCompleteTransferOperationMessage(
+                tx.address,
+                b4a.from(tx.tro.tx, 'hex'),
+                b4a.from(tx.tro.txv, 'hex'),
+                b4a.from(tx.tro.in, 'hex'),
+                tx.tro.to,
+                b4a.from(tx.tro.am, 'hex'),
+                b4a.from(tx.tro.is, 'hex'),
+            ),
         hash: tx.tro.tx
     }
 }
@@ -41,11 +43,11 @@ let admin, writer1, writer2, writer3, tmpDirectory;
 hook('Initialize nodes for addWriter tests', async t => {
     const randomChannel = randomBytes(32).toString('hex');
     const baseOptions = {
-        enable_tx_apply_logs: false,
-        enable_interactive_mode: false,
-        enable_role_requester: false,
+        enableTxApplyLogs: false,
+        enableInteractiveMode: false,
+        enableRoleRequester: false,
         channel: randomChannel,
-        enable_validator_observer: false
+        enableValidatorObserver: false
     }
     tmpDirectory = await initTemporaryDirectory();
     admin = await setupMsbAdmin(testKeyPair1, tmpDirectory, baseOptions);
@@ -78,4 +80,4 @@ hook('Clean up handleApplyTransferOperation setup', async t => {
 
     await Promise.all(toClose)
     if (tmpDirectory) await removeTemporaryDirectory(tmpDirectory);
-});
+});

package/tests/unit/messageOperations/assembleAddIndexerMessage.test.js

@@ -4,12 +4,13 @@ import { OperationType } from '../../src/utils/protobuf/applyOperations.cjs';
 import { writingKeyNonAdmin, walletNonAdmin, initAll ,walletAdmin} from '../fixtures/assembleMessage.fixtures.js';
 import { messageOperationsBkoTest } from './commonsStateMessageOperationsTest.js';
 import { safeDecodeApplyOperation } from '../../src/utils/protobuf/operationHelpers.js';
+import { config } from '../../helpers/config.js';
 
 const testName = 'assembleAddIndexerMessage';
 test(testName, async (t) => {
     await initAll();
     const assembler = async (wallet, address) => {
-        return safeDecodeApplyOperation(await CompleteStateMessageOperations.assembleAddIndexerMessage(wallet,address));
+        return safeDecodeApplyOperation(await new CompleteStateMessageOperations(wallet, config).assembleAddIndexerMessage(address));
     }
     
     await messageOperationsBkoTest(t, testName, assembler, walletAdmin, writingKeyNonAdmin, OperationType.ADD_INDEXER, 2, walletNonAdmin.address);
@@ -18,4 +19,3 @@ test(testName, async (t) => {
 
 
 
-

package/tests/unit/messageOperations/assembleAddWriterMessage.test.js

@@ -4,12 +4,13 @@ import {OperationType} from '../../src/utils/protobuf/applyOperations.cjs';
 import {initAll, walletNonAdmin, writingKeyNonAdmin} from '../fixtures/assembleMessage.fixtures.js';
 import {messageOperationsEkoTest} from './commonsStateMessageOperationsTest.js';
 import {safeDecodeApplyOperation} from '../../src/utils/protobuf/operationHelpers.js';
+import { config } from '../../helpers/config.js'
 
 const testName = 'assembleAddWriterMessage';
 test(testName, async (t) => {
     await initAll();
     const assembler = async (wallet, writingKey) => {
-        return safeDecodeApplyOperation(await CompleteStateMessageOperations.assembleAddWriterMessage(wallet, writingKey));
+        return safeDecodeApplyOperation(await new CompleteStateMessageOperations(wallet, config).assembleAddWriterMessage(writingKey));
     }
     
     await messageOperationsEkoTest(t, testName, assembler, walletNonAdmin, writingKeyNonAdmin, OperationType.ADD_WRITER, 3, walletNonAdmin.address);

package/tests/unit/messageOperations/assembleAdminMessage.test.js

@@ -1,6 +1,5 @@
 import test from 'brittle';
 import b4a from 'b4a';
-
 import CompleteStateMessageOperations from '../../src/messages/completeStateMessages/CompleteStateMessageOperations.js';
 import {default as fixtures} from '../fixtures/assembleMessage.fixtures.js';
 import {OperationType} from "../../src/utils/constants.js";
@@ -8,6 +7,7 @@ import {bufferToAddress} from "../../src/core/state/utils/address.js";
 import {safeDecodeApplyOperation} from '../../src/utils/protobuf/operationHelpers.js';
 import {isAddressValid} from "../../src/core/state/utils/address.js";
 import {errorMessageIncludes} from "../utils/regexHelper.js";
+import { config } from '../../helpers/config.js';
 
 test('assembleAdminMessage', async (t) => {
     await fixtures.initAll();
@@ -18,16 +18,15 @@ test('assembleAdminMessage', async (t) => {
 
 
     t.test('assembleAdminMessage - setup admin', async (k) => {
-
-        const msg = safeDecodeApplyOperation(await CompleteStateMessageOperations.assembleAddAdminMessage(walletAdmin, writingKeyAdmin));
+        const msg = safeDecodeApplyOperation(await new CompleteStateMessageOperations(walletAdmin, config).assembleAddAdminMessage(writingKeyAdmin));
 
         k.ok(msg, 'Message should be created');
         k.is(Object.keys(msg).length, 3, 'Message should have 3 keys');
         k.is(Object.keys(msg.eko).length, 3, 'Message value have 3 keys');
         k.is(msg.type, OperationType.ADD_ADMIN, 'Message type should be ADD_ADMIN');
-        k.is(bufferToAddress(msg.address), walletAdmin.address, 'Message address should be the public key of the wallet');
+        k.is(bufferToAddress(msg.address, config.addressPrefix), walletAdmin.address, 'Message address should be the public key of the wallet');
 
-        k.ok(isAddressValid(msg.address), 'Message address should be a valid address');
+        k.ok(isAddressValid(msg.address, config.addressPrefix), 'Message address should be a valid address');
 
         k.ok(b4a.equals(msg.eko.wk, writingKeyAdmin), 'Message wk should be the writing key');
         k.is(msg.eko.nonce.length, 32, 'Message nonce should be 32 bytes long');
@@ -37,15 +36,15 @@ test('assembleAdminMessage', async (t) => {
     });
 
     t.test('assembleAdminMessage - admin recovery message', async (k) => {
-        const msg = safeDecodeApplyOperation(await CompleteStateMessageOperations.assembleAddAdminMessage(walletAdmin, writingKeyNonAdmin));
+        const msg = safeDecodeApplyOperation(await new CompleteStateMessageOperations(walletAdmin, config).assembleAddAdminMessage(writingKeyNonAdmin));
 
         k.ok(msg, 'Message should be created');
         k.is(Object.keys(msg).length, 3, 'Message should have 3 keys');
         k.is(Object.keys(msg.eko).length, 3, 'Message value have 3 keys');
         k.is(msg.type, OperationType.ADD_ADMIN, 'Message type should be ADD_ADMIN');
 
-        k.is(bufferToAddress(msg.address), walletAdmin.address, 'Message address should be address of the wallet');
-        k.ok(isAddressValid(msg.address), 'Message address should be a valid address');
+        k.is(bufferToAddress(msg.address, config.addressPrefix), walletAdmin.address, 'Message address should be address of the wallet');
+        k.ok(isAddressValid(msg.address, config.addressPrefix), 'Message address should be a valid address');
 
         k.ok(b4a.equals(msg.eko.wk, writingKeyNonAdmin), 'Message wk should be the writing key');
         k.is(msg.eko.sig.length, 64, 'Message signature should be 64 bytes long')
@@ -55,14 +54,14 @@ test('assembleAdminMessage', async (t) => {
 
     t.test('assembleAdminMessage - writer key is null', async (k) => {
         await k.exception(
-            async () => await CompleteStateMessageOperations.assembleAddAdminMessage(walletAdmin, null),
+            async () => await new CompleteStateMessageOperations(walletAdmin, config).assembleAddAdminMessage(null),
             errorMessageIncludes('Writer key must be a 32 length buffer')
         );
     });
 
     t.test("assembleAdminMessage - admin wallet is null", async (k) => {
         await k.exception(
-            async () => await CompleteStateMessageOperations.assembleAddAdminMessage(null, writingKeyAdmin),
+            async () => await new CompleteStateMessageOperations(null, config).assembleAddAdminMessage(writingKeyAdmin),
             errorMessageIncludes('Wallet must be a valid wallet object')
         );
     });

package/tests/unit/messageOperations/assembleBanWriterMessage.test.js

@@ -4,13 +4,14 @@ import { OperationType } from '../../src/utils/protobuf/applyOperations.cjs';
 import { writingKeyNonAdmin, walletNonAdmin, initAll, walletAdmin } from '../fixtures/assembleMessage.fixtures.js';
 import { messageOperationsBkoTest } from './commonsStateMessageOperationsTest.js';
 import { safeDecodeApplyOperation } from '../../src/utils/protobuf/operationHelpers.js';
+import { config } from '../../helpers/config.js';
 
 const testName = 'assembleBanWriterMessage';
 test(testName, async (t) => {
     await initAll();
     const assembler = async (wallet,address) => {
-        return safeDecodeApplyOperation(await CompleteStateMessageOperations.assembleBanWriterMessage(wallet,address));
+        return safeDecodeApplyOperation(await new CompleteStateMessageOperations(wallet, config).assembleBanWriterMessage(address));
     }
     await messageOperationsBkoTest(t, testName, assembler, walletAdmin, writingKeyNonAdmin, OperationType.BAN_VALIDATOR, 2, walletNonAdmin.address);
     
-});
+});

package/tests/unit/messageOperations/assemblePostTransaction.test.js

@@ -7,7 +7,8 @@ import b4a from 'b4a';
 import {safeDecodeApplyOperation} from '../../src/utils/protobuf/operationHelpers.js';
 import {isAddressValid} from "../../src/core/state/utils/address.js";
 import {errorMessageIncludes} from "../utils/regexHelper.js";
-import {generatePostTx, randomBytes} from "../../helpers/setupApplyTests.js";
+import {randomBytes} from "../../helpers/setupApplyTests.js";
+import { config } from '../../helpers/config.js';
 
 const msgTxoLength = 10;
 const opType = OperationType.TX;
@@ -26,8 +27,7 @@ test('assemblePostTxMessage - ....', async (k) => {
     const externalBootstrap = randomBytes(32);
     const msbBootstrap = randomBytes(32);
 
-    const decodedPostTx = safeDecodeApplyOperation(await CompleteStateMessageOperations.assembleCompleteTransactionOperationMessage(
-        nonAdminWallet,
+    const decodedPostTx = safeDecodeApplyOperation(await new CompleteStateMessageOperations(nonAdminWallet, config).assembleCompleteTransactionOperationMessage(
         validatorAddress,
         txHash,
         incomingAddress,
@@ -44,11 +44,11 @@ test('assemblePostTxMessage - ....', async (k) => {
 
     k.is(decodedPostTx.type, opType, `Message type should be ${opType}`);
 
-    k.ok(isAddressValid(decodedPostTx.address), 'Message validator address should be a valid address');
-    k.ok(isAddressValid(decodedPostTx.txo.ia), 'Message incoming address should be a valid address');
+    k.ok(isAddressValid(decodedPostTx.address, config.addressPrefix), 'Message validator address should be a valid address');
+    k.ok(isAddressValid(decodedPostTx.txo.ia, config.addressPrefix), 'Message incoming address should be a valid address');
 
-    k.ok(bufferToAddress(decodedPostTx.txo.ia) === incomingAddress, 'Message incoming address should be the address of the peer wallet');
-    k.ok(bufferToAddress(decodedPostTx.address) === validatorAddress, 'Message validator address should be the address of the non-admin wallet');
+    k.ok(bufferToAddress(decodedPostTx.txo.ia, config.addressPrefix) === incomingAddress, 'Message incoming address should be the address of the peer wallet');
+    k.ok(bufferToAddress(decodedPostTx.address, config.addressPrefix) === validatorAddress, 'Message validator address should be the address of the non-admin wallet');
 
     k.ok(b4a.isBuffer(decodedPostTx.txo.tx), 'tx should be a buffer');
     k.is(decodedPostTx.txo.tx.length, 32, 'tx should be 32 bytes long');
@@ -76,8 +76,7 @@ test('assemblePostTxMessage - ....', async (k) => {
             address: 'trac1y6kkq48fgu3ur'
         }
         await k.exception(
-            async () => await CompleteStateMessageOperations.assembleCompleteTransactionOperationMessage(
-                invalidWallet,
+            async () => await new CompleteStateMessageOperations(invalidWallet, config).assembleCompleteTransactionOperationMessage(
                 validatorAddress,
                 txHash,
                 incomingAddress,
@@ -97,8 +96,7 @@ test('assemblePostTxMessage - ....', async (k) => {
             address: 'testnet1y6kkq48fgu3urrhg0gm7h8zdyxl3gnaazd2u7568lfl5zxqs285q6kuljk'
         }
         await k.exception(
-            async () => await CompleteStateMessageOperations.assembleCompleteTransactionOperationMessage(
-                invalidWallet,
+            async () => await new CompleteStateMessageOperations(invalidWallet, config).assembleCompleteTransactionOperationMessage(
                 validatorAddress,
                 txHash,
                 incomingAddress,
@@ -118,8 +116,7 @@ test('assemblePostTxMessage - ....', async (k) => {
             address: ''
         }
         await k.exception(
-            async () => await CompleteStateMessageOperations.assembleCompleteTransactionOperationMessage(
-                invalidWallet,
+            async () => await new CompleteStateMessageOperations(invalidWallet, config).assembleCompleteTransactionOperationMessage(
                 validatorAddress,
                 txHash,
                 incomingAddress,
@@ -136,8 +133,7 @@ test('assemblePostTxMessage - ....', async (k) => {
 
     k.test(`assemblePostTxMessage - Invalid wallet instance - null Wallet `, async (k) => {
         await k.exception(
-            async () => await CompleteStateMessageOperations.assembleCompleteTransactionOperationMessage(
-                null,
+            async () => await new CompleteStateMessageOperations(null, config).assembleCompleteTransactionOperationMessage(
                 validatorAddress,
                 txHash,
                 incomingAddress,
@@ -154,8 +150,7 @@ test('assemblePostTxMessage - ....', async (k) => {
 
     k.test(`assemblePostTxMessage - Invalid wallet instance - undefined Wallet`, async (k) => {
         await k.exception(
-            async () => await CompleteStateMessageOperations.assembleCompleteTransactionOperationMessage(
-                undefined,
+            async () => await new CompleteStateMessageOperations(undefined, config).assembleCompleteTransactionOperationMessage(
                 validatorAddress,
                 txHash,
                 incomingAddress,
@@ -175,8 +170,7 @@ test('assemblePostTxMessage - ....', async (k) => {
         const invalid = 'trac1y6kkq48fgu3urrhg0gm7h8zdyxl3gnaazd2u7568lfl5zxqs285q6kuljką';
 
         await k.exception(
-            async () => await CompleteStateMessageOperations.assembleCompleteTransactionOperationMessage(
-                nonAdminWallet,
+            async () => await new CompleteStateMessageOperations(nonAdminWallet, config).assembleCompleteTransactionOperationMessage(
                 invalid,
                 txHash,
                 incomingAddress,
@@ -195,8 +189,7 @@ test('assemblePostTxMessage - ....', async (k) => {
         const invalid = 'trac1y6kkq48fgu3ur';
 
         await k.exception(
-            async () => await CompleteStateMessageOperations.assembleCompleteTransactionOperationMessage(
-                nonAdminWallet,
+            async () => await new CompleteStateMessageOperations(nonAdminWallet, config).assembleCompleteTransactionOperationMessage(
                 invalid,
                 txHash,
                 incomingAddress,
@@ -215,8 +208,7 @@ test('assemblePostTxMessage - ....', async (k) => {
         const invalid = 'testnet1y6kkq48fgu3urrhg0gm7h8zdyxl3gnaazd2u7568lfl5zxqs285q6kuljk';
 
         await k.exception(
-            async () => await CompleteStateMessageOperations.assembleCompleteTransactionOperationMessage(
-                nonAdminWallet,
+            async () => await new CompleteStateMessageOperations(nonAdminWallet, config).assembleCompleteTransactionOperationMessage(
                 invalid,
                 txHash,
                 incomingAddress,
@@ -235,8 +227,7 @@ test('assemblePostTxMessage - ....', async (k) => {
         const invalid = '';
 
         await k.exception(
-            async () => await CompleteStateMessageOperations.assembleCompleteTransactionOperationMessage(
-                nonAdminWallet,
+            async () => await new CompleteStateMessageOperations(nonAdminWallet, config).assembleCompleteTransactionOperationMessage(
                 invalid,
                 txHash,
                 incomingAddress,
@@ -253,8 +244,7 @@ test('assemblePostTxMessage - ....', async (k) => {
     k.test(`assemblePostTxMessage - Address parameter (validator address) - Null`, async (k) => {
 
         await k.exception(
-            async () => await CompleteStateMessageOperations.assembleCompleteTransactionOperationMessage(
-                nonAdminWallet,
+            async () => await new CompleteStateMessageOperations(nonAdminWallet, config).assembleCompleteTransactionOperationMessage(
                 null,
                 txHash,
                 incomingAddress,
@@ -270,8 +260,7 @@ test('assemblePostTxMessage - ....', async (k) => {
 
     k.test(`assemblePostTxMessage - Address parameter (validator address) - undefined`, async (k) => {
         await k.exception(
-            async () => await CompleteStateMessageOperations.assembleCompleteTransactionOperationMessage(
-                nonAdminWallet,
+            async () => await new CompleteStateMessageOperations(nonAdminWallet, config).assembleCompleteTransactionOperationMessage(
                 undefined,
                 txHash,
                 incomingAddress,
@@ -288,8 +277,7 @@ test('assemblePostTxMessage - ....', async (k) => {
     k.test(`assemblePostTxMessage - Address parameter (incoming address) - 'ą' does not belongs to the TRAC bench alphabet`, async (k) => {
         const invalid = 'trac1y6kkq48fgu3urrhg0gm7h8zdyxl3gnaazd2u7568lfl5zxqs285q6kuljką';
         await k.exception(
-            async () => await CompleteStateMessageOperations.assembleCompleteTransactionOperationMessage(
-                nonAdminWallet,
+        async () => await new CompleteStateMessageOperations(nonAdminWallet, config).assembleCompleteTransactionOperationMessage(
                 validatorAddress, // correct validator address
                 txHash,
                 invalid, // invalid incoming address
@@ -307,8 +295,7 @@ test('assemblePostTxMessage - ....', async (k) => {
     k.test(`assemblePostTxMessage - Address parameter (incoming address) - trac address is to short`, async (k) => {
         const invalid = 'trac1y6kkq48fgu3ur';
         await k.exception(
-            async () => await CompleteStateMessageOperations.assembleCompleteTransactionOperationMessage(
-                nonAdminWallet,
+        async () => await new CompleteStateMessageOperations(nonAdminWallet, config).assembleCompleteTransactionOperationMessage(
                 validatorAddress,
                 txHash,
                 invalid,
@@ -326,8 +313,7 @@ test('assemblePostTxMessage - ....', async (k) => {
     k.test(`assemblePostTxMessage- Address parameter (incoming address) - invalid prefix`, async (k) => {
         const invalid = 'testnet1y6kkq48fgu3urrhg0gm7h8zdyxl3gnaazd2u7568lfl5zxqs285q6kuljk';
         await k.exception(
-            async () => await CompleteStateMessageOperations.assembleCompleteTransactionOperationMessage(
-                nonAdminWallet,
+        async () => await new CompleteStateMessageOperations(nonAdminWallet, config).assembleCompleteTransactionOperationMessage(
                 validatorAddress,
                 txHash,
                 invalid,
@@ -344,8 +330,7 @@ test('assemblePostTxMessage - ....', async (k) => {
     k.test(`assemblePostTxMessage - Address parameter (incoming address) - empty string`, async (k) => {
         const invalid = '';
         await k.exception(
-            async () => await CompleteStateMessageOperations.assembleCompleteTransactionOperationMessage(
-                nonAdminWallet,
+        async () => await new CompleteStateMessageOperations(nonAdminWallet, config).assembleCompleteTransactionOperationMessage(
                 validatorAddress,
                 txHash,
                 invalid,
@@ -361,8 +346,7 @@ test('assemblePostTxMessage - ....', async (k) => {
 
     k.test(`assemblePostTxMessage - Address parameter (incoming address) - Null`, async (k) => {
         await k.exception(
-            async () => await CompleteStateMessageOperations.assembleCompleteTransactionOperationMessage(
-                nonAdminWallet,
+        async () => await new CompleteStateMessageOperations(nonAdminWallet, config).assembleCompleteTransactionOperationMessage(
                 validatorAddress,
                 txHash,
                 null,
@@ -378,8 +362,7 @@ test('assemblePostTxMessage - ....', async (k) => {
 
     k.test(`assemblePostTxMessage - Address parameter (incoming address) - undefined`, async (k) => {
         await k.exception(
-            async () => await CompleteStateMessageOperations.assembleCompleteTransactionOperationMessage(
-                nonAdminWallet,
+        async () => await new CompleteStateMessageOperations(nonAdminWallet, config).assembleCompleteTransactionOperationMessage(
                 validatorAddress,
                 txHash,
                 undefined,
@@ -421,8 +404,7 @@ test('assemblePostTxMessage - ....', async (k) => {
                 };
                 args[param.key] = invalid.value;
                 await k.exception(
-                    async () => await CompleteStateMessageOperations.assembleCompleteTransactionOperationMessage(
-                        nonAdminWallet,
+                    async () => await new CompleteStateMessageOperations(nonAdminWallet, config).assembleCompleteTransactionOperationMessage(
                         validatorAddress,
                         args.txHash,
                         incomingAddress,

package/tests/unit/messageOperations/assembleRemoveIndexerMessage.test.js

@@ -4,16 +4,16 @@ import { OperationType } from '../../src/utils/protobuf/applyOperations.cjs';
 import { writingKeyNonAdmin, walletNonAdmin, initAll ,walletAdmin} from '../fixtures/assembleMessage.fixtures.js';
 import { messageOperationsBkoTest } from './commonsStateMessageOperationsTest.js';
 import { safeDecodeApplyOperation } from '../../src/utils/protobuf/operationHelpers.js';
+import { config } from '../../helpers/config.js';
 
 const testName = 'assembleRemoveIndexerMessage';
 test(testName, async (t) => {
     await initAll();
     const assembler = async (wallet,address) => {
-        return safeDecodeApplyOperation(await CompleteStateMessageOperations.assembleRemoveIndexerMessage(wallet,address));
+        return safeDecodeApplyOperation(await new CompleteStateMessageOperations(wallet, config).assembleRemoveIndexerMessage(address));
     }
 
     await messageOperationsBkoTest(t, testName, assembler, walletAdmin, writingKeyNonAdmin, OperationType.REMOVE_INDEXER, 2, walletNonAdmin.address);
 });
 
 
-

package/tests/unit/messageOperations/assembleRemoveWriterMessage.test.js

@@ -4,13 +4,13 @@ import {OperationType} from '../../src/utils/protobuf/applyOperations.cjs';
 import {initAll, walletNonAdmin, writingKeyNonAdmin} from '../fixtures/assembleMessage.fixtures.js';
 import {messageOperationsEkoTest} from './commonsStateMessageOperationsTest.js';
 import {safeDecodeApplyOperation} from '../../src/utils/protobuf/operationHelpers.js';
-
+import { config } from '../../helpers/config.js';
 
 const testName = 'assembleRemoveWriterMessage';
 test(testName, async (t) => {
     await initAll();
         const assembler = async (wallet, writingKey) => {
-            return safeDecodeApplyOperation(await CompleteStateMessageOperations.assembleRemoveWriterMessage(wallet, writingKey));
+            return safeDecodeApplyOperation(await new CompleteStateMessageOperations(wallet, config).assembleRemoveWriterMessage(writingKey));
     }
     await messageOperationsEkoTest(t, testName, assembler, walletNonAdmin, writingKeyNonAdmin, OperationType.REMOVE_WRITER, 3, walletNonAdmin.address);
 });

package/tests/unit/messageOperations/assembleWhitelistMessages.test.js

@@ -7,6 +7,7 @@ import fileUtils from "../../src/utils/fileUtils.js";
 import CompleteStateMessageOperations from "../../src/messages/completeStateMessages/CompleteStateMessageOperations.js";
 import {bufferToAddress} from "../../src/core/state/utils/address.js";
 import {errorMessageIncludes} from "../utils/regexHelper.js";
+import { config } from '../../helpers/config.js'
 
 // MOCK SETUP
 const whitelistAddresses = [
@@ -22,7 +23,7 @@ test('assembleWhitelistMessages', async (t) => {
 
 
     t.test('assembleWhitelistMessages - Happy Path', async (k) => {
-        const mapMsg = await CompleteStateMessageOperations.assembleAppendWhitelistMessages(walletAdmin);
+        const mapMsg = await new CompleteStateMessageOperations(walletAdmin, config).assembleAppendWhitelistMessages();
         const msg = mapMsg.get(whitelistAddresses[0])
         k.ok(msg, 'Message should be created');
         k.ok(msg.length > 0, 'Message should be an array with at least one element');
@@ -31,7 +32,7 @@ test('assembleWhitelistMessages', async (t) => {
         k.is(Object.keys(decodedMsg.bko).length, 2, 'Message value should have 2 keys');
         k.is(decodedMsg.type, OperationType.APPEND_WHITELIST, 'Message type should be APPEND_WHITELIST');
 
-        k.is(bufferToAddress(decodedMsg.address) , whitelistAddresses[0], 'Message address should be the address in the file');
+        k.is(bufferToAddress(decodedMsg.address, config.addressPrefix) , whitelistAddresses[0], 'Message address should be the address in the file');
         k.is(decodedMsg.bko.nonce.length, 32, 'Message nonce should be 32 bytes long');
         k.ok(b4a.isBuffer(decodedMsg.bko.nonce), 'Message nonce should be a buffer');
         k.is(decodedMsg.bko.sig.length, 64, 'Message signature should be 64 bytes long');
@@ -40,7 +41,7 @@ test('assembleWhitelistMessages', async (t) => {
 
     t.test('assembleWhitelistMessages - Should return null when wallet is invalid', async (k) => {
         await k.exception(
-            async () => await CompleteStateMessageOperations.assembleAppendWhitelistMessages(null),
+            async () => await new CompleteStateMessageOperations(null, config).assembleAppendWhitelistMessages(),
             errorMessageIncludes('Wallet must be a valid wallet object')
         );
     });
@@ -48,7 +49,7 @@ test('assembleWhitelistMessages', async (t) => {
 
     t.test('assembleWhitelistMessages - Empty object', async (k) => {
         await k.exception(
-            async () => await CompleteStateMessageOperations.assembleAppendWhitelistMessages({}),
+            async () => await new CompleteStateMessageOperations({}, config).assembleAppendWhitelistMessages(),
             errorMessageIncludes('Wallet should have a valid TRAC address.')
         );
 

package/tests/unit/messageOperations/commonsStateMessageOperationsTest.js

@@ -2,6 +2,7 @@ import b4a from 'b4a';
 import {OperationType} from "../../src/utils/constants.js";
 import {bufferToAddress, isAddressValid} from "../../src/core/state/utils/address.js";
 import {errorMessageIncludes} from "../utils/regexHelper.js"
+import { config } from '../../helpers/config.js'
 
 export async function messageOperationsEkoTest(t, fnName, assembler, wallet, writingKey, opType, msgValueLength, expectedMessageAddress) {
     console.log('address:', expectedMessageAddress)
@@ -17,8 +18,8 @@ export async function messageOperationsEkoTest(t, fnName, assembler, wallet, wri
             k.ok(b4a.equals(msg.eko.wk, writingKey), 'Message wk should be the writing key');
         }
 
-        k.ok(bufferToAddress(msg.address) === expectedMessageAddress, 'Message key should be the the expected one');
-        k.ok(isAddressValid(msg.address), 'Message address should be a valid address');
+        k.ok(bufferToAddress(msg.address, config.addressPrefix) === expectedMessageAddress, 'Message key should be the the expected one');
+        k.ok(isAddressValid(msg.address, config.addressPrefix), 'Message address should be a valid address');
 
         k.is(msg.eko.nonce.length, 32, 'Message nonce should be 32 bytes long');
         k.ok(b4a.isBuffer(msg.eko.nonce), 'Message nonce should be a buffer');
@@ -152,7 +153,7 @@ export async function messageOperationsBkoTest(t, fnName, assembler, wallet, wri
 
         k.is(msg.type, opType, `Message type should be ${opType}`);
 
-        k.ok(bufferToAddress(msg.address) === expectedMessageAddress, 'Message address should be the the expected one');
+        k.ok(bufferToAddress(msg.address, config.addressPrefix) === expectedMessageAddress, 'Message address should be the the expected one');
         k.is(msg.bko.nonce.length, 32, 'Message nonce should be 32 bytes long');
         k.ok(b4a.isBuffer(msg.bko.nonce), 'Message nonce should be a buffer');
         k.is(msg.bko.sig.length, 64, 'Message signature should be 64 bytes long');

package/tests/unit/network/ConnectionManager.test.js

@@ -5,6 +5,7 @@ import { testKeyPair1, testKeyPair2, testKeyPair3, testKeyPair4, testKeyPair5, t
 import ConnectionManager from "../../../src/core/network/services/ConnectionManager.js";
 import { tick } from "../../helpers/setupApplyTests.js";
 import b4a from 'b4a'
+import { createConfig, ENV } from "../../../src/config/env.js";
 
 const createConnection = (key) => {
     const emitter = new EventEmitter()
@@ -18,7 +19,8 @@ const createConnection = (key) => {
 }
 
 const makeManager = (maxValidators = 6, conns = connections) => {
-    const connectionManager = new ConnectionManager({ maxValidators })
+    const merged = createConfig(ENV.DEVELOPMENT, { maxValidators })
+    const connectionManager = new ConnectionManager(merged)
 
     conns.forEach(({ key, connection }) => {
         connectionManager.addValidator(key, connection)
@@ -78,7 +80,7 @@ test('ConnectionManager', () => {
                 createConnection(testKeyPair2.publicKey),
             ]
 
-            const connectionManager = new ConnectionManager({ maxValidators: maxConnections })
+            const connectionManager = makeManager(maxConnections)
             localConnections.forEach(({ key, connection }) => {
                 connectionManager.addValidator(key, connection)
             })

package/tests/unit/network/NetworkWalletFactory.test.js

@@ -3,15 +3,14 @@ import sinon from 'sinon';
 import b4a from 'b4a';
 
 import PeerWallet from 'trac-wallet';
-import { TRAC_NETWORK_MSB_MAINNET_PREFIX } from 'trac-wallet/constants.js';
-
 import NetworkWalletFactory, { EphemeralWallet } from '../../../src/core/network/identity/NetworkWalletFactory.js';
 import { errorMessageIncludes } from '../../helpers/regexHelper.js';
 import { testKeyPair1, testKeyPair2 } from '../../fixtures/apply.fixtures.js';
+import { config } from '../../helpers/config.js';
 
 test('NetworkWalletFactory.provide returns wallet when enabled', async t => {
     const publicKey = b4a.from(testKeyPair2.publicKey, 'hex');
-    const address = PeerWallet.encodeBech32m(TRAC_NETWORK_MSB_MAINNET_PREFIX, publicKey);
+    const address = PeerWallet.encodeBech32m(config.addressPrefix, publicKey);
     const signResult = b4a.from('abcd', 'hex');
     const wallet = {
         publicKey,
@@ -20,7 +19,7 @@ test('NetworkWalletFactory.provide returns wallet when enabled', async t => {
         verify: sinon.stub().returns(true)
     };
 
-    const provider = NetworkWalletFactory.provide({ wallet, enableWallet: true });
+    const provider = NetworkWalletFactory.provide({ wallet, enableWallet: true, networkPrefix: config.addressPrefix });
     const message = b4a.from('00112233', 'hex');
     const signature = provider.sign(message);
 
@@ -39,7 +38,7 @@ test('NetworkWalletFactory.provide returns wallet when enabled', async t => {
 test('NetworkWalletFactory.provide requires both public and secret keys when wallet disabled', async t => {
     const publicKey = b4a.from(testKeyPair1.publicKey, 'hex');
     await t.exception(
-        () => NetworkWalletFactory.provide({ enableWallet: false, keyPair: { publicKey } }),
+        () => NetworkWalletFactory.provide({ enableWallet: false, keyPair: { publicKey }, networkPrefix: config.addressPrefix }),
         errorMessageIncludes('keyPair with publicKey and secretKey is required')
     );
 });
@@ -50,7 +49,8 @@ test('NetworkWalletFactory.provide rejects non-buffer inputs', async t => {
         () =>
             NetworkWalletFactory.provide({
                 enableWallet: false,
-                keyPair: { publicKey: 'not-a-buffer', secretKey }
+                keyPair: { publicKey: 'not-a-buffer', secretKey },
+                networkPrefix: config.addressPrefix
             }),
         errorMessageIncludes('must be a Buffer')
     );
@@ -65,7 +65,7 @@ test('NetworkWalletFactory.provide propagates invalid public key length errors',
             NetworkWalletFactory.provide({
                 enableWallet: false,
                 keyPair: { publicKey: invalidPublicKey, secretKey },
-                networkPrefix: TRAC_NETWORK_MSB_MAINNET_PREFIX
+                networkPrefix: config.addressPrefix
             }),
         errorMessageIncludes('Invalid public key')
     );
@@ -79,14 +79,14 @@ test('NetworkWalletFactory.provide derives address and signs payloads from keyPa
     const provider = NetworkWalletFactory.provide({
         enableWallet: false,
         keyPair,
-        networkPrefix: TRAC_NETWORK_MSB_MAINNET_PREFIX
+        networkPrefix: config.addressPrefix
     });
     const message = b4a.from('123455555', 'hex');
     const signature = provider.sign(message);
 
     t.is(
         provider.address,
-        PeerWallet.encodeBech32m(TRAC_NETWORK_MSB_MAINNET_PREFIX, provider.publicKey)
+        PeerWallet.encodeBech32m(config.addressPrefix, provider.publicKey)
     );
     t.ok(PeerWallet.verify(signature, message, provider.publicKey));
     t.ok(provider.verify(signature, message));
@@ -104,7 +104,7 @@ test('NetworkWalletFactory handles falsy address derivation results', async t =>
             NetworkWalletFactory.provide({
                 enableWallet: false,
                 keyPair,
-                networkPrefix: TRAC_NETWORK_MSB_MAINNET_PREFIX
+                networkPrefix: config.addressPrefix
             }),
         errorMessageIncludes('failed to derive address')
     );
@@ -124,7 +124,7 @@ test('NetworkWalletFactory propagates encoder exceptions', async t => {
             NetworkWalletFactory.provide({
                 enableWallet: false,
                 keyPair,
-                networkPrefix: TRAC_NETWORK_MSB_MAINNET_PREFIX
+                networkPrefix: config.addressPrefix
             }),
         errorMessageIncludes('test exception')
     );
@@ -137,12 +137,12 @@ test('EphemeralWallet exposes wallet like interface', async t => {
         publicKey: b4a.from(testKeyPair1.publicKey, 'hex'),
         secretKey: b4a.from(testKeyPair1.secretKey, 'hex')
     };
-    const wallet = new EphemeralWallet(keyPair, TRAC_NETWORK_MSB_MAINNET_PREFIX);
+    const wallet = new EphemeralWallet(keyPair, config.addressPrefix);
     const message = b4a.from('feedface', 'hex');
     const signature = wallet.sign(message);
 
     t.alike(wallet.publicKey, keyPair.publicKey);
-    t.is(wallet.address, PeerWallet.encodeBech32m(TRAC_NETWORK_MSB_MAINNET_PREFIX, keyPair.publicKey));
+    t.is(wallet.address, PeerWallet.encodeBech32m(config.addressPrefix, keyPair.publicKey));
     t.ok(PeerWallet.verify(signature, message, wallet.publicKey));
     t.ok(wallet.verify(signature, message));
 });
@@ -150,7 +150,7 @@ test('EphemeralWallet exposes wallet like interface', async t => {
 test('EphemeralWallet requires both public and secret keys', async t => {
     const publicKey = b4a.from(testKeyPair1.publicKey, 'hex');
     await t.exception(
-        () => new EphemeralWallet({ publicKey }, TRAC_NETWORK_MSB_MAINNET_PREFIX),
+        () => new EphemeralWallet({ publicKey }, config.addressPrefix),
         errorMessageIncludes('keyPair with publicKey and secretKey is required')
     );
 });