trac-msb 0.2.18 → 0.2.19

package/tests/unit/network/v1/v1ValidationSchema/common.test.js

@@ -1,308 +0,0 @@
-import b4a from 'b4a';
-
-export const describeValue = (value) => {
-    if (value === null) return 'null';
-    if (value === undefined) return 'undefined';
-    if (b4a.isBuffer(value)) return `buffer(len=${value.length})`;
-    if (Number.isNaN(value)) return 'NaN';
-    if (value === Infinity) return 'Infinity';
-    if (Array.isArray(value)) return 'array';
-    if (value instanceof Map) return 'map';
-    if (value instanceof Set) return 'set';
-    if (value instanceof Date) return 'date';
-    if (value instanceof RegExp) return 'regexp';
-    if (value instanceof Error) return `error(${value.message})`;
-    if (typeof value === 'bigint') return `bigint(${value})`;
-    return typeof value;
-};
-
-export const assertNoThrowAndAbsent = (t, validateFn, input, message) => {
-    let result;
-    t.execution(() => {
-        result = validateFn(input);
-    }, `${message} (no throw)`);
-    t.absent(result, `${message} (should fail)`);
-};
-
-export function topLevelValidationTests(
-    t,
-    validateFn,
-    validFixture,
-    valueKey,
-    notAllowedDataTypes,
-    topFields,
-    expectedType
-) {
-    t.test('strict mode', t => {
-        const extraTopLevel = {
-            ...validFixture,
-            extra: b4a.from('redundant field', 'utf-8'),
-        };
-        t.absent(validateFn(extraTopLevel), 'Extra field should fail due to $$strict');
-        t.absent(validateFn({}), 'Empty object should fail');
-    });
-
-    t.test('operation type', t => {
-        const invalidOperationType = { ...validFixture, type: 'invalid-op' };
-        t.absent(validateFn(invalidOperationType), 'Invalid operation type should fail');
-
-        const notDefinedOperationType = { ...validFixture, type: 999 };
-        t.absent(validateFn(notDefinedOperationType), 'Invalid operation type should fail');
-
-        const zeroValue = { ...validFixture, type: 0 };
-        t.absent(validateFn(zeroValue), 'Type with value 0 should fail');
-
-        const negativeValue = { ...validFixture, type: -1 };
-        t.absent(validateFn(negativeValue), 'Negative type value should fail');
-
-        const wrongKnownType = { ...validFixture, type: expectedType + 1 };
-        t.absent(validateFn(wrongKnownType), 'Wrong known type should fail');
-    });
-
-    t.test('nested objects', t => {
-        const nestedObjectInsideValue = {
-            ...validFixture,
-            [valueKey]: {
-                ...validFixture[valueKey],
-                nested: { foo: b4a.from('bar', 'utf-8') }
-            }
-        };
-        t.absent(validateFn(nestedObjectInsideValue), `Unexpected nested field inside -${valueKey}- should fail due to strict`);
-
-        const nestedObjectInsideValue2 = {
-            ...validFixture,
-            nested: { foo: b4a.from('bar', 'utf-8') }
-        };
-        t.absent(validateFn(nestedObjectInsideValue2), 'Unexpected nested field inside general object should fail due to strict');
-
-        const nestedObjectInsideType = {
-            ...validFixture,
-            type: {
-                foo: b4a.from('bar', 'utf-8'),
-                nested: { foo: b4a.from('bar', 'utf-8') }
-            }
-        };
-        t.absent(validateFn(nestedObjectInsideType), 'Unexpected nested field inside `type` field should fail');
-
-        const nestedObjectInsideId = {
-            ...validFixture,
-            id: {
-                foo: b4a.from('bar', 'utf-8'),
-                nested: { foo: b4a.from('bar', 'utf-8') }
-            }
-        };
-        t.absent(validateFn(nestedObjectInsideId), 'Unexpected nested field inside `id` field should fail');
-
-        const nestedObjectInsideTimestamp = {
-            ...validFixture,
-            timestamp: {
-                foo: b4a.from('bar', 'utf-8'),
-                nested: { foo: b4a.from('bar', 'utf-8') }
-            }
-        };
-        t.absent(validateFn(nestedObjectInsideTimestamp), 'Unexpected nested field inside `timestamp` field should fail');
-
-        const nestedObjectInsideCapabilities = {
-            ...validFixture,
-            capabilities: {
-                foo: b4a.from('bar', 'utf-8'),
-                nested: { foo: b4a.from('bar', 'utf-8') }
-            }
-        };
-        t.absent(validateFn(nestedObjectInsideCapabilities), 'Unexpected nested field inside `capabilities` field should fail');
-    });
-
-    t.test('invalid data types', t => {
-        for (const invalidDataType of notAllowedDataTypes) {
-            if (typeof invalidDataType !== 'number') {
-                const invalidTypeForType = { ...validFixture, type: invalidDataType };
-                t.absent(
-                    validateFn(invalidTypeForType),
-                    `Invalid data type for 'type' key ${describeValue(invalidDataType)} should fail`
-                );
-            }
-
-            if (typeof invalidDataType !== 'string') {
-                const invalidTypeForId = { ...validFixture, id: invalidDataType };
-                t.absent(
-                    validateFn(invalidTypeForId),
-                    `Invalid data type for 'id' key ${describeValue(invalidDataType)} should fail`
-                );
-            }
-
-            if (typeof invalidDataType !== 'number') {
-                const invalidTypeForTimestamp = { ...validFixture, timestamp: invalidDataType };
-                t.absent(
-                    validateFn(invalidTypeForTimestamp),
-                    `Invalid data type for 'timestamp' key ${describeValue(invalidDataType)} should fail`
-                );
-            }
-
-            if (!Array.isArray(invalidDataType)) {
-                const invalidTypeForCapabilities = { ...validFixture, capabilities: invalidDataType };
-                t.absent(
-                    validateFn(invalidTypeForCapabilities),
-                    `Invalid data type for 'capabilities' key ${describeValue(invalidDataType)} should fail`
-                );
-            }
-
-            if (String(invalidDataType) !== '[object Object]') {
-                const invalidTypeForPayload = { ...validFixture, [valueKey]: invalidDataType };
-                t.absent(
-                    validateFn(invalidTypeForPayload),
-                    `Invalid data type for ${valueKey} key ${describeValue(invalidDataType)} should fail`
-                );
-            }
-        }
-
-        const invalidOperationTypeDiffType = { ...validFixture, type: "string" }
-        t.absent(validateFn(invalidOperationTypeDiffType), 'Wrong type for `type` should fail')
-
-        for (const mainField of topFields) {
-            const missingFieldInvalidInput = { ...validFixture }
-            delete missingFieldInvalidInput[mainField]
-            t.absent(validateFn(missingFieldInvalidInput), `Missing ${mainField} should fail`);
-        }
-    });
-}
-
-export function headerFieldValueValidationTests(t, validateFn, validFixture) {
-    t.absent(
-        validateFn({...validFixture, id: ''}),
-        'empty id should fail'
-    );
-
-    t.absent(
-        validateFn({...validFixture, id: 'x'.repeat(65)}),
-        'id longer than 64 chars should fail'
-    );
-
-    t.absent(
-        validateFn({...validFixture, timestamp: 0}),
-        'timestamp 0 should fail'
-    );
-
-    t.absent(
-        validateFn({...validFixture, timestamp: -1}),
-        'negative timestamp should fail'
-    );
-
-    t.absent(
-        validateFn({...validFixture, timestamp: 1.1}),
-        'non-integer timestamp should fail'
-    );
-
-    t.absent(
-        validateFn({...validFixture, timestamp: NaN}),
-        'timestamp NaN should fail'
-    );
-
-    t.absent(
-        validateFn({...validFixture, timestamp: Infinity}),
-        'timestamp Infinity should fail'
-    );
-
-    t.absent(
-        validateFn({...validFixture, timestamp: Number.MAX_SAFE_INTEGER + 1}),
-        'timestamp above MAX_SAFE_INTEGER should fail'
-    );
-
-    t.absent(
-        validateFn({...validFixture, capabilities: 'cap:a'}),
-        'capabilities must be an array'
-    );
-
-    t.absent(
-        validateFn({...validFixture, capabilities: [1]}),
-        'capabilities items must be strings'
-    );
-}
-
-export function valueLevelValidationTests(
-    t,
-    validateFn,
-    validFixture,
-    valueKey,
-    valueFields,
-    notAllowedDataTypes,
-    opts = {}
-) {
-    const skipInvalidType = opts.skipInvalidType || (() => false);
-
-    for (const field of valueFields) {
-        const missing = structuredClone(validFixture);
-        delete missing[valueKey][field];
-        t.absent(validateFn(missing), `Missing ${valueKey}.${field} should fail`);
-    }
-
-    t.test(`Invalid data types for each field in ${valueKey}`, t => {
-        for (const field of valueFields) {
-            for (const invalidType of notAllowedDataTypes) {
-                if (skipInvalidType(field, invalidType)) continue;
-
-                const withInvalidDataType = structuredClone(validFixture);
-                withInvalidDataType[valueKey][field] = invalidType;
-                t.absent(
-                    validateFn(withInvalidDataType),
-                    `Invalid data type for ${valueKey}.${field}: ${describeValue(invalidType)} should fail`
-                );
-            }
-        }
-    });
-
-    t.test("Extra field in value", t => {
-        const extraInValue = structuredClone(validFixture);
-        extraInValue[valueKey].extraField = b4a.from('redundant', 'utf-8');
-        t.absent(validateFn(extraInValue), 'Extra field should fail due to strict')
-    });
-}
-
-export function fieldsBufferLengthTest(
-    t,
-    validateFn,
-    validFixture,
-    valueKey,
-    requiredFieldLengthsForValue
-) {
-    for (const [field, expectedLen] of Object.entries(requiredFieldLengthsForValue)) {
-        const emptyBuffer = b4a.alloc(0);
-        const oneTooShort = b4a.alloc(expectedLen - 1, 0x01);
-        const tooShort = b4a.alloc(expectedLen - 2, 0x01);
-        const exact = b4a.alloc(expectedLen, 0x01);
-        const oneTooLong = b4a.alloc(expectedLen + 1, 0x01);
-        const tooLong = b4a.alloc(expectedLen + 2, 0x01);
-
-        const buildValueLevel = (val) => ({
-            ...validFixture,
-            [valueKey]: {
-                ...validFixture[valueKey],
-                [field]: val
-            }
-        });
-
-        const inputs = {
-            emptyBufferInput: buildValueLevel(emptyBuffer),
-            shortInput: buildValueLevel(tooShort),
-            oneTooShortInput: buildValueLevel(oneTooShort),
-            exactInput: buildValueLevel(exact),
-            oneTooLongInput: buildValueLevel(oneTooLong),
-            longInput: buildValueLevel(tooLong),
-        };
-
-        t.absent(validateFn(inputs.emptyBufferInput), `${valueKey}.${field} empty buffer (length ${emptyBuffer.length}) should fail`);
-        t.absent(validateFn(inputs.shortInput), `${valueKey}.${field} too short (length ${tooShort.length}) should fail`);
-        t.absent(validateFn(inputs.oneTooShortInput), `${valueKey}.${field} one too short (length ${oneTooShort.length}) should fail`);
-        t.ok(validateFn(inputs.exactInput), `${valueKey}.${field} exact length (length ${exact.length}) should pass`);
-        t.absent(validateFn(inputs.oneTooLongInput), `${valueKey}.${field} one too long (length ${oneTooLong.length}) should fail`);
-        t.absent(validateFn(inputs.longInput), `${valueKey}.${field} too long (length ${tooLong.length}) should fail`);
-    }
-}
-
-export function fieldsNonZeroBufferTest(t, validateFn, validFixture, valueKey, fields) {
-    for (const field of fields) {
-        const zeroFilled = structuredClone(validFixture);
-        const len = zeroFilled[valueKey][field]?.length ?? 0;
-        zeroFilled[valueKey][field] = b4a.alloc(len, 0);
-        t.absent(validateFn(zeroFilled), `${valueKey}.${field} all-zero buffer should fail`);
-    }
-}

package/tests/unit/network/v1/v1ValidationSchema/livenessRequest.test.js

@@ -1,90 +0,0 @@
-import test from 'brittle';
-import b4a from 'b4a';
-
-import V1ValidationSchema from '../../../../../src/core/network/protocols/v1/validators/V1ValidationSchema.js';
-import {
-    NetworkOperationType,
-    NONCE_BYTE_LENGTH,
-    SIGNATURE_BYTE_LENGTH,
-} from '../../../../../src/utils/constants.js';
-import {not_allowed_data_types} from '../../../../fixtures/check.fixtures.js';
-
-import {
-    fieldsBufferLengthTest,
-    fieldsNonZeroBufferTest,
-    headerFieldValueValidationTests,
-    topLevelValidationTests,
-    valueLevelValidationTests,
-} from './common.test.js';
-
-const v = new V1ValidationSchema();
-
-const validFixture = {
-    type: NetworkOperationType.LIVENESS_REQUEST,
-    id: 'test-id',
-    timestamp: Date.now(),
-    liveness_request: {
-        nonce: b4a.alloc(NONCE_BYTE_LENGTH, 1),
-        signature: b4a.alloc(SIGNATURE_BYTE_LENGTH, 2),
-    },
-    capabilities: ['cap:a', 'cap:b'],
-};
-
-const topFields = ['type', 'id', 'timestamp', 'liveness_request', 'capabilities'];
-const valueFields = ['nonce', 'signature'];
-const requiredLengths = {
-    nonce: NONCE_BYTE_LENGTH,
-    signature: SIGNATURE_BYTE_LENGTH,
-};
-
-test('V1ValidationSchema.validateV1LivenessRequest - happy path', t => {
-    t.ok(v.validateV1LivenessRequest(validFixture), 'valid LIVENESS_REQUEST should pass');
-});
-
-test('V1ValidationSchema.validateV1LivenessRequest - top level validation', t => {
-    topLevelValidationTests(
-        t,
-        v.validateV1LivenessRequest.bind(v),
-        validFixture,
-        'liveness_request',
-        not_allowed_data_types,
-        topFields,
-        NetworkOperationType.LIVENESS_REQUEST
-    );
-});
-
-test('V1ValidationSchema.validateV1LivenessRequest - header field values', t => {
-    headerFieldValueValidationTests(t, v.validateV1LivenessRequest.bind(v), validFixture);
-});
-
-test('V1ValidationSchema.validateV1LivenessRequest - payload validation', t => {
-    valueLevelValidationTests(
-        t,
-        v.validateV1LivenessRequest.bind(v),
-        validFixture,
-        'liveness_request',
-        valueFields,
-        not_allowed_data_types,
-    );
-});
-
-test('V1ValidationSchema.validateV1LivenessRequest - buffer lengths', t => {
-    fieldsBufferLengthTest(
-        t,
-        v.validateV1LivenessRequest.bind(v),
-        validFixture,
-        'liveness_request',
-        requiredLengths
-    );
-});
-
-test('V1ValidationSchema.validateV1LivenessRequest - non-zero buffers', t => {
-    fieldsNonZeroBufferTest(
-        t,
-        v.validateV1LivenessRequest.bind(v),
-        validFixture,
-        'liveness_request',
-        ['nonce', 'signature']
-    );
-});
-

package/tests/unit/network/v1/v1ValidationSchema/livenessResponse.test.js

@@ -1,133 +0,0 @@
-import test from 'brittle';
-import b4a from 'b4a';
-
-import V1ValidationSchema from '../../../../../src/core/network/protocols/v1/validators/V1ValidationSchema.js';
-import {
-    NetworkOperationType,
-    NONCE_BYTE_LENGTH,
-    ResultCode,
-    SIGNATURE_BYTE_LENGTH,
-} from '../../../../../src/utils/constants.js';
-import {not_allowed_data_types} from '../../../../fixtures/check.fixtures.js';
-
-import {
-    assertNoThrowAndAbsent,
-    fieldsBufferLengthTest,
-    fieldsNonZeroBufferTest,
-    headerFieldValueValidationTests,
-    topLevelValidationTests,
-    valueLevelValidationTests,
-} from './common.test.js';
-
-const v = new V1ValidationSchema();
-
-const validFixture = {
-    type: NetworkOperationType.LIVENESS_RESPONSE,
-    id: 'test-id',
-    timestamp: Date.now(),
-    liveness_response: {
-        nonce: b4a.alloc(NONCE_BYTE_LENGTH, 1),
-        signature: b4a.alloc(SIGNATURE_BYTE_LENGTH, 2),
-        result: ResultCode.OK,
-    },
-    capabilities: ['cap:a'],
-};
-
-const topFields = ['type', 'id', 'timestamp', 'liveness_response', 'capabilities'];
-const valueFields = ['nonce', 'signature', 'result'];
-const requiredLengths = {
-    nonce: NONCE_BYTE_LENGTH,
-    signature: SIGNATURE_BYTE_LENGTH,
-};
-
-test('V1ValidationSchema.validateV1LivenessResponse - happy path', t => {
-    t.ok(v.validateV1LivenessResponse(validFixture), 'valid LIVENESS_RESPONSE should pass');
-});
-
-test('V1ValidationSchema.validateV1LivenessResponse - payload/type mismatch (request payload + response type)', t => {
-    const op = structuredClone(validFixture);
-    delete op.liveness_response;
-    op.liveness_request = {
-        nonce: b4a.alloc(NONCE_BYTE_LENGTH, 1),
-        signature: b4a.alloc(SIGNATURE_BYTE_LENGTH, 2),
-    };
-
-    assertNoThrowAndAbsent(
-        t,
-        v.validateV1LivenessResponse.bind(v),
-        op,
-        'liveness_request payload with type=LIVENESS_RESPONSE'
-    );
-});
-
-test('V1ValidationSchema.validateV1LivenessResponse - top level validation', t => {
-    topLevelValidationTests(
-        t,
-        v.validateV1LivenessResponse.bind(v),
-        validFixture,
-        'liveness_response',
-        not_allowed_data_types,
-        topFields,
-        NetworkOperationType.LIVENESS_RESPONSE
-    );
-});
-
-test('V1ValidationSchema.validateV1LivenessResponse - header field values', t => {
-    headerFieldValueValidationTests(t, v.validateV1LivenessResponse.bind(v), validFixture);
-});
-
-test('V1ValidationSchema.validateV1LivenessResponse - payload validation', t => {
-    valueLevelValidationTests(
-        t,
-        v.validateV1LivenessResponse.bind(v),
-        validFixture,
-        'liveness_response',
-        valueFields,
-        not_allowed_data_types,
-        {
-            skipInvalidType: (field, invalidType) => field === 'result' && typeof invalidType === 'number',
-        }
-    );
-});
-
-test('V1ValidationSchema.validateV1LivenessResponse - result value validation', t => {
-    const negative = structuredClone(validFixture);
-    negative.liveness_response.result = -1;
-    t.absent(v.validateV1LivenessResponse(negative), 'negative result should fail');
-
-    const nonInteger = structuredClone(validFixture);
-    nonInteger.liveness_response.result = 1.1;
-    t.absent(v.validateV1LivenessResponse(nonInteger), 'non-integer result should fail');
-
-    const nan = structuredClone(validFixture);
-    nan.liveness_response.result = NaN;
-    t.absent(v.validateV1LivenessResponse(nan), 'result NaN should fail');
-
-    const infinity = structuredClone(validFixture);
-    infinity.liveness_response.result = Infinity;
-    t.absent(v.validateV1LivenessResponse(infinity), 'result Infinity should fail');
-
-    const unknownCode = structuredClone(validFixture);
-    unknownCode.liveness_response.result = Math.max(...Object.values(ResultCode)) + 1;
-    t.absent(v.validateV1LivenessResponse(unknownCode), 'unknown result code should fail');
-});
-
-test('V1ValidationSchema.validateV1LivenessResponse - buffer lengths', t => {
-    fieldsBufferLengthTest(
-        t,
-        v.validateV1LivenessResponse.bind(v),
-        validFixture,
-        'liveness_response',
-        requiredLengths
-    );
-});
-
-test('V1ValidationSchema.validateV1LivenessResponse - non-zero buffers', t => {
-    fieldsNonZeroBufferTest(
-        t,
-        v.validateV1LivenessResponse.bind(v),
-        validFixture,
-        'liveness_response',
-        ['nonce', 'signature']
-    );
-});

package/tests/unit/state/State.test.js

@@ -1,80 +0,0 @@
-import { test, hook } from 'brittle';
-import { encode, decode, ZERO_BALANCE } from '../../src/core/state/utils/nodeEntry.js';
-import esmock from "esmock";
-import sinon from "sinon";
-import { randomBuffer, tokenUnits } from './stateTestUtils.js';
-import { WRITER_BYTE_LENGTH, ADMIN_INITIAL_BALANCE } from '../../src/utils/constants.js';
-import { $TNK, toBalance } from '../../src/core/state/utils/balance.js';
-import b4a from 'b4a'
-
-let state
-hook('Initialize state', async () => {
-    const checkout = sinon.stub().returns({ get: () => {
-            return { value: encode({
-                wk: randomBuffer(WRITER_BYTE_LENGTH),
-                isWhitelisted: true,
-                isWriter: true,
-                isIndexer: true,
-                balance: ADMIN_INITIAL_BALANCE })
-            }
-        }
-    });
-
-    const AutoBaseMock = sinon.stub().returns({ view: { checkout, core: { signedLength: 1 }} });
-    const State = await esmock('../../src/core/state/State.js', {
-        "autobase": AutoBaseMock
-    });
-    state = new State(null, null, null)
-});
-
-test('State#incrementBalance', () => {
-    test('adds two balances and produce a node entry', async t => {
-        const entry = await state.incrementBalance('adminAddress', $TNK(150n))
-        t.is(toBalance(decode(entry).balance).asBigInt(), tokenUnits(1150n), 'balance matches');
-    })
-
-    test('do not add zero', async t => {
-        const entry = await state.incrementBalance('adminAddress', $TNK(0n))
-        t.is(entry, null, 'entry is null');
-    })
-
-    test('null entry', async t => {
-        const AutoBaseMock = sinon.stub().returns({ view: { checkout: sinon.stub().returns({ get: () => ({ value: null }) }), core: { signedLength: 1 }} });
-        const State = await esmock('../../src/core/state/State.js', {
-            "autobase": AutoBaseMock
-        });
-        const entry = await new State(null, null, null).incrementBalance('adminAddress', $TNK(150n))
-        t.is(entry, null, 'entry is null');
-    })
-});
-
-test('State#derementBalance', async t => {
-    test('subtract two balances and produce a node entry', async t => {
-        const entry = await state.decrementBalance('adminAddress', $TNK(150n))
-        t.is(toBalance(decode(entry).balance).asBigInt(), tokenUnits(850n), 'balance matches');
-    })
-
-    test('do not subtract zero', async t => {
-        const entry = await state.decrementBalance('adminAddress', $TNK(0n))
-        t.is(entry, null, 'entry is null');
-    })
-
-    test('do not produce negative balance', async t => {
-        const entry = await state.decrementBalance('adminAddress', $TNK(1001n))
-        t.is(entry, null, 'entry is null');
-    })
-
-    test('can zero balance', async t => {
-        const entry = await state.decrementBalance('adminAddress', $TNK(1000n))
-        t.ok(b4a.equals(decode(entry).balance, ZERO_BALANCE), 'balance matches');
-    })
-
-    test('null entry', async t => {
-        const AutoBaseMock = sinon.stub().returns({ view: { checkout: sinon.stub().returns({ get: () => ({ value: null }) }), core: { signedLength: 1 }} });
-        const State = await esmock('../../src/core/state/State.js', {
-            "autobase": AutoBaseMock
-        });
-        const entry = await new State(null, null, null).decrementBalance('adminAddress', $TNK(150n))
-        t.is(entry, null, 'entry is null');
-    })
-});

package/tests/unit/state/apply/addAdmin/addAdminHappyPathScenario.js

@@ -1,42 +0,0 @@
-import { test } from 'brittle';
-import {
-	eventFlush,
-	deriveIndexerSequenceState
-} from '../../../../helpers/autobaseTestHelpers.js';
-import nodeEntryUtils from '../../../../../src/core/state/utils/nodeEntry.js';
-import { toTerm } from '../../../../../src/core/state/utils/balance.js';
-import { applyStateMessageFactory } from '../../../../../src/messages/state/applyStateMessageFactory.js';
-import { safeEncodeApplyOperation } from '../../../../../src/utils/protobuf/operationHelpers.js';
-import { setupAddAdminScenario, assertAdminState } from './addAdminScenarioHelpers.js';
-import { config } from '../../../../helpers/config.js';
-
-export default function addAdminHappyPathScenario() {
-	test('State.apply addAdmin bootstraps admin node - happy path', async t => {
-		const networkContext = await setupAddAdminScenario(t);
-		const adminNode = networkContext.adminBootstrap;
-		const readerNodes = networkContext.peers.slice(1);
-		const reader = readerNodes[0];
-
-		const txValidity = await deriveIndexerSequenceState(adminNode.base);
-		const addAdminPayload = safeEncodeApplyOperation(
-			await applyStateMessageFactory(adminNode.wallet, config)
-				.buildCompleteAddAdminMessage(
-					adminNode.wallet.address,
-					adminNode.base.local.key,
-					txValidity
-				)
-		);
-
-		await adminNode.base.append(addAdminPayload);
-		await adminNode.base.update();
-		await eventFlush();
-
-		await assertAdminState(t, adminNode.base, adminNode.wallet, adminNode.base.local.key, addAdminPayload);
-
-		await networkContext.sync();
-		await assertAdminState(t, reader.base, adminNode.wallet, adminNode.base.local.key, addAdminPayload);
-
-		const readerNodeEntry = await reader.base.view.get(reader.wallet.address);
-		t.is(readerNodeEntry, null, 'reader node remains without any role');
-	});
-}