trac-msb 0.2.4 → 0.2.6

package/tests/unit/state/apply/removeIndexer/state.apply.removeIndexer.test.js

@@ -0,0 +1,291 @@
+import removeIndexerHappyPathScenario from './removeIndexerHappyPathScenario.js';
+import removeIndexerReAddAndRemoveAgainScenario from './removeIndexerReAddAndRemoveAgainScenario.js';
+import removeIndexerRemoveMultipleIndexersScenario from './removeIndexerRemoveMultipleIndexersScenario.js';
+import removeIndexerTargetNotIndexerScenario from './removeIndexerTargetNotIndexerScenario.js';
+import removeIndexerWriterKeyMissingScenario from './removeIndexerWriterKeyMissingScenario.js';
+import AdminControlOperationValidationScenario from '../common/adminControlOperationValidationScenario.js';
+import RequesterAddressValidationScenario from '../common/requesterAddressValidationScenario.js';
+import createRequesterPublicKeyValidationScenario from '../common/requesterPublicKeyValidationScenario.js';
+import InvalidAddressValidationScenario from '../common/payload-structure/invalidAddressValidationScenario.js';
+import createAddressWithInvalidPublicKeyScenario from '../common/payload-structure/addressWithInvalidPublicKeyScenario.js';
+import AdminEntryMissingScenario from '../common/access-control/adminEntryMissingScenario.js';
+import AdminEntryDecodeFailureScenario from '../common/access-control/adminEntryDecodeFailureScenario.js';
+import AdminOnlyGuardScenario from '../common/access-control/adminOnlyGuardScenario.js';
+import AdminPublicKeyDecodeFailureScenario from '../common/access-control/adminPublicKeyDecodeFailureScenario.js';
+import AdminConsistencyMismatchScenario from '../common/access-control/adminConsistencyMismatchScenario.js';
+import InvalidHashValidationScenario from '../common/payload-structure/invalidHashValidationScenario.js';
+import InvalidSignatureValidationScenario, { SignatureMutationStrategy } from '../common/payload-structure/invalidSignatureValidationScenario.js';
+import TransactionValidityMismatchScenario from '../common/transactionValidityMismatchScenario.js';
+import OperationAlreadyAppliedScenario from '../common/operationAlreadyAppliedScenario.js';
+import RequesterNodeEntryMissingScenario from '../common/requester/requesterNodeEntryMissingScenario.js';
+import RequesterBalanceScenarioBase from '../common/balances/base/requesterBalanceScenarioBase.js';
+import RequesterBalanceInsufficientScenario from '../common/balances/requesterBalanceInsufficientScenario.js';
+import RequesterBalanceFeeApplicationFailureScenario from '../common/balances/requesterBalanceFeeApplicationFailureScenario.js';
+import {
+	selectIndexerCandidatePeer,
+	ensureIndexerRegistration
+} from '../addIndexer/addIndexerScenarioHelpers.js';
+import IndexerNodeEntryMissingScenario from '../common/indexer/indexerNodeEntryMissingScenario.js';
+import IndexerNodeEntryDecodeFailureScenario from '../common/indexer/indexerNodeEntryDecodeFailureScenario.js';
+import IndexerRoleUpdateFailureScenario from '../common/indexer/indexerRoleUpdateFailureScenario.js';
+import OperationValidationScenarioBase from '../common/base/OperationValidationScenarioBase.js';
+import { applyWithRequesterEntryCorruption } from '../addWriter/addWriterScenarioHelpers.js';
+import {
+	setupRemoveIndexerScenario,
+	buildRemoveIndexerPayload,
+	buildRemoveIndexerPayloadWithTxValidity,
+	applyWithRemoveIndexerRoleUpdateFailure,
+	assertRemoveIndexerSuccessState,
+	assertRemoveIndexerFailureState,
+	assertRemoveIndexerGuardFailureState
+} from './removeIndexerScenarioHelpers.js';
+import IndexerSequenceStateInvalidScenario from '../common/indexer/indexerSequenceStateInvalidScenario.js';
+
+removeIndexerHappyPathScenario();
+removeIndexerReAddAndRemoveAgainScenario();
+removeIndexerRemoveMultipleIndexersScenario();
+
+// Handler validation order (removeIndexer)
+new AdminControlOperationValidationScenario({
+	title: 'State.apply removeIndexer rejects payloads when contract schema validation fails',
+	setupScenario: setupRemoveIndexerScenario,
+	buildValidPayload: context => buildRemoveIndexerPayload(context),
+	assertStateUnchanged: (t, context) => assertRemoveIndexerGuardFailureState(t, context, { skipSync: true }),
+	expectedLogs: ['Contract schema validation failed.']
+}).performScenario();
+
+new RequesterAddressValidationScenario({
+	title: 'State.apply removeIndexer rejects payloads when requester address is invalid',
+	setupScenario: setupRemoveIndexerScenario,
+	buildValidPayload: context => buildRemoveIndexerPayload(context),
+	assertStateUnchanged: (t, context) => assertRemoveIndexerGuardFailureState(t, context, { skipSync: true }),
+	expectedLogs: ['Requester address is invalid.']
+}).performScenario();
+
+createRequesterPublicKeyValidationScenario({
+	title: 'State.apply removeIndexer rejects payloads when requester public key is invalid',
+	setupScenario: setupRemoveIndexerScenario,
+	buildValidPayload: context => buildRemoveIndexerPayload(context),
+	assertStateUnchanged: (t, context) => assertRemoveIndexerGuardFailureState(t, context, { skipSync: true }),
+	expectedLogs: ['Error while decoding requester public key.']
+}).performScenario();
+
+new InvalidAddressValidationScenario({
+	title: 'State.apply removeIndexer rejects payloads when target indexer address is invalid',
+	setupScenario: setupRemoveIndexerScenario,
+	buildValidPayload: context => buildRemoveIndexerPayload(context),
+	assertStateUnchanged: (t, context) => assertRemoveIndexerGuardFailureState(t, context, { skipSync: true }),
+	addressPath: ['aco', 'ia'],
+	expectedLogs: ['Target indexer address is invalid.']
+}).performScenario();
+
+createAddressWithInvalidPublicKeyScenario({
+	title: 'State.apply removeIndexer rejects payloads when target indexer public key is invalid',
+	setupScenario: setupRemoveIndexerScenario,
+	buildValidPayload: context => buildRemoveIndexerPayload(context),
+	assertStateUnchanged: (t, context) => assertRemoveIndexerGuardFailureState(t, context, { skipSync: true }),
+	addressPath: ['aco', 'ia'],
+	expectedLogs: ['Failed to decode target indexer public key.']
+}).performScenario();
+
+new AdminEntryMissingScenario({
+	title: 'State.apply removeIndexer rejects payloads when admin entry is missing',
+	setupScenario: setupRemoveIndexerScenario,
+	buildValidPayload: context => buildRemoveIndexerPayload(context),
+	assertStateUnchanged: (t, context) => assertRemoveIndexerGuardFailureState(t, context, { skipSync: true }),
+	expectedLogs: ['Invalid admin entry.']
+}).performScenario();
+
+new AdminEntryDecodeFailureScenario({
+	title: 'State.apply removeIndexer rejects payloads when admin entry cannot be decoded',
+	setupScenario: setupRemoveIndexerScenario,
+	buildValidPayload: context => buildRemoveIndexerPayload(context),
+	assertStateUnchanged: (t, context) => assertRemoveIndexerGuardFailureState(t, context, { skipSync: true }),
+	expectedLogs: ['Failed to decode admin entry.']
+}).performScenario();
+
+new AdminOnlyGuardScenario({
+	title: 'State.apply removeIndexer rejects non-admin nodes',
+	setupScenario: setupRemoveIndexerScenario,
+	buildValidPayload: context => buildRemoveIndexerPayload(context),
+	assertStateUnchanged: (t, context) => assertRemoveIndexerGuardFailureState(t, context, { skipSync: true }),
+	expectedLogs: ['Node is not allowed to perform this operation. (ADMIN ONLY)']
+}).performScenario();
+
+new AdminPublicKeyDecodeFailureScenario({
+	title: 'State.apply removeIndexer rejects payloads when admin public key cannot be decoded',
+	setupScenario: setupRemoveIndexerScenario,
+	buildValidPayload: context => buildRemoveIndexerPayload(context),
+	assertStateUnchanged: (t, context) => assertRemoveIndexerGuardFailureState(t, context, { skipSync: true }),
+	expectedLogs: ['Failed to decode admin public key.']
+}).performScenario();
+
+new AdminConsistencyMismatchScenario({
+	title: 'State.apply removeIndexer rejects payloads when admin public key mismatches requester',
+	setupScenario: setupRemoveIndexerScenario,
+	buildValidPayload: context => buildRemoveIndexerPayload(context),
+	assertStateUnchanged: (t, context) => assertRemoveIndexerGuardFailureState(t, context, { skipSync: true }),
+	expectedLogs: ['System admin and node public keys do not match.']
+}).performScenario();
+
+new InvalidHashValidationScenario({
+	title: 'State.apply removeIndexer rejects payloads when message hash mismatches tx hash',
+	setupScenario: setupRemoveIndexerScenario,
+	buildValidPayload: context => buildRemoveIndexerPayload(context),
+	assertStateUnchanged: (t, context) => assertRemoveIndexerFailureState(t, context, { skipSync: true }),
+	expectedLogs: ['Message hash does not match the tx_hash.']
+}).performScenario();
+
+new InvalidSignatureValidationScenario({
+	title: 'State.apply removeIndexer rejects payloads when admin signature is invalid (foreign signature)',
+	setupScenario: setupRemoveIndexerScenario,
+	buildValidPayload: context => buildRemoveIndexerPayload(context),
+	assertStateUnchanged: (t, context) => assertRemoveIndexerFailureState(t, context, { skipSync: true }),
+	expectedLogs: ['Failed to verify message signature.']
+}).performScenario();
+
+new InvalidSignatureValidationScenario({
+	title: 'State.apply removeIndexer rejects payloads when admin signature is invalid (zero fill)',
+	setupScenario: setupRemoveIndexerScenario,
+	buildValidPayload: context => buildRemoveIndexerPayload(context),
+	assertStateUnchanged: (t, context) => assertRemoveIndexerFailureState(t, context, { skipSync: true }),
+	strategy: SignatureMutationStrategy.ZERO_FILL,
+	expectedLogs: ['Failed to verify message signature.']
+}).performScenario();
+
+new InvalidSignatureValidationScenario({
+	title: 'State.apply removeIndexer rejects payloads when admin signature is invalid (type mismatch)',
+	setupScenario: setupRemoveIndexerScenario,
+	buildValidPayload: context => buildRemoveIndexerPayload(context),
+	assertStateUnchanged: (t, context) => assertRemoveIndexerFailureState(t, context, { skipSync: true }),
+	strategy: SignatureMutationStrategy.TYPE_MISMATCH,
+	expectedLogs: ['Failed to verify message signature.']
+}).performScenario();
+
+new IndexerSequenceStateInvalidScenario({
+	title: 'State.apply removeIndexer rejects payloads when indexer sequence state is invalid',
+	setupScenario: setupRemoveIndexerScenario,
+	buildValidPayload: context => buildRemoveIndexerPayload(context),
+	assertStateUnchanged: (t, context) => assertRemoveIndexerGuardFailureState(t, context, { skipSync: true }),
+	expectedLogs: ['Indexer sequence state is invalid.']
+}).performScenario();
+
+new TransactionValidityMismatchScenario({
+	title: 'State.apply removeIndexer rejects payloads when transaction validity mismatches indexer state',
+	setupScenario: setupRemoveIndexerScenario,
+	buildValidPayload: context => buildRemoveIndexerPayload(context),
+	assertStateUnchanged: (t, context) => assertRemoveIndexerFailureState(t, context, { skipSync: true }),
+	txValidityPath: ['aco', 'txv'],
+	rebuildPayloadWithTxValidity: ({ context, mutatedTxValidity }) =>
+		buildRemoveIndexerPayloadWithTxValidity(context, mutatedTxValidity),
+	expectedLogs: ['Transaction was not executed.']
+}).performScenario();
+
+new OperationAlreadyAppliedScenario({
+	title: 'State.apply removeIndexer rejects payloads when operation was already applied',
+	setupScenario: setupRemoveIndexerScenario,
+	buildValidPayload: context => buildRemoveIndexerPayload(context),
+	assertStateUnchanged: (t, context, validPayload) =>
+		assertRemoveIndexerSuccessState(t, context, {
+			indexerPeer: context.removeIndexerScenario?.indexerPeer ?? selectIndexerCandidatePeer(context),
+			adminPeer: context.adminBootstrap,
+			indexerEntryBefore: context.removeIndexerScenario?.indexerEntryBeforeRemoval,
+			adminEntryBefore: context.removeIndexerScenario?.adminEntryBeforeRemoval,
+			payload: validPayload,
+			writersLengthBefore: context.removeIndexerScenario?.writersLengthBeforeRemoval,
+			skipSync: true
+		}),
+	beforeInvalidApply: ({ context, node }) => {
+		const writerKey = context.removeIndexerScenario?.indexerPeer?.base?.local?.key;
+		if (!writerKey) return null;
+		return ensureIndexerRegistration(node.base, writerKey);
+	},
+	expectedLogs: ['Operation has already been applied.']
+}).performScenario();
+
+new IndexerNodeEntryMissingScenario({
+	title: 'State.apply removeIndexer rejects payloads when target indexer entry is missing',
+	setupScenario: setupRemoveIndexerScenario,
+	buildValidPayload: context => buildRemoveIndexerPayload(context),
+	assertStateUnchanged: (t, context) => assertRemoveIndexerFailureState(t, context, { skipSync: true }),
+	selectPeer: context => context.removeIndexerScenario?.indexerPeer ?? selectIndexerCandidatePeer(context),
+	expectedLogs: ['Failed to verify target indexer entry.']
+}).performScenario();
+
+new IndexerNodeEntryDecodeFailureScenario({
+	title: 'State.apply removeIndexer rejects payloads when target indexer entry cannot be decoded',
+	setupScenario: setupRemoveIndexerScenario,
+	buildValidPayload: context => buildRemoveIndexerPayload(context),
+	assertStateUnchanged: (t, context) => assertRemoveIndexerFailureState(t, context, { skipSync: true }),
+	selectPeer: context => context.removeIndexerScenario?.indexerPeer ?? selectIndexerCandidatePeer(context),
+	expectedLogs: ['Failed to decode target indexer node entry.']
+}).performScenario();
+
+removeIndexerTargetNotIndexerScenario();
+
+new IndexerRoleUpdateFailureScenario({
+	title: 'State.apply removeIndexer rejects payloads when node role update fails',
+	setupScenario: setupRemoveIndexerScenario,
+	buildValidPayload: context => buildRemoveIndexerPayload(context),
+	assertStateUnchanged: (t, context) => assertRemoveIndexerGuardFailureState(t, context, { skipSync: true }),
+	applyRoleMutationFailure: applyWithRemoveIndexerRoleUpdateFailure,
+	expectedLogs: ['Failed to update node role.']
+}).performScenario();
+
+removeIndexerWriterKeyMissingScenario();
+
+new RequesterNodeEntryMissingScenario({
+	title: 'State.apply removeIndexer rejects payloads when requester node entry is missing',
+	setupScenario: setupRemoveIndexerScenario,
+	buildValidPayload: context => buildRemoveIndexerPayload(context),
+	assertStateUnchanged: (t, context) => assertRemoveIndexerFailureState(t, context, { skipSync: true }),
+	selectPeer: context => context.adminBootstrap,
+	expectedLogs: ['Invalid requester node entry.']
+}).performScenario();
+
+new OperationValidationScenarioBase({
+	title: 'State.apply removeIndexer rejects payloads when requester node entry cannot be decoded',
+	setupScenario: setupRemoveIndexerScenario,
+	buildValidPayload: context => buildRemoveIndexerPayload(context),
+	mutatePayload: (_t, payload) => payload,
+	applyInvalidPayload: (context, invalidPayload) =>
+		applyWithRequesterEntryCorruption(context, invalidPayload, { peer: context.adminBootstrap }),
+	assertStateUnchanged: (t, context) => assertRemoveIndexerFailureState(t, context, { skipSync: true }),
+	expectedLogs: ['Failed to decode requester node entry.']
+}).performScenario();
+
+new RequesterBalanceScenarioBase({
+	title: 'State.apply removeIndexer rejects payloads when admin balance cannot be decoded',
+	setupScenario: setupRemoveIndexerScenario,
+	buildValidPayload: context => buildRemoveIndexerPayload(context),
+	assertStateUnchanged: (t, context) => assertRemoveIndexerFailureState(t, context, { skipSync: true }),
+	mutateDecodedEntry: decoded => ({ ...decoded, balance: decoded.balance ? decoded.balance.subarray(0, 1) : null }),
+	selectPeer: context => context.adminBootstrap,
+	expectedLogs: ['Invalid admin balance.']
+}).performScenario();
+
+new RequesterBalanceInsufficientScenario({
+	title: 'State.apply removeIndexer rejects payloads when requester balance is insufficient',
+	setupScenario: setupRemoveIndexerScenario,
+	buildValidPayload: context => buildRemoveIndexerPayload(context),
+	assertStateUnchanged: (t, context) => assertRemoveIndexerFailureState(t, context, { skipSync: true }),
+	selectPeer: context => context.adminBootstrap
+}).performScenario();
+
+new RequesterBalanceFeeApplicationFailureScenario({
+	title: 'State.apply removeIndexer rejects payloads when requester fee cannot be applied',
+	setupScenario: setupRemoveIndexerScenario,
+	buildValidPayload: context => buildRemoveIndexerPayload(context),
+	assertStateUnchanged: (t, context) => assertRemoveIndexerFailureState(t, context, { skipSync: true }),
+	selectPeer: context => context.adminBootstrap
+}).performScenario();
+
+new RequesterBalanceScenarioBase({
+	title: 'State.apply removeIndexer rejects payloads when requester balance update fails',
+	setupScenario: setupRemoveIndexerScenario,
+	buildValidPayload: context => buildRemoveIndexerPayload(context),
+	assertStateUnchanged: (t, context) => assertRemoveIndexerFailureState(t, context, { skipSync: true }),
+	selectPeer: context => context.adminBootstrap,
+	failNextBalanceUpdate: true,
+	expectedLogs: ['Failed to update requester node.']
+}).performScenario();

package/tests/unit/state/apply/removeWriter/removeWriterAndAddWriterAgainScenario.js

@@ -0,0 +1,87 @@
+import { test } from 'brittle';
+import b4a from 'b4a';
+import nodeEntryUtils from '../../../../../src/core/state/utils/nodeEntry.js';
+import {
+	setupRemoveWriterScenario,
+	selectWriterPeer,
+	buildRemoveWriterPayload,
+	assertRemoveWriterSuccessState
+} from './removeWriterScenarioHelpers.js';
+import {
+	buildAddWriterPayload,
+	assertAddWriterSuccessState
+} from '../addWriter/addWriterScenarioHelpers.js';
+import { eventFlush } from '../../../../helpers/autobaseTestHelpers.js';
+import lengthEntryUtils from '../../../../../src/core/state/utils/lengthEntry.js';
+import { EntryType } from '../../../../../src/utils/constants.js';
+
+export default function removeWriterAndAddWriterAgainScenario() {
+	test('State.apply removeWriter followed by addWriter re-promotes the same node', async t => {
+		const context = await setupRemoveWriterScenario(t);
+		const validatorPeer = context.adminBootstrap;
+		const writerPeer = selectWriterPeer(context);
+		const writerAddress = writerPeer.wallet.address;
+
+		const writerEntryBeforeRemoval = await validatorPeer.base.view.get(writerAddress);
+		t.ok(writerEntryBeforeRemoval, 'writer entry exists before removeWriter');
+		const validatorEntryBeforeRemoval = await validatorPeer.base.view.get(
+			validatorPeer.wallet.address
+		);
+		t.ok(validatorEntryBeforeRemoval, 'validator entry exists before removeWriter');
+
+		const removeWriterPayload = await buildRemoveWriterPayload(context, {
+			readerPeer: writerPeer,
+			validatorPeer
+		});
+
+		await validatorPeer.base.append(removeWriterPayload);
+		await validatorPeer.base.update();
+		await eventFlush();
+
+		await assertRemoveWriterSuccessState(t, context, {
+			writerPeer,
+			validatorPeer,
+			writerEntryBefore: writerEntryBeforeRemoval,
+			validatorEntryBefore: validatorEntryBeforeRemoval,
+			payload: removeWriterPayload
+		});
+
+		const validatorEntryBeforeReAdd = await validatorPeer.base.view.get(
+			validatorPeer.wallet.address
+		);
+		t.ok(validatorEntryBeforeReAdd, 'validator entry exists before addWriter re-promotion');
+		const decodedValidatorBeforeReAdd = nodeEntryUtils.decode(validatorEntryBeforeReAdd.value);
+		t.ok(decodedValidatorBeforeReAdd, 'validator entry decodes before addWriter re-promotion');
+
+		const writerEntryAfterRemoval = await validatorPeer.base.view.get(writerAddress);
+		t.ok(writerEntryAfterRemoval, 'writer entry exists after removeWriter');
+		const decodedWriterAfterRemoval = nodeEntryUtils.decode(writerEntryAfterRemoval.value);
+		t.ok(decodedWriterAfterRemoval, 'writer entry decodes after removeWriter');
+
+		const writerBalanceBeforeReAdd = b4a.from(decodedWriterAfterRemoval.balance);
+		const validatorBalanceBeforeReAdd = b4a.from(decodedValidatorBeforeReAdd.balance);
+		const writersLengthEntry = await validatorPeer.base.view.get(EntryType.WRITERS_LENGTH);
+		const nextWriterIndex = writersLengthEntry
+			? lengthEntryUtils.decodeBE(writersLengthEntry.value)
+			: 0;
+
+		const reAddPayload = await buildAddWriterPayload(context, {
+			readerPeer: writerPeer,
+			validatorPeer
+		});
+
+		await validatorPeer.base.append(reAddPayload);
+		await validatorPeer.base.update();
+		await eventFlush();
+
+		await assertAddWriterSuccessState(t, context, {
+			readerPeer: writerPeer,
+			validatorPeer,
+			writerInitialBalance: writerBalanceBeforeReAdd,
+			validatorBalanceBefore: validatorBalanceBeforeReAdd,
+			payload: reAddPayload,
+			writerKeyBuffer: writerPeer.base.local.key,
+			expectedWriterIndex: nextWriterIndex
+		});
+	});
+}

package/tests/unit/state/apply/removeWriter/removeWriterHappyPathScenario.js

@@ -0,0 +1,38 @@
+import { test } from 'brittle';
+import { eventFlush } from '../../../../helpers/autobaseTestHelpers.js';
+import {
+	setupRemoveWriterScenario,
+	selectWriterPeer,
+	buildRemoveWriterPayload,
+	assertRemoveWriterSuccessState
+} from './removeWriterScenarioHelpers.js';
+
+export default function removeWriterHappyPathScenario() {
+	test('State.apply removeWriter demotes writers and refunds stake - happy path', async t => {
+		const context = await setupRemoveWriterScenario(t);
+		const validatorPeer = context.adminBootstrap;
+		const writerPeer = selectWriterPeer(context);
+
+		const writerEntryBefore = await validatorPeer.base.view.get(writerPeer.wallet.address);
+		t.ok(writerEntryBefore, 'writer entry exists before removeWriter');
+		const validatorEntryBefore = await validatorPeer.base.view.get(validatorPeer.wallet.address);
+		t.ok(validatorEntryBefore, 'validator entry exists before removeWriter');
+
+		const payload = await buildRemoveWriterPayload(context, {
+			readerPeer: writerPeer,
+			validatorPeer
+		});
+
+		await validatorPeer.base.append(payload);
+		await validatorPeer.base.update();
+		await eventFlush();
+
+		await assertRemoveWriterSuccessState(t, context, {
+			writerPeer,
+			validatorPeer,
+			writerEntryBefore,
+			validatorEntryBefore,
+			payload
+		});
+	});
+}

package/tests/unit/state/apply/removeWriter/removeWriterInvalidValidatorSignatureScenario.js

@@ -0,0 +1,32 @@
+import b4a from 'b4a';
+import OperationValidationScenarioBase from '../common/base/OperationValidationScenarioBase.js';
+import { safeDecodeApplyOperation, safeEncodeApplyOperation } from '../../../../../src/utils/protobuf/operationHelpers.js';
+import {
+	setupRemoveWriterScenario,
+	buildRemoveWriterPayload,
+	assertRemoveWriterFailureState
+} from './removeWriterScenarioHelpers.js';
+import { applyWithRoleAccessBypass } from '../addWriter/addWriterScenarioHelpers.js';
+
+function mutateValidatorSignature(t, validPayload) {
+	const decoded = safeDecodeApplyOperation(validPayload);
+	t.ok(decoded, 'fixtures decode');
+	const parent = decoded?.rao;
+	if (!parent?.vs) return validPayload;
+	const mutated = b4a.from(parent.vs);
+	mutated[mutated.length - 1] ^= 0xff;
+	parent.vs = mutated;
+	return safeEncodeApplyOperation(decoded);
+}
+
+export default function removeWriterInvalidValidatorSignatureScenario() {
+	new OperationValidationScenarioBase({
+		title: 'State.apply removeWriter rejects payloads when validator signature is invalid',
+		setupScenario: setupRemoveWriterScenario,
+		buildValidPayload: context => buildRemoveWriterPayload(context),
+		mutatePayload: mutateValidatorSignature,
+		applyInvalidPayload: applyWithRoleAccessBypass,
+		assertStateUnchanged: assertRemoveWriterFailureState,
+		expectedLogs: ['Failed to verify validator message signature.']
+	}).performScenario();
+}

package/tests/unit/state/apply/removeWriter/removeWriterRequesterBalanceInsufficientScenario.js

@@ -0,0 +1,21 @@
+import b4a from 'b4a';
+import RequesterBalanceScenarioBase from '../common/balances/base/requesterBalanceScenarioBase.js';
+import {
+	setupRemoveWriterScenario,
+	buildRemoveWriterPayload,
+	assertRemoveWriterFailureState,
+	selectWriterPeer
+} from './removeWriterScenarioHelpers.js';
+
+export default function removeWriterRequesterBalanceInsufficientScenario() {
+	new RequesterBalanceScenarioBase({
+		title: 'State.apply removeWriter rejects payloads when requester balance is insufficient',
+		setupScenario: setupRemoveWriterScenario,
+		buildValidPayload: context => buildRemoveWriterPayload(context),
+		assertStateUnchanged: (t, context) => assertRemoveWriterFailureState(t, context, { skipSync: true }),
+		selectPeer: selectWriterPeer,
+		mutateDecodedEntry: decoded =>
+			decoded ? { ...decoded, balance: b4a.alloc(decoded.balance.length) } : decoded,
+		expectedLogs: ['Insufficient requester balance.', 'Remove writer operation ignored.']
+	}).performScenario();
+}

package/tests/unit/state/apply/removeWriter/removeWriterRequesterEntryDecodeFailureScenario.js

@@ -0,0 +1,19 @@
+import OperationValidationScenarioBase from '../common/base/OperationValidationScenarioBase.js';
+import {
+	setupRemoveWriterScenario,
+	buildRemoveWriterPayload,
+	assertRemoveWriterFailureState
+} from './removeWriterScenarioHelpers.js';
+import { applyWithRequesterEntryCorruption } from '../addWriter/addWriterScenarioHelpers.js';
+
+export default function removeWriterRequesterEntryDecodeFailureScenario() {
+	new OperationValidationScenarioBase({
+		title: 'State.apply removeWriter rejects payloads when requester entry cannot be decoded',
+		setupScenario: setupRemoveWriterScenario,
+		buildValidPayload: context => buildRemoveWriterPayload(context),
+		mutatePayload: (_t, payload) => payload,
+		applyInvalidPayload: applyWithRequesterEntryCorruption,
+		assertStateUnchanged: (t, context) => assertRemoveWriterFailureState(t, context, { skipSync: true }),
+		expectedLogs: ['Failed to decode requester node entry.']
+	}).performScenario();
+}

package/tests/unit/state/apply/removeWriter/removeWriterRequesterEntryMissingScenario.js

@@ -0,0 +1,19 @@
+import OperationValidationScenarioBase from '../common/base/OperationValidationScenarioBase.js';
+import {
+	setupRemoveWriterScenario,
+	buildRemoveWriterPayload,
+	assertRemoveWriterFailureState
+} from './removeWriterScenarioHelpers.js';
+import { applyWithRequesterEntryRemoval } from '../addWriter/addWriterScenarioHelpers.js';
+
+export default function removeWriterRequesterEntryMissingScenario() {
+	new OperationValidationScenarioBase({
+		title: 'State.apply removeWriter rejects payloads when requester entry is missing',
+		setupScenario: setupRemoveWriterScenario,
+		buildValidPayload: context => buildRemoveWriterPayload(context),
+		mutatePayload: (_t, payload) => payload,
+		applyInvalidPayload: applyWithRequesterEntryRemoval,
+		assertStateUnchanged: (t, context) => assertRemoveWriterFailureState(t, context, { skipSync: true }),
+		expectedLogs: ['Failed to verify requester node entry.']
+	}).performScenario();
+}

package/tests/unit/state/apply/removeWriter/removeWriterRequesterIndexerScenario.js

@@ -0,0 +1,21 @@
+import OperationValidationScenarioBase from '../common/base/OperationValidationScenarioBase.js';
+import {
+	setupRemoveWriterScenario,
+	buildRemoveWriterPayload,
+	assertRemoveWriterFailureState
+} from './removeWriterScenarioHelpers.js';
+import nodeRoleUtils from '../../../../../src/core/state/utils/roles.js';
+import { applyWithRequesterRoleOverride } from '../addWriter/addWriterScenarioHelpers.js';
+
+export default function removeWriterRequesterIndexerScenario() {
+	new OperationValidationScenarioBase({
+		title: 'State.apply removeWriter rejects payloads when requester is an indexer',
+		setupScenario: setupRemoveWriterScenario,
+		buildValidPayload: context => buildRemoveWriterPayload(context),
+		mutatePayload: (_t, payload) => payload,
+		applyInvalidPayload: (context, invalidPayload) =>
+			applyWithRequesterRoleOverride(context, invalidPayload, nodeRoleUtils.NodeRole.INDEXER),
+		assertStateUnchanged: (t, context) => assertRemoveWriterFailureState(t, context, { skipSync: true }),
+		expectedLogs: ['Node has to be a writer, and cannot be an indexer.']
+	}).performScenario();
+}

package/tests/unit/state/apply/removeWriter/removeWriterRequesterNotWriterScenario.js

@@ -0,0 +1,21 @@
+import OperationValidationScenarioBase from '../common/base/OperationValidationScenarioBase.js';
+import {
+	setupRemoveWriterScenario,
+	buildRemoveWriterPayload,
+	assertRemoveWriterFailureState
+} from './removeWriterScenarioHelpers.js';
+import nodeRoleUtils from '../../../../../src/core/state/utils/roles.js';
+import { applyWithRequesterRoleOverride } from '../addWriter/addWriterScenarioHelpers.js';
+
+export default function removeWriterRequesterNotWriterScenario() {
+	new OperationValidationScenarioBase({
+		title: 'State.apply removeWriter rejects payloads when requester is not a writer',
+		setupScenario: setupRemoveWriterScenario,
+		buildValidPayload: context => buildRemoveWriterPayload(context),
+		mutatePayload: (_t, payload) => payload,
+		applyInvalidPayload: (context, invalidPayload) =>
+			applyWithRequesterRoleOverride(context, invalidPayload, nodeRoleUtils.NodeRole.READER),
+		assertStateUnchanged: (t, context) => assertRemoveWriterFailureState(t, context, { skipSync: true }),
+		expectedLogs: ['Node has to be a writer, and cannot be an indexer.', 'Failed to remove writer.']
+	}).performScenario();
+}

package/tests/unit/state/apply/removeWriter/removeWriterRequesterRoleUpdateFailureScenario.js

@@ -0,0 +1,19 @@
+import OperationValidationScenarioBase from '../common/base/OperationValidationScenarioBase.js';
+import {
+	setupRemoveWriterScenario,
+	buildRemoveWriterPayload,
+	assertRemoveWriterFailureState,
+	applyWithRequesterRoleMutationFailure
+} from './removeWriterScenarioHelpers.js';
+
+export default function removeWriterRequesterRoleUpdateFailureScenario() {
+	new OperationValidationScenarioBase({
+		title: 'State.apply removeWriter rejects payloads when requester role cannot be updated',
+		setupScenario: setupRemoveWriterScenario,
+		buildValidPayload: context => buildRemoveWriterPayload(context),
+		mutatePayload: (_t, payload) => payload,
+		applyInvalidPayload: applyWithRequesterRoleMutationFailure,
+		assertStateUnchanged: (t, context) => assertRemoveWriterFailureState(t, context, { skipSync: true }),
+		expectedLogs: ['Failed to update node entry role.']
+	}).performScenario();
+}