trac-msb 0.2.12 → 0.2.13

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

@@ -13,10 +13,11 @@ 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 = {
@@ -34,64 +35,15 @@ 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 = '1';
+    const id = uuidv7();
     const caps = ['cap:b', 'cap:a'];
-    const data = b4a.from('ping', 'utf8');
 
     for (const code of uniqueResultCodes()) {
-        const payload = await director.buildLivenessResponse(id, data, caps, code);
+        const payload = await director.buildLivenessResponse(id, caps, code);
         t.is(payload.type, NetworkOperationType.LIVENESS_RESPONSE);
         t.is(payload.liveness_response.result, code);
 
@@ -115,7 +67,7 @@ test('NetworkMessageDirector builds broadcast transaction request and verifies s
     const wallet = createWallet();
     const director = new NetworkMessageDirector(new NetworkMessageBuilder(wallet, config));
 
-    const id = '1';
+    const id = uuidv7();
     const data = b4a.from('deadbeef', 'hex');
     const caps = ['cap:b', 'cap:a'];
 
@@ -144,19 +96,36 @@ test('NetworkMessageDirector iterates broadcast transaction response ResultCode
     const wallet = createWallet();
     const director = new NetworkMessageDirector(new NetworkMessageBuilder(wallet, config));
 
-    const id = '1';
+    const id = uuidv7();
     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 payload = await director.buildBroadcastTransactionResponse(id, caps, code);
+        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
+        );
         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)
         );
@@ -165,37 +134,214 @@ 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 iterates validator connection response ResultCode values', async t => {
+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 = '1';
+    const id = uuidv7();
     const caps = ['cap:b', 'cap:a'];
-    const otherAddress = asAddress('36fdaf941de4afe602cbb1e2f56dc582466ef23fad1da55c09fd6dd841cbd117');
+    const proof = b4a.from('deadbeef', 'hex');
+    const timestamp = Date.now();
 
-    for (const code of uniqueResultCodes()) {
-        const payload = await director.buildValidatorConnectionResponse(
+    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,
-            otherAddress,
             caps,
-            code
-        );
-        t.is(payload.type, NetworkOperationType.VALIDATOR_CONNECTION_RESPONSE);
-        t.is(payload.validator_connection_response.result, code);
+            NetworkResultCode.OK,
+            proof
+        ),
+        errorMessageIncludes('Result code OK requires non-empty proof and timestamp > 0.')
+    );
+});
 
-        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));
-    }
+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 => {
+    const wallet = createWallet();
+    const director = new NetworkMessageDirector(new NetworkMessageBuilder(wallet, config));
+
+    const id = uuidv7();
+    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.')
+    );
+});
+
+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(
+            id,
+            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'];
+
+    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.')
+    );
 });

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

@@ -0,0 +1,54 @@
+import { test } from 'brittle';
+import sinon from 'sinon';
+import b4a from 'b4a';
+import { config } from '../../helpers/config.js';
+import NetworkMessageRouter from '../../../src/core/network/protocols/legacy/NetworkMessageRouter.js';
+import LegacyGetRequestHandler from '../../../src/core/network/protocols/legacy/handlers/LegacyGetRequestHandler.js';
+import LegacyResponseHandler from '../../../src/core/network/protocols/legacy/handlers/LegacyResponseHandler.js';
+import { NETWORK_MESSAGE_TYPES } from '../../../src/utils/constants.js';
+
+const makeConnection = (sandbox) => ({
+    remotePublicKey: b4a.alloc(32, 0x01),
+    protocolSession: {
+        setLegacyAsPreferredProtocol: sandbox.stub()
+    },
+    end: sandbox.stub()
+});
+
+const makeRouterContext = (t) => {
+    const sandbox = sinon.createSandbox();
+    t.teardown(() => sandbox.restore());
+
+    const getHandler = sandbox.stub(LegacyGetRequestHandler.prototype, 'handle').resolves();
+    const responseHandler = sandbox.stub(LegacyResponseHandler.prototype, 'handle').resolves();
+    const router = new NetworkMessageRouter({}, { address: 'test-wallet' }, {}, {}, config);
+    const connection = makeConnection(sandbox);
+
+    return { connection, getHandler, responseHandler, router };
+};
+
+test('LegacyNetworkMessageRouter', async (t) => {
+    await t.test('routes legacy string GET messages', async (t) => {
+        const { connection, getHandler, responseHandler, router } = makeRouterContext(t);
+        const message = NETWORK_MESSAGE_TYPES.GET.VALIDATOR;
+
+        await router.route(message, connection);
+
+        t.ok(connection.protocolSession.setLegacyAsPreferredProtocol.calledOnce, 'should prefer legacy protocol');
+        t.ok(getHandler.calledOnce, 'should route GET message');
+        t.ok(responseHandler.notCalled, 'should not route response handler');
+        t.is(getHandler.firstCall.args[0], message, 'passes GET message through to handler');
+    });
+
+    await t.test('routes legacy object response messages', async (t) => {
+        const { connection, getHandler, responseHandler, router } = makeRouterContext(t);
+        const message = { op: NETWORK_MESSAGE_TYPES.RESPONSE.VALIDATOR };
+
+        await router.route(message, connection);
+
+        t.ok(connection.protocolSession.setLegacyAsPreferredProtocol.calledOnce, 'should prefer legacy protocol');
+        t.ok(responseHandler.calledOnce, 'should route response message');
+        t.ok(getHandler.notCalled, 'should not route GET handler');
+        t.is(responseHandler.firstCall.args[0], message, 'passes response message through to handler');
+    });
+});

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

@@ -0,0 +1,127 @@
+import { test } from 'brittle';
+import sinon from 'sinon';
+import b4a from 'b4a';
+
+import NetworkWalletFactory from '../../../src/core/network/identity/NetworkWalletFactory.js';
+import ProtocolSession from '../../../src/core/network/protocols/ProtocolSession.js';
+import { ResultCode } from '../../../src/utils/constants.js';
+import { config } from '../../helpers/config.js';
+import { testKeyPair1 } from '../../fixtures/apply.fixtures.js';
+
+function createWallet() {
+    const keyPair = {
+        publicKey: b4a.from(testKeyPair1.publicKey, 'hex'),
+        secretKey: b4a.from(testKeyPair1.secretKey, 'hex')
+    };
+    return NetworkWalletFactory.provide({
+        enableWallet: false,
+        keyPair,
+        networkPrefix: config.addressPrefix
+    });
+}
+
+function makeProtocol(sendStub) {
+    return {
+        send: sendStub ?? sinon.stub().resolves(ResultCode.OK),
+        sendAndForget: sinon.stub(),
+        decode: sinon.stub(),
+        close: sinon.stub()
+    };
+}
+
+test('ProtocolSession', (t) => {
+    t.teardown(() => sinon.restore());
+
+    test('probe sets preferred protocol to v1 on OK', async (t) => {
+        const v1Send = sinon.stub().resolves(ResultCode.OK);
+        const session = new ProtocolSession(
+            makeProtocol(),
+            makeProtocol(v1Send),
+            createWallet(),
+            config
+        );
+
+        await session.probe();
+        t.is(session.preferredProtocol, session.supportedProtocols.V1);
+        t.ok(v1Send.calledOnce);
+    });
+
+    test('probe sets preferred protocol to legacy on non-OK', async (t) => {
+        const v1Send = sinon.stub().resolves(ResultCode.TIMEOUT);
+        const session = new ProtocolSession(
+            makeProtocol(),
+            makeProtocol(v1Send),
+            createWallet(),
+            config
+        );
+
+        await session.probe();
+        t.is(session.preferredProtocol, session.supportedProtocols.LEGACY);
+        t.ok(v1Send.calledOnce);
+    });
+
+    test('probe sets preferred protocol to legacy on rejection', async (t) => {
+        const v1Send = sinon.stub().rejects(new Error('boom'));
+        const session = new ProtocolSession(
+            makeProtocol(),
+            makeProtocol(v1Send),
+            createWallet(),
+            config
+        );
+
+        await session.probe();
+        t.is(session.preferredProtocol, session.supportedProtocols.LEGACY);
+        t.ok(v1Send.calledOnce);
+    });
+
+    test('sendHealthCheck returns OK when preferred is v1', async (t) => {
+        const v1Send = sinon.stub().resolves(ResultCode.OK);
+        const session = new ProtocolSession(
+            makeProtocol(),
+            makeProtocol(v1Send),
+            createWallet(),
+            config
+        );
+
+        session.setV1AsPreferredProtocol();
+        const result = await session.sendHealthCheck();
+        t.is(result, ResultCode.OK);
+        t.ok(v1Send.calledOnce);
+    });
+
+    test('sendHealthCheck returns OK when preferred is legacy', async (t) => {
+        const session = new ProtocolSession(
+            makeProtocol(),
+            makeProtocol(),
+            createWallet(),
+            config
+        );
+
+        session.setLegacyAsPreferredProtocol();
+        const result = await session.sendHealthCheck();
+        t.is(result, ResultCode.OK);
+    });
+
+    test('sendHealthCheck returns UNSPECIFIED when not probed', async (t) => {
+        const session = new ProtocolSession(
+            makeProtocol(),
+            makeProtocol(),
+            createWallet(),
+            config
+        );
+
+        const result = await session.sendHealthCheck();
+        t.is(result, ResultCode.UNSPECIFIED);
+    });
+
+    test('isHealthCheckSupported throws when not probed', async (t) => {
+        const session = new ProtocolSession(
+            makeProtocol(),
+            makeProtocol(),
+            createWallet(),
+            config
+        );
+
+        await t.exception.all(() => session.isHealthCheckSupported());
+    });
+});

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

@@ -2,8 +2,11 @@ import { default as test } from 'brittle';
 
 async function runNetworkModuleTests() {
     test.pause();
-    await import('./ConnectionManager.test.js');
+    await import('./LegacyNetworkMessageRouter.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();
 }