trac-msb 0.2.13 → 0.2.15

package/tests/unit/messages/network/NetworkMessageDirector.test.js

@@ -13,11 +13,10 @@ import {
     idToBuffer,
     timestampToBuffer
 } from '../../../../src/utils/buffer.js';
+import { addressToBuffer } from '../../../../src/core/state/utils/address.js';
 import { config } from '../../../helpers/config.js';
 import { asAddress } from '../../../helpers/address.js';
 import { testKeyPair1 } from '../../../fixtures/apply.fixtures.js';
-import { v7 as uuidv7 } from 'uuid';
-import { errorMessageIncludes } from '../../../helpers/regexHelper.js';
 
 function createWallet() {
     const keyPair = {
@@ -35,15 +34,64 @@ function uniqueResultCodes() {
     return [...new Set(Object.values(NetworkResultCode))].sort((a, b) => a - b);
 }
 
+test('NetworkMessageDirector builds validator connection request and verifies signature', async t => {
+    const wallet = createWallet();
+    const director = new NetworkMessageDirector(new NetworkMessageBuilder(wallet, config));
+
+    const id = '1';
+    const caps = ['cap:b', 'cap:a'];
+
+    const payload = await director.buildValidatorConnectionRequest(id, wallet.address, caps);
+    t.is(payload.type, NetworkOperationType.VALIDATOR_CONNECTION_REQUEST);
+    t.is(payload.id, id);
+    t.alike(payload.capabilities, caps);
+
+    const msg = createMessage(
+        payload.type,
+        idToBuffer(payload.id),
+        timestampToBuffer(payload.timestamp),
+        addressToBuffer(wallet.address, config.addressPrefix),
+        payload.validator_connection_request.nonce,
+        encodeCapabilities(caps)
+    );
+    const hash = await PeerWallet.blake3(msg);
+    t.ok(wallet.verify(payload.validator_connection_request.signature, hash, wallet.publicKey));
+});
+
+test('NetworkMessageDirector builds liveness request and verifies signature', async t => {
+    const wallet = createWallet();
+    const director = new NetworkMessageDirector(new NetworkMessageBuilder(wallet, config));
+
+    const id = '1';
+    const caps = ['cap:b', 'cap:a'];
+    const data = b4a.from('ping', 'utf8');
+
+    const payload = await director.buildLivenessRequest(id, data, caps);
+    t.is(payload.type, NetworkOperationType.LIVENESS_REQUEST);
+    t.is(payload.id, id);
+    t.alike(payload.capabilities, caps);
+
+    const msg = createMessage(
+        payload.type,
+        idToBuffer(payload.id),
+        timestampToBuffer(payload.timestamp),
+        payload.liveness_request.nonce,
+        encodeCapabilities(caps)
+    );
+    const hash = await PeerWallet.blake3(msg);
+    t.ok(wallet.verify(payload.liveness_request.signature, hash, wallet.publicKey));
+});
+
 test('NetworkMessageDirector iterates liveness response ResultCode values', async t => {
     const wallet = createWallet();
     const director = new NetworkMessageDirector(new NetworkMessageBuilder(wallet, config));
 
-    const id = uuidv7();
+    const id = '1';
     const caps = ['cap:b', 'cap:a'];
+    const data = b4a.from('ping', 'utf8');
 
     for (const code of uniqueResultCodes()) {
-        const payload = await director.buildLivenessResponse(id, caps, code);
+        const payload = await director.buildLivenessResponse(id, data, caps, code);
         t.is(payload.type, NetworkOperationType.LIVENESS_RESPONSE);
         t.is(payload.liveness_response.result, code);
 
@@ -67,7 +115,7 @@ test('NetworkMessageDirector builds broadcast transaction request and verifies s
     const wallet = createWallet();
     const director = new NetworkMessageDirector(new NetworkMessageBuilder(wallet, config));
 
-    const id = uuidv7();
+    const id = '1';
     const data = b4a.from('deadbeef', 'hex');
     const caps = ['cap:b', 'cap:a'];
 
@@ -96,36 +144,19 @@ test('NetworkMessageDirector iterates broadcast transaction response ResultCode
     const wallet = createWallet();
     const director = new NetworkMessageDirector(new NetworkMessageBuilder(wallet, config));
 
-    const id = uuidv7();
+    const id = '1';
     const caps = ['cap:b', 'cap:a'];
-    const proof = b4a.from('deadbeef', 'hex');
-    const timestamp = Date.now();
-    const emptyProof = b4a.alloc(0);
 
     for (const code of uniqueResultCodes()) {
-        const includeProof = code === NetworkResultCode.OK;
-        const proofUnavailable = code === NetworkResultCode.TX_ACCEPTED_PROOF_UNAVAILABLE;
-        const responseProof = includeProof ? proof : emptyProof;
-        const responseTimestamp = includeProof || proofUnavailable ? timestamp : 0;
-        const payload = await director.buildBroadcastTransactionResponse(
-            id,
-            caps,
-            code,
-            responseProof,
-            responseTimestamp
-        );
+        const payload = await director.buildBroadcastTransactionResponse(id, caps, code);
         t.is(payload.type, NetworkOperationType.BROADCAST_TRANSACTION_RESPONSE);
         t.is(payload.broadcast_transaction_response.result, code);
-        t.alike(payload.broadcast_transaction_response.proof, responseProof);
-        t.is(payload.broadcast_transaction_response.timestamp, responseTimestamp);
 
         const msg = createMessage(
             payload.type,
             idToBuffer(payload.id),
             timestampToBuffer(payload.timestamp),
             payload.broadcast_transaction_response.nonce,
-            responseProof,
-            timestampToBuffer(responseTimestamp),
             safeWriteUInt32BE(code, 0),
             encodeCapabilities(caps)
         );
@@ -134,214 +165,37 @@ test('NetworkMessageDirector iterates broadcast transaction response ResultCode
 
         const decoded = decodeV1networkOperation(encodeV1networkOperation(payload));
         t.is(decoded.broadcast_transaction_response.result, code);
-        t.alike(decoded.broadcast_transaction_response.proof, responseProof);
-        t.is(decoded.broadcast_transaction_response.timestamp, responseTimestamp);
     }
 });
 
-test('NetworkMessageDirector builds broadcast transaction response with proof and timestamp', async t => {
-    const wallet = createWallet();
-    const director = new NetworkMessageDirector(new NetworkMessageBuilder(wallet, config));
-
-    const id = uuidv7();
-    const caps = ['cap:b', 'cap:a'];
-    const proof = b4a.from('deadbeef', 'hex');
-    const timestamp = Date.now();
-
-    const payload = await director.buildBroadcastTransactionResponse(
-        id,
-        caps,
-        NetworkResultCode.OK,
-        proof,
-        timestamp
-    );
-
-    t.alike(payload.broadcast_transaction_response.proof, proof);
-    t.is(payload.broadcast_transaction_response.timestamp, timestamp);
-
-    const msg = createMessage(
-        payload.type,
-        idToBuffer(payload.id),
-        timestampToBuffer(payload.timestamp),
-        payload.broadcast_transaction_response.nonce,
-        proof,
-        timestampToBuffer(timestamp),
-        safeWriteUInt32BE(NetworkResultCode.OK, 0),
-        encodeCapabilities(caps)
-    );
-    const hash = await PeerWallet.blake3(msg);
-    t.ok(wallet.verify(payload.broadcast_transaction_response.signature, hash, wallet.publicKey));
-
-    const decoded = decodeV1networkOperation(encodeV1networkOperation(payload));
-    t.alike(decoded.broadcast_transaction_response.proof, proof);
-    t.is(decoded.broadcast_transaction_response.timestamp, timestamp);
-});
-
-test('NetworkMessageDirector rejects OK response when proof is provided without timestamp', async t => {
-    const wallet = createWallet();
-    const director = new NetworkMessageDirector(new NetworkMessageBuilder(wallet, config));
-
-    const id = uuidv7();
-    const caps = ['cap:b', 'cap:a'];
-    const proof = b4a.from('deadbeef', 'hex');
-
-    await t.exception(
-        () => director.buildBroadcastTransactionResponse(
-            id,
-            caps,
-            NetworkResultCode.OK,
-            proof
-        ),
-        errorMessageIncludes('Result code OK requires non-empty proof and timestamp > 0.')
-    );
-});
-
-test('NetworkMessageDirector rejects OK response when timestamp is provided without proof', async t => {
-    const wallet = createWallet();
-    const director = new NetworkMessageDirector(new NetworkMessageBuilder(wallet, config));
-
-    const id = uuidv7();
-    const caps = ['cap:b', 'cap:a'];
-    const timestamp = Date.now();
-
-    await t.exception(
-        () => director.buildBroadcastTransactionResponse(
-            id,
-            caps,
-            NetworkResultCode.OK,
-            null,
-            timestamp
-        ),
-        errorMessageIncludes('Result code OK requires non-empty proof and timestamp > 0.')
-    );
-});
-
-test('NetworkMessageDirector allows TX_ACCEPTED_PROOF_UNAVAILABLE response with timestamp and empty proof', async t => {
+test('NetworkMessageDirector iterates validator connection response ResultCode values', async t => {
     const wallet = createWallet();
     const director = new NetworkMessageDirector(new NetworkMessageBuilder(wallet, config));
 
-    const id = uuidv7();
+    const id = '1';
     const caps = ['cap:b', 'cap:a'];
-    const timestamp = Date.now();
-    const emptyProof = b4a.alloc(0);
-
-    const payload = await director.buildBroadcastTransactionResponse(
-        id,
-        caps,
-        NetworkResultCode.TX_ACCEPTED_PROOF_UNAVAILABLE,
-        emptyProof,
-        timestamp
-    );
-
-    t.alike(payload.broadcast_transaction_response.proof, emptyProof);
-    t.is(payload.broadcast_transaction_response.timestamp, timestamp);
-    t.is(payload.broadcast_transaction_response.result, NetworkResultCode.TX_ACCEPTED_PROOF_UNAVAILABLE);
-
-    const msg = createMessage(
-        payload.type,
-        idToBuffer(payload.id),
-        timestampToBuffer(payload.timestamp),
-        payload.broadcast_transaction_response.nonce,
-        emptyProof,
-        timestampToBuffer(timestamp),
-        safeWriteUInt32BE(NetworkResultCode.TX_ACCEPTED_PROOF_UNAVAILABLE, 0),
-        encodeCapabilities(caps)
-    );
-    const hash = await PeerWallet.blake3(msg);
-    t.ok(wallet.verify(payload.broadcast_transaction_response.signature, hash, wallet.publicKey));
-
-    const decoded = decodeV1networkOperation(encodeV1networkOperation(payload));
-    t.is(decoded.broadcast_transaction_response.timestamp, timestamp);
-    t.is(decoded.broadcast_transaction_response.result, NetworkResultCode.TX_ACCEPTED_PROOF_UNAVAILABLE);
-});
-
-test('NetworkMessageDirector rejects OK response when proof and timestamp are both missing', async t => {
-    const wallet = createWallet();
-    const director = new NetworkMessageDirector(new NetworkMessageBuilder(wallet, config));
-
-    const id = uuidv7();
-    const caps = ['cap:b', 'cap:a'];
-
-    await t.exception(
-        () => director.buildBroadcastTransactionResponse(
-            id,
-            caps,
-            NetworkResultCode.OK
-        ),
-        errorMessageIncludes('Result code OK requires non-empty proof and timestamp > 0.')
-    );
-});
-
-test('NetworkMessageDirector rejects TX_ACCEPTED_PROOF_UNAVAILABLE response when timestamp is missing', async t => {
-    const wallet = createWallet();
-    const director = new NetworkMessageDirector(new NetworkMessageBuilder(wallet, config));
-
-    const id = uuidv7();
-    const caps = ['cap:b', 'cap:a'];
-
-    await t.exception(
-        () => director.buildBroadcastTransactionResponse(
-            id,
-            caps,
-            NetworkResultCode.TX_ACCEPTED_PROOF_UNAVAILABLE
-        ),
-        errorMessageIncludes('Result code TX_ACCEPTED_PROOF_UNAVAILABLE requires timestamp > 0.')
-    );
-});
+    const otherAddress = asAddress('36fdaf941de4afe602cbb1e2f56dc582466ef23fad1da55c09fd6dd841cbd117');
 
-test('NetworkMessageDirector rejects TX_ACCEPTED_PROOF_UNAVAILABLE response when proof is non-empty', async t => {
-    const wallet = createWallet();
-    const director = new NetworkMessageDirector(new NetworkMessageBuilder(wallet, config));
-
-    const id = uuidv7();
-    const caps = ['cap:b', 'cap:a'];
-
-    await t.exception(
-        () => director.buildBroadcastTransactionResponse(
-            id,
-            caps,
-            NetworkResultCode.TX_ACCEPTED_PROOF_UNAVAILABLE,
-            b4a.from('deadbeef', 'hex'),
-            Date.now()
-        ),
-        errorMessageIncludes('Result code TX_ACCEPTED_PROOF_UNAVAILABLE requires empty proof.')
-    );
-});
-
-test('NetworkMessageDirector rejects non-OK response when proof is non-empty', async t => {
-    const wallet = createWallet();
-    const director = new NetworkMessageDirector(new NetworkMessageBuilder(wallet, config));
-
-    const id = uuidv7();
-    const caps = ['cap:b', 'cap:a'];
-
-    await t.exception(
-        () => director.buildBroadcastTransactionResponse(
+    for (const code of uniqueResultCodes()) {
+        const payload = await director.buildValidatorConnectionResponse(
             id,
+            otherAddress,
             caps,
-            NetworkResultCode.INVALID_PAYLOAD,
-            b4a.from('deadbeef', 'hex'),
-            0
-        ),
-        errorMessageIncludes('Non-OK result code requires empty proof.')
-    );
-});
-
-test('NetworkMessageDirector rejects non-OK response with timestamp > 0 unless proof is unavailable', async t => {
-    const wallet = createWallet();
-    const director = new NetworkMessageDirector(new NetworkMessageBuilder(wallet, config));
-
-    const id = uuidv7();
-    const caps = ['cap:b', 'cap:a'];
+            code
+        );
+        t.is(payload.type, NetworkOperationType.VALIDATOR_CONNECTION_RESPONSE);
+        t.is(payload.validator_connection_response.result, code);
 
-    await t.exception(
-        () => director.buildBroadcastTransactionResponse(
-            id,
-            caps,
-            NetworkResultCode.INVALID_PAYLOAD,
-            null,
-            Date.now()
-        ),
-        errorMessageIncludes('Non-OK result code requires timestamp to be 0, except TX_ACCEPTED_PROOF_UNAVAILABLE.')
-    );
+        const msg = createMessage(
+            payload.type,
+            idToBuffer(payload.id),
+            timestampToBuffer(payload.timestamp),
+            addressToBuffer(otherAddress, config.addressPrefix),
+            payload.validator_connection_response.nonce,
+            safeWriteUInt32BE(code, 0),
+            encodeCapabilities(caps)
+        );
+        const hash = await PeerWallet.blake3(msg);
+        t.ok(wallet.verify(payload.validator_connection_response.signature, hash, wallet.publicKey));
+    }
 });

package/tests/unit/messages/state/applyStateMessageBuilder.complete.test.js

@@ -12,7 +12,11 @@ const hex = (value, bytes) => value.repeat(bytes);
 const toBuf = value => b4a.from(value, 'hex');
 
 async function createWallet(mnemonic) {
-    const wallet = new PeerWallet({ mnemonic, networkPrefix: config.addressPrefix });
+    const wallet = new PeerWallet({
+        mnemonic,
+        networkPrefix: config.addressPrefix,
+        derivationPath: config.derivationPath
+    });
     await wallet.ready;
     return wallet;
 }

package/tests/unit/messages/state/applyStateMessageBuilder.partial.test.js

@@ -12,7 +12,11 @@ import { isAddressValid } from '../../../../src/core/state/utils/address.js';
 const hex = (value, bytes) => value.repeat(bytes);
 
 async function createWallet(mnemonic) {
-    const wallet = new PeerWallet({ mnemonic, networkPrefix: config.addressPrefix });
+    const wallet = new PeerWallet({
+        mnemonic,
+        networkPrefix: config.addressPrefix,
+        derivationPath: config.derivationPath
+    });
     await wallet.ready;
     return wallet;
 }

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

@@ -0,0 +1,191 @@
+import sinon from "sinon";
+import { hook, test } from 'brittle'
+import { default as EventEmitter } from "bare-events"
+import { testKeyPair1, testKeyPair2, testKeyPair3, testKeyPair4, testKeyPair5, testKeyPair6, testKeyPair7, testKeyPair8, testKeyPair9 } from "../../fixtures/apply.fixtures.js";
+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()
+    emitter.protocolSession = {
+        has: (name) => name === 'legacy',
+        send: sinon.stub().resolves(),
+    };
+    emitter.connected = true
+    emitter.remotePublicKey = b4a.from(key, 'hex')
+    
+    return { key: b4a.from(key, 'hex'), connection: emitter }
+}
+
+const makeManager = (maxValidators = 6, conns = connections) => {
+    const merged = createConfig(ENV.DEVELOPMENT, { maxValidators })
+    const connectionManager = new ConnectionManager(merged)
+
+    conns.forEach(({ key, connection }) => {
+        connectionManager.addValidator(key, connection)
+    });
+
+    return connectionManager
+}
+
+const reset = () => {
+    sinon.restore()
+    connections.forEach(connection => {
+        connection.connection.protocolSession.send.resetHistory()
+    })
+}
+
+let connections
+hook('Initialize state', async () => {
+    connections = [
+        createConnection(testKeyPair1.publicKey),
+        createConnection(testKeyPair2.publicKey),
+        createConnection(testKeyPair3.publicKey),
+        createConnection(testKeyPair4.publicKey),
+    ]
+});
+
+test('ConnectionManager', () => {
+    test('addValidator', async t => {
+        test('adds a validator', async t => {
+            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')
+        })
+
+        test('dont surpass maxConnections', async t => {
+            reset()
+            const maxConnections = 5
+            const connectionManager = makeManager(maxConnections)
+            t.is(connectionManager.connectionCount(), connections.length, 'should have the same length')
+
+            const toAdd = createConnection(testKeyPair5.publicKey)
+            connectionManager.addValidator(toAdd.key, toAdd.connection)
+            t.is(connectionManager.connectionCount(), maxConnections, 'should match the max connections')
+
+            const toNotAdd = createConnection(testKeyPair6.publicKey)
+            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 => {
+        test('true', async t => {
+            reset()
+            const connectionManager = makeManager()
+            connections.forEach(con => {
+                t.ok(connectionManager.connected(con.key), 'should respond true')
+            })
+        })
+
+        test('false', async t => {
+            reset()
+            const connectionManager = makeManager()
+            t.ok(!connectionManager.connected(testKeyPair6.publicKey), 'should respond false')
+        })
+    })
+
+    test('send', async t => {
+        test('triggers send on messenger', async t => {
+            reset()
+            const connectionManager = makeManager()
+
+            const target = connectionManager.send([1,2,3,4])
+
+            const totalCalls = connections.reduce((sum, con) => sum + con.connection.protocolSession.send.callCount, 0)
+            t.is(totalCalls, 1, 'should send to exactly one validator')
+            t.ok(target, 'should return a target public key')
+        })
+
+        test('does not throw on individual send errors', async t => {
+            reset()
+            const errorConnections = [
+                createConnection(testKeyPair7.publicKey),
+                createConnection(testKeyPair8.publicKey),
+            ]
+
+            errorConnections.forEach(con => {
+                con.connection.protocolSession.send = sinon.stub().throws(new Error())
+            })
+
+            const connectionManager = makeManager(5, errorConnections)
+
+            t.is(errorConnections.length, 2, 'should have two connections')
+            connectionManager.send([1,2,3,4])
+            t.ok(true, 'send should not throw even if individual sends fail')
+        })
+    })
+
+    test('on close', async t => {
+        test('removes from list', async t => {
+            reset()
+            const connectionManager = makeManager()
+
+            const connectionCount = connectionManager.connectionCount()
+
+            connections[1].connection.connected = false
+            connections[1].connection.emit('close')
+            await tick()
+            t.is(connectionCount, connectionManager.connectionCount() + 1, 'first on the list should have been called')
+        })
+    })
+
+    test('remove', async t => {
+        test('removes a validator by public key', async t => {
+            reset()
+            const connectionManager = makeManager()
+            const previousCount = connectionManager.connectionCount()
+            const lastValidator = connections.shift()
+            
+            t.ok(connectionManager.connected(lastValidator.key), 'should be connected')
+            connectionManager.remove(lastValidator.key)
+
+            t.is(connectionManager.connectionCount(), previousCount - 1, 'should reduce the connection count')
+            t.ok(!connectionManager.connected(lastValidator.key), 'should be connected')
+        })
+    })
+
+    test('on close', async t => {
+        test('removes from list', async t => {
+            reset()
+            const connectionManager = makeManager()
+
+            const connectionCount = connectionManager.connectionCount()
+
+            connections[1].connection.connected = false
+            connections[1].connection.emit('close')
+            await tick()
+            t.is(connectionCount, connectionManager.connectionCount() + 1, 'first on the list should have been called')
+        })
+    })
+})

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

@@ -2,11 +2,8 @@ import { default as test } from 'brittle';
 
 async function runNetworkModuleTests() {
     test.pause();
-    await import('./LegacyNetworkMessageRouter.test.js');
+    await import('./ConnectionManager.test.js');
     await import('./NetworkWalletFactory.test.js');
-    await import('./ProtocolSession.test.js');
-    await import('./services/services.test.js');
-    await import('./v1/v1.test.js');
     test.resume();
 }
 

package/tests/unit/unit.test.js

@@ -4,10 +4,10 @@ import { default as test } from 'brittle';
 
 async function runTests() {
 	test.pause();
-	await import('./utils/utils.test.js');
-	await import('./messages/messages.test.js');
 	await import('./network/networkModule.test.js')
 	await import('./state/stateModule.test.js');
+	await import('./utils/utils.test.js');
+	await import('./messages/messages.test.js');
 	test.resume();
 }
 

package/tests/unit/utils/fileUtils/readAddressesFromWhitelistFile.test.js

@@ -30,9 +30,9 @@ hook('Initialize dummy whitelist files', async t => {
     // Edge: large file
     let large = '';
     const randomAddress = async () => {
-        const wallet = new PeerWallet();
+        const wallet = new PeerWallet({ derivationPath: config.derivationPath });
         await wallet.ready;
-        await wallet.generateKeyPair();
+        await wallet.generateKeyPair(undefined, config.derivationPath);
         return wallet.address;
     };
     for (let i = 0; i < 1000; i++) {

package/tests/unit/utils/fileUtils/readBalanceMigrationFile.test.js

@@ -47,9 +47,9 @@ hook('Initialize dummy balance files', async t => {
     // Edge: large file
     let large = '';
     const randomAddress = async () => {
-        const wallet = new PeerWallet();
+        const wallet = new PeerWallet({ derivationPath: config.derivationPath });
         await wallet.ready;
-        await wallet.generateKeyPair();
+        await wallet.generateKeyPair(undefined, config.derivationPath);
         return wallet.address;
     }
     for (let i = 0; i < 1000; i++) {

package/tests/unit/utils/protobuf/operationHelpers.test.js

@@ -85,8 +85,8 @@ test('Decode throws on buffer with unknown wire type (skip case)', t => {
     const bufWithWire7 = b4a.from([0x0F]);
     try {
         applyOperations.Operation.decode(bufWithWire7);
-        t.fail('Expected decode to throw on unknown wire type');
     } catch (err) {
+        console.error('Caught error:', err);
         t.ok(err instanceof Error && err.message.includes('Could not decode varint'), 'Should throw an error instance to be thrown for unknown wire type');
     }
 });
@@ -242,6 +242,8 @@ test('Protobuf encode/decode is order-independent for all operation types', t =>
 
 test('encodeV1networkOperation/decodeV1networkOperation roundtrip for network v1 payloads', t => {
     const payloadsHashMap = new Map([
+        ['validatorConnectionRequest', networkV1Fixtures.payloadValidatorConnectionRequest],
+        ['validatorConnectionResponse', networkV1Fixtures.payloadValidatorConnectionResponse],
         ['livenessRequest', networkV1Fixtures.payloadLivenessRequest],
         ['livenessResponse', networkV1Fixtures.payloadLivenessResponse],
         ['broadcastTransactionRequest', networkV1Fixtures.payloadBroadcastTransactionRequest],
@@ -252,7 +254,7 @@ test('encodeV1networkOperation/decodeV1networkOperation roundtrip for network v1
         const encoded = encodeV1networkOperation(payload);
         const decoded = decodeV1networkOperation(encoded);
         t.ok(b4a.isBuffer(encoded) && encoded.length > 0, `Payload ${key} encodes to a non-empty buffer`);
-        t.alike(decoded, payload, `Payload ${key} decodes back correctly`);
+        t.ok(JSON.stringify(decoded) === JSON.stringify(payload), `Payload ${key} decodes back correctly`);
     }
 });
 

package/tests/unit/utils/utils.test.js

@@ -6,7 +6,6 @@ async function runTests() {
 	test.pause();
 
 	await import('./check/check.test.js');
-	await import('./deepEqualApplyPayload/deepEqualApplyPayload.test.js');
 	await import('./protobuf/operationHelpers.test.js');
 	await import('./helpers/helpers.test.js');
 	await import('./fileUtils/readAddressesFromWhitelistFile.test.js');