trac-msb 0.2.12 → 0.2.13

package/src/utils/protobuf/operationHelpers.js

@@ -1,7 +1,17 @@
 import applyOperations from './applyOperations.cjs';
-import networkV1Operations from './network.cjs';
+import networkV1Generated from './networkV1.generated.cjs';
 import b4a from 'b4a';
 
+const networkV1Operations = networkV1Generated.network.v1;
+const NETWORK_TO_OBJECT_OPTIONS = Object.freeze({
+    enums: Number,
+    longs: Number,
+    bytes: Buffer,
+    defaults: true,
+    arrays: true,
+    oneofs: false
+});
+
 /**
  * Safely encodes an operation using `applyOperations.Operation.encode`.
  * If the encoding fails (e.g., due to an invalid payload), returns an empty Buffer.
@@ -36,6 +46,14 @@ export const safeDecodeApplyOperation = (payload) => {
     return null;
 }
 
+export const unsafeDecodeApplyOperation= (payload) => {
+    return applyOperations.Operation.decode(payload);
+}
+
+export const unsafeEncodeApplyOperation = (payload) => {
+    return applyOperations.Operation.encode(payload);
+}
+
 export const normalizeIncomingMessage = (message) => {
     if (!message) return null;
     if (b4a.isBuffer(message)) {
@@ -51,10 +69,13 @@ export const normalizeIncomingMessage = (message) => {
 };
 
 export const encodeV1networkOperation = (payload) => {
-    return networkV1Operations.MessageHeader.encode(payload);
+    return b4a.from(networkV1Operations.MessageHeader.encode(payload).finish());
 }
 
 
 export const decodeV1networkOperation = (payload) => {
-    return networkV1Operations.MessageHeader.decode(payload);
+    return networkV1Operations.MessageHeader.toObject(
+        networkV1Operations.MessageHeader.decode(payload),
+        NETWORK_TO_OBJECT_OPTIONS
+    );
 }

package/tests/acceptance/v1/account/account.test.mjs

@@ -108,11 +108,17 @@ export const registerAccountTests = (context) => {
 
         it("returns 500 on internal error", async () => {
             const originalGetNodeEntry = context.rpcMsb.state.getNodeEntry
+            const failingAddress = randomAddress(context.rpcMsb.config.addressPrefix)
 
-            context.rpcMsb.state.getNodeEntry = async () => { throw new Error("test") }
+            context.rpcMsb.state.getNodeEntry = async (address) => {
+                if (address === failingAddress) {
+                    throw new Error("test")
+                }
+                return originalGetNodeEntry.call(context.rpcMsb.state, address)
+            }
 
             try {
-                const res = await request(context.server).get(`/v1/account/${context.wallet.address}`)
+                const res = await request(context.server).get(`/v1/account/${failingAddress}`)
                 expect(res.statusCode).toBe(500)
                 expect(res.body).toEqual({ error: 'An error occurred processing the request.' })
             } finally {

package/tests/acceptance/v1/tx/tx.test.mjs

@@ -1,5 +1,24 @@
 import request from "supertest"
 import { buildRpcSelfTransferPayload, waitForConnection } from "../../../helpers/transactionPayloads.mjs"
+import { sleep } from "../../../../src/utils/helpers.js"
+
+const TX_ENDPOINT_TIMEOUT_MS = 4000
+const TX_ENDPOINT_RETRY_INTERVAL_MS = 100
+
+const waitForStatusCode = async (requestFactory, expectedStatusCode, timeoutMs = TX_ENDPOINT_TIMEOUT_MS) => {
+    const startedAt = Date.now()
+    let response = null
+
+    while ((Date.now() - startedAt) < timeoutMs) {
+        response = await requestFactory()
+        if (response.statusCode === expectedStatusCode) {
+            return response
+        }
+        await sleep(TX_ENDPOINT_RETRY_INTERVAL_MS)
+    }
+
+    return response
+}
 
 export const registerTxTests = (context) => {
     describe("GET /v1/tx/:hash", () => {
@@ -17,7 +36,10 @@ export const registerTxTests = (context) => {
                 .send(JSON.stringify({ payload }))
             expect(broadcastRes.statusCode).toBe(200)
 
-            const res = await request(context.server).get(`/v1/tx/${txHashHex}`)
+            const res = await waitForStatusCode(
+                () => request(context.server).get(`/v1/tx/${txHashHex}`),
+                200
+            )
             expect(res.statusCode).toBe(200)
             expect(res.body).toMatchObject({ txDetails: expect.any(Object) })
         })

package/tests/acceptance/v1/tx-details/tx-details.test.mjs

@@ -1,5 +1,24 @@
 import request from "supertest"
 import { buildRpcSelfTransferPayload, waitForConnection } from "../../../helpers/transactionPayloads.mjs"
+import { sleep } from "../../../../src/utils/helpers.js"
+
+const TX_DETAILS_TIMEOUT_MS = 4000
+const TX_DETAILS_RETRY_INTERVAL_MS = 100
+
+const waitForStatusCode = async (requestFactory, expectedStatusCode, timeoutMs = TX_DETAILS_TIMEOUT_MS) => {
+    const startedAt = Date.now()
+    let response = null
+
+    while ((Date.now() - startedAt) < timeoutMs) {
+        response = await requestFactory()
+        if (response.statusCode === expectedStatusCode) {
+            return response
+        }
+        await sleep(TX_DETAILS_RETRY_INTERVAL_MS)
+    }
+
+    return response
+}
 
 export const registerTxDetailsTests = (context) => {
     describe("GET /v1/tx/details", () => {
@@ -17,8 +36,11 @@ export const registerTxDetailsTests = (context) => {
                 .send(JSON.stringify({ payload }))
             expect(broadcastRes.statusCode).toBe(200)
 
-            const resConfirmed = await request(context.server)
-                .get(`/v1/tx/details/${txHashHex}?confirmed=true`)
+            const resConfirmed = await waitForStatusCode(
+                () => request(context.server)
+                    .get(`/v1/tx/details/${txHashHex}?confirmed=true`),
+                200
+            )
             expect(resConfirmed.statusCode).toBe(200)
 
             expect(resConfirmed.body).toMatchObject({
@@ -27,8 +49,11 @@ export const registerTxDetailsTests = (context) => {
                 fee: expect.any(String)
             })
 
-            const resUnconfirmed = await request(context.server)
-                .get(`/v1/tx/details/${txHashHex}?confirmed=false`)
+            const resUnconfirmed = await waitForStatusCode(
+                () => request(context.server)
+                    .get(`/v1/tx/details/${txHashHex}?confirmed=false`),
+                200
+            )
             expect(resUnconfirmed.statusCode).toBe(200)
 
             expect(resUnconfirmed.body).toMatchObject({
@@ -57,8 +82,11 @@ export const registerTxDetailsTests = (context) => {
                     .send(JSON.stringify({ payload }))
                 expect(broadcastRes.statusCode).toBe(200)
 
-                const res = await request(context.server)
-                    .get(`/v1/tx/details/${txHashHex}?confirmed=false`)
+                const res = await waitForStatusCode(
+                    () => request(context.server)
+                        .get(`/v1/tx/details/${txHashHex}?confirmed=false`),
+                    200
+                )
                 expect(res.statusCode).toBe(200)
 
                 expect(res.body).toMatchObject({

package/tests/fixtures/networkV1.fixtures.js

@@ -1,32 +1,6 @@
 import b4a from 'b4a';
 import { v7 as uuidv7 } from 'uuid';
 import { NetworkOperationType, ResultCode as NetworkResultCode } from '../../src/utils/constants.js';
-import { asAddress } from '../helpers/address.js';
-
-const payloadValidatorConnectionRequest = {
-    type: NetworkOperationType.VALIDATOR_CONNECTION_REQUEST,
-    id: uuidv7(),
-    timestamp: 123,
-    validator_connection_request: {
-        issuer_address: asAddress('36fdaf941de4afe602cbb1e2f56dc582466ef23fad1da55c09fd6dd841cbd117'),
-        nonce: b4a.from('00', 'hex'),
-        signature: b4a.from('01', 'hex')
-    },
-    capabilities: ['cap:a', 'cap:b']
-};
-
-const payloadValidatorConnectionResponse = {
-    type: NetworkOperationType.VALIDATOR_CONNECTION_RESPONSE,
-    id: uuidv7(),
-    timestamp: 456,
-    validator_connection_response: {
-        issuer_address: asAddress('36fdaf941de4afe602cbb1e2f56dc582466ef23fad1da55c09fd6dd841cbd117'),
-        nonce: b4a.from('02', 'hex'),
-        signature: b4a.from('03', 'hex'),
-        result: NetworkResultCode.OK
-    },
-    capabilities: ['cap:a']
-};
 
 const payloadLivenessRequest = {
     type: NetworkOperationType.LIVENESS_REQUEST,
@@ -70,14 +44,14 @@ const payloadBroadcastTransactionResponse = {
     broadcast_transaction_response: {
         nonce: b4a.from('0a', 'hex'),
         signature: b4a.from('0b', 'hex'),
+        proof: b4a.from('0c', 'hex'),
+        timestamp: 161719,
         result: NetworkResultCode.OK
     },
     capabilities: ['cap:b']
 };
 
 export default {
-    payloadValidatorConnectionRequest,
-    payloadValidatorConnectionResponse,
     payloadLivenessRequest,
     payloadLivenessResponse,
     payloadBroadcastTransactionRequest,

package/tests/helpers/transactionPayloads.mjs

@@ -23,10 +23,10 @@ export const waitForConnection = async node => {
 
 /**
  * Build a base64-encoded transfer payload and matching tx hash
- * that are compatible with MSB's PartialTransfer validator.
+ * that are compatible with MSB's PartialTransferValidator validator.
  *
  * This helper mirrors the hashing/signing logic used by
- * PartialOperation.validateSignature, so that tests broadcast
+ * PartialOperationValidator.validateSignature, so that tests broadcast
  * transactions the node will accept without touching consensus code.
  *
  * @param {object} context - General context

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

@@ -17,7 +17,6 @@ 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';
@@ -38,81 +37,6 @@ function uniqueResultCodes() {
     return [...new Set(Object.values(NetworkResultCode))].sort((a, b) => a - b);
 }
 
-test('NetworkMessageBuilder builds validator connection request and verifies signature', async t => {
-    const wallet = createWallet();
-    const builder = new NetworkMessageBuilder(wallet, config);
-
-    const id = uuidv7();
-    const caps = ['cap:b', 'cap:a'];
-
-    await builder
-        .setType(NetworkOperationType.VALIDATOR_CONNECTION_REQUEST)
-        .setId(id)
-        .setTimestamp()
-        .setIssuerAddress(wallet.address)
-        .setCapabilities(caps)
-        .buildPayload();
-
-    const payload = builder.getResult();
-    t.is(payload.type, NetworkOperationType.VALIDATOR_CONNECTION_REQUEST);
-    t.is(payload.id, id);
-    t.alike(payload.capabilities, caps);
-    t.ok(b4a.isBuffer(payload.validator_connection_request.nonce));
-    t.ok(b4a.isBuffer(payload.validator_connection_request.signature));
-
-    const message = createMessage(
-        payload.type,
-        idToBuffer(id),
-        timestampToBuffer(payload.timestamp),
-        addressToBuffer(wallet.address, config.addressPrefix),
-        payload.validator_connection_request.nonce,
-        encodeCapabilities(caps)
-    );
-    const hash = await PeerWallet.blake3(message);
-    t.ok(wallet.verify(payload.validator_connection_request.signature, hash, wallet.publicKey));
-
-    const roundTrip = decodeV1networkOperation(encodeV1networkOperation(payload));
-    t.is(roundTrip.type, NetworkOperationType.VALIDATOR_CONNECTION_REQUEST);
-});
-
-test('NetworkMessageBuilder iterates validator connection response ResultCode values', async t => {
-    const wallet = createWallet();
-    const builder = new NetworkMessageBuilder(wallet, config);
-    const id = uuidv7();
-    const otherAddress = asAddress('36fdaf941de4afe602cbb1e2f56dc582466ef23fad1da55c09fd6dd841cbd117');
-    const caps = ['cap:b', 'cap:a'];
-
-    for (const code of uniqueResultCodes()) {
-        await builder
-            .setType(NetworkOperationType.VALIDATOR_CONNECTION_RESPONSE)
-            .setId(id)
-            .setTimestamp()
-            .setIssuerAddress(otherAddress)
-            .setCapabilities(caps)
-            .setResultCode(code)
-            .buildPayload();
-
-        const payload = builder.getResult();
-        t.is(payload.type, NetworkOperationType.VALIDATOR_CONNECTION_RESPONSE);
-        t.is(payload.validator_connection_response.result, code);
-
-        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));
-
-        const decoded = decodeV1networkOperation(encodeV1networkOperation(payload));
-        t.is(decoded.validator_connection_response.result, code);
-    }
-});
-
 test('NetworkMessageBuilder iterates liveness response ResultCode values', async t => {
     const wallet = createWallet();
     const builder = new NetworkMessageBuilder(wallet, config);
@@ -125,7 +49,6 @@ test('NetworkMessageBuilder iterates liveness response ResultCode values', async
             .setType(NetworkOperationType.LIVENESS_RESPONSE)
             .setId(id)
             .setTimestamp()
-            .setData(data)
             .setCapabilities(caps)
             .setResultCode(code)
             .buildPayload();
@@ -156,13 +79,11 @@ test('NetworkMessageBuilder builds liveness request and verifies signature (data
 
     const id = uuidv7();
     const caps = ['cap:b', 'cap:a'];
-    const data = b4a.from('ping', 'utf8');
 
     await builder
         .setType(NetworkOperationType.LIVENESS_REQUEST)
         .setId(id)
         .setTimestamp()
-        .setData(data)
         .setCapabilities(caps)
         .buildPayload();
 
@@ -187,36 +108,275 @@ test('NetworkMessageBuilder iterates broadcast transaction response ResultCode v
     const builder = new NetworkMessageBuilder(wallet, config);
     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 includeProof = code === NetworkResultCode.OK;
+        const proofUnavailable = code === NetworkResultCode.TX_ACCEPTED_PROOF_UNAVAILABLE;
+        const responseProof = includeProof ? proof : emptyProof;
+        const responseTimestampLedger = includeProof || proofUnavailable ? timestamp : 0;
         await builder
             .setType(NetworkOperationType.BROADCAST_TRANSACTION_RESPONSE)
             .setId(id)
             .setTimestamp()
             .setCapabilities(caps)
+            .setProof(responseProof)
+            .setTimestampLedger(responseTimestampLedger)
             .setResultCode(code)
             .buildPayload();
 
         const payload = builder.getResult();
         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, responseTimestampLedger);
 
         const msg = createMessage(
             payload.type,
             idToBuffer(payload.id),
             timestampToBuffer(payload.timestamp),
             payload.broadcast_transaction_response.nonce,
+            responseProof,
+            timestampToBuffer(responseTimestampLedger),
             safeWriteUInt32BE(code, 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.result, code);
+        t.alike(decoded.broadcast_transaction_response.proof, responseProof);
+        t.is(decoded.broadcast_transaction_response.timestamp, responseTimestampLedger);
     }
 });
 
+test('NetworkMessageBuilder builds broadcast transaction response with proof and timestamp', async t => {
+    const wallet = createWallet();
+    const builder = new NetworkMessageBuilder(wallet, config);
+    const id = uuidv7();
+    const caps = ['cap:b', 'cap:a'];
+    const proof = b4a.from('deadbeef', 'hex');
+    const timestamp = Date.now();
+
+    await builder
+        .setType(NetworkOperationType.BROADCAST_TRANSACTION_RESPONSE)
+        .setId(id)
+        .setTimestamp()
+        .setCapabilities(caps)
+        .setProof(proof)
+        .setTimestampLedger(timestamp)
+        .setResultCode(NetworkResultCode.OK)
+        .buildPayload();
+
+    const payload = builder.getResult();
+    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('NetworkMessageBuilder rejects OK response when proof is provided without timestamp', async t => {
+    const wallet = createWallet();
+    const builder = new NetworkMessageBuilder(wallet, config);
+    const id = uuidv7();
+    const caps = ['cap:b', 'cap:a'];
+    const proof = b4a.from('deadbeef', 'hex');
+
+    await t.exception(
+        () =>
+            builder
+                .setType(NetworkOperationType.BROADCAST_TRANSACTION_RESPONSE)
+                .setId(id)
+                .setTimestamp()
+                .setCapabilities(caps)
+                .setProof(proof)
+                .setResultCode(NetworkResultCode.OK)
+                .buildPayload(),
+        errorMessageIncludes('Result code OK requires non-empty proof and timestamp > 0.')
+    );
+});
+
+test('NetworkMessageBuilder rejects OK response when timestamp is provided without proof', async t => {
+    const wallet = createWallet();
+    const builder = new NetworkMessageBuilder(wallet, config);
+    const id = uuidv7();
+    const caps = ['cap:b', 'cap:a'];
+    const timestamp = Date.now();
+
+    await t.exception(
+        () =>
+            builder
+                .setType(NetworkOperationType.BROADCAST_TRANSACTION_RESPONSE)
+                .setId(id)
+                .setTimestamp()
+                .setCapabilities(caps)
+                .setTimestampLedger(timestamp)
+                .setResultCode(NetworkResultCode.OK)
+                .buildPayload(),
+        errorMessageIncludes('Result code OK requires non-empty proof and timestamp > 0.')
+    );
+});
+
+test('NetworkMessageBuilder allows TX_ACCEPTED_PROOF_UNAVAILABLE response with timestamp and empty proof', async t => {
+    const wallet = createWallet();
+    const builder = new NetworkMessageBuilder(wallet, config);
+    const id = uuidv7();
+    const caps = ['cap:b', 'cap:a'];
+    const timestamp = Date.now();
+    const emptyProof = b4a.alloc(0);
+
+    await builder
+        .setType(NetworkOperationType.BROADCAST_TRANSACTION_RESPONSE)
+        .setId(id)
+        .setTimestamp()
+        .setCapabilities(caps)
+        .setProof(emptyProof)
+        .setTimestampLedger(timestamp)
+        .setResultCode(NetworkResultCode.TX_ACCEPTED_PROOF_UNAVAILABLE)
+        .buildPayload();
+
+    const payload = builder.getResult();
+    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('NetworkMessageBuilder rejects OK response when proof and timestamp are both missing', async t => {
+    const wallet = createWallet();
+    const builder = new NetworkMessageBuilder(wallet, config);
+    const id = uuidv7();
+    const caps = ['cap:b', 'cap:a'];
+
+    await t.exception(
+        () =>
+            builder
+                .setType(NetworkOperationType.BROADCAST_TRANSACTION_RESPONSE)
+                .setId(id)
+                .setTimestamp()
+                .setCapabilities(caps)
+                .setResultCode(NetworkResultCode.OK)
+                .buildPayload(),
+        errorMessageIncludes('Result code OK requires non-empty proof and timestamp > 0.')
+    );
+});
+
+test('NetworkMessageBuilder rejects TX_ACCEPTED_PROOF_UNAVAILABLE response when timestamp is missing', async t => {
+    const wallet = createWallet();
+    const builder = new NetworkMessageBuilder(wallet, config);
+    const id = uuidv7();
+    const caps = ['cap:b', 'cap:a'];
+
+    await t.exception(
+        () =>
+            builder
+                .setType(NetworkOperationType.BROADCAST_TRANSACTION_RESPONSE)
+                .setId(id)
+                .setTimestamp()
+                .setCapabilities(caps)
+                .setResultCode(NetworkResultCode.TX_ACCEPTED_PROOF_UNAVAILABLE)
+                .buildPayload(),
+        errorMessageIncludes('Result code TX_ACCEPTED_PROOF_UNAVAILABLE requires timestamp > 0.')
+    );
+});
+
+test('NetworkMessageBuilder rejects TX_ACCEPTED_PROOF_UNAVAILABLE response when proof is non-empty', async t => {
+    const wallet = createWallet();
+    const builder = new NetworkMessageBuilder(wallet, config);
+    const id = uuidv7();
+    const caps = ['cap:b', 'cap:a'];
+
+    await t.exception(
+        () =>
+            builder
+                .setType(NetworkOperationType.BROADCAST_TRANSACTION_RESPONSE)
+                .setId(id)
+                .setTimestamp()
+                .setCapabilities(caps)
+                .setProof(b4a.from('deadbeef', 'hex'))
+                .setTimestampLedger(Date.now())
+                .setResultCode(NetworkResultCode.TX_ACCEPTED_PROOF_UNAVAILABLE)
+                .buildPayload(),
+        errorMessageIncludes('Result code TX_ACCEPTED_PROOF_UNAVAILABLE requires empty proof.')
+    );
+});
+
+test('NetworkMessageBuilder rejects non-OK response when proof is non-empty', async t => {
+    const wallet = createWallet();
+    const builder = new NetworkMessageBuilder(wallet, config);
+    const id = uuidv7();
+    const caps = ['cap:b', 'cap:a'];
+
+    await t.exception(
+        () =>
+            builder
+                .setType(NetworkOperationType.BROADCAST_TRANSACTION_RESPONSE)
+                .setId(id)
+                .setTimestamp()
+                .setCapabilities(caps)
+                .setProof(b4a.from('deadbeef', 'hex'))
+                .setTimestampLedger(0)
+                .setResultCode(NetworkResultCode.INVALID_PAYLOAD)
+                .buildPayload(),
+        errorMessageIncludes('Non-OK result code requires empty proof.')
+    );
+});
+
+test('NetworkMessageBuilder rejects non-OK response with timestamp > 0 unless proof is unavailable', async t => {
+    const wallet = createWallet();
+    const builder = new NetworkMessageBuilder(wallet, config);
+    const id = uuidv7();
+    const caps = ['cap:b', 'cap:a'];
+
+    await t.exception(
+        () =>
+            builder
+                .setType(NetworkOperationType.BROADCAST_TRANSACTION_RESPONSE)
+                .setId(id)
+                .setTimestamp()
+                .setCapabilities(caps)
+                .setTimestampLedger(Date.now())
+                .setResultCode(NetworkResultCode.INVALID_PAYLOAD)
+                .buildPayload(),
+        errorMessageIncludes('Non-OK result code requires timestamp to be 0, except TX_ACCEPTED_PROOF_UNAVAILABLE.')
+    );
+});
+
 test('NetworkMessageBuilder builds broadcast transaction request and verifies signature', async t => {
     const wallet = createWallet();
     const builder = new NetworkMessageBuilder(wallet, config);