trac-msb 0.2.6 → 0.2.8

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)
@@ -50,7 +52,6 @@ test('ConnectionManager', () => {
             reset()
             const connectionManager = makeManager()
             t.is(connectionManager.connectionCount(), connections.length, 'should have the same length')
-            
             const data = createConnection(testKeyPair5.publicKey)
             connectionManager.addValidator(data.key, data.connection)
             t.is(connectionManager.connectionCount(), connections.length + 1, 'should have the same length')
@@ -70,6 +71,31 @@ test('ConnectionManager', () => {
             connectionManager.addValidator(toNotAdd.key, toNotAdd.connection)
             t.is(connectionManager.connectionCount(), maxConnections, 'should not increase length')
         })
+
+        test('does not add new validator when pool is full', async t => {
+            reset()
+            const maxConnections = 2
+            const localConnections = [
+                createConnection(testKeyPair1.publicKey),
+                createConnection(testKeyPair2.publicKey),
+            ]
+
+            const connectionManager = makeManager(maxConnections)
+            localConnections.forEach(({ key, connection }) => {
+                connectionManager.addValidator(key, connection)
+            })
+
+            t.is(connectionManager.connectionCount(), maxConnections, 'pool should be full')
+
+            const newConn = createConnection(testKeyPair3.publicKey)
+            connectionManager.addValidator(newConn.key, newConn.connection)
+
+            t.is(connectionManager.connectionCount(), maxConnections, 'should stay at max size')
+            t.not(connectionManager.connected(newConn.key), 'new validator should not be in the pool')
+
+            const remainingOld = localConnections.filter(c => connectionManager.connected(c.key)).length
+            t.is(remainingOld, 2, 'all of the old validators should remain')
+        })
     })
 
     test('connected', async t => {
@@ -93,84 +119,29 @@ test('ConnectionManager', () => {
             reset()
             const connectionManager = makeManager()
 
-            connectionManager.send([1,2,3,4])
-            t.ok(connections[0].connection.messenger.send.calledWith([1,2,3,4]), 'first on the list should have been called')
-        })
-
-        test('rotate the messenger', async t => {
-            reset()
-            const connectionManager = makeManager()
-
-            for (let i = 0; i < 10; i++) {
-                connectionManager.send([1,2,3,4])
-                t.ok(connections[0].connection.messenger.send.calledWith([1,2,3,4]), 'first on the list should have been called')
-            }
-        })
-
-        test('resets rotation', async t => {
-            reset()
-            const connectionManager = makeManager()
-
-            for (let i = 0; i < 10; i++) {
-                connectionManager.send([1,2,3,4])
-                t.ok(connections[0].connection.messenger.send.calledWith([1,2,3,4]), 'first on the list should have been called')
-            }
-
-            for (let i = 0; i < 10; i++) {
-                connectionManager.send([1,2,3,4])
-                t.ok(connections[1].connection.messenger.send.calledWith([1,2,3,4]), 'first on the list should have been called')
-            }
-
-            for (let i = 0; i < 10; i++) {
-                connectionManager.send([1,2,3,4])
-                t.ok(connections[2].connection.messenger.send.calledWith([1,2,3,4]), 'first on the list should have been called')
-            }
-
-            for (let i = 0; i < 10; i++) {
-                connectionManager.send([1,2,3,4])
-                t.ok(connections[3].connection.messenger.send.calledWith([1,2,3,4]), 'first on the list should have been called')
-            }
-
-            t.is(connections[0].connection.messenger.send.callCount, 10, 'first should have been called 10 times')
-            t.is(connections[1].connection.messenger.send.callCount, 10, 'second should have been called 10 times')
-            t.is(connections[2].connection.messenger.send.callCount, 10, 'third should have been called 10 times')
-            t.is(connections[3].connection.messenger.send.callCount, 10, 'fourth should have been called 10 times')
+            const target = connectionManager.send([1,2,3,4])
 
-            connectionManager.send([1,2,3,4])
-            t.ok(connections[0].connection.messenger.send.calledWith([1,2,3,4]), 'first on the list should have been called')
-            t.is(connections[0].connection.messenger.send.callCount, 11, 'first should have been called 11 times')
+            const totalCalls = connections.reduce((sum, con) => sum + con.connection.messenger.send.callCount, 0)
+            t.is(totalCalls, 1, 'should send to exactly one validator')
+            t.ok(target, 'should return a target public key')
         })
 
-        test('rotates on exception', async t => {
+        test('does not throw on individual send errors', async t => {
             reset()
-            const conns = [
+            const errorConnections = [
                 createConnection(testKeyPair7.publicKey),
                 createConnection(testKeyPair8.publicKey),
-                createConnection(testKeyPair9.publicKey),
             ]
 
-            conns[0].connection.messenger.send = sinon.stub().throws(new Error())
-            conns[1].connection.messenger.send = sinon.stub().throws(new Error())
-
-            const connectionManager = makeManager(5, conns)
-            connectionManager.send([1,2,3,4])
-
-            t.is(conns[0].connection.messenger.send.callCount, 1, 'first should have been called 10 times')
-            t.is(conns[1].connection.messenger.send.callCount, 1, 'second should have been called 10 times')
-            t.is(conns[2].connection.messenger.send.callCount, 1, 'third should have been called 10 times')
-        })
-    })
+            errorConnections.forEach(con => {
+                con.connection.messenger.send = sinon.stub().throws(new Error())
+            })
 
-    test('rotate', async t => {
-        test('resets the rotation', async t => {
-            reset()
-            const connectionManager = makeManager()
+            const connectionManager = makeManager(5, errorConnections)
 
-            connectionManager.send([1,2,3,4]) // this shouldnt trigger rotation
-            t.ok(connections[0].connection.messenger.send.calledWith([1,2,3,4]), 'first on the list should have been called')
-            connectionManager.rotate() // rotate
+            t.is(errorConnections.length, 2, 'should have two connections')
             connectionManager.send([1,2,3,4])
-            t.ok(connections[1].connection.messenger.send.calledWith([1,2,3,4]), 'first on the list should have been called')
+            t.ok(true, 'send should not throw even if individual sends fail')
         })
     })
 
@@ -216,4 +187,4 @@ test('ConnectionManager', () => {
             t.is(connectionCount, connectionManager.connectionCount() + 1, 'first on the list should have been called')
         })
     })
-})
+})