trac-msb 0.2.4 → 0.2.6

package/tests/unit/state/apply/common/validatorConsistency/validatorInactiveScenario.js

@@ -0,0 +1,19 @@
+import b4a from 'b4a';
+import { WRITER_MASK } from '../../../../../../src/core/state/utils/roles.js';
+import ValidatorConsistencyScenarioBase from './base/validatorConsistencyScenarioBase.js';
+
+export default class ValidatorInactiveScenario extends ValidatorConsistencyScenarioBase {
+	constructor(options) {
+		super({
+			...options,
+			mutateEntry: entry => {
+				if (!entry.value) {
+					throw new Error('Validator inactive scenario requires an existing validator entry.');
+				}
+				const mutated = b4a.from(entry.value);
+				mutated[0] &= ~WRITER_MASK;
+				return { ...entry, value: mutated };
+			}
+		});
+	}
+}

package/tests/unit/state/apply/common/validatorConsistency/validatorWriterKeyMismatchScenario.js

@@ -0,0 +1,18 @@
+import b4a from 'b4a';
+import ValidatorConsistencyScenarioBase from './base/validatorConsistencyScenarioBase.js';
+
+export default class ValidatorWriterKeyMismatchScenario extends ValidatorConsistencyScenarioBase {
+	constructor(options) {
+		super({
+			...options,
+			mutateEntry: entry => {
+				if (!entry.value) {
+					throw new Error('Validator writer key mismatch scenario requires an existing validator entry.');
+				}
+				const mutated = b4a.from(entry.value);
+				if (mutated.length > 33) mutated[1] ^= 0xff;
+				return { ...entry, value: mutated };
+			}
+		});
+	}
+}

package/tests/unit/state/apply/common/validatorEntryValidation/base/validatorEntryValidationScenarioBase.js

@@ -0,0 +1,314 @@
+import b4a from 'b4a';
+import OperationValidationScenarioBase from '../../base/OperationValidationScenarioBase.js';
+import nodeEntryUtils from '../../../../../../../src/core/state/utils/nodeEntry.js';
+import { safeDecodeApplyOperation } from '../../../../../../../src/utils/protobuf/operationHelpers.js';
+import addressUtils from '../../../../../../../src/core/state/utils/address.js';
+import { eventFlush } from '../../../../../../helpers/autobaseTestHelpers.js';
+import { BALANCE_ZERO } from '../../../../../../../src/core/state/utils/balance.js';
+
+const DEFAULT_VALIDATOR_ADDRESS_PATH = ['rao', 'va'];
+const VALIDATOR_ENTRY_MARK = Symbol('validator-entry-mark');
+const VALIDATOR_BALANCE_MARK = Symbol('validator-balance-mark');
+
+export default class ValidatorEntryValidationScenarioBase extends OperationValidationScenarioBase {
+	constructor({
+		title,
+		setupScenario,
+		buildValidPayload,
+		assertStateUnchanged,
+		mutateEntry = entryPassThrough,
+		mutateDecodedEntry = null,
+		selectNode = defaultSelectNode,
+		validatorAddressPath = DEFAULT_VALIDATOR_ADDRESS_PATH,
+		expectedLogs,
+		mutatePayload,
+		applyInvalidPayload,
+		failNextBalanceAdd = false,
+		failNextBalanceUpdate = false
+	}) {
+		if (typeof mutateEntry !== 'function') {
+			throw new Error('Validator entry validation scenario requires a mutateEntry function.');
+		}
+
+		super({
+			title,
+			setupScenario,
+			buildValidPayload,
+			mutatePayload: mutatePayload ?? passThroughPayload,
+			applyInvalidPayload:
+				typeof applyInvalidPayload === 'function'
+					? applyInvalidPayload
+					: createApplyInvalidPayload({
+							selectNode,
+							validatorAddressPath,
+							mutateEntry,
+							mutateDecodedEntry,
+							failNextBalanceAdd,
+							failNextBalanceUpdate
+					  }),
+			assertStateUnchanged,
+			expectedLogs
+		});
+	}
+}
+
+function passThroughPayload(_t, payload) {
+	return payload;
+}
+
+function entryPassThrough(entry) {
+	return entry;
+}
+
+function defaultSelectNode(context) {
+	return context.adminBootstrap ?? context.bootstrap ?? context.peers?.[0] ?? null;
+}
+
+function createApplyInvalidPayload({
+	selectNode,
+	validatorAddressPath,
+	mutateEntry,
+	mutateDecodedEntry,
+	failNextBalanceAdd,
+	failNextBalanceUpdate
+}) {
+	return async (context, payload, t, validPayload) => {
+		const node = selectNode(context);
+		if (!node?.base) {
+			throw new Error('Validator entry validation scenario requires a writable node.');
+		}
+
+		const validatorAddress = extractValidatorAddress(validPayload ?? payload, validatorAddressPath);
+		if (!validatorAddress) {
+			throw new Error('Validator address could not be derived from payload.');
+		}
+
+		const cleanup = patchValidatorEntry({
+			base: node.base,
+			mutateEntry,
+			mutateDecodedEntry,
+			failNextBalanceAdd,
+			failNextBalanceUpdate,
+			context,
+			t,
+			validatorAddressString: validatorAddress.string,
+			validatorAddressBuffer: validatorAddress.buffer
+		});
+
+		try {
+			await node.base.append(payload);
+			await node.base.update();
+			await eventFlush();
+		} finally {
+			await cleanup();
+		}
+	};
+}
+
+function patchValidatorEntry({
+	base,
+	mutateEntry,
+	mutateDecodedEntry,
+	failNextBalanceAdd,
+	failNextBalanceUpdate,
+	context,
+	t,
+	validatorAddressString,
+	validatorAddressBuffer
+}) {
+	const originalApply = base._handlers.apply;
+	const originalDecode = nodeEntryUtils.decode;
+	const balancePrototype = Object.getPrototypeOf(BALANCE_ZERO);
+	const originalAdd = balancePrototype.add;
+	const originalUpdate = balancePrototype.update;
+
+	let shouldInterceptNextApply = true;
+	let targetEntryBuffer = null;
+	let shouldFailNextAdd = false;
+	let shouldMarkNextBalance = false;
+
+	const setTargetEntryBuffer = buffer => {
+		if (buffer && b4a.isBuffer(buffer)) {
+			targetEntryBuffer = b4a.from(buffer);
+		} else {
+			targetEntryBuffer = null;
+		}
+	};
+
+	const isTargetEntryBuffer = buffer =>
+		targetEntryBuffer &&
+		b4a.isBuffer(buffer) &&
+		buffer.length === targetEntryBuffer.length &&
+		b4a.equals(buffer, targetEntryBuffer);
+
+	nodeEntryUtils.decode = function patchedDecode(buffer) {
+		const decoded = originalDecode(buffer);
+		if (isTargetEntryBuffer(buffer)) {
+			markValidatorBuffer(buffer);
+			shouldFailNextAdd = failNextBalanceAdd;
+			shouldMarkNextBalance = failNextBalanceUpdate;
+
+			if (mutateDecodedEntry) {
+				const mutated = mutateDecodedEntry(decoded, {
+					context,
+					t,
+					validatorAddress: validatorAddressString
+				});
+				if (mutated && typeof mutated === 'object') {
+					return mutated;
+				}
+			}
+		}
+		return decoded;
+	};
+
+	balancePrototype.add = function patchedAdd(balance) {
+		if (shouldFailNextAdd) {
+			shouldFailNextAdd = false;
+			return null;
+		}
+		const result = originalAdd.call(this, balance);
+		if (shouldMarkNextBalance && result) {
+			shouldMarkNextBalance = false;
+			result[VALIDATOR_BALANCE_MARK] = true;
+		}
+		return result;
+	};
+
+	balancePrototype.update = function patchedUpdate(nodeEntryBuffer) {
+		if (this?.[VALIDATOR_BALANCE_MARK]) {
+			this[VALIDATOR_BALANCE_MARK] = false;
+			return null;
+		}
+		return originalUpdate.call(this, nodeEntryBuffer);
+	};
+
+	base._handlers.apply = async function patchedApply(nodes, view, baseCtx) {
+		if (!shouldInterceptNextApply) {
+			return originalApply.call(this, nodes, view, baseCtx);
+		}
+
+		shouldInterceptNextApply = false;
+		const originalBatch = view.batch;
+		view.batch = function patchedBatch(...args) {
+			const batch = originalBatch.apply(this, args);
+			if (!batch || typeof batch.get !== 'function') {
+				return batch;
+			}
+
+			const originalGet = batch.get.bind(batch);
+			let hasMutatedEntry = false;
+
+			batch.get = async key => {
+				if (
+					!hasMutatedEntry &&
+					isValidatorKeyMatch(key, validatorAddressString, validatorAddressBuffer)
+				) {
+					hasMutatedEntry = true;
+					const entry = await originalGet(key);
+					if (entry?.value && b4a.isBuffer(entry.value)) {
+						setTargetEntryBuffer(entry.value);
+						markValidatorBuffer(entry.value);
+					} else {
+						setTargetEntryBuffer(null);
+					}
+
+					const mutation = await mutateEntry(entry, {
+						context,
+						t,
+						validatorAddress: validatorAddressString
+					});
+
+					const mutatedEntry = applyEntryMutation(entry, mutation);
+					if (mutatedEntry?.value && b4a.isBuffer(mutatedEntry.value)) {
+						setTargetEntryBuffer(mutatedEntry.value);
+						markValidatorBuffer(mutatedEntry.value);
+					} else if (mutatedEntry === null) {
+						setTargetEntryBuffer(null);
+					}
+					return mutatedEntry;
+				}
+
+				return originalGet(key);
+			};
+
+			return batch;
+		};
+
+		try {
+			return await originalApply.call(this, nodes, view, baseCtx);
+		} finally {
+			view.batch = originalBatch;
+		}
+	};
+
+	return async () => {
+		base._handlers.apply = originalApply;
+		nodeEntryUtils.decode = originalDecode;
+		const prototype = Object.getPrototypeOf(BALANCE_ZERO);
+		prototype.add = originalAdd;
+		prototype.update = originalUpdate;
+	};
+}
+
+function applyEntryMutation(entry, mutation) {
+	if (typeof mutation === 'undefined') {
+		return entry;
+	}
+
+	if (mutation === null) {
+		return null;
+	}
+
+	if (entry && (b4a.isBuffer(mutation) || mutation instanceof Uint8Array)) {
+		const wrapped = { ...entry, value: b4a.from(mutation) };
+		markValidatorBuffer(wrapped.value);
+		return wrapped;
+	}
+
+	if (mutation && typeof mutation === 'object') {
+		if (mutation.value && b4a.isBuffer(mutation.value)) {
+			markValidatorBuffer(mutation.value);
+		}
+		return mutation;
+	}
+
+	throw new Error('Invalid validator entry mutation result.');
+}
+
+function extractValidatorAddress(payloadBuffer, path) {
+	const decoded = safeDecodeApplyOperation(payloadBuffer);
+	if (!decoded) return null;
+
+	const value = Array.isArray(path) && path.length > 0 ? traversePath(decoded, path) : null;
+	if (!value || !b4a.isBuffer(value) || value.length === 0) {
+		return null;
+	}
+
+	const addressString = addressUtils.bufferToAddress(value);
+	if (!addressString) {
+		return null;
+	}
+
+	return { buffer: value, string: addressString };
+}
+
+function traversePath(payload, path) {
+	return path.reduce((current, segment) => (current ? current[segment] : null), payload);
+}
+
+function isValidatorKeyMatch(key, targetString, targetBuffer) {
+	if (typeof key === 'string') {
+		return key === targetString;
+	}
+	if (b4a.isBuffer(key) && targetBuffer) {
+		return b4a.equals(key, targetBuffer);
+	}
+	return false;
+}
+
+function markValidatorBuffer(buffer) {
+	if (buffer && typeof buffer === 'object') {
+		buffer[VALIDATOR_ENTRY_MARK] = true;
+	}
+}

package/tests/unit/state/apply/common/validatorEntryValidation/validatorEntryInvalidBalanceScenario.js

@@ -0,0 +1,18 @@
+import b4a from 'b4a';
+import ValidatorEntryValidationScenarioBase from './base/validatorEntryValidationScenarioBase.js';
+
+export default class ValidatorEntryInvalidBalanceScenario extends ValidatorEntryValidationScenarioBase {
+	constructor(options) {
+		super({
+			...options,
+			mutateDecodedEntry: decoded => {
+				if (!decoded) return decoded;
+				return {
+					...decoded,
+					balance: b4a.alloc(1)
+				};
+			},
+			expectedLogs: options?.expectedLogs ?? ['Invalid validator balance.']
+		});
+	}
+}

package/tests/unit/state/apply/common/writerKeyExistsValidationScenario.js

@@ -0,0 +1,43 @@
+import { eventFlush } from '../../../../helpers/autobaseTestHelpers.js';
+import OperationValidationScenarioBase from './base/OperationValidationScenarioBase.js';
+
+export default class WriterKeyExistsValidationScenario extends OperationValidationScenarioBase {
+	constructor({
+		title,
+		setupScenario,
+		buildValidPayload,
+		assertStateUnchanged,
+		mutatePayload = passThroughPayload,
+		applyInvalidPayload,
+		expectedLogs
+	}) {
+		super({
+			title,
+			setupScenario,
+			buildValidPayload,
+			mutatePayload,
+			applyInvalidPayload: applyInvalidPayload ?? defaultApplyInvalidPayload,
+			assertStateUnchanged,
+			expectedLogs
+		});
+	}
+}
+
+function passThroughPayload(_t, payload) {
+	return payload;
+}
+
+async function defaultApplyInvalidPayload(context, invalidPayload, _t, validPayload) {
+	const adminNode = context.adminBootstrap ?? context.bootstrap;
+	if (!adminNode) {
+		throw new Error('Writer key validation scenario requires an admin bootstrap node.');
+	}
+
+	await adminNode.base.append(validPayload);
+	await adminNode.base.update();
+	await eventFlush();
+
+	await adminNode.base.append(invalidPayload);
+	await adminNode.base.update();
+	await eventFlush();
+}

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

@@ -0,0 +1,53 @@
+import { test } from 'brittle';
+import { eventFlush } from '../../../../helpers/autobaseTestHelpers.js';
+import setupDisableInitializationScenario, {
+	buildDisableInitializationPayload,
+	assertInitializationDisabledState
+} from './disableInitializationScenarioHelpers.js';
+import { safeDecodeApplyOperation } from '../../../../../src/utils/protobuf/operationHelpers.js';
+
+export default function disableInitializationAlreadyDisabledScenario() {
+	test('State.apply disableInitialization aborts when initialization already disabled', async t => {
+		const context = await setupDisableInitializationScenario(t);
+		const adminNode = context.adminBootstrap;
+		const readerNode = context.peers[1];
+
+		const firstPayload = await buildDisableInitializationPayload(context);
+		await adminNode.base.append(firstPayload);
+		await adminNode.base.update();
+		await eventFlush();
+		await assertInitializationDisabledState(t, adminNode.base, firstPayload);
+
+		const expectedLog = 'Balance initialization already disabled.';
+		const capturedLogs = [];
+		const originalConsoleError = console.error;
+		console.error = (...args) => {
+			capturedLogs.push(args);
+			originalConsoleError(...args);
+		};
+
+		const secondPayload = await buildDisableInitializationPayload(context);
+		try {
+			await adminNode.base.append(secondPayload);
+			await adminNode.base.update();
+			await eventFlush();
+		} finally {
+			console.error = originalConsoleError;
+		}
+
+		const decodedSecondPayload = safeDecodeApplyOperation(secondPayload);
+		t.ok(decodedSecondPayload?.cao?.tx, 'fixtures decode');
+		const secondTxKey = decodedSecondPayload.cao.tx.toString('hex');
+		const secondTxEntry = await adminNode.base.view.get(secondTxKey);
+		t.is(secondTxEntry, null, 'second disable tx not recorded');
+
+		await assertInitializationDisabledState(t, adminNode.base);
+		await context.sync();
+		await assertInitializationDisabledState(t, readerNode.base);
+
+		const logFound = capturedLogs.some(args =>
+			args.some(arg => typeof arg === 'string' && arg.includes(expectedLog))
+		);
+		t.ok(logFound, `expected apply log "${expectedLog}" was emitted`);
+	});
+}

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

@@ -0,0 +1,24 @@
+import { test } from 'brittle';
+import setupDisableInitializationScenario, {
+	buildDisableInitializationPayload,
+	assertInitializationDisabledState
+} from './disableInitializationScenarioHelpers.js';
+import { eventFlush } from '../../../../helpers/autobaseTestHelpers.js';
+
+export default function disableInitializationHappyPathScenario() {
+	test('State.apply disableInitialization disables initialization - happy path', async t => {
+		const context = await setupDisableInitializationScenario(t);
+		const adminNode = context.adminBootstrap;
+		const readerNode = context.peers[1];
+
+		const disablePayload = await buildDisableInitializationPayload(context);
+		await adminNode.base.append(disablePayload);
+		await adminNode.base.update();
+		await eventFlush();
+
+		await assertInitializationDisabledState(t, adminNode.base, disablePayload);
+
+		await context.sync();
+		await assertInitializationDisabledState(t, readerNode.base, disablePayload);
+	});
+}

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

@@ -0,0 +1,197 @@
+import b4a from 'b4a';
+import { setupStateNetwork } from '../../../../helpers/StateNetworkFactory.js';
+import {
+	seedBootstrapIndexer,
+	defaultOpenHyperbeeView,
+	deriveIndexerSequenceState,
+	eventFlush
+} from '../../../../helpers/autobaseTestHelpers.js';
+import CompleteStateMessageOperations from '../../../../../src/messages/completeStateMessages/CompleteStateMessageOperations.js';
+import { AUTOBASE_VALUE_ENCODING, EntryType } from '../../../../../src/utils/constants.js';
+import { safeDecodeApplyOperation, safeEncodeApplyOperation } from '../../../../../src/utils/protobuf/operationHelpers.js';
+import { safeWriteUInt32BE } from '../../../../../src/utils/buffer.js';
+import { buildAddAdminRequesterPayload } from '../addAdmin/addAdminScenarioHelpers.js';
+
+export async function setupDisableInitializationScenario(t) {
+	const context = await setupStateNetwork({
+		nodes: 2,
+		valueEncoding: AUTOBASE_VALUE_ENCODING,
+		open: defaultOpenHyperbeeView
+	});
+
+	seedBootstrapIndexer(context);
+
+	t.teardown(async () => {
+		await context.teardown();
+	});
+
+	await bootstrapAdmin(context);
+	return context;
+}
+
+export async function setupDisableInitializationAdminReaderScenario(t) {
+	const context = await setupDisableInitializationScenario(t);
+	const adminNode = context.adminBootstrap;
+	const readerNode = context.peers[1];
+
+	if (!readerNode) {
+		throw new Error('Disable initialization scenarios require at least one reader node.');
+	}
+
+	return { context, adminNode, readerNode };
+}
+
+async function bootstrapAdmin(context) {
+	const adminNode = context.adminBootstrap;
+	const payload = await buildAddAdminRequesterPayload(context);
+
+	await adminNode.base.append(payload);
+	await adminNode.base.update();
+	await eventFlush();
+}
+
+export async function buildDisableInitializationPayload(context) {
+	const adminNode = context.adminBootstrap;
+	const txValidity = await deriveIndexerSequenceState(adminNode.base);
+
+	return CompleteStateMessageOperations.assembleDisableInitializationMessage(
+		adminNode.wallet,
+		adminNode.base.local.key,
+		txValidity
+	);
+}
+
+export async function buildDisableInitializationPayloadWithTxValidity(context, txValidity) {
+	const adminNode = context.adminBootstrap;
+	return CompleteStateMessageOperations.assembleDisableInitializationMessage(
+		adminNode.wallet,
+		adminNode.base.local.key,
+		txValidity
+	);
+}
+
+export async function assertInitializationDisabledState(t, base, payload) {
+	const initializationEntry = await base.view.get(EntryType.INITIALIZATION);
+	t.ok(initializationEntry, 'initialization entry exists');
+	t.ok(
+		b4a.equals(initializationEntry.value, safeWriteUInt32BE(0, 0)),
+		'initialization flag cleared'
+	);
+
+	if (!payload) return;
+
+	const decodedPayload = safeDecodeApplyOperation(payload);
+	t.ok(decodedPayload?.cao?.tx, 'disable payload decodes');
+
+	const txKey = decodedPayload.cao.tx.toString('hex');
+	const txEntry = await base.view.get(txKey);
+	t.ok(txEntry, 'disable initialization tx recorded to prevent replays');
+}
+
+export function mutateDisableInitializationPayloadForInvalidSchema(t, validPayload) {
+	const decodedPayload = safeDecodeApplyOperation(validPayload);
+	t.ok(decodedPayload, 'fixtures decode');
+
+	decodedPayload.cao.tx = b4a.alloc(decodedPayload.cao.tx.length);
+	return safeEncodeApplyOperation(decodedPayload);
+}
+
+export async function assertDisableInitializationFailureState(
+	t,
+	context,
+	{ skipSync = false, validPayload = null } = {}
+) {
+	const adminNode = context.adminBootstrap;
+	const readerNodes = context.peers.slice(1);
+
+	await assertInitializationEnabled(t, adminNode.base);
+	await assertOperationNotRecorded(t, adminNode.base, validPayload);
+
+	if (!skipSync) {
+		await context.sync();
+		for (const reader of readerNodes) {
+			await assertInitializationEnabled(t, reader.base);
+			await assertOperationNotRecorded(t, reader.base, validPayload);
+		}
+	}
+}
+
+async function assertInitializationEnabled(t, base) {
+	const initializationEntry = await base.view.get(EntryType.INITIALIZATION);
+	t.ok(initializationEntry, 'initialization entry exists');
+	t.ok(
+		b4a.equals(initializationEntry.value, safeWriteUInt32BE(1, 0)),
+		'initialization flag remains enabled'
+	);
+}
+
+async function assertOperationNotRecorded(t, base, payload) {
+	if (!payload) return;
+
+	const decodedPayload = safeDecodeApplyOperation(payload);
+	if (!decodedPayload?.cao?.tx) return;
+
+	const txKey = decodedPayload.cao.tx.toString('hex');
+	const txEntry = await base.view.get(txKey);
+	t.is(txEntry, null, 'disable initialization tx not recorded');
+}
+
+export function bypassDisableInitializationAlreadyDisabledGuardOnce(context) {
+	const adminNode = context.adminBootstrap;
+	if (!adminNode?.base) {
+		throw new Error('Disable initialization guard bypass requires an admin bootstrap node.');
+	}
+
+	const originalApply = adminNode.base._handlers.apply;
+	let shouldBypass = true;
+
+	adminNode.base._handlers.apply = async (nodes, view, baseCtx) => {
+		if (!shouldBypass) {
+			return originalApply(nodes, view, baseCtx);
+		}
+
+		shouldBypass = false;
+		const previousBatch = view.batch;
+		const boundBatch = previousBatch.bind(view);
+
+		view.batch = function patchedBatch(...args) {
+			const batch = boundBatch(...args);
+			const originalGet = batch.get?.bind(batch);
+			if (typeof originalGet === 'function') {
+				batch.get = async key => {
+					const entry = await originalGet(key);
+					if (isInitializationEntryKey(key) && entry?.value) {
+						return {
+							...entry,
+							value: safeWriteUInt32BE(1, 0)
+						};
+					}
+					return entry;
+				};
+			}
+			return batch;
+		};
+
+		try {
+			return await originalApply(nodes, view, baseCtx);
+		} finally {
+			view.batch = previousBatch;
+		}
+	};
+
+	return () => {
+		adminNode.base._handlers.apply = originalApply;
+	};
+}
+
+function isInitializationEntryKey(key) {
+	if (typeof key === 'string') {
+		return key === EntryType.INITIALIZATION;
+	}
+	if (b4a.isBuffer(key)) {
+		return b4a.equals(key, b4a.from(EntryType.INITIALIZATION));
+	}
+	return false;
+}
+
+export default setupDisableInitializationScenario;