trac-msb 0.2.18 → 0.2.19

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

@@ -1,512 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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();
-