trac-msb 0.2.4 → 0.2.6

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

@@ -0,0 +1,161 @@
+import InvalidPayloadValidationScenario from '../common/payload-structure/invalidPayloadValidationScenario.js';
+import AdminEntryDecodeFailureScenario from '../common/access-control/adminEntryDecodeFailureScenario.js';
+import AdminPublicKeyDecodeFailureScenario from '../common/access-control/adminPublicKeyDecodeFailureScenario.js';
+import AdminOnlyGuardScenario from '../common/access-control/adminOnlyGuardScenario.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 RequesterAddressValidationScenario from '../common/requesterAddressValidationScenario.js';
+import createRequesterPublicKeyValidationScenario from '../common/requesterPublicKeyValidationScenario.js';
+import IndexerSequenceStateInvalidScenario from '../common/indexer/indexerSequenceStateInvalidScenario.js';
+import disableInitializationHappyPathScenario from './disableInitializationHappyPathScenario.js';
+import disableInitializationAlreadyDisabledScenario from './disableInitializationAlreadyDisabledScenario.js';
+import {
+	setupDisableInitializationScenario,
+	buildDisableInitializationPayload,
+	buildDisableInitializationPayloadWithTxValidity,
+	mutateDisableInitializationPayloadForInvalidSchema,
+	assertDisableInitializationFailureState,
+	assertInitializationDisabledState,
+	bypassDisableInitializationAlreadyDisabledGuardOnce
+} from './disableInitializationScenarioHelpers.js';
+
+disableInitializationHappyPathScenario();
+
+new InvalidPayloadValidationScenario({
+	title: 'State.apply disableInitialization rejects payloads that fail schema validation',
+	setupScenario: setupDisableInitializationScenario,
+	buildValidPayload: buildDisableInitializationPayload,
+	mutatePayload: mutateDisableInitializationPayloadForInvalidSchema,
+	assertStateUnchanged: assertDisableInitializationFailureState,
+	expectedLogs: ['Schema validation failed.']
+}).performScenario();
+
+disableInitializationAlreadyDisabledScenario();
+
+new RequesterAddressValidationScenario({
+	title: 'State.apply disableInitialization requester address is invalid',
+	setupScenario: setupDisableInitializationScenario,
+	buildValidPayload: buildDisableInitializationPayload,
+	assertStateUnchanged: assertDisableInitializationFailureState,
+	expectedLogs: ['Failed to validate requester address.']
+}).performScenario();
+
+createRequesterPublicKeyValidationScenario({
+	title: 'State.apply disableInitialization requester public key is invalid',
+	setupScenario: setupDisableInitializationScenario,
+	buildValidPayload: buildDisableInitializationPayload,
+	assertStateUnchanged: assertDisableInitializationFailureState,
+	expectedLogs: ['Failed to decode requester public key.']
+}).performScenario();
+
+new AdminEntryDecodeFailureScenario({
+	title: 'State.apply disableInitialization aborts when admin entry cannot be decoded',
+	setupScenario: setupDisableInitializationScenario,
+	buildValidPayload: buildDisableInitializationPayload,
+	assertStateUnchanged: (t, context, validPayload) =>
+		assertDisableInitializationFailureState(t, context, { skipSync: true, validPayload }),
+	expectedLogs: ['Failed to decode admin entry.']
+}).performScenario();
+
+new AdminOnlyGuardScenario({
+	title: 'State.apply disableInitialization rejects non-admin nodes',
+	setupScenario: setupDisableInitializationScenario,
+	buildValidPayload: buildDisableInitializationPayload,
+	assertStateUnchanged: (t, context, validPayload) =>
+		assertDisableInitializationFailureState(t, context, { skipSync: true, validPayload }),
+	expectedLogs: ['Node is not allowed to perform this operation. (ADMIN ONLY)']
+}).performScenario();
+
+new AdminPublicKeyDecodeFailureScenario({
+	title: 'State.apply disableInitialization aborts when admin public key cannot be decoded',
+	setupScenario: setupDisableInitializationScenario,
+	buildValidPayload: buildDisableInitializationPayload,
+	assertStateUnchanged: (t, context, validPayload) =>
+		assertDisableInitializationFailureState(t, context, { skipSync: true, validPayload }),
+	expectedLogs: ['Failed to decode admin public key.']
+}).performScenario();
+
+new AdminConsistencyMismatchScenario({
+	title: 'State.apply disableInitialization rejects when admin key mismatch occurs',
+	setupScenario: setupDisableInitializationScenario,
+	buildValidPayload: buildDisableInitializationPayload,
+	assertStateUnchanged: (t, context, validPayload) =>
+		assertDisableInitializationFailureState(t, context, { skipSync: true, validPayload }),
+	expectedLogs: ['System admin and node public keys do not match.']
+}).performScenario();
+
+new InvalidHashValidationScenario({
+	title: 'State.apply disableInitialization requester message hash mismatch',
+	setupScenario: setupDisableInitializationScenario,
+	buildValidPayload: buildDisableInitializationPayload,
+	assertStateUnchanged: assertDisableInitializationFailureState,
+	expectedLogs: ['Message hash does not match the tx_hash.']
+}).performScenario();
+
+new InvalidSignatureValidationScenario({
+	title: 'State.apply disableInitialization requester signature is invalid (foreign signature)',
+	setupScenario: setupDisableInitializationScenario,
+	buildValidPayload: buildDisableInitializationPayload,
+	assertStateUnchanged: assertDisableInitializationFailureState,
+	expectedLogs: ['Failed to verify message signature.']
+}).performScenario();
+
+new InvalidSignatureValidationScenario({
+	title: 'State.apply disableInitialization requester signature is invalid (zero fill)',
+	setupScenario: setupDisableInitializationScenario,
+	buildValidPayload: buildDisableInitializationPayload,
+	assertStateUnchanged: assertDisableInitializationFailureState,
+	strategy: SignatureMutationStrategy.ZERO_FILL,
+	expectedLogs: ['Failed to verify message signature.']
+}).performScenario();
+
+new InvalidSignatureValidationScenario({
+	title: 'State.apply disableInitialization requester signature is invalid (type mismatch)',
+	setupScenario: setupDisableInitializationScenario,
+	buildValidPayload: buildDisableInitializationPayload,
+	assertStateUnchanged: assertDisableInitializationFailureState,
+	strategy: SignatureMutationStrategy.TYPE_MISMATCH,
+	expectedLogs: ['Failed to verify message signature.']
+}).performScenario();
+
+new IndexerSequenceStateInvalidScenario({
+	title: 'State.apply disableInitialization rejects payload when indexer sequence state is invalid',
+	setupScenario: setupDisableInitializationScenario,
+	buildValidPayload: buildDisableInitializationPayload,
+	assertStateUnchanged: (t, context, validPayload, invalidPayload) =>
+		assertDisableInitializationFailureState(t, context, {
+			skipSync: true,
+			validPayload: invalidPayload ?? validPayload
+		}),
+	expectedLogs: ['Indexer sequence state is invalid.']
+}).performScenario();
+
+new TransactionValidityMismatchScenario({
+	title: 'State.apply disableInitialization rejects payload when tx validity mismatches indexer state',
+	setupScenario: setupDisableInitializationScenario,
+	buildValidPayload: buildDisableInitializationPayload,
+	assertStateUnchanged: assertDisableInitializationFailureState,
+	rebuildPayloadWithTxValidity: ({ context, mutatedTxValidity }) =>
+		buildDisableInitializationPayloadWithTxValidity(context, mutatedTxValidity),
+	expectedLogs: ['Transaction was not executed.']
+}).performScenario();
+
+new OperationAlreadyAppliedScenario({
+	title: 'State.apply disableInitialization rejects duplicate operations',
+	setupScenario: setupDisableInitializationScenario,
+	buildValidPayload: buildDisableInitializationPayload,
+	assertStateUnchanged: async (t, context, validPayload) => {
+		const adminNode = context.adminBootstrap;
+		const readerNode = context.peers?.[1];
+		await assertInitializationDisabledState(t, adminNode.base, validPayload);
+		if (readerNode) {
+			await context.sync();
+			await assertInitializationDisabledState(t, readerNode.base, validPayload);
+		}
+	},
+	beforeInvalidApply: ({ context }) => bypassDisableInitializationAlreadyDisabledGuardOnce(context),
+	expectedLogs: ['Operation has already been applied.']
+}).performScenario();

package/tests/unit/state/apply/missing-tests.md

@@ -0,0 +1,18 @@
+# Missing guard coverage in `src/core/state/State.js`
+
+Unit tests under `tests/unit/state/apply` still lack scenarios for these guard logs:
+
+- `handleApplyInitializeBalanceOperation`: “Invalid requester message.”
+- `handleApplyDisableBalanceInitializationOperation`: “Invalid requester message.”
+- `handleApplyAddAdminOperation`: “Invalid requester message.”, “Something went wrong while updating license index.”, “Something went wrong while updating writers index.”
+- `handleApplyAddIndexerOperation`: “Invalid requester message.”
+- `handleApplyRemoveIndexerOperation`: “Invalid requester message.”
+- `handleApplyAddWriterOperation` / `#addWriter`: “Invalid requester message.”, “Invalid validator message.”, “Failed to add writer.”, “Add writer operation ignored.”, “Failed to update node entry with a writer role.”, “Something went wrong while updating writers index.”
+- `handleApplyRemoveWriterOperation` / `#removeWriter`: “Invalid requester message.”, “Invalid validator message.”, “Failed to remove writer.”, “Remove writer operation ignored.”, “Failed to decode validator node entry.”
+- `handleApplyBanValidatorOperation`: “Invalid requester message.”
+- `handleApplyBootstrapDeploymentOperation`: “Invalid requester message.”, “Invalid validator message.”
+- `handleApplyTxOperation`: “Invalid requester message.”, “Invalid validator message.”
+- `handleApplyTransferOperation`: “Invalid requester message.”, “Invalid validator message.”
+- `#withdrawStakedBalanceApply`: “Invalid staked balance.”, “No staked balance to unstake.”, “Invalid current balance.”, “Failed to add staked balance to current balance.”
+- `#validatorPenaltyApply`: “Admin entry not found.”, “Admin cannot be penalized.”
+- `#transferFeeTxOperation`: “Invalid incoming data.”

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

@@ -0,0 +1,58 @@
+import b4a from 'b4a';
+import { test } from 'brittle';
+import { eventFlush } from '../../../../helpers/autobaseTestHelpers.js';
+import { EntryType } from '../../../../../src/utils/constants.js';
+import { selectIndexerCandidatePeer } from '../addIndexer/addIndexerScenarioHelpers.js';
+import {
+	setupRemoveIndexerScenario,
+	buildRemoveIndexerPayload,
+	assertRemoveIndexerSuccessState
+} from './removeIndexerScenarioHelpers.js';
+
+export default function removeIndexerHappyPathScenario() {
+	test('State.apply removeIndexer downgrades indexers to writers (happy path)', async t => {
+		const context = await setupRemoveIndexerScenario(t);
+		const adminPeer = context.adminBootstrap;
+		const indexerPeer =
+			context.removeIndexerScenario?.indexerPeer ?? selectIndexerCandidatePeer(context);
+
+		const indexerEntryBefore =
+			context.removeIndexerScenario?.indexerEntryBeforeRemoval ??
+			(await adminPeer.base.view.get(indexerPeer.wallet.address));
+		t.ok(indexerEntryBefore, 'indexer entry exists before removeIndexer');
+
+		const adminEntryBefore =
+			context.removeIndexerScenario?.adminEntryBeforeRemoval ??
+			(await adminPeer.base.view.get(adminPeer.wallet.address));
+		t.ok(adminEntryBefore, 'admin entry exists before removeIndexer');
+
+		const writersLengthBefore =
+			context.removeIndexerScenario?.writersLengthBeforeRemoval ??
+			(await readWritersLength(adminPeer.base));
+
+		const payload = await buildRemoveIndexerPayload(context, {
+			indexerPeer,
+			adminPeer
+		});
+
+		await adminPeer.base.append(payload);
+		await adminPeer.base.update();
+		await eventFlush();
+
+		await assertRemoveIndexerSuccessState(t, context, {
+			indexerPeer,
+			adminPeer,
+			indexerEntryBefore: { value: b4a.from(indexerEntryBefore.value) },
+			adminEntryBefore: { value: b4a.from(adminEntryBefore.value) },
+			payload,
+			writersLengthBefore,
+			skipSync: true
+		});
+	});
+}
+
+async function readWritersLength(base) {
+	const entry = await base.view.get(EntryType.WRITERS_LENGTH);
+	if (!entry?.value) return 0;
+	return entry.value.readUInt32BE();
+}

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

@@ -0,0 +1,98 @@
+import b4a from 'b4a';
+import { test } from 'brittle';
+import { eventFlush } from '../../../../helpers/autobaseTestHelpers.js';
+import { EntryType } from '../../../../../src/utils/constants.js';
+import {
+	setupRemoveIndexerScenario,
+	buildRemoveIndexerPayload,
+	assertRemoveIndexerSuccessState
+} from './removeIndexerScenarioHelpers.js';
+import {
+	buildAddIndexerPayload,
+	assertAddIndexerSuccessState,
+	selectIndexerCandidatePeer
+} from '../addIndexer/addIndexerScenarioHelpers.js';
+
+export default function removeIndexerReAddAndRemoveAgainScenario() {
+	test('State.apply removeIndexer can re-downgrade a re-promoted indexer without index drift', async t => {
+		const context = await setupRemoveIndexerScenario(t, { nodes: 4 });
+		const adminPeer = context.adminBootstrap;
+		const indexerPeer =
+			context.removeIndexerScenario?.indexerPeer ?? selectIndexerCandidatePeer(context);
+
+		// First removeIndexer
+		const writersLengthBeforeFirstRemove =
+			context.removeIndexerScenario?.writersLengthBeforeRemoval ??
+			(await readWritersLength(adminPeer.base));
+		const indexerEntryBeforeFirstRemove =
+			context.removeIndexerScenario?.indexerEntryBeforeRemoval ??
+			(await adminPeer.base.view.get(indexerPeer.wallet.address));
+		const adminEntryBeforeFirstRemove =
+			context.removeIndexerScenario?.adminEntryBeforeRemoval ??
+			(await adminPeer.base.view.get(adminPeer.wallet.address));
+
+		const firstRemovePayload = await buildRemoveIndexerPayload(context, {
+			indexerPeer,
+			adminPeer
+		});
+		await adminPeer.base.append(firstRemovePayload);
+		await adminPeer.base.update();
+		await eventFlush();
+
+		await assertRemoveIndexerSuccessState(t, context, {
+			indexerPeer,
+			adminPeer,
+			indexerEntryBefore: { value: b4a.from(indexerEntryBeforeFirstRemove.value) },
+			adminEntryBefore: { value: b4a.from(adminEntryBeforeFirstRemove.value) },
+			payload: firstRemovePayload,
+			writersLengthBefore: writersLengthBeforeFirstRemove,
+			skipSync: true
+		});
+
+		// Re-add as indexer
+		const writerEntryBeforeReAdd = await adminPeer.base.view.get(indexerPeer.wallet.address);
+		const adminEntryBeforeReAdd = await adminPeer.base.view.get(adminPeer.wallet.address);
+		const reAddPayload = await buildAddIndexerPayload(context, { writerPeer: indexerPeer, adminPeer });
+		await adminPeer.base.append(reAddPayload);
+		await adminPeer.base.update();
+		await eventFlush();
+
+		await assertAddIndexerSuccessState(t, context, {
+			writerPeer: indexerPeer,
+			adminPeer,
+			writerEntryBefore: { value: b4a.from(writerEntryBeforeReAdd.value) },
+			adminEntryBefore: { value: b4a.from(adminEntryBeforeReAdd.value) },
+			payload: reAddPayload,
+			skipSync: true
+		});
+
+		// Second removeIndexer
+		const writersLengthBeforeSecondRemove = await readWritersLength(adminPeer.base);
+		const indexerEntryBeforeSecondRemove = await adminPeer.base.view.get(indexerPeer.wallet.address);
+		const adminEntryBeforeSecondRemove = await adminPeer.base.view.get(adminPeer.wallet.address);
+		const secondRemovePayload = await buildRemoveIndexerPayload(context, {
+			indexerPeer,
+			adminPeer
+		});
+
+		await adminPeer.base.append(secondRemovePayload);
+		await adminPeer.base.update();
+		await eventFlush();
+
+		await assertRemoveIndexerSuccessState(t, context, {
+			indexerPeer,
+			adminPeer,
+			indexerEntryBefore: { value: b4a.from(indexerEntryBeforeSecondRemove.value) },
+			adminEntryBefore: { value: b4a.from(adminEntryBeforeSecondRemove.value) },
+			payload: secondRemovePayload,
+			writersLengthBefore: writersLengthBeforeSecondRemove,
+			skipSync: true
+		});
+	});
+}
+
+async function readWritersLength(base) {
+	const entry = await base.view.get(EntryType.WRITERS_LENGTH);
+	if (!entry?.value) return 0;
+	return entry.value.readUInt32BE();
+}

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

@@ -0,0 +1,167 @@
+import b4a from 'b4a';
+import { test } from 'brittle';
+import nodeEntryUtils from '../../../../../src/core/state/utils/nodeEntry.js';
+import { EntryType } from '../../../../../src/utils/constants.js';
+import lengthEntryUtils from '../../../../../src/core/state/utils/lengthEntry.js';
+import { eventFlush } from '../../../../helpers/autobaseTestHelpers.js';
+import { initializeBalances, whitelistAddress } from '../common/commonScenarioHelper.js';
+import { promotePeerToWriter } from '../addWriter/addWriterScenarioHelpers.js';
+import {
+	setupAddIndexerScenario,
+	selectIndexerCandidatePeer,
+	buildAddIndexerPayload,
+	assertAddIndexerSuccessState,
+	ensureIndexerRegistration
+} from '../addIndexer/addIndexerScenarioHelpers.js';
+import { buildRemoveIndexerPayload, assertRemoveIndexerSuccessState } from './removeIndexerScenarioHelpers.js';
+
+export default function removeIndexerRemoveMultipleIndexersScenario() {
+	test('State.apply removeIndexer removes multiple indexers sequentially, leaving only admin', async t => {
+		const context = await setupAddIndexerScenario(t, { nodes: 4 });
+		const adminPeer = context.adminBootstrap;
+		const initialIndexerCount = getIndexerCount(adminPeer.base);
+
+		const candidates = [
+			selectIndexerCandidatePeer(context, 0),
+			selectIndexerCandidatePeer(context, 1),
+			selectIndexerCandidatePeer(context, 2)
+		];
+
+		for (const peer of candidates.slice(1)) {
+			await prepareWriterCandidate(t, context, peer);
+		}
+
+		for (const peer of candidates) {
+			await promoteWriterToIndexer(t, context, peer);
+		}
+
+		for (const peer of candidates) {
+			const writersLengthBefore = await readWritersLength(adminPeer.base);
+			const indexerEntryBefore = await adminPeer.base.view.get(peer.wallet.address);
+			const adminEntryBefore = await adminPeer.base.view.get(adminPeer.wallet.address);
+
+			ensureIndexerRegistration(adminPeer.base, peer.base.local.key);
+
+			const payload = await buildRemoveIndexerPayload(context, {
+				indexerPeer: peer,
+				adminPeer
+			});
+
+			await adminPeer.base.append(payload);
+			await adminPeer.base.update();
+			await eventFlush();
+
+			await assertRemoveIndexerSuccessState(t, context, {
+				indexerPeer: peer,
+				adminPeer,
+				indexerEntryBefore: { value: b4a.from(indexerEntryBefore.value) },
+				adminEntryBefore: { value: b4a.from(adminEntryBefore.value) },
+				payload,
+				writersLengthBefore,
+				skipSync: true
+			});
+
+		}
+
+		assertIndexerCount(t, context, 1);
+		await assertOnlyAdminIsIndexer(t, context);
+	});
+}
+
+async function prepareWriterCandidate(t, context, peer) {
+	const funding = context.addWriterScenario?.writerInitialBalance;
+	if (!funding) {
+		throw new Error('addIndexer scenarios require writerInitialBalance buffer.');
+	}
+	const expectedWriterIndex = await deriveNextWriterIndex(context.adminBootstrap.base);
+	await initializeBalances(context, [[peer.wallet.address, funding]]);
+	await whitelistAddress(context, peer.wallet.address);
+	await promotePeerToWriter(t, context, { readerPeer: peer, expectedWriterIndex });
+}
+
+async function promoteWriterToIndexer(t, context, writerPeer) {
+	const adminPeer = context.adminBootstrap;
+	const writerAddress = writerPeer.wallet.address;
+
+	const writerEntryBefore = await adminPeer.base.view.get(writerAddress);
+	t.ok(writerEntryBefore, 'writer entry exists before addIndexer');
+	const adminEntryBefore = await adminPeer.base.view.get(adminPeer.wallet.address);
+	t.ok(adminEntryBefore, 'admin entry exists before addIndexer');
+
+	const payload = await buildAddIndexerPayload(context, {
+		writerPeer,
+		adminPeer
+	});
+
+	await adminPeer.base.append(payload);
+	await adminPeer.base.update();
+	await eventFlush();
+
+	await assertAddIndexerSuccessState(t, context, {
+		writerPeer,
+		adminPeer,
+		writerEntryBefore: { value: b4a.from(writerEntryBefore.value) },
+		adminEntryBefore: { value: b4a.from(adminEntryBefore.value) },
+		payload,
+		skipSync: true
+	});
+}
+
+function getIndexerCount(base) {
+	return Object.values(base.system.indexers ?? {}).length;
+}
+
+function assertIndexerCount(t, context, expectedCount) {
+	const base = context.adminBootstrap.base;
+	const count = getIndexerCount(base);
+	t.is(count, expectedCount, 'admin observes expected indexer count');
+}
+
+async function assertOnlyAdminIsIndexer(t, context) {
+	const adminKey = context.adminBootstrap.base.local.key;
+	const membership = Object.values(context.adminBootstrap.base.system.indexers ?? {});
+	t.is(membership.length, 1, 'admin retains a single indexer');
+	const onlyEntry = membership[0]?.key;
+	t.ok(onlyEntry && b4a.equals(onlyEntry, adminKey), 'admin stays sole indexer');
+
+	// Removed indexers should now be writers without validator membership (admin view).
+	for (const candidate of context.peers.slice(1, 4)) {
+		await assertNodeIsWriterNonIndexer(t, candidate, [context.adminBootstrap]);
+	}
+}
+
+async function assertNodeIsWriterNonIndexer(t, targetPeer, allPeers) {
+	const writingKey = targetPeer.base.local.key;
+	for (const peer of allPeers) {
+		const entry = await peer.base.view.get(targetPeer.wallet.address);
+		t.ok(entry, `${peer.name} sees downgraded entry for ${targetPeer.wallet.address}`);
+		const decoded = nodeEntryUtils.decode(entry?.value);
+		t.ok(decoded, `${peer.name} decodes downgraded entry for ${targetPeer.wallet.address}`);
+		if (!decoded) continue;
+		t.is(decoded.isIndexer, false, `${peer.name} marks ${targetPeer.wallet.address} as non-indexer`);
+		t.is(decoded.isWriter, true, `${peer.name} keeps ${targetPeer.wallet.address} as writer`);
+		t.is(decoded.isWhitelisted, true, `${peer.name} keeps ${targetPeer.wallet.address} whitelisted`);
+		const hasMembership = indexerMembershipIncludes(peer.base, writingKey);
+		t.is(hasMembership, false, `${peer.name} does not keep ${targetPeer.wallet.address} in validator set`);
+	}
+}
+
+async function readWritersLength(base) {
+	const entry = await base.view.get(EntryType.WRITERS_LENGTH);
+	if (!entry?.value) return 0;
+	return entry.value.readUInt32BE();
+}
+
+async function deriveNextWriterIndex(base) {
+	const entry = await base.view.get(EntryType.WRITERS_LENGTH);
+	if (!entry?.value) {
+		return 0;
+	}
+	return lengthEntryUtils.decodeBE(entry.value);
+}
+
+function indexerMembershipIncludes(base, writingKey) {
+	const entries = base?.system?.indexers;
+	if (!entries) return false;
+	return Object.values(entries).some(entry => entry?.key && b4a.equals(entry.key, writingKey));
+}