trac-msb 0.2.4 → 0.2.6

package/tests/unit/state/apply/common/access-control/adminEntryExistsScenario.js

@@ -0,0 +1,93 @@
+import { eventFlush } from '../../../../../helpers/autobaseTestHelpers.js';
+import OperationValidationScenarioBase from '../base/OperationValidationScenarioBase.js';
+
+export default class AdminEntryExistsScenario extends OperationValidationScenarioBase {
+	constructor({
+		title,
+		setupScenario,
+		buildValidPayload,
+		assertStateUnchanged,
+		buildDuplicatePayload,
+		selectInitialNode = defaultSelectNode,
+		selectDuplicateNode,
+		beforeDuplicateApply,
+		applyInitialPayload = true,
+		expectedLogs
+	}) {
+		const mutatePayload =
+			buildDuplicatePayload
+				? ((t, validPayload, context) => buildDuplicatePayload(context, t, validPayload))
+				: ((_, validPayload) => validPayload);
+
+		const applyInvalidPayload = createApplyInvalidPayload({
+			selectInitialNode,
+			selectDuplicateNode: selectDuplicateNode ?? selectInitialNode,
+			beforeDuplicateApply,
+			applyInitialPayload
+		});
+
+		super({
+			title,
+			setupScenario,
+			buildValidPayload,
+			mutatePayload,
+			applyInvalidPayload,
+			assertStateUnchanged,
+			expectedLogs
+		});
+	}
+}
+
+function createApplyInvalidPayload({
+	selectInitialNode,
+	selectDuplicateNode,
+	beforeDuplicateApply,
+	applyInitialPayload
+}) {
+	return async (context, invalidPayload, t, validPayload) => {
+		const initialNode = selectInitialNode?.(context);
+		const duplicateNode = selectDuplicateNode?.(context);
+
+		if (applyInitialPayload && !initialNode?.base) {
+			throw new Error('Admin entry exists scenario requires an initial node with a writable base.');
+		}
+
+		if (!duplicateNode?.base) {
+			throw new Error('Admin entry exists scenario requires a duplicate node with a writable base.');
+		}
+
+		if (applyInitialPayload) {
+			await applyPayload(initialNode, validPayload);
+		}
+
+		let cleanup;
+		if (beforeDuplicateApply) {
+			cleanup = await beforeDuplicateApply({
+				context,
+				t,
+				initialPayload: validPayload,
+				duplicatePayload: invalidPayload,
+				initialNode,
+				duplicateNode
+			});
+		}
+
+		try {
+			await applyPayload(duplicateNode, invalidPayload);
+		} finally {
+			if (typeof cleanup === 'function') {
+				await cleanup();
+			}
+		}
+	};
+}
+
+async function applyPayload(node, payload) {
+	await node.base.append(payload);
+	await node.base.update();
+	await eventFlush();
+}
+
+function defaultSelectNode(context) {
+	return context.adminBootstrap ?? context.bootstrap ?? context.peers?.[0] ?? null;
+}

package/tests/unit/state/apply/common/access-control/adminEntryMissingScenario.js

@@ -0,0 +1,108 @@
+import b4a from 'b4a';
+import { eventFlush } from '../../../../../helpers/autobaseTestHelpers.js';
+import OperationValidationScenarioBase from '../base/OperationValidationScenarioBase.js';
+import { EntryType } from '../../../../../../src/utils/constants.js';
+
+const ADMIN_KEY_BUFFER = b4a.from(EntryType.ADMIN);
+
+export default class AdminEntryMissingScenario extends OperationValidationScenarioBase {
+	constructor({
+		title,
+		setupScenario,
+		buildValidPayload,
+		assertStateUnchanged,
+		selectNode = defaultSelectNode,
+		expectedLogs
+	}) {
+		super({
+			title,
+			setupScenario,
+			buildValidPayload,
+			mutatePayload: passThroughPayload,
+			applyInvalidPayload: createApplyInvalidPayload(selectNode),
+			assertStateUnchanged,
+			expectedLogs
+		});
+	}
+}
+
+function passThroughPayload(_t, payload) {
+	return payload;
+}
+
+function defaultSelectNode(context) {
+	return context.adminBootstrap ?? context.bootstrap ?? context.peers?.[0] ?? null;
+}
+
+function createApplyInvalidPayload(selectNode) {
+	return async (context, payload) => {
+		const node = selectNode(context);
+		if (!node?.base) {
+			throw new Error('Admin entry missing scenario requires a writable node.');
+		}
+
+		const cleanup = patchAdminEntryAbsent(node.base);
+		try {
+			await applyPayload(node, payload);
+		} finally {
+			await cleanup?.();
+		}
+	};
+}
+
+function patchAdminEntryAbsent(base) {
+	const originalApply = base._handlers.apply;
+	let shouldPatchNextApply = true;
+
+	base._handlers.apply = async (nodes, view, baseCtx) => {
+		if (!shouldPatchNextApply) {
+			return originalApply(nodes, view, baseCtx);
+		}
+
+		shouldPatchNextApply = 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') {
+				let suppressed = false;
+				batch.get = async key => {
+					if (!isAdminEntryKey(key) || suppressed) {
+						return originalGet(key);
+					}
+					suppressed = true;
+					return null;
+				};
+			}
+			return batch;
+		};
+
+		try {
+			return await originalApply(nodes, view, baseCtx);
+		} finally {
+			view.batch = previousBatch;
+		}
+	};
+
+	return () => {
+		base._handlers.apply = originalApply;
+	};
+}
+
+function isAdminEntryKey(key) {
+	if (typeof key === 'string') {
+		return key === EntryType.ADMIN;
+	}
+	if (b4a.isBuffer(key)) {
+		return b4a.equals(key, ADMIN_KEY_BUFFER);
+	}
+	return false;
+}
+
+async function applyPayload(node, payload) {
+	await node.base.append(payload);
+	await node.base.update();
+	await eventFlush();
+}

package/tests/unit/state/apply/common/access-control/adminOnlyGuardScenario.js

@@ -0,0 +1,126 @@
+import { eventFlush } from '../../../../../helpers/autobaseTestHelpers.js';
+import OperationValidationScenarioBase from '../base/OperationValidationScenarioBase.js';
+
+export default class AdminOnlyGuardScenario extends OperationValidationScenarioBase {
+	constructor({
+		title,
+		setupScenario,
+		buildValidPayload,
+		assertStateUnchanged,
+		selectNode = defaultSelectNode,
+		selectReader = defaultSelectReader,
+		beforeApply,
+		expectedLogs
+	}) {
+			super({
+				title,
+				setupScenario,
+				buildValidPayload,
+				mutatePayload: passThroughPayload,
+				applyInvalidPayload: createApplyInvalidPayload({
+					selectNode,
+					selectReader,
+					beforeApply
+				}),
+			assertStateUnchanged,
+			expectedLogs
+		});
+	}
+}
+
+function passThroughPayload(_t, payload) {
+	return payload;
+}
+
+function defaultSelectNode(context) {
+	return context.adminBootstrap ?? context.bootstrap ?? context.peers?.[0] ?? null;
+}
+
+function defaultSelectReader(context) {
+	const readers = context.peers?.slice(1) ?? [];
+	return readers[0] ?? null;
+}
+
+function createApplyInvalidPayload({ selectNode, selectReader, beforeApply }) {
+	return async (context, payload, t, validPayload) => {
+		const node = selectNode(context);
+		const fakeNode = selectReader(context);
+
+		if (!node?.base) {
+			throw new Error('Admin-only guard scenario requires a writable node.');
+		}
+
+		if (!fakeNode?.base) {
+			throw new Error('Admin-only guard scenario requires a fake reader node.');
+		}
+
+		const cleanupFns = [];
+
+		if (beforeApply) {
+			const cleanup = await beforeApply({
+				context,
+				t,
+				payload,
+				validPayload,
+				node,
+				impersonator: fakeNode
+			});
+			if (typeof cleanup === 'function') {
+				cleanupFns.push(cleanup);
+			}
+		}
+
+		cleanupFns.push(patchRequesterKey(node.base, fakeNode.base.local.key));
+
+		try {
+			await applyPayload(node, payload);
+		} finally {
+			while (cleanupFns.length) {
+				const cleanup = cleanupFns.pop();
+				await cleanup?.();
+			}
+		}
+	};
+}
+
+function patchRequesterKey(base, impersonatorKey) {
+	const originalApply = base._handlers.apply;
+	let shouldPatchNextApply = true;
+
+	base._handlers.apply = async (nodes, view, baseCtx) => {
+		if (!shouldPatchNextApply) {
+			return originalApply(nodes, view, baseCtx);
+		}
+
+		shouldPatchNextApply = false;
+		const patchedNodes = nodes.map(node => {
+			if (!node?.from) return node;
+			return {
+				...node,
+				from: new Proxy(node.from, {
+					// We only need to spoof node.from.key. Using a Proxy lets us override that single
+					// property while delegating every other access back to the original object via Reflect.
+					// This keeps the Hypercore/Autobase node shape intact without manual cloning.
+					get(target, prop, receiver) {
+						if (prop === 'key') {
+							return impersonatorKey;
+						}
+						return Reflect.get(target, prop, receiver);
+					}
+				})
+			};
+		});
+
+		return originalApply(patchedNodes, view, baseCtx);
+	};
+
+	return () => {
+		base._handlers.apply = originalApply;
+	};
+}
+
+async function applyPayload(node, payload) {
+	await node.base.append(payload);
+	await node.base.update();
+	await eventFlush();
+}

package/tests/unit/state/apply/common/access-control/adminPublicKeyDecodeFailureScenario.js

@@ -0,0 +1,120 @@
+import b4a from 'b4a';
+import OperationValidationScenarioBase from '../base/OperationValidationScenarioBase.js';
+import { eventFlush } from '../../../../../helpers/autobaseTestHelpers.js';
+import { EntryType, TRAC_ADDRESS_SIZE } from '../../../../../../src/utils/constants.js';
+
+const ADMIN_KEY_BUFFER = b4a.from(EntryType.ADMIN);
+
+export default class AdminPublicKeyDecodeFailureScenario extends OperationValidationScenarioBase {
+	constructor({
+		title,
+		setupScenario,
+		buildValidPayload,
+		assertStateUnchanged,
+		expectedLogs
+	}) {
+		super({
+			title,
+			setupScenario,
+			buildValidPayload,
+			mutatePayload: passThroughPayload,
+			applyInvalidPayload: applyWithCorruptedAdminEntry,
+			assertStateUnchanged,
+			expectedLogs
+		});
+	}
+}
+
+function passThroughPayload(_t, payload) {
+	return payload;
+}
+
+async function applyWithCorruptedAdminEntry(context, payload) {
+	const adminNode = context.adminBootstrap;
+	if (!adminNode?.base) {
+		throw new Error('Admin public key decode scenario requires an admin bootstrap node.');
+	}
+
+	const cleanup = patchAdminEntryAddress(adminNode.base);
+	try {
+		await adminNode.base.append(payload);
+		await adminNode.base.update();
+		await eventFlush();
+	} finally {
+		await cleanup?.();
+	}
+}
+
+function patchAdminEntryAddress(base) {
+	const originalApply = base._handlers.apply;
+	let shouldPatchNextApply = true;
+
+	base._handlers.apply = async (nodes, view, baseCtx) => {
+		if (!shouldPatchNextApply) {
+			return originalApply(nodes, view, baseCtx);
+		}
+
+		shouldPatchNextApply = 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') {
+				let mutatedOnce = false;
+				batch.get = async key => {
+					if (!isAdminEntryKey(key) || mutatedOnce) {
+						return originalGet(key);
+					}
+
+					const adminEntry = await originalGet(key);
+					if (!adminEntry?.value) {
+						return adminEntry;
+					}
+
+					mutatedOnce = true;
+					return {
+						...adminEntry,
+						value: mutateAdminAddress(adminEntry.value)
+					};
+				};
+			}
+
+			return batch;
+		};
+
+		try {
+			return await originalApply(nodes, view, baseCtx);
+		} finally {
+			view.batch = previousBatch;
+		}
+	};
+
+	return () => {
+		base._handlers.apply = originalApply;
+	};
+}
+
+function mutateAdminAddress(value) {
+	if (!b4a.isBuffer(value) || value.length < TRAC_ADDRESS_SIZE) {
+		return value;
+	}
+
+	const mutated = b4a.from(value);
+	const lastIndex = TRAC_ADDRESS_SIZE - 1;
+	const asciiP = 'p'.charCodeAt(0);
+	const asciiQ = 'q'.charCodeAt(0);
+	mutated[lastIndex] = mutated[lastIndex] === asciiP ? asciiQ : asciiP;
+	return mutated;
+}
+
+function isAdminEntryKey(key) {
+	if (typeof key === 'string') {
+		return key === EntryType.ADMIN;
+	}
+	if (b4a.isBuffer(key)) {
+		return b4a.equals(key, ADMIN_KEY_BUFFER);
+	}
+	return false;
+}

package/tests/unit/state/apply/common/access-control/roleAccessOperationValidationScenario.js

@@ -0,0 +1,50 @@
+import { eventFlush } from '../../../../../helpers/autobaseTestHelpers.js';
+import {
+	safeDecodeApplyOperation,
+	safeEncodeApplyOperation
+} from '../../../../../../src/utils/protobuf/operationHelpers.js';
+import OperationValidationScenarioBase from '../base/OperationValidationScenarioBase.js';
+
+export default class RoleAccessOperationValidationScenario extends OperationValidationScenarioBase {
+	constructor({
+		title,
+		setupScenario,
+		buildValidPayload,
+		assertStateUnchanged,
+		mutatePayload = defaultMutateRoleAccessOperation,
+		applyInvalidPayload = defaultApplyInvalidPayload,
+		expectedLogs
+	}) {
+		super({
+			title,
+			setupScenario,
+			buildValidPayload,
+			mutatePayload,
+			applyInvalidPayload,
+			assertStateUnchanged,
+			expectedLogs
+		});
+	}
+}
+
+async function defaultMutateRoleAccessOperation(t, validPayload) {
+	const decodedPayload = safeDecodeApplyOperation(validPayload);
+	t.ok(decodedPayload, 'role access payload decodes');
+	const roleAccess = decodedPayload?.rao;
+	t.ok(roleAccess, 'role access payload contains RAO component');
+	if (!roleAccess) return validPayload;
+
+	const originalWritingKey = roleAccess.iw;
+	t.ok(originalWritingKey, 'role access payload includes writing key');
+	if (!originalWritingKey) return validPayload;
+
+	roleAccess.iw = originalWritingKey.subarray(0, 8);
+	return safeEncodeApplyOperation(decodedPayload);
+}
+
+async function defaultApplyInvalidPayload(context, invalidPayload) {
+	const node = context.bootstrap ?? context.adminBootstrap;
+	await node.base.append(invalidPayload);
+	await node.base.update();
+	await eventFlush();
+}

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

@@ -0,0 +1,56 @@
+import { eventFlush } from '../../../../helpers/autobaseTestHelpers.js';
+import {
+	safeDecodeApplyOperation,
+	safeEncodeApplyOperation
+} from '../../../../../src/utils/protobuf/operationHelpers.js';
+import OperationValidationScenarioBase from './base/OperationValidationScenarioBase.js';
+
+export default class AdminControlOperationValidationScenario extends OperationValidationScenarioBase {
+	constructor({
+		title,
+		setupScenario,
+		buildValidPayload,
+		assertStateUnchanged,
+		mutatePayload = defaultMutateAdminControlOperation,
+		applyInvalidPayload = defaultApplyInvalidPayload,
+		expectedLogs
+	}) {
+		super({
+			title,
+			setupScenario,
+			buildValidPayload,
+			mutatePayload,
+			applyInvalidPayload,
+			assertStateUnchanged,
+			expectedLogs
+		});
+	}
+}
+
+async function defaultMutateAdminControlOperation(t, validPayload) {
+	const decodedPayload = safeDecodeApplyOperation(validPayload);
+	t.ok(decodedPayload, 'admin control payload decodes');
+	const adminControl = decodedPayload?.aco;
+	t.ok(adminControl, 'admin control payload includes ACO component');
+	if (!adminControl) return validPayload;
+
+	const originalTx = adminControl.tx;
+	t.ok(originalTx, 'admin control payload includes transaction hash');
+	if (!originalTx) return validPayload;
+
+	adminControl.tx = originalTx.subarray(0, Math.max(1, originalTx.length - 1));
+	return safeEncodeApplyOperation(decodedPayload);
+}
+
+async function defaultApplyInvalidPayload(context, invalidPayload) {
+	const operatorNode = context.adminBootstrap ?? context.bootstrap;
+	if (!operatorNode?.base) {
+		throw new Error(
+			'Admin control validation scenarios require an admin bootstrap or bootstrap node with a base.'
+		);
+	}
+
+	await operatorNode.base.append(invalidPayload);
+	await operatorNode.base.update();
+	await eventFlush();
+}

package/tests/unit/state/apply/common/balances/adminEntryUpdateFailureScenario.js

@@ -0,0 +1,52 @@
+import OperationValidationScenarioBase from '../base/OperationValidationScenarioBase.js';
+import { BALANCE_ZERO } from '../../../../../../src/core/state/utils/balance.js';
+import { eventFlush } from '../../../../../helpers/autobaseTestHelpers.js';
+
+/**
+ * Forces a single failure when updating the admin entry balance (Balance#update returns null).
+ * Useful for handlers that subtract a fee from the admin and then persist the updated entry.
+ */
+export default function createAdminEntryUpdateFailureScenario({
+	title,
+	setupScenario,
+	buildValidPayload,
+	assertStateUnchanged,
+	selectNode,
+	beforeApply,
+	expectedLogs = ['Failed to update admin entry.']
+}) {
+	return new OperationValidationScenarioBase({
+		title,
+		setupScenario,
+		buildValidPayload,
+		mutatePayload: (_t, payload) => payload,
+		applyInvalidPayload: async (context, invalidPayload) => {
+			const node = selectNode ? selectNode(context) : context.adminBootstrap;
+			if (beforeApply) {
+				await beforeApply(context);
+			}
+			const balancePrototype = Object.getPrototypeOf(BALANCE_ZERO);
+			const originalUpdate = balancePrototype.update;
+			let shouldFailNextUpdate = true;
+
+			balancePrototype.update = function patchedUpdate(...args) {
+				if (shouldFailNextUpdate) {
+					shouldFailNextUpdate = false;
+					console.error(expectedLogs[0]);
+					return null;
+				}
+				return originalUpdate.call(this, ...args);
+			};
+
+			try {
+				await node.base.append(invalidPayload);
+				await node.base.update();
+				await eventFlush();
+			} finally {
+				balancePrototype.update = originalUpdate;
+			}
+		},
+		assertStateUnchanged,
+		expectedLogs
+	});
+}