trac-msb 0.2.12 → 0.2.13

package/tests/unit/network/v1/V1BroadcastTransactionResponse.test.js

@@ -0,0 +1,512 @@
+import {test} from 'brittle';
+import b4a from 'b4a';
+import Autobase from 'autobase';
+import Hypercore from 'hypercore';
+
+import V1BroadcastTransactionResponse, {extractRequiredVaFromDecodedTx} from '../../../../src/core/network/protocols/v1/validators/V1BroadcastTransactionResponse.js';
+import {V1ProtocolError} from '../../../../src/core/network/protocols/v1/V1ProtocolError.js';
+import Check from '../../../../src/utils/check.js';
+import {
+    unsafeEncodeApplyOperation,
+    unsafeDecodeApplyOperation,
+} from '../../../../src/utils/protobuf/operationHelpers.js';
+import {addressToBuffer} from '../../../../src/core/state/utils/address.js';
+import {publicKeyToAddress} from '../../../../src/utils/helpers.js';
+import {OperationType, ResultCode} from '../../../../src/utils/constants.js';
+import { config } from '../../../helpers/config.js';
+import protobufFixtures from '../../../fixtures/protobuf.fixtures.js';
+import { testKeyPair1 } from '../../../fixtures/apply.fixtures.js';
+
+const remotePublicKey = b4a.from(testKeyPair1.publicKey, 'hex');
+const remoteAddressBuffer = addressToBuffer(publicKeyToAddress(remotePublicKey, config), config.addressPrefix);
+const writerKey = b4a.alloc(32, 2);
+
+const createState = (overrides = {}) => ({
+    verifyProofOfPublication: async () => ({ ok: true }),
+    getRegisteredWriterKey: async () => remoteAddressBuffer,
+    getNodeEntry: async () => ({
+        isWriter: true,
+        wk: writerKey,
+    }),
+    ...overrides
+});
+
+const createValidator = (stateOverrides = {}) =>
+    new V1BroadcastTransactionResponse(createState(stateOverrides), config);
+
+const overrideCheckMethods = (t, overrides) => {
+    const originals = {};
+    for (const [name, impl] of Object.entries(overrides)) {
+        originals[name] = Check.prototype[name];
+        Check.prototype[name] = impl;
+    }
+
+    t.teardown(() => {
+        for (const [name, original] of Object.entries(originals)) {
+            Check.prototype[name] = original;
+        }
+    });
+};
+
+const overrideFunction = (t, target, key, replacement) => {
+    const original = target[key];
+    target[key] = replacement;
+    t.teardown(() => {
+        target[key] = original;
+    });
+};
+
+test('extractRequiredVaFromDecodedTx throws VALIDATOR_TX_OBJECT_INVALID for non-object', t => {
+    try {
+        extractRequiredVaFromDecodedTx(null);
+        t.fail('expected throw');
+    } catch (err) {
+        t.is(err.resultCode, ResultCode.VALIDATOR_TX_OBJECT_INVALID);
+    }
+});
+
+test('extractRequiredVaFromDecodedTx throws VALIDATOR_VA_MISSING when va is missing', t => {
+    try {
+        extractRequiredVaFromDecodedTx({type: 1, txo: {tx: b4a.alloc(32)}});
+        t.fail('expected throw');
+    } catch (err) {
+        t.is(err.resultCode, ResultCode.VALIDATOR_VA_MISSING);
+    }
+});
+
+test('extractRequiredVaFromDecodedTx returns va buffer when present', t => {
+    const va = b4a.alloc(39, 1);
+    const extracted = extractRequiredVaFromDecodedTx({
+        type: OperationType.TX,
+        txo: {va}
+    });
+
+    t.ok(b4a.equals(extracted, va));
+});
+
+test('validate skips proof validation when result code is non-OK', async t => {
+    const validator = createValidator();
+    let proofCalled = false;
+
+    validator.isPayloadSchemaValid = () => true;
+    validator.validateResponseType = () => true;
+    validator.validatePeerCorrectness = () => true;
+    validator.validateSignature = async () => true;
+    validator.verifyProofOfPublication = async () => {
+        proofCalled = true;
+        return {};
+    };
+
+    const payload = {
+        broadcast_transaction_response: {
+            result: ResultCode.TIMEOUT,
+        }
+    };
+
+    const result = await validator.validate(
+        payload,
+        { remotePublicKey: b4a.alloc(32, 1) },
+        {},
+        null
+    );
+
+    t.is(result, true);
+    t.absent(proofCalled);
+});
+
+test('validate runs proof validation pipeline when result code is OK', async t => {
+    const validator = createValidator();
+    const calls = [];
+
+    validator.isPayloadSchemaValid = () => calls.push('schema');
+    validator.validateResponseType = () => calls.push('type');
+    validator.validatePeerCorrectness = () => calls.push('peer');
+    validator.validateSignature = async () => calls.push('signature');
+    validator.verifyProofOfPublication = async () => {
+        calls.push('proof');
+        return { proof: {}, manifest: {} };
+    };
+    validator.assertProofPayloadMatchesRequestPayload = async () => {
+        calls.push('assert-proof-payload');
+        return {
+            validatorDecodedTx: { type: OperationType.TX, txo: { va: remoteAddressBuffer } },
+            manifest: {}
+        };
+    };
+    validator.validateDecodedCompletePayloadSchema = () => calls.push('schema-complete');
+    validator.validateWritingKey = async () => {
+        calls.push('writer-key');
+        return {
+            writerKeyFromManifest: writerKey,
+            validatorAddressCorrelatedWithManifest: remoteAddressBuffer
+        };
+    };
+    validator.validateValidatorCorrectness = async () => calls.push('validator-correctness');
+
+    const result = await validator.validate(
+        { broadcast_transaction_response: { result: ResultCode.OK } },
+        { remotePublicKey },
+        { requestTxData: b4a.alloc(1), requestedTo: b4a.toString(remotePublicKey, 'hex') },
+        {}
+    );
+
+    t.is(result, true);
+    t.alike(calls, [
+        'schema',
+        'type',
+        'peer',
+        'signature',
+        'proof',
+        'assert-proof-payload',
+        'schema-complete',
+        'writer-key',
+        'validator-correctness'
+    ]);
+});
+
+test('validate rejects TX_COMMITTED_RECEIPT_MISSING as validator internal error', async t => {
+    const validator = createValidator();
+
+    validator.isPayloadSchemaValid = () => true;
+    validator.validateResponseType = () => true;
+    validator.validatePeerCorrectness = () => true;
+    validator.validateSignature = async () => true;
+
+    const payload = {
+        broadcast_transaction_response: {
+            result: ResultCode.TX_COMMITTED_RECEIPT_MISSING,
+        }
+    };
+
+    try {
+        await validator.validate(
+            payload,
+            { remotePublicKey: b4a.alloc(32, 1) },
+            {},
+            null
+        );
+        t.fail('expected validate to throw');
+    } catch (error) {
+        t.ok(error instanceof V1ProtocolError);
+        t.is(error.resultCode, ResultCode.TX_COMMITTED_RECEIPT_MISSING);
+        t.is(error.endConnection, true);
+    }
+});
+
+test('validateDecodedCompletePayloadSchema throws for missing, unknown and unsupported types', t => {
+    const validator = createValidator();
+
+    try {
+        validator.validateDecodedCompletePayloadSchema({});
+        t.fail('expected missing type to throw');
+    } catch (error) {
+        t.is(error.resultCode, ResultCode.VALIDATOR_RESPONSE_TX_TYPE_INVALID);
+    }
+
+    try {
+        validator.validateDecodedCompletePayloadSchema({ type: 9999 });
+        t.fail('expected unknown type to throw');
+    } catch (error) {
+        t.is(error.resultCode, ResultCode.VALIDATOR_RESPONSE_TX_TYPE_UNKNOWN);
+    }
+
+    try {
+        validator.validateDecodedCompletePayloadSchema({ type: OperationType.ADD_ADMIN });
+        t.fail('expected unsupported type to throw');
+    } catch (error) {
+        t.is(error.resultCode, ResultCode.VALIDATOR_RESPONSE_TX_TYPE_UNSUPPORTED);
+    }
+});
+
+test('validateDecodedCompletePayloadSchema selects proper validators for supported operation types', t => {
+    const validator = createValidator();
+    const called = [];
+
+    overrideCheckMethods(t, {
+        validateRoleAccessOperation: () => {
+            called.push('role');
+            return true;
+        },
+        validateBootstrapDeploymentOperation: () => {
+            called.push('bootstrap');
+            return true;
+        },
+        validateTransactionOperation: () => {
+            called.push('tx');
+            return true;
+        },
+        validateTransferOperation: () => {
+            called.push('transfer');
+            return true;
+        },
+    });
+
+    validator.validateDecodedCompletePayloadSchema({ type: OperationType.ADD_WRITER });
+    validator.validateDecodedCompletePayloadSchema({ type: OperationType.BOOTSTRAP_DEPLOYMENT });
+    validator.validateDecodedCompletePayloadSchema({ type: OperationType.TX });
+    validator.validateDecodedCompletePayloadSchema({ type: OperationType.TRANSFER });
+
+    t.alike(called, ['role', 'bootstrap', 'tx', 'transfer']);
+});
+
+test('validateDecodedCompletePayloadSchema throws VALIDATOR_RESPONSE_SCHEMA_INVALID when selected validator fails', t => {
+    const validator = createValidator();
+
+    overrideCheckMethods(t, {
+        validateTransactionOperation: () => false,
+    });
+
+    try {
+        validator.validateDecodedCompletePayloadSchema({ type: OperationType.TX });
+        t.fail('expected schema invalid');
+    } catch (error) {
+        t.is(error.resultCode, ResultCode.VALIDATOR_RESPONSE_SCHEMA_INVALID);
+    }
+});
+
+test('verifyProofOfPublication delegates verification to state instance', async t => {
+    const validator = createValidator({
+        verifyProofOfPublication: receivedProof => {
+            t.ok(b4a.equals(receivedProof, proof));
+            return { ok: true };
+        }
+    });
+    const proof = b4a.from('deadbeef', 'hex');
+
+    const result = await validator.verifyProofOfPublication({
+        broadcast_transaction_response: {
+            proof,
+        }
+    });
+
+    t.alike(result, { ok: true });
+});
+
+test('assertProofPayloadMatchesRequestPayload throws when pending request tx data is missing', async t => {
+    const validator = createValidator();
+
+    try {
+        await validator.assertProofPayloadMatchesRequestPayload(
+            { proof: { block: { value: b4a.alloc(1) }, manifest: {} } },
+            { requestTxData: null }
+        );
+        t.fail('expected missing tx data to throw');
+    } catch (error) {
+        t.is(error.resultCode, ResultCode.PENDING_REQUEST_MISSING_TX_DATA);
+    }
+});
+
+test('assertProofPayloadMatchesRequestPayload throws PROOF_PAYLOAD_MISMATCH when decoded payloads differ', async t => {
+    const validator = createValidator();
+
+    const requestTxData = unsafeEncodeApplyOperation(protobufFixtures.validPartialTransactionOperation);
+    const responseTxData = unsafeEncodeApplyOperation(protobufFixtures.validPartialTransferOperation);
+
+    overrideFunction(t, Autobase, 'decodeValue', async () => responseTxData);
+
+    try {
+        await validator.assertProofPayloadMatchesRequestPayload(
+            {
+                proof: {
+                    block: { value: b4a.alloc(1) },
+                    manifest: {}
+                }
+            },
+            { requestTxData }
+        );
+        t.fail('expected payload mismatch');
+    } catch (error) {
+        t.is(error.resultCode, ResultCode.PROOF_PAYLOAD_MISMATCH);
+    }
+});
+
+test('assertProofPayloadMatchesRequestPayload strips validator metadata before comparison', async t => {
+    const validator = createValidator();
+
+    const requestPayload = structuredClone(protobufFixtures.validTransactionOperation);
+    requestPayload.txo.va = null;
+    requestPayload.txo.vn = null;
+    requestPayload.txo.vs = null;
+    const requestTxData = unsafeEncodeApplyOperation(requestPayload);
+    const responseTxData = unsafeEncodeApplyOperation(protobufFixtures.validTransactionOperation);
+    const manifest = { signers: [] };
+
+    overrideFunction(t, Autobase, 'decodeValue', async () => responseTxData);
+
+    const result = await validator.assertProofPayloadMatchesRequestPayload(
+        {
+            proof: {
+                block: { value: b4a.alloc(1) },
+                manifest,
+            }
+        },
+        { requestTxData }
+    );
+
+    t.is(result.validatorDecodedTx.type, OperationType.TX);
+    t.alike(result.manifest, manifest);
+
+    const decodedResponse = unsafeDecodeApplyOperation(responseTxData);
+    t.alike(result.validatorDecodedTx, decodedResponse);
+});
+
+test('validateWritingKey throws when writer key is not registered', async t => {
+    const validator = createValidator({
+        getRegisteredWriterKey: async () => null
+    });
+
+    overrideFunction(t, Hypercore, 'key', () => writerKey);
+
+    try {
+        await validator.validateWritingKey({}, {});
+        t.fail('expected validateWritingKey to throw');
+    } catch (error) {
+        t.is(error.resultCode, ResultCode.VALIDATOR_WRITER_KEY_NOT_REGISTERED);
+    }
+});
+
+test('validateWritingKey returns writer key and correlated validator address', async t => {
+    const registeredAddress = b4a.alloc(39, 7);
+    const validator = createValidator({
+        getRegisteredWriterKey: async writerKeyHex => {
+            t.is(writerKeyHex, b4a.toString(writerKey, 'hex'));
+            return registeredAddress;
+        }
+    });
+
+    overrideFunction(t, Hypercore, 'key', () => writerKey);
+
+    const result = await validator.validateWritingKey({}, {});
+
+    t.ok(b4a.equals(result.writerKeyFromManifest, writerKey));
+    t.ok(b4a.equals(result.validatorAddressCorrelatedWithManifest, registeredAddress));
+});
+
+test('validateValidatorCorrectness throws VALIDATOR_ADDRESS_MISMATCH when tx va differs from connection-derived address', async t => {
+    const validator = createValidator({
+        getNodeEntry: async () => null
+    });
+
+    try {
+        await validator.validateValidatorCorrectness(
+            { txo: { va: b4a.alloc(remoteAddressBuffer.length, 9) } },
+            remotePublicKey,
+            writerKey,
+            remoteAddressBuffer
+        );
+        t.fail('expected address mismatch');
+    } catch (error) {
+        t.is(error.resultCode, ResultCode.VALIDATOR_ADDRESS_MISMATCH);
+    }
+});
+
+test('validateValidatorCorrectness throws VALIDATOR_ADDRESS_MISMATCH when tx va differs from manifest-correlated address', async t => {
+    const validator = createValidator({
+        getNodeEntry: async () => null
+    });
+
+    try {
+        await validator.validateValidatorCorrectness(
+            { txo: { va: remoteAddressBuffer } },
+            remotePublicKey,
+            writerKey,
+            b4a.alloc(remoteAddressBuffer.length, 8)
+        );
+        t.fail('expected address mismatch');
+    } catch (error) {
+        t.is(error.resultCode, ResultCode.VALIDATOR_ADDRESS_MISMATCH);
+    }
+});
+
+test('validateValidatorCorrectness throws VALIDATOR_NODE_ENTRY_NOT_FOUND when state has no node entry', async t => {
+    const validator = createValidator({
+        getNodeEntry: async () => null
+    });
+
+    try {
+        await validator.validateValidatorCorrectness(
+            { txo: { va: remoteAddressBuffer } },
+            remotePublicKey,
+            writerKey,
+            remoteAddressBuffer
+        );
+        t.fail('expected missing node entry');
+    } catch (error) {
+        t.is(error.resultCode, ResultCode.VALIDATOR_NODE_ENTRY_NOT_FOUND);
+    }
+});
+
+test('validateValidatorCorrectness throws VALIDATOR_NODE_NOT_WRITER when node is not a writer', async t => {
+    const validator = createValidator({
+        getNodeEntry: async () => ({
+            isWriter: false,
+            wk: writerKey,
+        })
+    });
+
+    try {
+        await validator.validateValidatorCorrectness(
+            { txo: { va: remoteAddressBuffer } },
+            remotePublicKey,
+            writerKey,
+            remoteAddressBuffer
+        );
+        t.fail('expected node-not-writer');
+    } catch (error) {
+        t.is(error.resultCode, ResultCode.VALIDATOR_NODE_NOT_WRITER);
+    }
+});
+
+test('validateValidatorCorrectness throws VALIDATOR_WRITER_KEY_MISMATCH when state writer key differs', async t => {
+    const validator = createValidator({
+        getNodeEntry: async () => ({
+            isWriter: true,
+            wk: b4a.alloc(32, 99),
+        })
+    });
+
+    try {
+        await validator.validateValidatorCorrectness(
+            { txo: { va: remoteAddressBuffer } },
+            remotePublicKey,
+            writerKey,
+            remoteAddressBuffer
+        );
+        t.fail('expected writer-key mismatch');
+    } catch (error) {
+        t.is(error.resultCode, ResultCode.VALIDATOR_WRITER_KEY_MISMATCH);
+    }
+});
+
+test('validateValidatorCorrectness passes when validator address and writer key are consistent', async t => {
+    const validator = createValidator({
+        getNodeEntry: async () => ({
+            isWriter: true,
+            wk: writerKey,
+        })
+    });
+
+    await validator.validateValidatorCorrectness(
+        { txo: { va: remoteAddressBuffer } },
+        remotePublicKey,
+        writerKey,
+        remoteAddressBuffer
+    );
+
+    t.pass();
+});
+
+test('validateIfResultCodeIsValidatorInternalError throws only for TX_COMMITTED_RECEIPT_MISSING', t => {
+    const validator = createValidator();
+
+    try {
+        validator.validateIfResultCodeIsValidatorInternalError(ResultCode.TX_COMMITTED_RECEIPT_MISSING);
+        t.fail('expected internal error result code to throw');
+    } catch (error) {
+        t.is(error.resultCode, ResultCode.TX_COMMITTED_RECEIPT_MISSING);
+        t.is(error.endConnection, true);
+    }
+
+    validator.validateIfResultCodeIsValidatorInternalError(ResultCode.OK);
+    t.pass();
+});

package/tests/unit/network/v1/V1LivenessRequest.test.js

@@ -0,0 +1,32 @@
+import test from 'brittle';
+import b4a from 'b4a';
+
+import V1LivenessRequest from '../../../../src/core/network/protocols/v1/validators/V1LivenessRequest.js';
+import { config } from '../../../helpers/config.js';
+import { errorMessageIncludes } from '../../../helpers/regexHelper.js';
+
+test('V1LivenessRequest.validate runs schema and signature validation', async t => {
+    const validator = new V1LivenessRequest(config);
+    const calls = [];
+
+    validator.isPayloadSchemaValid = () => calls.push('schema');
+    validator.validateSignature = async () => calls.push('signature');
+
+    const result = await validator.validate({}, b4a.alloc(32, 1));
+
+    t.is(result, true);
+    t.alike(calls, ['schema', 'signature']);
+});
+
+test('V1LivenessRequest.validate propagates signature validation errors', async t => {
+    const validator = new V1LivenessRequest(config);
+    validator.isPayloadSchemaValid = () => true;
+    validator.validateSignature = async () => {
+        throw new Error('signature failed');
+    };
+
+    await t.exception(
+        async () => validator.validate({}, b4a.alloc(32, 1)),
+        errorMessageIncludes('signature failed')
+    );
+});

package/tests/unit/network/v1/V1LivenessResponse.test.js

@@ -0,0 +1,45 @@
+import test from 'brittle';
+import b4a from 'b4a';
+
+import V1LivenessResponse from '../../../../src/core/network/protocols/v1/validators/V1LivenessResponse.js';
+import { config } from '../../../helpers/config.js';
+import { errorMessageIncludes } from '../../../helpers/regexHelper.js';
+
+test('V1LivenessResponse.validate runs all validation steps in order', async t => {
+    const validator = new V1LivenessResponse(config);
+    const calls = [];
+
+    validator.isPayloadSchemaValid = () => calls.push('schema');
+    validator.validateResponseType = () => calls.push('responseType');
+    validator.validatePeerCorrectness = () => calls.push('peer');
+    validator.validateSignature = async () => calls.push('signature');
+
+    const result = await validator.validate(
+        {},
+        { remotePublicKey: b4a.alloc(32, 1) },
+        { requestedTo: b4a.toString(b4a.alloc(32, 1), 'hex') }
+    );
+
+    t.is(result, true);
+    t.alike(calls, ['schema', 'responseType', 'peer', 'signature']);
+});
+
+test('V1LivenessResponse.validate propagates response-type errors', async t => {
+    const validator = new V1LivenessResponse(config);
+
+    validator.isPayloadSchemaValid = () => true;
+    validator.validateResponseType = () => {
+        throw new Error('invalid response type');
+    };
+    validator.validatePeerCorrectness = () => true;
+    validator.validateSignature = async () => true;
+
+    await t.exception(
+        async () => validator.validate(
+            {},
+            { remotePublicKey: b4a.alloc(32, 1) },
+            { requestedTo: b4a.toString(b4a.alloc(32, 1), 'hex') }
+        ),
+        errorMessageIncludes('invalid response type')
+    );
+});

package/tests/unit/network/v1/V1ResultCode.test.js

@@ -0,0 +1,84 @@
+import {test} from 'brittle';
+
+import {ResultCode} from '../../../../src/utils/constants.js';
+
+const expectedResultCodeMap = Object.freeze({
+    UNSPECIFIED: 0,
+    OK: 1,
+    INVALID_PAYLOAD: 2,
+    RATE_LIMITED: 3,
+    SIGNATURE_INVALID: 4,
+    UNEXPECTED_ERROR: 5,
+    TIMEOUT: 6,
+    NODE_HAS_NO_WRITE_ACCESS: 7,
+    TX_ACCEPTED_PROOF_UNAVAILABLE: 8,
+    NODE_OVERLOADED: 9,
+    TX_ALREADY_PENDING: 10,
+    OPERATION_TYPE_UNKNOWN: 11,
+    SCHEMA_VALIDATION_FAILED: 12,
+    REQUESTER_ADDRESS_INVALID: 13,
+    REQUESTER_PUBLIC_KEY_INVALID: 14,
+    TX_HASH_MISMATCH: 15,
+    TX_SIGNATURE_INVALID: 16,
+    TX_EXPIRED: 17,
+    TX_ALREADY_EXISTS: 18,
+    OPERATION_ALREADY_COMPLETED: 19,
+    REQUESTER_NOT_FOUND: 20,
+    INSUFFICIENT_FEE_BALANCE: 21,
+    EXTERNAL_BOOTSTRAP_EQUALS_MSB_BOOTSTRAP: 22,
+    SELF_VALIDATION_FORBIDDEN: 23,
+    ROLE_NODE_ENTRY_NOT_FOUND: 24,
+    ROLE_NODE_ALREADY_WRITER: 25,
+    ROLE_NODE_NOT_WHITELISTED: 26,
+    ROLE_NODE_NOT_WRITER: 27,
+    ROLE_NODE_IS_INDEXER: 28,
+    ROLE_ADMIN_ENTRY_MISSING: 29,
+    ROLE_INVALID_RECOVERY_CASE: 30,
+    ROLE_UNKNOWN_OPERATION: 31,
+    ROLE_INVALID_WRITER_KEY: 32,
+    ROLE_INSUFFICIENT_FEE_BALANCE: 33,
+    MSB_BOOTSTRAP_MISMATCH: 34,
+    EXTERNAL_BOOTSTRAP_NOT_DEPLOYED: 35,
+    EXTERNAL_BOOTSTRAP_TX_MISSING: 36,
+    EXTERNAL_BOOTSTRAP_MISMATCH: 37,
+    BOOTSTRAP_ALREADY_EXISTS: 38,
+    TRANSFER_RECIPIENT_ADDRESS_INVALID: 39,
+    TRANSFER_RECIPIENT_PUBLIC_KEY_INVALID: 40,
+    TRANSFER_AMOUNT_TOO_LARGE: 41,
+    TRANSFER_SENDER_NOT_FOUND: 42,
+    TRANSFER_INSUFFICIENT_BALANCE: 43,
+    TRANSFER_RECIPIENT_BALANCE_OVERFLOW: 44,
+    TX_HASH_INVALID_FORMAT: 45,
+    INTERNAL_ENQUEUE_VALIDATION_FAILED: 46,
+    TX_COMMITTED_RECEIPT_MISSING: 47,
+    VALIDATOR_RESPONSE_TX_TYPE_INVALID: 48,
+    VALIDATOR_RESPONSE_TX_TYPE_UNKNOWN: 49,
+    VALIDATOR_RESPONSE_TX_TYPE_UNSUPPORTED: 50,
+    VALIDATOR_RESPONSE_SCHEMA_INVALID: 51,
+    PENDING_REQUEST_MISSING_TX_DATA: 52,
+    PROOF_PAYLOAD_MISMATCH: 53,
+    VALIDATOR_WRITER_KEY_NOT_REGISTERED: 54,
+    VALIDATOR_ADDRESS_MISMATCH: 55,
+    VALIDATOR_NODE_ENTRY_NOT_FOUND: 56,
+    VALIDATOR_NODE_NOT_WRITER: 57,
+    VALIDATOR_WRITER_KEY_MISMATCH: 58,
+    VALIDATOR_TX_OBJECT_INVALID: 59,
+    VALIDATOR_VA_MISSING: 60,
+    TX_INVALID_PAYLOAD: 61
+});
+
+test('ResultCode values are unique', t => {
+    const values = Object.values(ResultCode);
+    t.is(new Set(values).size, values.length);
+});
+
+test('ResultCode preserves existing numeric values (append-only)', t => {
+    t.alike(ResultCode, expectedResultCodeMap);
+});
+
+test('ResultCode does not expose deprecated alias', t => {
+    t.absent(
+        Object.prototype.hasOwnProperty.call(ResultCode, 'TX_ACCEPTED_RECEIPT_MISSING'),
+        'deprecated alias should not be present'
+    );
+});

package/tests/unit/network/v1/V1ValidationSchema.test.js

@@ -0,0 +1,13 @@
+import { default as test } from 'brittle';
+
+async function runV1ValidationSchemaTests() {
+    test.pause();
+    await import('./v1ValidationSchema/livenessRequest.test.js');
+    await import('./v1ValidationSchema/livenessResponse.test.js');
+    await import('./v1ValidationSchema/broadcastTransactionRequest.test.js');
+    await import('./v1ValidationSchema/broadcastTransactionResponse.test.js');
+    test.resume();
+}
+
+await runV1ValidationSchemaTests();
+